File 1 of 1: DogsUnchained.sol
pragma solidity >=0.6.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
pragma solidity >=0.6.0 <0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), 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 {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma solidity >=0.6.0 <0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
pragma solidity >=0.6.0 <0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity >=0.6.2 <0.8.0;
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;
}
pragma solidity >=0.6.2 <0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity >=0.6.2 <0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity >=0.6.0 <0.8.0;
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
pragma solidity >=0.6.0 <0.8.0;
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;
}
}
pragma solidity >=0.6.0 <0.8.0;
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;
}
}
pragma solidity >=0.6.2 <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) private 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);
}
}
}
}
pragma solidity >=0.6.0 <0.8.0;
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, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(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));
}
}
pragma solidity >=0.6.0 <0.8.0;
library EnumerableMap {
struct MapEntry {
bytes32 _key;
bytes32 _value;
}
struct Map {
MapEntry[] _entries;
mapping (bytes32 => uint256) _indexes;
}
function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
uint256 keyIndex = map._indexes[key];
if (keyIndex == 0) {
map._entries.push(MapEntry({ _key: key, _value: 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) {
uint256 keyIndex = map._indexes[key];
if (keyIndex != 0) {
uint256 toDeleteIndex = keyIndex - 1;
uint256 lastIndex = map._entries.length - 1;
MapEntry storage lastEntry = map._entries[lastIndex];
map._entries[toDeleteIndex] = lastEntry;
map._indexes[lastEntry._key] = toDeleteIndex + 1;
map._entries.pop();
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);
return (true, map._entries[keyIndex - 1]._value);
}
function _get(Map storage map, bytes32 key) private view returns (bytes32) {
uint256 keyIndex = map._indexes[key];
require(keyIndex != 0, "EnumerableMap: nonexistent key");
return map._entries[keyIndex - 1]._value;
}
function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
uint256 keyIndex = map._indexes[key];
require(keyIndex != 0, errorMessage);
return map._entries[keyIndex - 1]._value;
}
struct UintToAddressMap {
Map _inner;
}
function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
return _set(map._inner, bytes32(key), bytes32(uint256(uint160(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, address) {
(bytes32 key, bytes32 value) = _at(map._inner, index);
return (uint256(key), address(uint160(uint256(value))));
}
function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
(bool success, bytes32 value) = _tryGet(map._inner, bytes32(key));
return (success, address(uint160(uint256(value))));
}
function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
return address(uint160(uint256(_get(map._inner, bytes32(key)))));
}
function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage))));
}
}
pragma solidity >=0.6.0 <0.8.0;
library Strings {
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);
uint256 index = digits - 1;
temp = value;
while (temp != 0) {
buffer[index--] = bytes1(uint8(48 + temp % 10));
temp /= 10;
}
return string(buffer);
}
}
pragma solidity >=0.6.0 <0.8.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (address => EnumerableSet.UintSet) private _holderTokens;
EnumerableMap.UintToAddressMap private _tokenOwners;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => mapping (address => 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_;
_registerInterface(_INTERFACE_ID_ERC721);
_registerInterface(_INTERFACE_ID_ERC721_METADATA);
_registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _holderTokens[owner].length();
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
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 (bytes(base).length == 0) {
return _tokenURI;
}
if (bytes(_tokenURI).length > 0) {
return string(abi.encodePacked(base, _tokenURI));
}
return string(abi.encodePacked(base, tokenId.toString()));
}
function baseURI() public view virtual returns (string memory) {
return _baseURI;
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
return _holderTokens[owner].at(index);
}
function totalSupply() public view virtual override returns (uint256) {
return _tokenOwners.length();
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
(uint256 tokenId, ) = _tokenOwners.at(index);
return tokenId;
}
function approve(address to, uint256 tokenId) public virtual override {
address 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 (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_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 {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_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 {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(address from, address 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(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_holderTokens[to].add(tokenId);
_tokenOwners.set(tokenId, to);
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
_approve(address(0), tokenId);
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
_holderTokens[owner].remove(tokenId);
_tokenOwners.remove(tokenId);
emit Transfer(owner, address(0), tokenId);
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
_approve(address(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(address from, address 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(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}
pragma solidity >=0.6.2 <0.8.0;
interface IProofOfSteak {
function redeem(address sender, uint256 tokenId, uint256 quantity) external;
}
pragma solidity >=0.6.0 <0.8.0;
contract Random is Ownable {
using SafeMath for uint256;
address public controller;
constructor() public {
controller = _msgSender();
}
function generate(address sender, uint256 nonce1, uint256 nonce2) external view returns (bytes32) {
}
function setController(address _controller) external onlyOwner {
controller = _controller;
}
}
pragma solidity >= 0.6.0 <0.8.0;
contract DogsUnchained is
Ownable,
ReentrancyGuard,
ERC721
{
using SafeMath for uint256;
bool public generalLock = true;
bool public steakholderLock = true;
struct Dog {
uint16 id;
uint8 breed;
uint8 background;
uint8 skin;
uint8 shirt;
uint8 neck;
uint8 mouth;
uint8 eyes;
uint8 head;
uint8 level;
}
uint256 private teamMint;
uint256 public constant MAX_TEAM_DOGS = 100;
uint256 public charitableMints;
uint256 public charitableWithdrawals;
uint256 public STEAKS_RESERVED;
uint256 public steaksRedeemed;
uint16[] private steakIndices;
uint256 public MAX_RESERVATIONS;
uint256 public totalReservations;
mapping(address => uint256) public reservations;
uint256 public reservationsRedeemed;
uint16[] private reservationIndices;
uint256 public MAX_DOGS;
mapping(uint256 => Dog) private dogs;
mapping(uint256 => uint256) public traitMaps;
IProofOfSteak public proofOfSteak;
address payable public teamAddress;
address payable public charityAddress;
string public prefix;
string public suffix;
Random private generator;
event TokenUpdated(
uint256 tokenId,
uint256 traitMap,
uint256 parent1,
uint256 parent2
);
event TraitsBurned(
uint256 tokenId,
uint256 traitMap
);
constructor(
uint256 _MAX_DOGS,
string memory _prefix,
string memory _suffix,
address _proofOfSteakAddress,
address _generatorAddress
) ERC721("Dogs Unchained", "DOGU") public {
MAX_DOGS = _MAX_DOGS;
prefix = _prefix;
suffix = _suffix;
proofOfSteak = IProofOfSteak(_proofOfSteakAddress);
teamAddress = _msgSender();
charityAddress = _msgSender();
generator = Random(_generatorAddress);
}
modifier onlySteakholderUnlocked() {
require(!steakholderLock, "Function is locked");
_;
}
modifier onlyGeneralUnlocked() {
require(!generalLock, "Function is locked");
_;
}
function redeemSteak(uint256 steakId, uint256 quantity, bool charitable) external payable nonReentrant onlySteakholderUnlocked {
require(quantity > 0, "Cannot mint 0 Dogs");
require(quantity <= 10, "Cannot redeem more than 10 Dogs at once");
require(msg.value == charitableCost(quantity, charitable), "Incorrect charitable amount");
proofOfSteak.redeem(_msgSender(), steakId, quantity);
uint256 randomId;
for (uint i = 0; i < quantity; i++) {
randomId = randomSteakID();
createDog(randomId, charitable);
steaksRedeemed = steaksRedeemed.add(1);
}
if (charitable) {
charitableMints = charitableMints.add(quantity);
}
}
function redeemReservation(uint256 quantity, bool charitable) external payable nonReentrant onlyGeneralUnlocked {
require(quantity > 0, "Cannot mint 0 Dogs");
require(quantity <= reservations[_msgSender()], "Cannot redeem more than reservation");
require(quantity <= 10, "Cannot mint more than 10 dogs at once");
require(
reservationsRedeemed
.add(STEAKS_RESERVED)
.add(MAX_TEAM_DOGS)
.add(quantity)
<= MAX_DOGS,
"Creating more dogs than limit"
);
require(msg.value == mintCost(quantity).add(charitableCost(quantity, charitable)), "Incorrect payment amount");
reservations[_msgSender()] = reservations[_msgSender()].sub(quantity);
uint256 randomId;
for (uint i = 0; i < quantity; i++) {
randomId = randomReservationID();
createDog(randomId, charitable);
reservationsRedeemed = reservationsRedeemed.add(1);
}
if (charitable) {
charitableMints = charitableMints.add(quantity);
}
}
function combineDogs(uint256 dogId1, uint256 dogId2, uint256 traitMap) external nonReentrant onlySteakholderUnlocked {
require(ownerOf(dogId1) == _msgSender(), "Must own these Dogs");
require(ownerOf(dogId2) == _msgSender(), "Must own these Dogs");
Dog storage dog1 = dogs[dogId1];
uint256 dog1map = structToBitmap(dog1);
Dog storage dog2 = dogs[dogId2];
uint256 dog2map = structToBitmap(dog2);
uint16 id = uint16(traitMap & 0xFFFF);
require(dog1.id == id || dog2.id == id, "Invalid ID");
Dog memory newDog = dogs[id];
Dog memory unusedTraits;
newDog.breed = unpackUint8(traitMap, 16);
require(dog1.breed == newDog.breed || dog2.breed == newDog.breed, "Invalid breed");
unusedTraits.breed = dog1.breed == newDog.breed ? dog2.breed : dog1.breed;
newDog.background = unpackUint8(traitMap, 24);
require(dog1.background == newDog.background || dog2.background == newDog.background, "Invalid background");
unusedTraits.background = dog1.background == newDog.background ? dog2.background : dog1.background;
newDog.skin = unpackUint8(traitMap, 32);
require(dog1.skin == newDog.skin || dog2.skin == newDog.skin, "Invalid skin");
unusedTraits.skin = dog1.skin == newDog.skin ? dog2.skin : dog1.skin;
newDog.shirt = unpackUint8(traitMap, 40);
require(dog1.shirt == newDog.shirt || dog2.shirt == newDog.shirt, "Invalid shirt");
unusedTraits.shirt = dog1.shirt == newDog.shirt ? dog2.shirt : dog1.shirt;
newDog.neck = unpackUint8(traitMap, 48);
require(dog1.neck == newDog.neck || dog2.neck == newDog.neck, "Invalid neck");
unusedTraits.neck = dog1.neck == newDog.neck ? dog2.neck : dog1.neck;
newDog.mouth = unpackUint8(traitMap, 56);
require(dog1.mouth == newDog.mouth || dog2.mouth == newDog.mouth, "Invalid mouth");
unusedTraits.mouth = dog1.mouth == newDog.mouth ? dog2.mouth : dog1.mouth;
newDog.eyes = unpackUint8(traitMap, 64);
require(dog1.eyes == newDog.eyes || dog2.eyes == newDog.eyes, "Invalid eyes");
unusedTraits.eyes = dog1.eyes == newDog.eyes ? dog2.eyes : dog1.eyes;
newDog.head = unpackUint8(traitMap, 72);
require(dog1.head == newDog.head || dog2.head == newDog.head, "Invalid head");
unusedTraits.head = dog1.head == newDog.head ? dog2.head : dog1.head;
uint256 bitmap = structToBitmap(newDog);
require(traitMaps[bitmap] == 0, "This trait combination already exists");
traitMaps[bitmap] = newDog.id;
newDog.level = dog1.level > dog2.level ? dog1.level + 1 : dog2.level + 1;
emit TokenUpdated(
newDog.id,
bitmap,
dog1map + dog1.id + (uint256(dog1.level) << 80),
dog2map + dog2.id + (uint256(dog2.level) << 80)
);
emit TraitsBurned(newDog.id == dog1.id ? dog2.id : dog1.id, structToBitmap(unusedTraits));
dogs[id] = newDog;
if (newDog.id == dog1.id) {
_burn(dog2.id);
} else {
_burn(dog1.id);
}
delete traitMaps[dog1map];
delete traitMaps[dog2map];
}
function mintCost(uint256 quantity) public pure returns (uint256) {
return quantity.mul(0.08 ether);
}
function charitableCost(uint256 quantity, bool charitable) public pure returns (uint256) {
return charitable ? quantity.mul(0.01 ether) : 0;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
return string(abi.encodePacked(prefix, tokenId.toString(), suffix));
}
function setSteaksReserved(uint256 quantity) public onlyOwner {
STEAKS_RESERVED = quantity;
steakIndices = new uint16[](STEAKS_RESERVED);
MAX_RESERVATIONS = MAX_DOGS - STEAKS_RESERVED - MAX_TEAM_DOGS;
reservationIndices = new uint16[](MAX_RESERVATIONS);
}
function devMint() public onlyOwner {
require(teamMint.add(10) <= MAX_TEAM_DOGS, "Cannot dev mint more");
for (uint i = 0; i < 10; i++) {
teamMint = teamMint.add(1);
createDog(teamMint, true);
}
}
function withdraw() public onlyOwner {
uint256 dueToCharity = (charitableMints.sub(charitableWithdrawals)).mul(0.02 ether);
payable(teamAddress).transfer(
address(this).balance.sub(dueToCharity)
);
}
function withdrawCharitable() public onlyOwner {
payable(charityAddress).transfer(
(charitableMints.sub(charitableWithdrawals)).mul(0.02 ether)
);
charitableWithdrawals = charitableMints;
}
function setTeamAddress(address payable _teamAddress) public onlyOwner {
teamAddress = _teamAddress;
}
function setCharityAddress(address payable _charityAddress) public onlyOwner {
charityAddress = _charityAddress;
}
function setSteakholderLock(bool _locked) external onlyOwner {
steakholderLock = _locked;
}
function setGeneralLock(bool _locked) external onlyOwner {
generalLock = _locked;
}
function setSuffixPrefix(string calldata _prefix, string calldata _suffix) external onlyOwner {
prefix = _prefix;
suffix = _suffix;
}
function addReservations(address[] calldata addresses, uint256[] calldata quantities) external onlyOwner {
require(addresses.length == quantities.length, "Mismatched inputs");
for (uint i = 0; i < addresses.length; i++) {
reservations[addresses[i]] = quantities[i];
}
}
function createDog(uint256 id, bool charitable) internal {
uint256 nonce;
Dog memory dog = generateDog(id, charitable, nonce);
while (traitMaps[structToBitmap(dog)] != 0) {
nonce = nonce.add(1);
dog = generateDog(id, charitable, nonce);
}
dogs[id] = dog;
traitMaps[structToBitmap(dog)] = id;
_safeMint(_msgSender(), id);
emit TokenUpdated(id, structToBitmap(dog), 0, 0);
}
function generateDog(uint256 id, bool charitable, uint256 nonce) internal view returns (Dog memory) {
bytes32 hash = generator.generate(_msgSender(), id, nonce);
Dog memory dog;
dog.id = uint16(id);
dog.level = 1;
dog.breed = uint8(hash[31]) % 5;
dog.background = randomTrait(
concatBytes(hash[0], hash[1]), charitable, 1, 1, 3, 7, 0
);
dog.skin = randomTrait(
concatBytes(hash[2], hash[3]), charitable, 2, 3, 3, 3, 0
);
dog.shirt = randomTrait(
concatBytes(hash[4], hash[5]), charitable, 2, 6, 14, 11, 15
);
dog.neck = randomTrait(
concatBytes(hash[6], hash[7]), charitable, 1, 2, 7, 7, 70
);
dog.mouth = randomTrait(
concatBytes(hash[8], hash[9]), charitable, 2, 4, 14, 11, 0
);
dog.eyes = randomTrait(
concatBytes(hash[10], hash[11]), charitable, 2, 6, 14, 9, 0
);
dog.head = randomTrait(
concatBytes(hash[12], hash[13]), charitable, 2, 4, 15, 9, 30
);
return dog;
}
function randomTrait(
uint16 seed,
bool charitable,
uint8 legendaries,
uint8 ultras,
uint8 rares,
uint8 commons,
uint16 nonePercent
) internal pure returns (uint8) {
uint256 trait = uint256(0xFFFF) * (100 - nonePercent) / 100;
if (seed > trait) {
return 0;
}
uint256 base = !charitable ? trait / 300 : trait / 200;
if (seed < base) return uint8(seed % legendaries) + 1;
base += !charitable ? trait / 50 : trait / 33;
if (seed < base) return legendaries + uint8(seed % ultras) + 1;
base += !charitable ? trait / 5 : trait * 3 / 10;
if (seed < base) return legendaries + ultras + uint8(seed % rares) + 1;
return legendaries + ultras + rares + uint8(seed % commons) + 1;
}
function structToBitmap(Dog memory dog) internal pure returns (uint256 bitmap) {
bitmap = uint256(dog.breed) << 16;
bitmap |= uint256(dog.background) << 24;
bitmap |= uint256(dog.skin) << 32;
bitmap |= uint256(dog.shirt) << 40;
bitmap |= uint256(dog.neck) << 48;
bitmap |= uint256(dog.mouth) << 56;
bitmap |= uint256(dog.eyes) << 64;
bitmap |= uint256(dog.head) << 72;
}
function concatBytes(bytes1 u1, bytes1 u2) internal pure returns (uint16) {
return uint16(uint8(u1)) << 8 | uint16(uint8(u2));
}
function unpackUint8(uint256 value, uint256 index) internal pure returns (uint8) {
return uint8((value & (0xFF << index)) >> index);
}
function randomSteakID() internal returns (uint256) {
uint256 remaining = STEAKS_RESERVED - steaksRedeemed;
uint256 random = uint256(generator.generate(_msgSender(), steaksRedeemed, remaining)) % remaining;
uint256 index = steakIndices[random] == 0 ? random : steakIndices[random];
steakIndices[random] = steakIndices[remaining - 1] == 0 ? uint16(remaining - 1) : steakIndices[remaining - 1];
return index + MAX_TEAM_DOGS + 1;
}
function randomReservationID() internal returns (uint256) {
uint256 remaining = MAX_RESERVATIONS - reservationsRedeemed;
uint256 random = uint256(generator.generate(_msgSender(), reservationsRedeemed, remaining)) % remaining;
uint256 index = reservationIndices[random] == 0 ? random : reservationIndices[random];
reservationIndices[random] = reservationIndices[remaining - 1] == 0 ? uint16(remaining - 1) : reservationIndices[remaining - 1];
return index + MAX_TEAM_DOGS + STEAKS_RESERVED + 1;
}
}
