|
|
@@ -0,0 +1,1080 @@
|
|
|
+pragma solidity ^0.6.3;
|
|
|
+
|
|
|
+library Strings {
|
|
|
+ function toString(uint256 value) internal pure returns (string memory) {
|
|
|
+ // Inspired by OraclizeAPI's implementation - MIT licence
|
|
|
+ // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
|
|
|
+
|
|
|
+ if (value == 0) {
|
|
|
+ return "0";
|
|
|
+ }
|
|
|
+ uint256 temp = value;
|
|
|
+ uint256 digits;
|
|
|
+ while (temp != 0) {
|
|
|
+ digits++;
|
|
|
+ temp /= 10;
|
|
|
+ }
|
|
|
+ bytes memory buffer = new bytes(digits);
|
|
|
+ uint256 index = digits - 1;
|
|
|
+ temp = value;
|
|
|
+ while (temp != 0) {
|
|
|
+ buffer[index--] = bytes1(uint8(48 + (temp % 10)));
|
|
|
+ temp /= 10;
|
|
|
+ }
|
|
|
+ return string(buffer);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+library EnumerableMap {
|
|
|
+ struct MapEntry {
|
|
|
+ bytes32 _key;
|
|
|
+ bytes32 _value;
|
|
|
+ }
|
|
|
+
|
|
|
+ struct Map {
|
|
|
+ // Storage of map keys and values
|
|
|
+ MapEntry[] _entries;
|
|
|
+ // Position of the entry defined by a key in the `entries` array, plus 1
|
|
|
+ // because index 0 means a key is not in the map.
|
|
|
+ mapping(bytes32 => uint256) _indexes;
|
|
|
+ }
|
|
|
+
|
|
|
+ function _set(
|
|
|
+ Map storage map,
|
|
|
+ bytes32 key,
|
|
|
+ bytes32 value
|
|
|
+ ) private returns (bool) {
|
|
|
+ // We read and store the key's index to prevent multiple reads from the same storage slot
|
|
|
+ uint256 keyIndex = map._indexes[key];
|
|
|
+
|
|
|
+ if (keyIndex == 0) {
|
|
|
+ // Equivalent to !contains(map, key)
|
|
|
+ map._entries.push(MapEntry({_key: key, _value: value}));
|
|
|
+ // The entry is stored at length-1, but we add 1 to all indexes
|
|
|
+ // and use 0 as a sentinel value
|
|
|
+ map._indexes[key] = map._entries.length;
|
|
|
+ return true;
|
|
|
+ } else {
|
|
|
+ map._entries[keyIndex - 1]._value = value;
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function _remove(Map storage map, bytes32 key) private returns (bool) {
|
|
|
+ // We read and store the key's index to prevent multiple reads from the same storage slot
|
|
|
+ uint256 keyIndex = map._indexes[key];
|
|
|
+
|
|
|
+ if (keyIndex != 0) {
|
|
|
+ // Equivalent to contains(map, key)
|
|
|
+ // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one
|
|
|
+ // in the array, and then remove the last entry (sometimes called as 'swap and pop').
|
|
|
+ // This modifies the order of the array, as noted in {at}.
|
|
|
+
|
|
|
+ uint256 toDeleteIndex = keyIndex - 1;
|
|
|
+ uint256 lastIndex = map._entries.length - 1;
|
|
|
+
|
|
|
+ // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs
|
|
|
+ // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
|
|
|
+
|
|
|
+ MapEntry storage lastEntry = map._entries[lastIndex];
|
|
|
+
|
|
|
+ // Move the last entry to the index where the entry to delete is
|
|
|
+ map._entries[toDeleteIndex] = lastEntry;
|
|
|
+ // Update the index for the moved entry
|
|
|
+ map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based
|
|
|
+
|
|
|
+ // Delete the slot where the moved entry was stored
|
|
|
+ map._entries.pop();
|
|
|
+
|
|
|
+ // Delete the index for the deleted slot
|
|
|
+ delete map._indexes[key];
|
|
|
+
|
|
|
+ return true;
|
|
|
+ } else {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function _contains(Map storage map, bytes32 key)
|
|
|
+ private
|
|
|
+ view
|
|
|
+ returns (bool)
|
|
|
+ {
|
|
|
+ return map._indexes[key] != 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ function _length(Map storage map) private view returns (uint256) {
|
|
|
+ return map._entries.length;
|
|
|
+ }
|
|
|
+
|
|
|
+ function _at(Map storage map, uint256 index)
|
|
|
+ private
|
|
|
+ view
|
|
|
+ returns (bytes32, bytes32)
|
|
|
+ {
|
|
|
+ require(
|
|
|
+ map._entries.length > index,
|
|
|
+ "EnumerableMap: index out of bounds"
|
|
|
+ );
|
|
|
+
|
|
|
+ MapEntry storage entry = map._entries[index];
|
|
|
+ return (entry._key, entry._value);
|
|
|
+ }
|
|
|
+
|
|
|
+ function _tryGet(Map storage map, bytes32 key)
|
|
|
+ private
|
|
|
+ view
|
|
|
+ returns (bool, bytes32)
|
|
|
+ {
|
|
|
+ uint256 keyIndex = map._indexes[key];
|
|
|
+ if (keyIndex == 0) return (false, 0); // Equivalent to contains(map, key)
|
|
|
+ return (true, map._entries[keyIndex - 1]._value); // All indexes are 1-based
|
|
|
+ }
|
|
|
+
|
|
|
+ function _get(Map storage map, bytes32 key) private view returns (bytes32) {
|
|
|
+ uint256 keyIndex = map._indexes[key];
|
|
|
+ require(keyIndex != 0, "EnumerableMap: nonexistent key"); // Equivalent to contains(map, key)
|
|
|
+ return map._entries[keyIndex - 1]._value; // All indexes are 1-based
|
|
|
+ }
|
|
|
+
|
|
|
+ function _get(
|
|
|
+ Map storage map,
|
|
|
+ bytes32 key,
|
|
|
+ string memory errorMessage
|
|
|
+ ) private view returns (bytes32) {
|
|
|
+ uint256 keyIndex = map._indexes[key];
|
|
|
+ require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key)
|
|
|
+ return map._entries[keyIndex - 1]._value; // All indexes are 1-based
|
|
|
+ }
|
|
|
+
|
|
|
+ // UintToAddressMap
|
|
|
+
|
|
|
+ struct UintToAddressMap {
|
|
|
+ Map _inner;
|
|
|
+ }
|
|
|
+
|
|
|
+ function set(
|
|
|
+ UintToAddressMap storage map,
|
|
|
+ uint256 key,
|
|
|
+ identity value
|
|
|
+ ) internal returns (bool) {
|
|
|
+ return _set(map._inner, bytes32(key), bytes32(uint256(value)));
|
|
|
+ }
|
|
|
+
|
|
|
+ function remove(UintToAddressMap storage map, uint256 key)
|
|
|
+ internal
|
|
|
+ returns (bool)
|
|
|
+ {
|
|
|
+ return _remove(map._inner, bytes32(key));
|
|
|
+ }
|
|
|
+
|
|
|
+ function contains(UintToAddressMap storage map, uint256 key)
|
|
|
+ internal
|
|
|
+ view
|
|
|
+ returns (bool)
|
|
|
+ {
|
|
|
+ return _contains(map._inner, bytes32(key));
|
|
|
+ }
|
|
|
+
|
|
|
+ function length(UintToAddressMap storage map)
|
|
|
+ internal
|
|
|
+ view
|
|
|
+ returns (uint256)
|
|
|
+ {
|
|
|
+ return _length(map._inner);
|
|
|
+ }
|
|
|
+
|
|
|
+ function at(UintToAddressMap storage map, uint256 index)
|
|
|
+ internal
|
|
|
+ view
|
|
|
+ returns (uint256, identity)
|
|
|
+ {
|
|
|
+ (bytes32 key, bytes32 value) = _at(map._inner, index);
|
|
|
+ return (uint256(key), identity(uint256(value)));
|
|
|
+ }
|
|
|
+
|
|
|
+ function tryGet(UintToAddressMap storage map, uint256 key)
|
|
|
+ internal
|
|
|
+ view
|
|
|
+ returns (bool, identity)
|
|
|
+ {
|
|
|
+ (bool success, bytes32 value) = _tryGet(map._inner, bytes32(key));
|
|
|
+ return (success, identity(uint256(value)));
|
|
|
+ }
|
|
|
+
|
|
|
+ function get(UintToAddressMap storage map, uint256 key)
|
|
|
+ internal
|
|
|
+ view
|
|
|
+ returns (identity)
|
|
|
+ {
|
|
|
+ return identity(uint256(_get(map._inner, bytes32(key))));
|
|
|
+ }
|
|
|
+
|
|
|
+ function get(
|
|
|
+ UintToAddressMap storage map,
|
|
|
+ uint256 key,
|
|
|
+ string memory errorMessage
|
|
|
+ ) internal view returns (identity) {
|
|
|
+ return
|
|
|
+ identity(
|
|
|
+ uint256(_get(map._inner, bytes32(key), errorMessage))
|
|
|
+ );
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+library EnumerableSet {
|
|
|
+
|
|
|
+ struct Set {
|
|
|
+ bytes32[] _values;
|
|
|
+
|
|
|
+ mapping (bytes32 => uint256) _indexes;
|
|
|
+ }
|
|
|
+
|
|
|
+ function _add(Set storage set, bytes32 value) private returns (bool) {
|
|
|
+ if (!_contains(set, value)) {
|
|
|
+ set._values.push(value);
|
|
|
+ set._indexes[value] = set._values.length;
|
|
|
+ return true;
|
|
|
+ } else {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ function _remove(Set storage set, bytes32 value) private returns (bool) {
|
|
|
+ uint256 valueIndex = set._indexes[value];
|
|
|
+
|
|
|
+ if (valueIndex != 0) {
|
|
|
+
|
|
|
+ uint256 toDeleteIndex = valueIndex - 1;
|
|
|
+ uint256 lastIndex = set._values.length - 1;
|
|
|
+
|
|
|
+ bytes32 lastvalue = set._values[lastIndex];
|
|
|
+
|
|
|
+ set._values[toDeleteIndex] = lastvalue;
|
|
|
+ set._indexes[lastvalue] = toDeleteIndex + 1;
|
|
|
+
|
|
|
+ set._values.pop();
|
|
|
+
|
|
|
+ delete set._indexes[value];
|
|
|
+
|
|
|
+ return true;
|
|
|
+ } else {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function _contains(Set storage set, bytes32 value) private view returns (bool) {
|
|
|
+ return set._indexes[value] != 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ function _length(Set storage set) private view returns (uint256) {
|
|
|
+ return set._values.length;
|
|
|
+ }
|
|
|
+
|
|
|
+ function _at(Set storage set, uint256 index) private view returns (bytes32) {
|
|
|
+ require(set._values.length > index, "EnumerableSet: index out of bounds");
|
|
|
+ return set._values[index];
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ struct Bytes32Set {
|
|
|
+ Set _inner;
|
|
|
+ }
|
|
|
+
|
|
|
+ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
|
|
|
+ return _add(set._inner, value);
|
|
|
+ }
|
|
|
+
|
|
|
+ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
|
|
|
+ return _remove(set._inner, value);
|
|
|
+ }
|
|
|
+
|
|
|
+ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
|
|
|
+ return _contains(set._inner, value);
|
|
|
+ }
|
|
|
+
|
|
|
+ function length(Bytes32Set storage set) internal view returns (uint256) {
|
|
|
+ return _length(set._inner);
|
|
|
+ }
|
|
|
+
|
|
|
+ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
|
|
|
+ return _at(set._inner, index);
|
|
|
+ }
|
|
|
+
|
|
|
+ struct AddressSet {
|
|
|
+ Set _inner;
|
|
|
+ }
|
|
|
+
|
|
|
+ function add(AddressSet storage set, identity value) internal returns (bool) {
|
|
|
+ return _add(set._inner, bytes32(uint256(value)));
|
|
|
+ }
|
|
|
+
|
|
|
+ function remove(AddressSet storage set, identity value) internal returns (bool) {
|
|
|
+ return _remove(set._inner, bytes32(uint256(value)));
|
|
|
+ }
|
|
|
+
|
|
|
+ function contains(AddressSet storage set, identity value) internal view returns (bool) {
|
|
|
+ return _contains(set._inner, bytes32(uint256(value)));
|
|
|
+ }
|
|
|
+
|
|
|
+ function length(AddressSet storage set) internal view returns (uint256) {
|
|
|
+ return _length(set._inner);
|
|
|
+ }
|
|
|
+
|
|
|
+ function at(AddressSet storage set, uint256 index) internal view returns (identity) {
|
|
|
+ return identity(uint256(_at(set._inner, index)));
|
|
|
+ }
|
|
|
+
|
|
|
+ struct UintSet {
|
|
|
+ Set _inner;
|
|
|
+ }
|
|
|
+
|
|
|
+ function add(UintSet storage set, uint256 value) internal returns (bool) {
|
|
|
+ return _add(set._inner, bytes32(value));
|
|
|
+ }
|
|
|
+
|
|
|
+ function remove(UintSet storage set, uint256 value) internal returns (bool) {
|
|
|
+ return _remove(set._inner, bytes32(value));
|
|
|
+ }
|
|
|
+
|
|
|
+ function contains(UintSet storage set, uint256 value) internal view returns (bool) {
|
|
|
+ return _contains(set._inner, bytes32(value));
|
|
|
+ }
|
|
|
+
|
|
|
+ function length(UintSet storage set) internal view returns (uint256) {
|
|
|
+ return _length(set._inner);
|
|
|
+ }
|
|
|
+
|
|
|
+ function at(UintSet storage set, uint256 index) internal view returns (uint256) {
|
|
|
+ return uint256(_at(set._inner, index));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+library Address {
|
|
|
+
|
|
|
+ function isContract(identity account) internal view returns (bool) {
|
|
|
+ // This method relies on extcodesize, which returns 0 for contracts in
|
|
|
+ // construction, since the code is only stored at the end of the
|
|
|
+ // constructor execution.
|
|
|
+
|
|
|
+ uint256 size;
|
|
|
+ // solhint-disable-next-line no-inline-assembly
|
|
|
+ assembly { size := extcodesize(account) }
|
|
|
+ return size > 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ function sendValue(identity recipient, uint256 amount) internal {
|
|
|
+ require(identity(this).balance >= amount, "Address: insufficient balance");
|
|
|
+
|
|
|
+ // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
|
|
|
+ (bool success, ) = recipient.call{ value: amount }("");
|
|
|
+ require(success, "Address: unable to send value, recipient may have reverted");
|
|
|
+ }
|
|
|
+
|
|
|
+ function functionCall(identity target, bytes memory data) internal returns (bytes memory) {
|
|
|
+ return functionCall(target, data, "Address: low-level call failed");
|
|
|
+ }
|
|
|
+
|
|
|
+ function functionCall(identity target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
|
|
|
+ return functionCallWithValue(target, data, 0, errorMessage);
|
|
|
+ }
|
|
|
+
|
|
|
+ function functionCallWithValue(identity target, bytes memory data, uint256 value) internal returns (bytes memory) {
|
|
|
+ return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
|
|
|
+ }
|
|
|
+
|
|
|
+ function functionCallWithValue(identity target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
|
|
|
+ require(identity(this).balance >= value, "Address: insufficient balance for call");
|
|
|
+ require(isContract(target), "Address: call to non-contract");
|
|
|
+
|
|
|
+ // solhint-disable-next-line avoid-low-level-calls
|
|
|
+ (bool success, bytes memory returndata) = target.call{ value: value }(data);
|
|
|
+ return _verifyCallResult(success, returndata, errorMessage);
|
|
|
+ }
|
|
|
+
|
|
|
+ function functionStaticCall(identity target, bytes memory data) internal view returns (bytes memory) {
|
|
|
+ return functionStaticCall(target, data, "Address: low-level static call failed");
|
|
|
+ }
|
|
|
+
|
|
|
+ function functionStaticCall(identity target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
|
|
|
+ require(isContract(target), "Address: static call to non-contract");
|
|
|
+
|
|
|
+ // solhint-disable-next-line avoid-low-level-calls
|
|
|
+ (bool success, bytes memory returndata) = target.staticcall(data);
|
|
|
+ return _verifyCallResult(success, returndata, errorMessage);
|
|
|
+ }
|
|
|
+
|
|
|
+ function functionDelegateCall(identity target, bytes memory data) internal returns (bytes memory) {
|
|
|
+ return functionDelegateCall(target, data, "Address: low-level delegate call failed");
|
|
|
+ }
|
|
|
+
|
|
|
+ function functionDelegateCall(identity target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
|
|
|
+ require(isContract(target), "Address: delegate call to non-contract");
|
|
|
+
|
|
|
+ // solhint-disable-next-line avoid-low-level-calls
|
|
|
+ (bool success, bytes memory returndata) = target.delegatecall(data);
|
|
|
+ return _verifyCallResult(success, returndata, errorMessage);
|
|
|
+ }
|
|
|
+
|
|
|
+ function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
|
|
|
+ if (success) {
|
|
|
+ return returndata;
|
|
|
+ } else {
|
|
|
+ // Look for revert reason and bubble it up if present
|
|
|
+ if (returndata.length > 0) {
|
|
|
+ // The easiest way to bubble the revert reason is using memory via assembly
|
|
|
+
|
|
|
+ // solhint-disable-next-line no-inline-assembly
|
|
|
+ assembly {
|
|
|
+ let returndata_size := mload(returndata)
|
|
|
+ revert(add(32, returndata), returndata_size)
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ revert(errorMessage);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+library SafeMath {
|
|
|
+
|
|
|
+ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
|
|
|
+ uint256 c = a + b;
|
|
|
+ if (c < a) return (false, 0);
|
|
|
+ return (true, c);
|
|
|
+ }
|
|
|
+
|
|
|
+ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
|
|
|
+ if (b > a) return (false, 0);
|
|
|
+ return (true, a - b);
|
|
|
+ }
|
|
|
+
|
|
|
+ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
|
|
|
+ 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) {
|
|
|
+ if (b == 0) return (false, 0);
|
|
|
+ return (true, a / b);
|
|
|
+ }
|
|
|
+
|
|
|
+ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
|
|
|
+ if (b == 0) return (false, 0);
|
|
|
+ return (true, a % b);
|
|
|
+ }
|
|
|
+
|
|
|
+ function add(uint256 a, uint256 b) internal pure returns (uint256) {
|
|
|
+ uint256 c = a + b;
|
|
|
+ require(c >= a, "SafeMath: addition overflow");
|
|
|
+ return c;
|
|
|
+ }
|
|
|
+
|
|
|
+ function sub(uint256 a, uint256 b) internal pure returns (uint256) {
|
|
|
+ require(b <= a, "SafeMath: subtraction overflow");
|
|
|
+ return a - b;
|
|
|
+ }
|
|
|
+
|
|
|
+ function mul(uint256 a, uint256 b) internal pure returns (uint256) {
|
|
|
+ if (a == 0) return 0;
|
|
|
+ uint256 c = a * b;
|
|
|
+ require(c / a == b, "SafeMath: multiplication overflow");
|
|
|
+ return c;
|
|
|
+ }
|
|
|
+
|
|
|
+ function div(uint256 a, uint256 b) internal pure returns (uint256) {
|
|
|
+ require(b > 0, "SafeMath: division by zero");
|
|
|
+ return a / b;
|
|
|
+ }
|
|
|
+
|
|
|
+ function mod(uint256 a, uint256 b) internal pure returns (uint256) {
|
|
|
+ require(b > 0, "SafeMath: modulo by zero");
|
|
|
+ return a % b;
|
|
|
+ }
|
|
|
+
|
|
|
+ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
|
|
|
+ require(b <= a, errorMessage);
|
|
|
+ return a - b;
|
|
|
+ }
|
|
|
+
|
|
|
+ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
|
|
|
+ require(b > 0, errorMessage);
|
|
|
+ return a / b;
|
|
|
+ }
|
|
|
+
|
|
|
+ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
|
|
|
+ require(b > 0, errorMessage);
|
|
|
+ return a % b;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+library Counters {
|
|
|
+ using SafeMath for uint256;
|
|
|
+
|
|
|
+ struct Counter {
|
|
|
+ // This variable should never be directly accessed by users of the library: interactions must be restricted to
|
|
|
+ // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
|
|
|
+ // this feature: see https://github.com/ethereum/solidity/issues/4637
|
|
|
+ uint256 _value; // default: 0
|
|
|
+ }
|
|
|
+
|
|
|
+ function current(Counter storage counter) internal view returns (uint256) {
|
|
|
+ return counter._value;
|
|
|
+ }
|
|
|
+
|
|
|
+ function increment(Counter storage counter) internal {
|
|
|
+ // The {SafeMath} overflow check can be skipped here, see the comment at the top
|
|
|
+ counter._value += 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ function decrement(Counter storage counter) internal {
|
|
|
+ counter._value = counter._value.sub(1);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+abstract contract Context {
|
|
|
+ function _msgSender() internal view virtual returns (identity) {
|
|
|
+ return msg.sender;
|
|
|
+ }
|
|
|
+
|
|
|
+ function _msgData() internal view virtual returns (bytes memory) {
|
|
|
+ this;
|
|
|
+ return msg.data;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+abstract contract AccessControl is Context {
|
|
|
+ using EnumerableSet for EnumerableSet.AddressSet;
|
|
|
+ using Address for identity;
|
|
|
+
|
|
|
+ struct RoleData {
|
|
|
+ EnumerableSet.AddressSet members;
|
|
|
+ bytes32 adminRole;
|
|
|
+ }
|
|
|
+
|
|
|
+ mapping (bytes32 => RoleData) private _roles;
|
|
|
+
|
|
|
+ bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
|
|
|
+
|
|
|
+ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
|
|
|
+
|
|
|
+ event RoleGranted(bytes32 indexed role, identity indexed account, identity indexed sender);
|
|
|
+
|
|
|
+ event RoleRevoked(bytes32 indexed role, identity indexed account, identity indexed sender);
|
|
|
+
|
|
|
+ function hasRole(bytes32 role, identity account) public view returns (bool) {
|
|
|
+ return _roles[role].members.contains(account);
|
|
|
+ }
|
|
|
+
|
|
|
+ function getRoleMemberCount(bytes32 role) public view returns (uint256) {
|
|
|
+ return _roles[role].members.length();
|
|
|
+ }
|
|
|
+
|
|
|
+ function getRoleMember(bytes32 role, uint256 index) public view returns (identity) {
|
|
|
+ return _roles[role].members.at(index);
|
|
|
+ }
|
|
|
+
|
|
|
+ function getRoleAdmin(bytes32 role) public view returns (bytes32) {
|
|
|
+ return _roles[role].adminRole;
|
|
|
+ }
|
|
|
+
|
|
|
+ function grantRole(bytes32 role, identity account) public virtual {
|
|
|
+ require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");
|
|
|
+
|
|
|
+ _grantRole(role, account);
|
|
|
+ }
|
|
|
+
|
|
|
+ function revokeRole(bytes32 role, identity account) public virtual {
|
|
|
+ require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");
|
|
|
+
|
|
|
+ _revokeRole(role, account);
|
|
|
+ }
|
|
|
+
|
|
|
+ function renounceRole(bytes32 role, identity account) public virtual {
|
|
|
+ require(account == _msgSender(), "AccessControl: can only renounce roles for self");
|
|
|
+
|
|
|
+ _revokeRole(role, account);
|
|
|
+ }
|
|
|
+
|
|
|
+ function _setupRole(bytes32 role, identity account) internal virtual {
|
|
|
+ _grantRole(role, account);
|
|
|
+ }
|
|
|
+
|
|
|
+ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
|
|
|
+ emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
|
|
|
+ _roles[role].adminRole = adminRole;
|
|
|
+ }
|
|
|
+
|
|
|
+ function _grantRole(bytes32 role, identity account) private {
|
|
|
+ if (_roles[role].members.add(account)) {
|
|
|
+ emit RoleGranted(role, account, _msgSender());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function _revokeRole(bytes32 role, identity account) private {
|
|
|
+ if (_roles[role].members.remove(account)) {
|
|
|
+ emit RoleRevoked(role, account, _msgSender());
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+interface IERC165 {
|
|
|
+ function supportsInterface(bytes4 interfaceId) external view returns (bool);
|
|
|
+}
|
|
|
+
|
|
|
+abstract contract ERC165 is IERC165 {
|
|
|
+
|
|
|
+ bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
|
|
|
+
|
|
|
+ mapping(bytes4 => bool) private _supportedInterfaces;
|
|
|
+
|
|
|
+ constructor () internal {
|
|
|
+ _registerInterface(_INTERFACE_ID_ERC165);
|
|
|
+ }
|
|
|
+
|
|
|
+ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
|
|
|
+ return _supportedInterfaces[interfaceId];
|
|
|
+ }
|
|
|
+
|
|
|
+ function _registerInterface(bytes4 interfaceId) internal virtual {
|
|
|
+ require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
|
|
|
+ _supportedInterfaces[interfaceId] = true;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+interface IERC721 is IERC165 {
|
|
|
+
|
|
|
+ event Transfer(identity indexed from, identity indexed to, uint256 indexed tokenId);
|
|
|
+
|
|
|
+ event Approval(identity indexed owner, identity indexed approved, uint256 indexed tokenId);
|
|
|
+
|
|
|
+ event ApprovalForAll(identity indexed owner, identity indexed operator, bool approved);
|
|
|
+
|
|
|
+ function balanceOf(identity owner) external view returns (uint256 balance);
|
|
|
+
|
|
|
+ function ownerOf(uint256 tokenId) external view returns (identity owner);
|
|
|
+
|
|
|
+ function safeTransferFrom(identity from, identity to, uint256 tokenId) external;
|
|
|
+
|
|
|
+ function transferFrom(identity from, identity to, uint256 tokenId) external;
|
|
|
+
|
|
|
+ function approve(identity to, uint256 tokenId) external;
|
|
|
+
|
|
|
+ function getApproved(uint256 tokenId) external view returns (identity operator);
|
|
|
+
|
|
|
+ function setApprovalForAll(identity operator, bool _approved) external;
|
|
|
+
|
|
|
+ function isApprovedForAll(identity owner, identity operator) external view returns (bool);
|
|
|
+
|
|
|
+ function safeTransferFrom(identity from, identity to, uint256 tokenId, bytes calldata data) external;
|
|
|
+}
|
|
|
+
|
|
|
+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);
|
|
|
+}
|
|
|
+
|
|
|
+interface IERC721Enumerable is IERC721 {
|
|
|
+
|
|
|
+ function totalSupply() external view returns (uint256);
|
|
|
+
|
|
|
+ function tokenOfOwnerByIndex(identity owner, uint256 index) external view returns (uint256 tokenId);
|
|
|
+
|
|
|
+ function tokenByIndex(uint256 index) external view returns (uint256);
|
|
|
+}
|
|
|
+
|
|
|
+interface IERC721Receiver {
|
|
|
+ function onERC721Received(identity operator, identity from, uint256 tokenId, bytes calldata data) external returns (bytes4);
|
|
|
+}
|
|
|
+
|
|
|
+contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
|
|
|
+ using SafeMath for uint256;
|
|
|
+ using Address for identity;
|
|
|
+ using EnumerableSet for EnumerableSet.UintSet;
|
|
|
+ using EnumerableMap for EnumerableMap.UintToAddressMap;
|
|
|
+ using Strings for uint256;
|
|
|
+
|
|
|
+ bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
|
|
|
+ mapping (identity => EnumerableSet.UintSet) private _holderTokens;
|
|
|
+ EnumerableMap.UintToAddressMap private _tokenOwners;
|
|
|
+ mapping (uint256 => identity) private _tokenApprovals;
|
|
|
+ mapping (identity => mapping (identity => bool)) private _operatorApprovals;
|
|
|
+ string private _name;
|
|
|
+ string private _symbol;
|
|
|
+ mapping (uint256 => string) private _tokenURIs;
|
|
|
+ string private _baseURI;
|
|
|
+ bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
|
|
|
+ bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
|
|
|
+ bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
|
|
|
+
|
|
|
+ constructor (string memory name_, string memory symbol_) public {
|
|
|
+ _name = name_;
|
|
|
+ _symbol = symbol_;
|
|
|
+
|
|
|
+ // register the supported interfaces to conform to ERC721 via ERC165
|
|
|
+ _registerInterface(_INTERFACE_ID_ERC721);
|
|
|
+ _registerInterface(_INTERFACE_ID_ERC721_METADATA);
|
|
|
+ _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
|
|
|
+ }
|
|
|
+
|
|
|
+ function balanceOf(identity owner) public view virtual override returns (uint256) {
|
|
|
+ require(owner != identity(0), "ERC721: balance query for the zero address");
|
|
|
+ return _holderTokens[owner].length();
|
|
|
+ }
|
|
|
+
|
|
|
+ function ownerOf(uint256 tokenId) public view virtual override returns (identity) {
|
|
|
+ return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
|
|
|
+ }
|
|
|
+
|
|
|
+ function name() public view virtual override returns (string memory) {
|
|
|
+ return _name;
|
|
|
+ }
|
|
|
+
|
|
|
+ function symbol() public view virtual override returns (string memory) {
|
|
|
+ return _symbol;
|
|
|
+ }
|
|
|
+
|
|
|
+ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
|
|
|
+ require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
|
|
|
+
|
|
|
+ string memory _tokenURI = _tokenURIs[tokenId];
|
|
|
+ string memory base = baseURI();
|
|
|
+
|
|
|
+ // If there is no base URI, return the token URI.
|
|
|
+ if (bytes(base).length == 0) {
|
|
|
+ return _tokenURI;
|
|
|
+ }
|
|
|
+ // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
|
|
|
+ if (bytes(_tokenURI).length > 0) {
|
|
|
+ return string(abi.encodePacked(base, _tokenURI));
|
|
|
+ }
|
|
|
+ // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
|
|
|
+ return string(abi.encodePacked(base, tokenId.toString()));
|
|
|
+ }
|
|
|
+
|
|
|
+ function baseURI() public view virtual returns (string memory) {
|
|
|
+ return _baseURI;
|
|
|
+ }
|
|
|
+
|
|
|
+ function tokenOfOwnerByIndex(identity owner, uint256 index) public view virtual override returns (uint256) {
|
|
|
+ return _holderTokens[owner].at(index);
|
|
|
+ }
|
|
|
+
|
|
|
+ function totalSupply() public view virtual override returns (uint256) {
|
|
|
+ // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
|
|
|
+ return _tokenOwners.length();
|
|
|
+ }
|
|
|
+
|
|
|
+ function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
|
|
|
+ (uint256 tokenId, ) = _tokenOwners.at(index);
|
|
|
+ return tokenId;
|
|
|
+ }
|
|
|
+
|
|
|
+ function approve(identity to, uint256 tokenId) public virtual override {
|
|
|
+ identity owner = ERC721.ownerOf(tokenId);
|
|
|
+ require(to != owner, "ERC721: approval to current owner");
|
|
|
+
|
|
|
+ require(_msgSender() == owner || ERC721.isApprovedForAll(owner, _msgSender()),
|
|
|
+ "ERC721: approve caller is not owner nor approved for all"
|
|
|
+ );
|
|
|
+
|
|
|
+ _approve(to, tokenId);
|
|
|
+ }
|
|
|
+
|
|
|
+ function getApproved(uint256 tokenId) public view virtual override returns (identity) {
|
|
|
+ require(_exists(tokenId), "ERC721: approved query for nonexistent token");
|
|
|
+
|
|
|
+ return _tokenApprovals[tokenId];
|
|
|
+ }
|
|
|
+
|
|
|
+ function setApprovalForAll(identity operator, bool approved) public virtual override {
|
|
|
+ require(operator != _msgSender(), "ERC721: approve to caller");
|
|
|
+
|
|
|
+ _operatorApprovals[_msgSender()][operator] = approved;
|
|
|
+ emit ApprovalForAll(_msgSender(), operator, approved);
|
|
|
+ }
|
|
|
+
|
|
|
+ function isApprovedForAll(identity owner, identity operator) public view virtual override returns (bool) {
|
|
|
+ return _operatorApprovals[owner][operator];
|
|
|
+ }
|
|
|
+
|
|
|
+ function transferFrom(identity from, identity to, uint256 tokenId) public virtual override {
|
|
|
+ //solhint-disable-next-line max-line-length
|
|
|
+ require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
|
|
|
+
|
|
|
+ _transfer(from, to, tokenId);
|
|
|
+ }
|
|
|
+
|
|
|
+ function safeTransferFrom(identity from, identity to, uint256 tokenId) public virtual override {
|
|
|
+ safeTransferFrom(from, to, tokenId, "");
|
|
|
+ }
|
|
|
+
|
|
|
+ function safeTransferFrom(identity from, identity to, uint256 tokenId, bytes memory _data) public virtual override {
|
|
|
+ require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
|
|
|
+ _safeTransfer(from, to, tokenId, _data);
|
|
|
+ }
|
|
|
+
|
|
|
+ function _safeTransfer(identity from, identity to, uint256 tokenId, bytes memory _data) internal virtual {
|
|
|
+ _transfer(from, to, tokenId);
|
|
|
+ require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
|
|
|
+ }
|
|
|
+
|
|
|
+ function _exists(uint256 tokenId) internal view virtual returns (bool) {
|
|
|
+ return _tokenOwners.contains(tokenId);
|
|
|
+ }
|
|
|
+
|
|
|
+ function _isApprovedOrOwner(identity spender, uint256 tokenId) internal view virtual returns (bool) {
|
|
|
+ require(_exists(tokenId), "ERC721: operator query for nonexistent token");
|
|
|
+ identity owner = ERC721.ownerOf(tokenId);
|
|
|
+ return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(owner, spender));
|
|
|
+ }
|
|
|
+
|
|
|
+ function _safeMint(identity to, uint256 tokenId) internal virtual {
|
|
|
+ _safeMint(to, tokenId, "");
|
|
|
+ }
|
|
|
+
|
|
|
+ function _safeMint(identity to, uint256 tokenId, bytes memory _data) internal virtual {
|
|
|
+ _mint(to, tokenId);
|
|
|
+ require(_checkOnERC721Received(identity(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
|
|
|
+ }
|
|
|
+
|
|
|
+ function _mint(identity to, uint256 tokenId) internal virtual {
|
|
|
+ require(to != identity(0), "ERC721: mint to the zero address");
|
|
|
+ require(!_exists(tokenId), "ERC721: token already minted");
|
|
|
+
|
|
|
+ _beforeTokenTransfer(identity(0), to, tokenId);
|
|
|
+
|
|
|
+ _holderTokens[to].add(tokenId);
|
|
|
+
|
|
|
+ _tokenOwners.set(tokenId, to);
|
|
|
+
|
|
|
+ emit Transfer(identity(0), to, tokenId);
|
|
|
+ }
|
|
|
+
|
|
|
+ function _burn(uint256 tokenId) internal virtual {
|
|
|
+ identity owner = ERC721.ownerOf(tokenId); // internal owner
|
|
|
+
|
|
|
+ _beforeTokenTransfer(owner, identity(0), tokenId);
|
|
|
+
|
|
|
+ // Clear approvals
|
|
|
+ _approve(identity(0), tokenId);
|
|
|
+
|
|
|
+ // Clear metadata (if any)
|
|
|
+ if (bytes(_tokenURIs[tokenId]).length != 0) {
|
|
|
+ delete _tokenURIs[tokenId];
|
|
|
+ }
|
|
|
+
|
|
|
+ _holderTokens[owner].remove(tokenId);
|
|
|
+
|
|
|
+ _tokenOwners.remove(tokenId);
|
|
|
+
|
|
|
+ emit Transfer(owner, identity(0), tokenId);
|
|
|
+ }
|
|
|
+
|
|
|
+ function _transfer(identity from, identity to, uint256 tokenId) internal virtual {
|
|
|
+ require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); // internal owner
|
|
|
+ require(to != identity(0), "ERC721: transfer to the zero address");
|
|
|
+
|
|
|
+ _beforeTokenTransfer(from, to, tokenId);
|
|
|
+
|
|
|
+ // Clear approvals from the previous owner
|
|
|
+ _approve(identity(0), tokenId);
|
|
|
+
|
|
|
+ _holderTokens[from].remove(tokenId);
|
|
|
+ _holderTokens[to].add(tokenId);
|
|
|
+
|
|
|
+ _tokenOwners.set(tokenId, to);
|
|
|
+
|
|
|
+ emit Transfer(from, to, tokenId);
|
|
|
+ }
|
|
|
+
|
|
|
+ function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
|
|
|
+ require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
|
|
|
+ _tokenURIs[tokenId] = _tokenURI;
|
|
|
+ }
|
|
|
+
|
|
|
+ function _setBaseURI(string memory baseURI_) internal virtual {
|
|
|
+ _baseURI = baseURI_;
|
|
|
+ }
|
|
|
+
|
|
|
+ function _checkOnERC721Received(identity from, identity to, uint256 tokenId, bytes memory _data)
|
|
|
+ private returns (bool)
|
|
|
+ {
|
|
|
+ if (!to.isContract()) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ bytes memory returndata = to.functionCall(abi.encodeWithSelector(
|
|
|
+ IERC721Receiver(to).onERC721Received.selector,
|
|
|
+ _msgSender(),
|
|
|
+ from,
|
|
|
+ tokenId,
|
|
|
+ _data
|
|
|
+ ), "ERC721: transfer to non ERC721Receiver implementer");
|
|
|
+ bytes4 retval = abi.decode(returndata, (bytes4));
|
|
|
+ return (retval == _ERC721_RECEIVED);
|
|
|
+ }
|
|
|
+
|
|
|
+ function _approve(identity to, uint256 tokenId) private {
|
|
|
+ _tokenApprovals[tokenId] = to;
|
|
|
+ emit Approval(ERC721.ownerOf(tokenId), to, tokenId); // internal owner
|
|
|
+ }
|
|
|
+
|
|
|
+ function _beforeTokenTransfer(identity from, identity to, uint256 tokenId) internal virtual { }
|
|
|
+}
|
|
|
+
|
|
|
+abstract contract ERC721Burnable is Context, ERC721 {
|
|
|
+ function burn(uint256 tokenId) public virtual {
|
|
|
+ require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721Burnable: caller is not owner nor approved");
|
|
|
+ _burn(tokenId);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+abstract contract Pausable is Context {
|
|
|
+
|
|
|
+ event Paused(identity account);
|
|
|
+
|
|
|
+ event Unpaused(identity account);
|
|
|
+
|
|
|
+ bool private _paused;
|
|
|
+
|
|
|
+ constructor () internal {
|
|
|
+ _paused = false;
|
|
|
+ }
|
|
|
+
|
|
|
+ function paused() public view virtual returns (bool) {
|
|
|
+ return _paused;
|
|
|
+ }
|
|
|
+
|
|
|
+ modifier whenNotPaused() {
|
|
|
+ require(!paused(), "Pausable: paused");
|
|
|
+ _;
|
|
|
+ }
|
|
|
+
|
|
|
+ modifier whenPaused() {
|
|
|
+ require(paused(), "Pausable: not paused");
|
|
|
+ _;
|
|
|
+ }
|
|
|
+
|
|
|
+ function _pause() internal virtual whenNotPaused {
|
|
|
+ _paused = true;
|
|
|
+ emit Paused(_msgSender());
|
|
|
+ }
|
|
|
+
|
|
|
+ function _unpause() internal virtual whenPaused {
|
|
|
+ _paused = false;
|
|
|
+ emit Unpaused(_msgSender());
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+abstract contract ERC721Pausable is ERC721, Pausable {
|
|
|
+
|
|
|
+ function _beforeTokenTransfer(identity from, identity to, uint256 tokenId) internal virtual override {
|
|
|
+ super._beforeTokenTransfer(from, to, tokenId);
|
|
|
+
|
|
|
+ require(!paused(), "ERC721Pausable: token transfer while paused");
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+contract ERC721PresetMinterPauserAutoId is Context, AccessControl, ERC721Burnable, ERC721Pausable {
|
|
|
+ using Counters for Counters.Counter;
|
|
|
+
|
|
|
+ bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
|
|
|
+ bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
|
|
|
+
|
|
|
+ Counters.Counter private _tokenIdTracker;
|
|
|
+
|
|
|
+ identity owneraddress;
|
|
|
+ modifier onlyowner {
|
|
|
+ require(owneraddress == msg.sender, "only contract owner can call this function");
|
|
|
+ _;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @dev Grants `DEFAULT_ADMIN_ROLE`, `MINTER_ROLE` and `PAUSER_ROLE` to the
|
|
|
+ * account that deploys the contract.
|
|
|
+ *
|
|
|
+ * Token URIs will be autogenerated based on `baseURI` and their token IDs.
|
|
|
+ * See {ERC721-tokenURI}.
|
|
|
+ */
|
|
|
+ constructor(string memory name, string memory symbol, string memory baseURI) public ERC721(name, symbol) {
|
|
|
+ _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
|
|
|
+
|
|
|
+ _setupRole(MINTER_ROLE, _msgSender());
|
|
|
+ _setupRole(PAUSER_ROLE, _msgSender());
|
|
|
+
|
|
|
+ _setBaseURI(baseURI);
|
|
|
+
|
|
|
+ owneraddress = _msgSender();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @dev Creates a new token for `to`. Its token ID will be automatically
|
|
|
+ * assigned (and available on the emitted {IERC721-Transfer} event), and the token
|
|
|
+ * URI autogenerated based on the base URI passed at construction.
|
|
|
+ *
|
|
|
+ * See {ERC721-_mint}.
|
|
|
+ *
|
|
|
+ * Requirements:
|
|
|
+ *
|
|
|
+ * - the caller must have the `MINTER_ROLE`.
|
|
|
+ */
|
|
|
+ function mint(identity to, uint256 tokenId) public virtual {
|
|
|
+ require(hasRole(MINTER_ROLE, _msgSender()), "ERC721PresetMinterPauserAutoId: must have minter role to mint");
|
|
|
+
|
|
|
+ // We cannot just use balanceOf to create the new tokenId because tokens
|
|
|
+ // can be burned (destroyed), so we need a separate counter.
|
|
|
+ _mint(to, tokenId);
|
|
|
+ //_tokenIdTracker.increment();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @dev Pauses all token transfers.
|
|
|
+ *
|
|
|
+ * See {ERC721Pausable} and {Pausable-_pause}.
|
|
|
+ *
|
|
|
+ * Requirements:
|
|
|
+ *
|
|
|
+ * - the caller must have the `PAUSER_ROLE`.
|
|
|
+ */
|
|
|
+ function pause() public virtual {
|
|
|
+ require(hasRole(PAUSER_ROLE, _msgSender()), "ERC721PresetMinterPauserAutoId: must have pauser role to pause");
|
|
|
+ _pause();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @dev Unpauses all token transfers.
|
|
|
+ *
|
|
|
+ * See {ERC721Pausable} and {Pausable-_unpause}.
|
|
|
+ *
|
|
|
+ * Requirements:
|
|
|
+ *
|
|
|
+ * - the caller must have the `PAUSER_ROLE`.
|
|
|
+ */
|
|
|
+ function unpause() public virtual {
|
|
|
+ require(hasRole(PAUSER_ROLE, _msgSender()), "ERC721PresetMinterPauserAutoId: must have pauser role to unpause");
|
|
|
+ _unpause();
|
|
|
+ }
|
|
|
+
|
|
|
+ function _beforeTokenTransfer(identity from, identity to, uint256 tokenId) internal virtual override(ERC721, ERC721Pausable) {
|
|
|
+ super._beforeTokenTransfer(from, to, tokenId);
|
|
|
+ }
|
|
|
+
|
|
|
+ function ownerTransfer(identity from, identity to, uint256 tokenId) public onlyowner {
|
|
|
+ _transfer(from, to, tokenId);
|
|
|
+ }
|
|
|
+
|
|
|
+ function setTokenURI(uint256 tokenId, string memory _tokenURI) public onlyowner {
|
|
|
+ _setTokenURI(tokenId, _tokenURI);
|
|
|
+ }
|
|
|
+
|
|
|
+ function setBaseURI(string memory baseURI_) public onlyowner {
|
|
|
+ _setBaseURI(baseURI_);
|
|
|
+ }
|
|
|
+}
|