编译器
0.8.12+commit.f00d7308
文件 1 的 30：Address.sol
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
文件 2 的 30：Context.sol
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
文件 3 的 30：ContextMixin.sol
pragma solidity ^0.8.0;
abstract contract ContextMixin {
function msgSender() internal view returns (address payable sender) {
if (msg.sender == address(this)) {
bytes memory array = msg.data;
uint256 index = msg.data.length;
assembly {
sender := and(
mload(add(array, index)),
0xffffffffffffffffffffffffffffffffffffffff
)
}
} else {
sender = payable(msg.sender);
}
return sender;
}
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
文件 4 的 30：Controllable.sol
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
abstract contract Controllable is Ownable {
mapping(address => bool) private controllers;
function addController(address controller) external onlyOwner {
controllers[controller] = true;
}
function removeController(address controller) external onlyOwner {
controllers[controller] = false;
}
function isController(address account) public view returns (bool) {
return controllers[account];
}
modifier onlyController() {
require(controllers[_msgSender()], "Controllable: caller is not the controller");
_;
}
}
文件 5 的 30：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");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' 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 if (signature.length == 64) {
bytes32 r;
bytes32 vs;
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} 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;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 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);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
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) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
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) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
文件 6 的 30：EIP712Base.sol
pragma solidity ^0.8.0;
import {Initializable} from "./Initializable.sol";
contract EIP712Base is Initializable {
struct EIP712Domain {
string name;
string version;
address verifyingContract;
bytes32 salt;
}
string public constant ERC712_VERSION = "1";
bytes32 internal constant EIP712_DOMAIN_TYPEHASH =
keccak256(
bytes(
"EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"
)
);
bytes32 internal domainSeperator;
function _initializeEIP712(string memory name) internal initializer {
_setDomainSeperator(name);
}
function _setDomainSeperator(string memory name) internal {
domainSeperator = keccak256(
abi.encode(
EIP712_DOMAIN_TYPEHASH,
keccak256(bytes(name)),
keccak256(bytes(ERC712_VERSION)),
address(this),
bytes32(getChainId())
)
);
}
function getDomainSeperator() public view returns (bytes32) {
return domainSeperator;
}
function getChainId() public view returns (uint256) {
uint256 id;
assembly {
id := chainid()
}
return id;
}
function toTypedMessageHash(bytes32 messageHash)
internal
view
returns (bytes32)
{
return
keccak256(
abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash)
);
}
}
文件 7 的 30：ERC165.sol
pragma solidity ^0.8.0;
import "./IERC165.sol";
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
文件 8 的 30：ERC20.sol
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
文件 9 的 30：ERC20Burnable.sol
pragma solidity ^0.8.0;
import "../ERC20.sol";
import "../../../utils/Context.sol";
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 currentAllowance = allowance(account, _msgSender());
require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
unchecked {
_approve(account, _msgSender(), currentAllowance - amount);
}
_burn(account, amount);
}
}
文件 10 的 30：ERC721AMultiMint.sol
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/token/ERC721/IERC721.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol';
import '@openzeppelin/contracts/utils/Address.sol';
import '@openzeppelin/contracts/utils/Context.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/introspection/ERC165.sol';
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();
error SetTimestampsDuplicates();
error SetTimestampsIncorrectOwner();
error InvalidQueryRange();
contract ERC721AMultiMint is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
uint256 private constant MAX_RANGE = 20;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
bool burned;
}
struct AddressData {
uint24 balance;
uint24 numberMinted;
uint24 numberBurned;
uint8 numberWhitelistMinted;
uint176 aux;
}
string private _name;
string private _symbol;
mapping(uint256 => TokenOwnership) internal _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
uint32 internal _currentIndex;
uint32 internal _burnCounter;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
_currentIndex = uint32(_startTokenId());
}
function _startTokenId() internal view virtual returns (uint256) {
return 0;
}
function totalSupply() public view returns (uint256) {
unchecked {
return _currentIndex - _burnCounter - _startTokenId();
}
}
function _totalMinted() internal view returns (uint256) {
unchecked {
return _currentIndex - _startTokenId();
}
}
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 override returns (uint256) {
if (owner == address(0)) revert BalanceQueryForZeroAddress();
return uint256(_addressData[owner].balance);
}
function _numberMinted(address owner) internal view returns (uint256) {
return uint256(_addressData[owner].numberMinted);
}
function _numberBurned(address owner) internal view returns (uint256) {
return uint256(_addressData[owner].numberBurned);
}
function _numberWhitelistMinted(address owner) internal view returns (uint8) {
return _addressData[owner].numberWhitelistMinted;
}
function _setNumberWhitelistMinted(address owner, uint8 number) internal {
_addressData[owner].numberWhitelistMinted = number;
}
function _getAux(address owner) internal view returns (uint176) {
return _addressData[owner].aux;
}
function _setAux(address owner, uint176 aux) internal {
_addressData[owner].aux = aux;
}
function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
uint256 curr = tokenId;
unchecked {
if (_startTokenId() <= curr && curr < _currentIndex) {
TokenOwnership memory ownership = _ownerships[curr];
if (!ownership.burned) {
if (ownership.addr != address(0)) {
return ownership;
}
while (true) {
curr--;
ownership = _ownerships[curr];
if (ownership.addr != address(0)) {
return ownership;
}
}
}
}
}
revert OwnerQueryForNonexistentToken();
}
function _setTimestampOf(uint256 tokenId, uint64 timestamp) internal returns (uint64) {
TokenOwnership memory prevOwnership = _ownershipOf(tokenId);
address owner = prevOwnership.addr;
unchecked {
TokenOwnership storage currSlot = _ownerships[tokenId];
currSlot.addr = owner;
currSlot.startTimestamp = timestamp;
uint256 nextTokenId = tokenId + 1;
TokenOwnership storage nextSlot = _ownerships[nextTokenId];
if (nextSlot.addr == address(0)) {
if (nextTokenId != _currentIndex) {
nextSlot.addr = owner;
nextSlot.startTimestamp = prevOwnership.startTimestamp;
}
}
}
return prevOwnership.startTimestamp;
}
function _setTimestampsOf(address owner, uint256[] calldata tokenIds, uint64 timestamp) internal returns (uint64[] memory prevTimestamps) {
unchecked {
uint256 length = tokenIds.length;
prevTimestamps = new uint64[](length);
uint256 prevTokenId = 0;
uint256 i = 0;
while (i < length) {
uint256 tokenId = tokenIds[i];
if (prevTokenId >= tokenId) revert SetTimestampsDuplicates();
TokenOwnership memory prevOwnership = _ownershipOf(tokenId);
prevTimestamps[i++] = prevOwnership.startTimestamp;
if (prevOwnership.addr != owner) revert SetTimestampsIncorrectOwner();
TokenOwnership storage currSlot = _ownerships[tokenId];
currSlot.addr = owner;
currSlot.startTimestamp = timestamp;
for (;;) {
uint256 nextTokenId = tokenId + 1;
TokenOwnership storage nextSlot = _ownerships[nextTokenId];
if (nextSlot.addr != address(0)) {
break;
}
if (nextTokenId == _currentIndex) {
break;
}
if (i >= length || tokenIds[i] != nextTokenId) {
nextSlot.addr = owner;
nextSlot.startTimestamp = prevOwnership.startTimestamp;
break;
}
prevTimestamps[i++] = prevOwnership.startTimestamp;
tokenId = nextTokenId;
}
prevTokenId = tokenId;
}
}
}
function ownerOf(uint256 tokenId) public view override returns (address) {
return _ownershipOf(tokenId).addr;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
if (!_exists(tokenId)) revert URIQueryForNonexistentToken();
string memory baseURI = _baseURI();
return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : '';
}
function _baseURI() internal view virtual returns (string memory) {
return '';
}
function approve(address to, uint256 tokenId) public override {
address owner = ERC721AMultiMint.ownerOf(tokenId);
if (to == owner) revert ApprovalToCurrentOwner();
if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
revert ApprovalCallerNotOwnerNorApproved();
}
_approve(to, tokenId, owner);
}
function getApproved(uint256 tokenId) public view override returns (address) {
if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
if (operator == _msgSender()) revert ApproveToCaller();
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, '');
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
_transfer(from, to, tokenId);
if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
}
function _exists(uint256 tokenId) internal view returns (bool) {
return _startTokenId() <= tokenId && tokenId < _currentIndex && !_ownerships[tokenId].burned;
}
function _safeMint(address to, uint256 quantity) internal {
_safeMint(to, quantity, '');
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
_mint(to, quantity, _data, true);
}
function _mint(
address to,
uint256 quantity,
bytes memory _data,
bool safe
) internal {
uint256 startTokenId = _currentIndex;
if (to == address(0)) revert MintToZeroAddress();
if (quantity == 0) revert MintZeroQuantity();
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
unchecked {
_addressData[to].balance += uint24(quantity);
_addressData[to].numberMinted += uint24(quantity);
uint256 updatedIndex = startTokenId;
uint256 end = updatedIndex + quantity;
uint256 writeCount = (quantity + MAX_RANGE - 1) / MAX_RANGE;
uint256 writeStep = quantity / writeCount;
uint256 writePosition = startTokenId;
for (uint256 i = 0; i < writeCount; ++i) {
_ownerships[writePosition].addr = to;
_ownerships[writePosition].startTimestamp = uint64(block.timestamp);
writePosition += writeStep;
}
if (safe && to.isContract()) {
do {
emit Transfer(address(0), to, updatedIndex);
if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
} while (updatedIndex != end);
if (_currentIndex != startTokenId) revert();
} else {
do {
emit Transfer(address(0), to, updatedIndex++);
} while (updatedIndex != end);
}
_currentIndex = uint32(updatedIndex);
}
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
function _transfer(
address from,
address to,
uint256 tokenId
) private {
TokenOwnership memory prevOwnership = _ownershipOf(tokenId);
if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();
bool isApprovedOrOwner = (_msgSender() == from ||
isApprovedForAll(from, _msgSender()) ||
getApproved(tokenId) == _msgSender());
if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
if (to == address(0)) revert TransferToZeroAddress();
_beforeTokenTransfers(from, to, tokenId, 1);
_approve(address(0), tokenId, from);
unchecked {
_addressData[from].balance -= 1;
_addressData[to].balance += 1;
TokenOwnership storage currSlot = _ownerships[tokenId];
currSlot.addr = to;
currSlot.startTimestamp = uint64(block.timestamp);
uint256 nextTokenId = tokenId + 1;
TokenOwnership storage nextSlot = _ownerships[nextTokenId];
if (nextSlot.addr == address(0)) {
if (nextTokenId != _currentIndex) {
nextSlot.addr = from;
nextSlot.startTimestamp = prevOwnership.startTimestamp;
}
}
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
_burn(tokenId, false);
}
function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
TokenOwnership memory prevOwnership = _ownershipOf(tokenId);
address from = prevOwnership.addr;
if (approvalCheck) {
bool isApprovedOrOwner = (_msgSender() == from ||
isApprovedForAll(from, _msgSender()) ||
getApproved(tokenId) == _msgSender());
if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
}
_beforeTokenTransfers(from, address(0), tokenId, 1);
_approve(address(0), tokenId, from);
unchecked {
AddressData storage addressData = _addressData[from];
addressData.balance -= 1;
addressData.numberBurned += 1;
TokenOwnership storage currSlot = _ownerships[tokenId];
currSlot.addr = from;
currSlot.startTimestamp = uint64(block.timestamp);
currSlot.burned = true;
uint256 nextTokenId = tokenId + 1;
TokenOwnership storage nextSlot = _ownerships[nextTokenId];
if (nextSlot.addr == address(0)) {
if (nextTokenId != _currentIndex) {
nextSlot.addr = from;
nextSlot.startTimestamp = prevOwnership.startTimestamp;
}
}
}
emit Transfer(from, address(0), tokenId);
_afterTokenTransfers(from, address(0), tokenId, 1);
unchecked {
_burnCounter++;
}
}
function _approve(
address to,
uint256 tokenId,
address owner
) private {
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function _checkContractOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert TransferToNonERC721ReceiverImplementer();
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function explicitOwnershipOf(uint256 tokenId) public view returns (TokenOwnership memory) {
TokenOwnership memory ownership;
if (tokenId < _startTokenId() || tokenId >= _currentIndex) {
return ownership;
}
ownership = _ownerships[tokenId];
if (ownership.burned) {
return ownership;
}
return _ownershipOf(tokenId);
}
function explicitOwnershipsOf(uint256[] memory tokenIds) external view returns (TokenOwnership[] memory) {
unchecked {
uint256 tokenIdsLength = tokenIds.length;
TokenOwnership[] memory ownerships = new TokenOwnership[](tokenIdsLength);
for (uint256 i; i != tokenIdsLength; ++i) {
ownerships[i] = explicitOwnershipOf(tokenIds[i]);
}
return ownerships;
}
}
function tokensOfOwnerIn(
address owner,
uint256 start,
uint256 stop
) external view returns (uint256[] memory) {
unchecked {
if (start >= stop) revert InvalidQueryRange();
uint256 tokenIdsIdx;
uint256 stopLimit = _currentIndex;
if (start < _startTokenId()) {
start = _startTokenId();
}
if (stop > stopLimit) {
stop = stopLimit;
}
uint256 tokenIdsMaxLength = balanceOf(owner);
if (start < stop) {
uint256 rangeLength = stop - start;
if (rangeLength < tokenIdsMaxLength) {
tokenIdsMaxLength = rangeLength;
}
} else {
tokenIdsMaxLength = 0;
}
uint256[] memory tokenIds = new uint256[](tokenIdsMaxLength);
if (tokenIdsMaxLength == 0) {
return tokenIds;
}
TokenOwnership memory ownership = explicitOwnershipOf(start);
address currOwnershipAddr;
if (!ownership.burned) {
currOwnershipAddr = ownership.addr;
}
for (uint256 i = start; i != stop && tokenIdsIdx != tokenIdsMaxLength; ++i) {
ownership = _ownerships[i];
if (ownership.burned) {
continue;
}
if (ownership.addr != address(0)) {
currOwnershipAddr = ownership.addr;
}
if (currOwnershipAddr == owner) {
tokenIds[tokenIdsIdx++] = i;
}
}
assembly {
mstore(tokenIds, tokenIdsIdx)
}
return tokenIds;
}
}
function tokensOfOwner(address owner) external view returns (uint256[] memory) {
unchecked {
uint256 tokenIdsIdx;
address currOwnershipAddr;
uint256 tokenIdsLength = balanceOf(owner);
uint256[] memory tokenIds = new uint256[](tokenIdsLength);
TokenOwnership memory ownership;
for (uint256 i = _startTokenId(); tokenIdsIdx != tokenIdsLength; ++i) {
ownership = _ownerships[i];
if (ownership.burned) {
continue;
}
if (ownership.addr != address(0)) {
currOwnershipAddr = ownership.addr;
}
if (currOwnershipAddr == owner) {
tokenIds[tokenIdsIdx++] = i;
}
}
return tokenIds;
}
}
function isOwnerOfTokens(address owner, uint256[] calldata tokenIds) external view returns (bool) {
uint256 tokenIdsLength = tokenIds.length;
if (tokenIdsLength == 0) {
return false;
}
uint256 tokenId = tokenIds[0];
if (_ownershipOf(tokenId).addr != owner) {
return false;
}
unchecked {
for (uint256 i=1; i<tokenIdsLength; ++i) {
uint256 nextTokenId = tokenId+1;
tokenId = tokenIds[i];
if (tokenId == nextTokenId && _ownerships[nextTokenId].addr == address(0)) {
if (tokenId >= _currentIndex) {
return false;
}
continue;
}
if (_ownershipOf(tokenId).addr != owner) {
return false;
}
}
}
return true;
}
}
文件 11 的 30：IERC165.sol
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 12 的 30：IERC20.sol
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
文件 13 的 30：IERC20Metadata.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 14 的 30：IERC721.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
文件 15 的 30：IERC721Metadata.sol
pragma solidity ^0.8.0;
import "../IERC721.sol";
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
文件 16 的 30：IERC721Receiver.sol
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
文件 17 的 30：IMetroBlockInfo.sol
pragma solidity ^0.8.4;
import "./IMetroBlockScores.sol";
interface IMetroBlockInfo is IMetroBlockScores {
function getBlockInfo(uint256 tokenId) external view returns (uint256 info);
function getHoodBoost(uint256[] calldata tokenIds) external view returns (uint256 score);
}
文件 18 的 30：IMetroBlockScores.sol
pragma solidity ^0.8.4;
interface IMetroBlockScores {
function getBlockScore(uint256 tokenId) external view returns (uint256 score);
}
文件 19 的 30：IMetroNFTLookup.sol
pragma solidity 0.8.12;
interface IMetroNFTLookup {
function getNFTContractAddress(uint256 tokenId) external view returns (address);
}
文件 20 的 30：IMetroVaultStorage.sol
import "../structs/MetroVaultStorageStructs.sol";
import "../../../nfts/interfaces/IMetroNFTLookup.sol";
pragma solidity 0.8.12;
interface IMetroVaultStorage is IMetroNFTLookup {
function getStake(uint256 tokenId) external view returns (Stake memory);
function getAccount(address owner) external view returns (Account memory);
function setStake(uint256 tokenId, Stake calldata newStake) external;
function setStakeTimestamp(uint256[] calldata tokenIds, uint40 timestamp) external;
function setStakeCity(uint256[] calldata tokenIds, uint16 cityId, bool resetTimestamp) external;
function setStakeExtra(uint256[] calldata tokenIds, uint40 extra, bool resetTimestamp) external;
function setStakeOwner(uint256[] calldata tokenIds, address owner, bool resetTimestamp) external;
function changeStakeOwner(uint256 tokenId, address newOwner, bool resetTimestamp) external;
function setAccountsExtra(address[] calldata owners, uint232[] calldata extras) external;
function setAccountExtra(address owner, uint232 extra) external;
function deleteStake(uint256[] calldata tokenIds) external;
function stakeBlocks(address owner, uint256[] calldata tokenIds, uint16 cityId, uint40 extra) external;
function stakeFromMint(address owner, uint256[] calldata tokenIds, uint16 cityId, uint40 extra) external;
function unstakeBlocks(address owner, uint256[] calldata tokenIds) external;
function unstakeBlocksTo(address owner, address to, uint256[] calldata tokenIds) external;
function tokensOfOwner(address account, uint256 start, uint256 stop) external view returns (uint256[] memory);
function stakeBlocks(
address owner,
uint256[] calldata tokenIds,
uint16[] calldata cityIds,
uint40[] calldata extras,
uint40[] calldata timestamps
) external;
}
文件 21 的 30：Initializable.sol
pragma solidity ^0.8.0;
contract Initializable {
bool inited = false;
modifier initializer() {
require(!inited, "already inited");
_;
inited = true;
}
}
文件 22 的 30：MetToken.sol
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
contract MetToken is ERC20, ERC20Burnable, Ownable {
mapping(address => bool) controllers;
constructor() ERC20("Metroverse", "MET") { }
function mint(address to, uint256 amount) external {
require(controllers[msg.sender], "Only controllers can mint");
_mint(to, amount);
}
function burnFrom(address account, uint256 amount) public override {
if (controllers[msg.sender]) {
_burn(account, amount);
}
else {
super.burnFrom(account, amount);
}
}
function addController(address controller) external onlyOwner {
controllers[controller] = true;
}
function removeController(address controller) external onlyOwner {
controllers[controller] = false;
}
}
文件 23 的 30：MetroMiniBlock.sol
pragma solidity 0.8.12;
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../../lib/enumerable/ERC721AMultiMint.sol";
import "../../lib/Controllable.sol";
import "../../opensea/ContextMixin.sol";
import "../../opensea/NativeMetaTransaction.sol";
import "../../vault/v2/interfaces/IMetroVaultStorage.sol";
import "../../vault/v2/MetroVaultDoor.sol";
import "../../MetToken.sol";
contract MetroMiniBlock is Controllable, ERC721AMultiMint, IMetroBlockInfo {
uint256 public constant MIN_MET_BLOCKS = 20_000;
uint256 public constant MAX_ETH_BLOCKS = 20_000;
uint256 public constant MAX_TRADE_BLOCKS = 10_000;
uint256 public constant MAX_BLOCKS = MIN_MET_BLOCKS + MAX_ETH_BLOCKS + MAX_TRADE_BLOCKS;
uint256 public constant BLOCK_ID_OFFSET = 20_000;
uint256 public constant BLOCKS_PER_TRADE = 10;
uint256 private constant MAX_GENESIS_BLOCK_ID = 10_000;
uint256 public constant MAX_BLOCKS_PER_WHITELIST = 2;
uint256 public constant MAX_BLOCKS_PER_MINT = 100;
uint256 public constant CEIL_MET_PRICE = 10_000 ether;
uint256 public constant FLOOR_MET_PRICE = 4_000 ether;
uint256 private constant MET_PRICE_MAX_DELTA = CEIL_MET_PRICE - FLOOR_MET_PRICE;
uint256 public constant PRICE_STEP = 50 ether;
uint256 public constant PRICE_PERIOD = 10 minutes;
uint32 public metMinted;
uint32 public ethMinted;
uint32 public tradeMinted;
uint32 public auctionStartTimestamp;
bool public metSaleActive = false;
bool public ethSaleActive = false;
bool public tradeSaleActive = false;
uint128 public ethPrice = 0.1 ether;
string public baseTokenURI = "ipfs://QmZGfurTKSkKp3DycpKV1AhnDtcSRtDyUZtRZnUwGQ9Ynr/";
address immutable public metTokenAddress;
address immutable public vaultStorageAddress;
address public blockInfoAddress;
address public proxyRegistryAddress;
address public signerAddress;
address public genesisLockerAddress;
address immutable public metroPassAddress;
constructor(
address _metTokenAddress,
address _vaultStorageAddress,
address _proxyRegistryAddress,
address _signerAddress,
address _genesisLockerAddress,
address _metroPassAddress) ERC721AMultiMint("Metroverse Mini City Block", "METROMINIBLOCK")
{
metTokenAddress = _metTokenAddress;
vaultStorageAddress = _vaultStorageAddress;
proxyRegistryAddress = _proxyRegistryAddress;
signerAddress = _signerAddress;
genesisLockerAddress = _genesisLockerAddress;
metroPassAddress = _metroPassAddress;
}
function setBlockInfoAddress(address _blockInfoAddress) external onlyOwner {
blockInfoAddress = _blockInfoAddress;
}
function setProxyRegistryAddress(address _proxyRegistryAddress) external onlyOwner {
proxyRegistryAddress = _proxyRegistryAddress;
}
function setSignerAddress(address _signerAddress) external onlyOwner {
signerAddress = _signerAddress;
}
function setGenesisLockerAddress(address _genesisLockerAddress) external onlyOwner {
genesisLockerAddress = _genesisLockerAddress;
}
function setEthPrice(uint128 price) public onlyOwner {
ethPrice = price;
}
function startMetSale() public onlyOwner {
metSaleActive = true;
auctionStartTimestamp = uint32(block.timestamp);
}
function stopMetSale() public onlyOwner {
metSaleActive = false;
}
function resumeMetSale() public onlyOwner {
metSaleActive = true;
}
function startEthSale() public onlyOwner {
ethSaleActive = true;
}
function stopEthSale() public onlyOwner {
ethSaleActive = false;
}
function startTradeSale() public onlyOwner {
tradeSaleActive = true;
}
function stopTradeSale() public onlyOwner {
tradeSaleActive = false;
}
function setBaseURI(string calldata URI) public onlyOwner {
baseTokenURI = URI;
}
function _baseURI() internal view virtual override returns (string memory) {
return baseTokenURI;
}
function getBlockScore(uint256 tokenId) external view returns (uint256 score) {
if (blockInfoAddress == address(0x0)) {
return 0;
}
return IMetroBlockInfo(blockInfoAddress).getBlockScore(tokenId);
}
function getBlockInfo(uint256 tokenId) external view returns (uint256 info) {
if (blockInfoAddress == address(0x0)) {
return 0;
}
return IMetroBlockInfo(blockInfoAddress).getBlockInfo(tokenId);
}
function getHoodBoost(uint256[] calldata tokenIds) external view returns (uint256 score) {
if (blockInfoAddress == address(0x0)) {
return 0;
}
return IMetroBlockInfo(blockInfoAddress).getHoodBoost(tokenIds);
}
function getAux(address owner) public view returns (uint176) {
return _getAux(owner);
}
function setAux(address owner, uint176 extra) public onlyController {
_setAux(owner, extra);
}
function numberWhitelistMinted(address owner) public view returns (uint8) {
return _numberWhitelistMinted(owner);
}
function timestampOf(uint256 tokenId) public view returns (uint64) {
return _ownershipOf(tokenId).startTimestamp;
}
function setTimestampOf(uint256 tokenId, uint64 timestamp) public onlyController returns (uint64) {
return _setTimestampOf(tokenId, timestamp);
}
function setTimestampsOf(address owner, uint256[] calldata tokenIds, uint64 timestamp) external onlyController returns (uint64[] memory) {
return _setTimestampsOf(owner, tokenIds, timestamp);
}
function _startTokenId() internal view override virtual returns (uint256) {
return BLOCK_ID_OFFSET + 1;
}
function totalMinted() public view virtual returns (uint256 supply)
{
return _totalMinted();
}
function currentMetPrice() public view returns (uint256) {
if (auctionStartTimestamp == 0) {
return CEIL_MET_PRICE;
}
uint256 passedPeriods = (block.timestamp - auctionStartTimestamp) / PRICE_PERIOD;
uint256 priceChange = PRICE_STEP * passedPeriods;
if (priceChange < MET_PRICE_MAX_DELTA) {
return CEIL_MET_PRICE - priceChange;
} else {
return FLOOR_MET_PRICE;
}
}
function withdraw() external onlyOwner {
payable(owner()).transfer(address(this).balance);
}
function metMint(uint256 amount) public {
require(metSaleActive, "MET sale is not active");
require(amount > 0, "Cannot mint zero blocks");
require(amount <= MAX_BLOCKS_PER_MINT, "Cannot mint that many blocks");
metMinted += uint32(amount);
require(totalMinted() + amount <= MAX_BLOCKS, "Exceeded max MET block count");
uint256 currentPrice = currentMetPrice();
MetToken metToken = MetToken(metTokenAddress);
metToken.burnFrom(msg.sender, currentPrice * amount);
_mintBlocks(amount);
}
function ethMint(bytes32 signatureR, bytes32 signatureVS, uint256 amount) public payable {
require(ethSaleActive, "ETH sale is not active");
require(signerAddress != address(0x0), "Signer address is not set");
require(amount > 0, "Cannot mint zero blocks");
require(amount <= MAX_BLOCKS_PER_MINT, "Cannot mint that many blocks");
ethMinted += uint32(amount);
require(ethMinted <= MAX_ETH_BLOCKS, "Exceeded max ETH block count");
require(totalMinted() + amount <= MAX_BLOCKS, "Exceeded max ETH block count");
bytes32 addressHash = keccak256(abi.encodePacked(msg.sender));
address signer = verifyHash(addressHash, signatureR, signatureVS);
require(signer == signerAddress, "Not whitelisted");
uint256 whitelistTotal = numberWhitelistMinted(msg.sender) + amount;
require(whitelistTotal <= MAX_BLOCKS_PER_WHITELIST, "Already minted");
require(msg.value == ethPrice * amount, "Wrong amount of ETH");
_setNumberWhitelistMinted(msg.sender, uint8(whitelistTotal));
_mintBlocks(amount);
}
function tradeMint(uint256[] calldata stakedTokenIds, uint256[] calldata unstakedTokenIds) public {
require(tradeSaleActive, "Trade sale is not active");
require(genesisLockerAddress != address(0), "No genesis locker available");
require(vaultStorageAddress != address(0), "No vault storage available");
uint256 amount = (stakedTokenIds.length + unstakedTokenIds.length) * BLOCKS_PER_TRADE;
require(amount > 0, "Cannot mint zero blocks");
require(amount <= MAX_BLOCKS_PER_MINT, "Cannot mint that many blocks");
tradeMinted += uint32(amount);
require(tradeMinted <= MAX_TRADE_BLOCKS, "Exceeded max trade block count");
require(totalMinted() + amount <= MAX_BLOCKS, "Exceeded max trade block count");
IERC721 metroPass = IERC721(metroPassAddress);
require(metroPass.balanceOf(msg.sender) > 0, "Only MetroPass holders are eligible");
IMetroVaultStorage vaultStorage = IMetroVaultStorage(vaultStorageAddress);
if (stakedTokenIds.length > 0) {
unchecked {
uint256 prevTokenId;
for (uint256 i = 0; i < stakedTokenIds.length; ++i) {
uint256 tokenId = stakedTokenIds[i];
require(prevTokenId < tokenId, 'no duplicates allowed');
prevTokenId = tokenId;
require(tokenId <= MAX_GENESIS_BLOCK_ID, "Only genesis blocks allowed");
Stake memory staked = vaultStorage.getStake(tokenId);
require(staked.owner == msg.sender, "not an owner");
}
}
vaultStorage.setStakeOwner(stakedTokenIds, genesisLockerAddress, true);
}
if (unstakedTokenIds.length > 0) {
unchecked {
for (uint256 i = 0; i < unstakedTokenIds.length; ++i) {
require(unstakedTokenIds[i] <= MAX_GENESIS_BLOCK_ID, "Only genesis blocks allowed");
}
}
vaultStorage.stakeBlocks(msg.sender, unstakedTokenIds, 0, 0);
vaultStorage.setStakeOwner(unstakedTokenIds, genesisLockerAddress, false);
}
_mintBlocks(amount);
}
function _mintBlocks(uint256 amount) internal {
_mint(msg.sender, amount, '', false);
}
function burn(uint256[] calldata tokenIds) public onlyController {
for (uint256 i = 0; i < tokenIds.length; i++) {
_burn(tokenIds[i]);
}
}
function verifyHash(bytes32 hash, bytes32 signatureR, bytes32 signatureVS) public pure
returns (address signer)
{
bytes32 messageDigest = ECDSA.toEthSignedMessageHash(hash);
return ECDSA.recover(messageDigest, signatureR, signatureVS);
}
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
if (proxyRegistryAddress != address(0x0)) {
ProxyRegistry proxyRegistry = ProxyRegistry(proxyRegistryAddress);
if (address(proxyRegistry.proxies(owner)) == operator) {
return true;
}
}
return isController(operator) || super.isApprovedForAll(owner, operator);
}
}
文件 24 的 30：MetroMiniBlockClaim.sol
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "../../nfts/interfaces/IMetroBlockInfo.sol";
import "../../nfts/mini-blocks/MetroMiniBlock.sol";
import "../../MetToken.sol";
contract MetroMiniBlockClaim is Ownable {
address immutable public tokenAddress;
address immutable public miniBlockAddress;
address public blockInfoAddress;
bool claimDisabled;
event Claimed(address indexed owner, uint256 amount);
constructor(address _tokenAddress, address _miniBlockAddress) {
tokenAddress = _tokenAddress;
miniBlockAddress = _miniBlockAddress;
}
function setBlockInfoAddress(address _blockInfoAddress) public onlyOwner {
blockInfoAddress = _blockInfoAddress;
}
function enableClaim() external onlyOwner {
claimDisabled = false;
}
function disableClaim() external onlyOwner {
claimDisabled = true;
}
function claim(uint256[] calldata tokenIds) external {
require(!claimDisabled, 'Claim is disabled');
_claim(_msgSender(), tokenIds);
}
function claimForAddress(address account, uint256[] calldata tokenIds) external {
require(!claimDisabled, 'Claim is disabled');
_claim(account, tokenIds);
}
function _claim(address account, uint256[] calldata tokenIds) internal {
uint256 earned = 0;
if (blockInfoAddress == address(0x0)) {
return;
}
MetroMiniBlock miniBlock = MetroMiniBlock(miniBlockAddress);
IMetroBlockInfo blockInfoContract = IMetroBlockInfo(blockInfoAddress);
uint64[] memory previousTimestamps = miniBlock.setTimestampsOf(account, tokenIds, uint64(block.timestamp));
for (uint256 i; i < tokenIds.length; ++i) {
uint256 score = blockInfoContract.getBlockScore(tokenIds[i]);
earned += 1 ether * score * (block.timestamp - previousTimestamps[i]) / 1 days;
}
if (earned > 0) {
uint256 boost = blockInfoContract.getHoodBoost(tokenIds);
earned = boost * earned / 10000;
MetToken(tokenAddress).mint(account, earned);
}
emit Claimed(account, earned);
}
function earningInfo(uint256[] calldata tokenIds) external view returns (EarningInfo memory) {
uint256 totalScore;
uint256 earned;
uint256 prevTokenId;
MetroMiniBlock miniBlock = MetroMiniBlock(miniBlockAddress);
IMetroBlockInfo blockInfoContract = IMetroBlockInfo(blockInfoAddress);
for (uint256 i; i < tokenIds.length; ++i) {
uint256 tokenId = tokenIds[i];
require(prevTokenId < tokenId, 'no duplicates allowed');
prevTokenId = tokenId;
uint256 score = blockInfoContract.getBlockScore(tokenId);
totalScore += score;
uint256 timestamp = miniBlock.timestampOf(tokenId);
earned += 1 ether * score * (block.timestamp - timestamp) / 1 days;
}
uint256 boost = blockInfoContract.getHoodBoost(tokenIds);
earned = boost * earned / 10000;
uint256 earnRatePerSecond = totalScore * 1 ether / 1 days;
earnRatePerSecond = boost * earnRatePerSecond / 10000;
return EarningInfo(earned, earnRatePerSecond);
}
function tokensOfOwner(address account) public view returns (uint256[] memory) {
return MetroMiniBlock(miniBlockAddress).tokensOfOwner(account);
}
function tokensOfOwnerIn(address account, uint256 start, uint256 stop) public view returns (uint256[] memory) {
return MetroMiniBlock(miniBlockAddress).tokensOfOwnerIn(account, start, stop);
}
}
文件 25 的 30：MetroVaultDoor.sol
pragma solidity 0.8.12;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interfaces/IMetroVaultStorage.sol";
import "../../nfts/interfaces/IMetroBlockInfo.sol";
import "../../MetToken.sol";
struct EarningInfo {
uint256 earned;
uint256 earnRatePerSecond;
}
contract MetroVaultDoor is Ownable {
uint256 public maxTokenCount = 20_000;
address public tokenAddress;
address public vaultAddress;
address public blockInfoAddress;
bool claimDisabled;
bool stakeDisabled;
event Claimed(address indexed owner, uint256 amount);
constructor(address _tokenAddress, address _vaultAddress) {
tokenAddress = _tokenAddress;
vaultAddress = _vaultAddress;
}
function setMaxTokenCount(uint256 _maxTokenCount) external onlyOwner {
maxTokenCount = _maxTokenCount;
}
function setBlockInfoAddress(address _blockInfoAddress) public onlyOwner {
blockInfoAddress = _blockInfoAddress;
}
function enableClaim() external onlyOwner {
claimDisabled = false;
}
function disableClaim() external onlyOwner {
claimDisabled = true;
}
function enableStake() external onlyOwner {
stakeDisabled = false;
}
function disableStake() external onlyOwner {
stakeDisabled = true;
}
function stake(uint256[] calldata tokenIds) external {
require(!stakeDisabled, 'Staking is disabled');
IMetroVaultStorage vault = IMetroVaultStorage(vaultAddress);
vault.stakeBlocks(_msgSender(), tokenIds, 0, 0);
}
function unstake(uint256[] calldata tokenIds, uint256[] calldata claimTokenIds) external {
if (!claimDisabled && claimTokenIds.length > 0) {
_claim(_msgSender(), claimTokenIds);
}
IMetroVaultStorage vault = IMetroVaultStorage(vaultAddress);
vault.unstakeBlocks(_msgSender(), tokenIds);
}
function claim(uint256[] calldata tokenIds) external {
require(!claimDisabled, 'Claim is disabled');
_claim(_msgSender(), tokenIds);
}
function claimForAddress(address account, uint256[] calldata tokenIds) external {
require(!claimDisabled, 'Claim is disabled');
_claim(account, tokenIds);
}
function _claim(address account, uint256[] calldata tokenIds) internal {
uint256 earned = 0;
if (blockInfoAddress == address(0x0)) {
return;
}
uint256 prevTokenId;
IMetroVaultStorage vault = IMetroVaultStorage(vaultAddress);
IMetroBlockInfo blockInfoContract = IMetroBlockInfo(blockInfoAddress);
for (uint i = 0; i < tokenIds.length; i++) {
uint256 tokenId = tokenIds[i];
require(prevTokenId < tokenId, 'no duplicates allowed');
prevTokenId = tokenId;
uint256 score = blockInfoContract.getBlockScore(tokenId);
Stake memory staked = vault.getStake(tokenId);
require(staked.owner == account, "not an owner");
earned += 1 ether * score * (block.timestamp - staked.timestamp) / 1 days;
}
vault.setStakeTimestamp(tokenIds, uint40(block.timestamp));
if (earned > 0) {
uint256 boost = blockInfoContract.getHoodBoost(tokenIds);
earned = boost * earned / 10000;
MetToken(tokenAddress).mint(account, earned);
}
emit Claimed(account, earned);
}
function earningInfo(uint256[] calldata tokenIds) external view returns (EarningInfo memory) {
uint256 totalScore = 0;
uint256 earned = 0;
IMetroVaultStorage vault = IMetroVaultStorage(vaultAddress);
IMetroBlockInfo blockInfoContract = IMetroBlockInfo(blockInfoAddress);
for (uint i = 0; i < tokenIds.length; i++) {
uint256 tokenId = tokenIds[i];
uint256 score = blockInfoContract.getBlockScore(tokenId);
totalScore += score;
Stake memory staked = vault.getStake(tokenId);
earned += 1 ether * score * (block.timestamp - staked.timestamp) / 1 days;
}
uint256 boost = blockInfoContract.getHoodBoost(tokenIds);
earned = boost * earned / 10000;
uint256 earnRatePerSecond = totalScore * 1 ether / 1 days;
earnRatePerSecond = boost * earnRatePerSecond / 10000;
return EarningInfo(earned, earnRatePerSecond);
}
function tokensOfOwner(address account) public view returns (uint256[] memory) {
return IMetroVaultStorage(vaultAddress).tokensOfOwner(account, 0, maxTokenCount);
}
function tokensOfOwnerCustom(address account, uint256 start, uint256 stop) public view returns (uint256[] memory) {
return IMetroVaultStorage(vaultAddress).tokensOfOwner(account, start, stop);
}
}
文件 26 的 30：MetroVaultStorageStructs.sol
pragma solidity 0.8.12;
struct Stake {
address owner;
uint40 timestamp;
uint16 cityId;
uint40 extra;
}
struct Account {
uint24 balance;
uint232 extra;
}
文件 27 的 30：NativeMetaTransaction.sol
pragma solidity ^0.8.0;
import {SafeMath} from "@openzeppelin/contracts/utils/math/SafeMath.sol";
import {EIP712Base} from "./EIP712Base.sol";
contract NativeMetaTransaction is EIP712Base {
using SafeMath for uint256;
bytes32 private constant META_TRANSACTION_TYPEHASH =
keccak256(
bytes(
"MetaTransaction(uint256 nonce,address from,bytes functionSignature)"
)
);
event MetaTransactionExecuted(
address userAddress,
address payable relayerAddress,
bytes functionSignature
);
mapping(address => uint256) nonces;
struct MetaTransaction {
uint256 nonce;
address from;
bytes functionSignature;
}
function executeMetaTransaction(
address userAddress,
bytes memory functionSignature,
bytes32 sigR,
bytes32 sigS,
uint8 sigV
) public payable returns (bytes memory) {
MetaTransaction memory metaTx = MetaTransaction({
nonce: nonces[userAddress],
from: userAddress,
functionSignature: functionSignature
});
require(
verify(userAddress, metaTx, sigR, sigS, sigV),
"Signer and signature do not match"
);
nonces[userAddress] = nonces[userAddress].add(1);
emit MetaTransactionExecuted(
userAddress,
payable(msg.sender),
functionSignature
);
(bool success, bytes memory returnData) = address(this).call(
abi.encodePacked(functionSignature, userAddress)
);
require(success, "Function call not successful");
return returnData;
}
function hashMetaTransaction(MetaTransaction memory metaTx)
internal
pure
returns (bytes32)
{
return
keccak256(
abi.encode(
META_TRANSACTION_TYPEHASH,
metaTx.nonce,
metaTx.from,
keccak256(metaTx.functionSignature)
)
);
}
function getNonce(address user) public view returns (uint256 nonce) {
nonce = nonces[user];
}
function verify(
address signer,
MetaTransaction memory metaTx,
bytes32 sigR,
bytes32 sigS,
uint8 sigV
) internal view returns (bool) {
require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER");
return
signer ==
ecrecover(
toTypedMessageHash(hashMetaTransaction(metaTx)),
sigV,
sigR,
sigS
);
}
}
文件 28 的 30：Ownable.sol
pragma solidity ^0.8.0;
import "../utils/Context.sol";
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
文件 29 的 30：SafeMath.sol
pragma solidity ^0.8.0;
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;
}
}
}
文件 30 的 30：Strings.sol
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
{
"compilationTarget": {
"contracts/nfts/mini-blocks/MetroMiniBlockClaim.sol": "MetroMiniBlockClaim"
},
"evmVersion": "london",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 2000
},
"remappings": []
}[{"inputs":[{"internalType":"address","name":"_tokenAddress","type":"address"},{"internalType":"address","name":"_miniBlockAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","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":"blockInfoAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"claimForAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"disableClaim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"earningInfo","outputs":[{"components":[{"internalType":"uint256","name":"earned","type":"uint256"},{"internalType":"uint256","name":"earnRatePerSecond","type":"uint256"}],"internalType":"struct EarningInfo","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"enableClaim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"miniBlockAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_blockInfoAddress","type":"address"}],"name":"setBlockInfoAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tokenAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"stop","type":"uint256"}],"name":"tokensOfOwnerIn","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]
