2470 lines
94 KiB
Solidity
2470 lines
94 KiB
Solidity
/*
|
|
* @source: etherscan.io
|
|
* @author: -
|
|
* @vulnerable_at_lines: 1152,1496,2467
|
|
*/
|
|
|
|
pragma solidity ^0.4.11;
|
|
|
|
|
|
contract ERC20 {
|
|
function totalSupply() constant returns (uint supply);
|
|
function balanceOf( address who ) constant returns (uint value);
|
|
function allowance( address owner, address spender ) constant returns (uint _allowance);
|
|
|
|
function transfer( address to, uint value) returns (bool ok);
|
|
function transferFrom( address from, address to, uint value) returns (bool ok);
|
|
function approve( address spender, uint value ) returns (bool ok);
|
|
|
|
event Transfer( address indexed from, address indexed to, uint value);
|
|
event Approval( address indexed owner, address indexed spender, uint value);
|
|
}
|
|
/**
|
|
* @title Ownable
|
|
* @dev The Ownable contract has an owner address, and provides basic authorization control
|
|
* functions, this simplifies the implementation of "user permissions".
|
|
*/
|
|
contract Ownable {
|
|
address public owner;
|
|
|
|
|
|
/**
|
|
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
|
|
* account.
|
|
*/
|
|
function Ownable() {
|
|
owner = msg.sender;
|
|
}
|
|
|
|
|
|
/**
|
|
* @dev Throws if called by any account other than the owner.
|
|
*/
|
|
modifier onlyOwner() {
|
|
require(msg.sender == owner);
|
|
_;
|
|
}
|
|
|
|
|
|
/**
|
|
* @dev Allows the current owner to transfer control of the contract to a newOwner.
|
|
* @param newOwner The address to transfer ownership to.
|
|
*/
|
|
function transferOwnership(address newOwner) onlyOwner {
|
|
if (newOwner != address(0)) {
|
|
owner = newOwner;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
|
|
/// @author Dieter Shirley <dete@axiomzen.co> (https://github.com/dete)
|
|
contract ERC721 {
|
|
// Required methods
|
|
function totalSupply() public view returns (uint256 total);
|
|
function balanceOf(address _owner) public view returns (uint256 balance);
|
|
function ownerOf(uint256 _tokenId) external view returns (address owner);
|
|
function approve(address _to, uint256 _tokenId) external;
|
|
function transfer(address _to, uint256 _tokenId) external;
|
|
function transferFrom(address _from, address _to, uint256 _tokenId) external;
|
|
|
|
// Events
|
|
event Transfer(address from, address to, uint256 tokenId);
|
|
event Approval(address owner, address approved, uint256 tokenId);
|
|
|
|
// Optional
|
|
// function name() public view returns (string name);
|
|
// function symbol() public view returns (string symbol);
|
|
// function tokensOfOwner(address _owner) external view returns (uint256[] tokenIds);
|
|
// function tokenMetadata(uint256 _tokenId, string _preferredTransport) public view returns (string infoUrl);
|
|
|
|
// ERC-165 Compatibility (https://github.com/ethereum/EIPs/issues/165)
|
|
function supportsInterface(bytes4 _interfaceID) external view returns (bool);
|
|
}
|
|
|
|
contract GeneScienceInterface {
|
|
/// @dev simply a boolean to indicate this is the contract we expect to be
|
|
function isGeneScience() public pure returns (bool);
|
|
|
|
/// @dev given genes of kitten 1 & 2, return a genetic combination - may have a random factor
|
|
/// @param genes1 genes of mom
|
|
/// @param genes2 genes of sire
|
|
/// @return the genes that are supposed to be passed down the child
|
|
function mixGenes(uint256[2] genes1, uint256[2] genes2,uint256 g1,uint256 g2, uint256 targetBlock) public returns (uint256[2]);
|
|
|
|
function getPureFromGene(uint256[2] gene) public view returns(uint256);
|
|
|
|
/// @dev get sex from genes 0: female 1: male
|
|
function getSex(uint256[2] gene) public view returns(uint256);
|
|
|
|
/// @dev get wizz type from gene
|
|
function getWizzType(uint256[2] gene) public view returns(uint256);
|
|
|
|
function clearWizzType(uint256[2] _gene) public returns(uint256[2]);
|
|
}
|
|
|
|
/// @title A facet of PandaCore that manages special access privileges.
|
|
/// @author Axiom Zen (https://www.axiomzen.co)
|
|
/// @dev See the PandaCore contract documentation to understand how the various contract facets are arranged.
|
|
contract PandaAccessControl {
|
|
// This facet controls access control for CryptoPandas. There are four roles managed here:
|
|
//
|
|
// - The CEO: The CEO can reassign other roles and change the addresses of our dependent smart
|
|
// contracts. It is also the only role that can unpause the smart contract. It is initially
|
|
// set to the address that created the smart contract in the PandaCore constructor.
|
|
//
|
|
// - The CFO: The CFO can withdraw funds from PandaCore and its auction contracts.
|
|
//
|
|
// - The COO: The COO can release gen0 pandas to auction, and mint promo cats.
|
|
//
|
|
// It should be noted that these roles are distinct without overlap in their access abilities, the
|
|
// abilities listed for each role above are exhaustive. In particular, while the CEO can assign any
|
|
// address to any role, the CEO address itself doesn't have the ability to act in those roles. This
|
|
// restriction is intentional so that we aren't tempted to use the CEO address frequently out of
|
|
// convenience. The less we use an address, the less likely it is that we somehow compromise the
|
|
// account.
|
|
|
|
/// @dev Emited when contract is upgraded - See README.md for updgrade plan
|
|
event ContractUpgrade(address newContract);
|
|
|
|
// The addresses of the accounts (or contracts) that can execute actions within each roles.
|
|
address public ceoAddress;
|
|
address public cfoAddress;
|
|
address public cooAddress;
|
|
|
|
// @dev Keeps track whether the contract is paused. When that is true, most actions are blocked
|
|
bool public paused = false;
|
|
|
|
/// @dev Access modifier for CEO-only functionality
|
|
modifier onlyCEO() {
|
|
require(msg.sender == ceoAddress);
|
|
_;
|
|
}
|
|
|
|
/// @dev Access modifier for CFO-only functionality
|
|
modifier onlyCFO() {
|
|
require(msg.sender == cfoAddress);
|
|
_;
|
|
}
|
|
|
|
/// @dev Access modifier for COO-only functionality
|
|
modifier onlyCOO() {
|
|
require(msg.sender == cooAddress);
|
|
_;
|
|
}
|
|
|
|
modifier onlyCLevel() {
|
|
require(
|
|
msg.sender == cooAddress ||
|
|
msg.sender == ceoAddress ||
|
|
msg.sender == cfoAddress
|
|
);
|
|
_;
|
|
}
|
|
|
|
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
|
|
/// @param _newCEO The address of the new CEO
|
|
function setCEO(address _newCEO) external onlyCEO {
|
|
require(_newCEO != address(0));
|
|
|
|
ceoAddress = _newCEO;
|
|
}
|
|
|
|
/// @dev Assigns a new address to act as the CFO. Only available to the current CEO.
|
|
/// @param _newCFO The address of the new CFO
|
|
function setCFO(address _newCFO) external onlyCEO {
|
|
require(_newCFO != address(0));
|
|
|
|
cfoAddress = _newCFO;
|
|
}
|
|
|
|
/// @dev Assigns a new address to act as the COO. Only available to the current CEO.
|
|
/// @param _newCOO The address of the new COO
|
|
function setCOO(address _newCOO) external onlyCEO {
|
|
require(_newCOO != address(0));
|
|
|
|
cooAddress = _newCOO;
|
|
}
|
|
|
|
/*** Pausable functionality adapted from OpenZeppelin ***/
|
|
|
|
/// @dev Modifier to allow actions only when the contract IS NOT paused
|
|
modifier whenNotPaused() {
|
|
require(!paused);
|
|
_;
|
|
}
|
|
|
|
/// @dev Modifier to allow actions only when the contract IS paused
|
|
modifier whenPaused {
|
|
require(paused);
|
|
_;
|
|
}
|
|
|
|
/// @dev Called by any "C-level" role to pause the contract. Used only when
|
|
/// a bug or exploit is detected and we need to limit damage.
|
|
function pause() external onlyCLevel whenNotPaused {
|
|
paused = true;
|
|
}
|
|
|
|
/// @dev Unpauses the smart contract. Can only be called by the CEO, since
|
|
/// one reason we may pause the contract is when CFO or COO accounts are
|
|
/// compromised.
|
|
/// @notice This is public rather than external so it can be called by
|
|
/// derived contracts.
|
|
function unpause() public onlyCEO whenPaused {
|
|
// can't unpause if contract was upgraded
|
|
paused = false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/// @title Base contract for CryptoPandas. Holds all common structs, events and base variables.
|
|
/// @author Axiom Zen (https://www.axiomzen.co)
|
|
/// @dev See the PandaCore contract documentation to understand how the various contract facets are arranged.
|
|
contract PandaBase is PandaAccessControl {
|
|
/*** EVENTS ***/
|
|
|
|
uint256 public constant GEN0_TOTAL_COUNT = 16200;
|
|
uint256 public gen0CreatedCount;
|
|
|
|
/// @dev The Birth event is fired whenever a new kitten comes into existence. This obviously
|
|
/// includes any time a cat is created through the giveBirth method, but it is also called
|
|
/// when a new gen0 cat is created.
|
|
event Birth(address owner, uint256 pandaId, uint256 matronId, uint256 sireId, uint256[2] genes);
|
|
|
|
/// @dev Transfer event as defined in current draft of ERC721. Emitted every time a kitten
|
|
/// ownership is assigned, including births.
|
|
event Transfer(address from, address to, uint256 tokenId);
|
|
|
|
/*** DATA TYPES ***/
|
|
|
|
/// @dev The main Panda struct. Every cat in CryptoPandas is represented by a copy
|
|
/// of this structure, so great care was taken to ensure that it fits neatly into
|
|
/// exactly two 256-bit words. Note that the order of the members in this structure
|
|
/// Ref: http://solidity.readthedocs.io/en/develop/miscellaneous.html
|
|
struct Panda {
|
|
// The Panda's genetic code is packed into these 256-bits, the format is
|
|
// sooper-sekret! A cat's genes never change.
|
|
uint256[2] genes;
|
|
|
|
// The timestamp from the block when this cat came into existence.
|
|
uint64 birthTime;
|
|
|
|
// The minimum timestamp after which this cat can engage in breeding
|
|
// activities again. This same timestamp is used for the pregnancy
|
|
// timer (for matrons) as well as the siring cooldown.
|
|
uint64 cooldownEndBlock;
|
|
|
|
// The ID of the parents of this panda, set to 0 for gen0 cats.
|
|
// Note that using 32-bit unsigned integers limits us to a "mere"
|
|
// 4 billion cats. This number might seem small until you realize
|
|
// that Ethereum currently has a limit of about 500 million
|
|
// transactions per year! So, this definitely won't be a problem
|
|
// for several years (even as Ethereum learns to scale).
|
|
uint32 matronId;
|
|
uint32 sireId;
|
|
|
|
// Set to the ID of the sire cat for matrons that are pregnant,
|
|
// zero otherwise. A non-zero value here is how we know a cat
|
|
// is pregnant. Used to retrieve the genetic material for the new
|
|
// kitten when the birth transpires.
|
|
uint32 siringWithId;
|
|
|
|
// Set to the index in the cooldown array (see below) that represents
|
|
// the current cooldown duration for this Panda. This starts at zero
|
|
// for gen0 cats, and is initialized to floor(generation/2) for others.
|
|
// Incremented by one for each successful breeding action, regardless
|
|
// of whether this cat is acting as matron or sire.
|
|
uint16 cooldownIndex;
|
|
|
|
// The "generation number" of this cat. Cats minted by the CK contract
|
|
// for sale are called "gen0" and have a generation number of 0. The
|
|
// generation number of all other cats is the larger of the two generation
|
|
// numbers of their parents, plus one.
|
|
// (i.e. max(matron.generation, sire.generation) + 1)
|
|
uint16 generation;
|
|
}
|
|
|
|
/*** CONSTANTS ***/
|
|
|
|
/// @dev A lookup table indicating the cooldown duration after any successful
|
|
/// breeding action, called "pregnancy time" for matrons and "siring cooldown"
|
|
/// for sires. Designed such that the cooldown roughly doubles each time a cat
|
|
/// is bred, encouraging owners not to just keep breeding the same cat over
|
|
/// and over again. Caps out at one week (a cat can breed an unbounded number
|
|
/// of times, and the maximum cooldown is always seven days).
|
|
uint32[9] public cooldowns = [
|
|
uint32(5 minutes),
|
|
uint32(30 minutes),
|
|
uint32(2 hours),
|
|
uint32(4 hours),
|
|
uint32(8 hours),
|
|
uint32(24 hours),
|
|
uint32(48 hours),
|
|
uint32(72 hours),
|
|
uint32(7 days)
|
|
];
|
|
|
|
// An approximation of currently how many seconds are in between blocks.
|
|
uint256 public secondsPerBlock = 15;
|
|
|
|
/*** STORAGE ***/
|
|
|
|
/// @dev An array containing the Panda struct for all Pandas in existence. The ID
|
|
/// of each cat is actually an index into this array. Note that ID 0 is a negacat,
|
|
/// the unPanda, the mythical beast that is the parent of all gen0 cats. A bizarre
|
|
/// creature that is both matron and sire... to itself! Has an invalid genetic code.
|
|
/// In other words, cat ID 0 is invalid... ;-)
|
|
Panda[] pandas;
|
|
|
|
/// @dev A mapping from cat IDs to the address that owns them. All cats have
|
|
/// some valid owner address, even gen0 cats are created with a non-zero owner.
|
|
mapping (uint256 => address) public pandaIndexToOwner;
|
|
|
|
// @dev A mapping from owner address to count of tokens that address owns.
|
|
// Used internally inside balanceOf() to resolve ownership count.
|
|
mapping (address => uint256) ownershipTokenCount;
|
|
|
|
/// @dev A mapping from PandaIDs to an address that has been approved to call
|
|
/// transferFrom(). Each Panda can only have one approved address for transfer
|
|
/// at any time. A zero value means no approval is outstanding.
|
|
mapping (uint256 => address) public pandaIndexToApproved;
|
|
|
|
/// @dev A mapping from PandaIDs to an address that has been approved to use
|
|
/// this Panda for siring via breedWith(). Each Panda can only have one approved
|
|
/// address for siring at any time. A zero value means no approval is outstanding.
|
|
mapping (uint256 => address) public sireAllowedToAddress;
|
|
|
|
/// @dev The address of the ClockAuction contract that handles sales of Pandas. This
|
|
/// same contract handles both peer-to-peer sales as well as the gen0 sales which are
|
|
/// initiated every 15 minutes.
|
|
SaleClockAuction public saleAuction;
|
|
|
|
/// @dev The address of a custom ClockAuction subclassed contract that handles siring
|
|
/// auctions. Needs to be separate from saleAuction because the actions taken on success
|
|
/// after a sales and siring auction are quite different.
|
|
SiringClockAuction public siringAuction;
|
|
|
|
|
|
/// @dev The address of the sibling contract that is used to implement the sooper-sekret
|
|
/// genetic combination algorithm.
|
|
GeneScienceInterface public geneScience;
|
|
|
|
|
|
SaleClockAuctionERC20 public saleAuctionERC20;
|
|
|
|
|
|
// wizz panda total
|
|
mapping (uint256 => uint256) public wizzPandaQuota;
|
|
mapping (uint256 => uint256) public wizzPandaCount;
|
|
|
|
|
|
/// wizz panda control
|
|
function getWizzPandaQuotaOf(uint256 _tp) view external returns(uint256) {
|
|
return wizzPandaQuota[_tp];
|
|
}
|
|
|
|
function getWizzPandaCountOf(uint256 _tp) view external returns(uint256) {
|
|
return wizzPandaCount[_tp];
|
|
}
|
|
|
|
function setTotalWizzPandaOf(uint256 _tp,uint256 _total) external onlyCLevel {
|
|
require (wizzPandaQuota[_tp]==0);
|
|
require (_total==uint256(uint32(_total)));
|
|
wizzPandaQuota[_tp] = _total;
|
|
}
|
|
|
|
function getWizzTypeOf(uint256 _id) view external returns(uint256) {
|
|
Panda memory _p = pandas[_id];
|
|
return geneScience.getWizzType(_p.genes);
|
|
}
|
|
|
|
/// @dev Assigns ownership of a specific Panda to an address.
|
|
function _transfer(address _from, address _to, uint256 _tokenId) internal {
|
|
// Since the number of kittens is capped to 2^32 we can't overflow this
|
|
ownershipTokenCount[_to]++;
|
|
// transfer ownership
|
|
pandaIndexToOwner[_tokenId] = _to;
|
|
// When creating new kittens _from is 0x0, but we can't account that address.
|
|
if (_from != address(0)) {
|
|
ownershipTokenCount[_from]--;
|
|
// once the kitten is transferred also clear sire allowances
|
|
delete sireAllowedToAddress[_tokenId];
|
|
// clear any previously approved ownership exchange
|
|
delete pandaIndexToApproved[_tokenId];
|
|
}
|
|
// Emit the transfer event.
|
|
Transfer(_from, _to, _tokenId);
|
|
}
|
|
|
|
/// @dev An internal method that creates a new panda and stores it. This
|
|
/// method doesn't do any checking and should only be called when the
|
|
/// input data is known to be valid. Will generate both a Birth event
|
|
/// and a Transfer event.
|
|
/// @param _matronId The panda ID of the matron of this cat (zero for gen0)
|
|
/// @param _sireId The panda ID of the sire of this cat (zero for gen0)
|
|
/// @param _generation The generation number of this cat, must be computed by caller.
|
|
/// @param _genes The panda's genetic code.
|
|
/// @param _owner The inital owner of this cat, must be non-zero (except for the unPanda, ID 0)
|
|
function _createPanda(
|
|
uint256 _matronId,
|
|
uint256 _sireId,
|
|
uint256 _generation,
|
|
uint256[2] _genes,
|
|
address _owner
|
|
)
|
|
internal
|
|
returns (uint)
|
|
{
|
|
// These requires are not strictly necessary, our calling code should make
|
|
// sure that these conditions are never broken. However! _createPanda() is already
|
|
// an expensive call (for storage), and it doesn't hurt to be especially careful
|
|
// to ensure our data structures are always valid.
|
|
require(_matronId == uint256(uint32(_matronId)));
|
|
require(_sireId == uint256(uint32(_sireId)));
|
|
require(_generation == uint256(uint16(_generation)));
|
|
|
|
|
|
// New panda starts with the same cooldown as parent gen/2
|
|
uint16 cooldownIndex = 0;
|
|
// when contract creation, geneScience ref is null
|
|
if (pandas.length>0){
|
|
uint16 pureDegree = uint16(geneScience.getPureFromGene(_genes));
|
|
if (pureDegree==0) {
|
|
pureDegree = 1;
|
|
}
|
|
cooldownIndex = 1000/pureDegree;
|
|
if (cooldownIndex%10 < 5){
|
|
cooldownIndex = cooldownIndex/10;
|
|
}else{
|
|
cooldownIndex = cooldownIndex/10 + 1;
|
|
}
|
|
cooldownIndex = cooldownIndex - 1;
|
|
if (cooldownIndex > 8) {
|
|
cooldownIndex = 8;
|
|
}
|
|
uint256 _tp = geneScience.getWizzType(_genes);
|
|
if (_tp>0 && wizzPandaQuota[_tp]<=wizzPandaCount[_tp]) {
|
|
_genes = geneScience.clearWizzType(_genes);
|
|
_tp = 0;
|
|
}
|
|
// gensis panda cooldownIndex should be 24 hours
|
|
if (_tp == 1){
|
|
cooldownIndex = 5;
|
|
}
|
|
|
|
// increase wizz counter
|
|
if (_tp>0){
|
|
wizzPandaCount[_tp] = wizzPandaCount[_tp] + 1;
|
|
}
|
|
// all gen0&gen1 except gensis
|
|
if (_generation <= 1 && _tp != 1){
|
|
require(gen0CreatedCount<GEN0_TOTAL_COUNT);
|
|
gen0CreatedCount++;
|
|
}
|
|
}
|
|
|
|
Panda memory _panda = Panda({
|
|
genes: _genes,
|
|
birthTime: uint64(now),
|
|
cooldownEndBlock: 0,
|
|
matronId: uint32(_matronId),
|
|
sireId: uint32(_sireId),
|
|
siringWithId: 0,
|
|
cooldownIndex: cooldownIndex,
|
|
generation: uint16(_generation)
|
|
});
|
|
uint256 newKittenId = pandas.push(_panda) - 1;
|
|
|
|
// It's probably never going to happen, 4 billion cats is A LOT, but
|
|
// let's just be 100% sure we never let this happen.
|
|
require(newKittenId == uint256(uint32(newKittenId)));
|
|
|
|
// emit the birth event
|
|
Birth(
|
|
_owner,
|
|
newKittenId,
|
|
uint256(_panda.matronId),
|
|
uint256(_panda.sireId),
|
|
_panda.genes
|
|
);
|
|
|
|
// This will assign ownership, and also emit the Transfer event as
|
|
// per ERC721 draft
|
|
_transfer(0, _owner, newKittenId);
|
|
|
|
return newKittenId;
|
|
}
|
|
|
|
// Any C-level can fix how many seconds per blocks are currently observed.
|
|
function setSecondsPerBlock(uint256 secs) external onlyCLevel {
|
|
require(secs < cooldowns[0]);
|
|
secondsPerBlock = secs;
|
|
}
|
|
}
|
|
/// @title The external contract that is responsible for generating metadata for the pandas,
|
|
/// it has one function that will return the data as bytes.
|
|
contract ERC721Metadata {
|
|
/// @dev Given a token Id, returns a byte array that is supposed to be converted into string.
|
|
function getMetadata(uint256 _tokenId, string) public view returns (bytes32[4] buffer, uint256 count) {
|
|
if (_tokenId == 1) {
|
|
buffer[0] = "Hello World! :D";
|
|
count = 15;
|
|
} else if (_tokenId == 2) {
|
|
buffer[0] = "I would definitely choose a medi";
|
|
buffer[1] = "um length string.";
|
|
count = 49;
|
|
} else if (_tokenId == 3) {
|
|
buffer[0] = "Lorem ipsum dolor sit amet, mi e";
|
|
buffer[1] = "st accumsan dapibus augue lorem,";
|
|
buffer[2] = " tristique vestibulum id, libero";
|
|
buffer[3] = " suscipit varius sapien aliquam.";
|
|
count = 128;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/// @title The facet of the CryptoPandas core contract that manages ownership, ERC-721 (draft) compliant.
|
|
/// @author Axiom Zen (https://www.axiomzen.co)
|
|
/// @dev Ref: https://github.com/ethereum/EIPs/issues/721
|
|
/// See the PandaCore contract documentation to understand how the various contract facets are arranged.
|
|
contract PandaOwnership is PandaBase, ERC721 {
|
|
|
|
/// @notice Name and symbol of the non fungible token, as defined in ERC721.
|
|
string public constant name = "PandaEarth";
|
|
string public constant symbol = "PE";
|
|
|
|
bytes4 constant InterfaceSignature_ERC165 =
|
|
bytes4(keccak256('supportsInterface(bytes4)'));
|
|
|
|
bytes4 constant InterfaceSignature_ERC721 =
|
|
bytes4(keccak256('name()')) ^
|
|
bytes4(keccak256('symbol()')) ^
|
|
bytes4(keccak256('totalSupply()')) ^
|
|
bytes4(keccak256('balanceOf(address)')) ^
|
|
bytes4(keccak256('ownerOf(uint256)')) ^
|
|
bytes4(keccak256('approve(address,uint256)')) ^
|
|
bytes4(keccak256('transfer(address,uint256)')) ^
|
|
bytes4(keccak256('transferFrom(address,address,uint256)')) ^
|
|
bytes4(keccak256('tokensOfOwner(address)')) ^
|
|
bytes4(keccak256('tokenMetadata(uint256,string)'));
|
|
|
|
/// @notice Introspection interface as per ERC-165 (https://github.com/ethereum/EIPs/issues/165).
|
|
/// Returns true for any standardized interfaces implemented by this contract. We implement
|
|
/// ERC-165 (obviously!) and ERC-721.
|
|
function supportsInterface(bytes4 _interfaceID) external view returns (bool)
|
|
{
|
|
// DEBUG ONLY
|
|
//require((InterfaceSignature_ERC165 == 0x01ffc9a7) && (InterfaceSignature_ERC721 == 0x9a20483d));
|
|
|
|
return ((_interfaceID == InterfaceSignature_ERC165) || (_interfaceID == InterfaceSignature_ERC721));
|
|
}
|
|
|
|
// Internal utility functions: These functions all assume that their input arguments
|
|
// are valid. We leave it to public methods to sanitize their inputs and follow
|
|
// the required logic.
|
|
|
|
/// @dev Checks if a given address is the current owner of a particular Panda.
|
|
/// @param _claimant the address we are validating against.
|
|
/// @param _tokenId kitten id, only valid when > 0
|
|
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
|
|
return pandaIndexToOwner[_tokenId] == _claimant;
|
|
}
|
|
|
|
/// @dev Checks if a given address currently has transferApproval for a particular Panda.
|
|
/// @param _claimant the address we are confirming kitten is approved for.
|
|
/// @param _tokenId kitten id, only valid when > 0
|
|
function _approvedFor(address _claimant, uint256 _tokenId) internal view returns (bool) {
|
|
return pandaIndexToApproved[_tokenId] == _claimant;
|
|
}
|
|
|
|
/// @dev Marks an address as being approved for transferFrom(), overwriting any previous
|
|
/// approval. Setting _approved to address(0) clears all transfer approval.
|
|
/// NOTE: _approve() does NOT send the Approval event. This is intentional because
|
|
/// _approve() and transferFrom() are used together for putting Pandas on auction, and
|
|
/// there is no value in spamming the log with Approval events in that case.
|
|
function _approve(uint256 _tokenId, address _approved) internal {
|
|
pandaIndexToApproved[_tokenId] = _approved;
|
|
}
|
|
|
|
/// @notice Returns the number of Pandas owned by a specific address.
|
|
/// @param _owner The owner address to check.
|
|
/// @dev Required for ERC-721 compliance
|
|
function balanceOf(address _owner) public view returns (uint256 count) {
|
|
return ownershipTokenCount[_owner];
|
|
}
|
|
|
|
/// @notice Transfers a Panda to another address. If transferring to a smart
|
|
/// contract be VERY CAREFUL to ensure that it is aware of ERC-721 (or
|
|
/// CryptoPandas specifically) or your Panda may be lost forever. Seriously.
|
|
/// @param _to The address of the recipient, can be a user or contract.
|
|
/// @param _tokenId The ID of the Panda to transfer.
|
|
/// @dev Required for ERC-721 compliance.
|
|
function transfer(
|
|
address _to,
|
|
uint256 _tokenId
|
|
)
|
|
external
|
|
whenNotPaused
|
|
{
|
|
// Safety check to prevent against an unexpected 0x0 default.
|
|
require(_to != address(0));
|
|
// Disallow transfers to this contract to prevent accidental misuse.
|
|
// The contract should never own any pandas (except very briefly
|
|
// after a gen0 cat is created and before it goes on auction).
|
|
require(_to != address(this));
|
|
// Disallow transfers to the auction contracts to prevent accidental
|
|
// misuse. Auction contracts should only take ownership of pandas
|
|
// through the allow + transferFrom flow.
|
|
require(_to != address(saleAuction));
|
|
require(_to != address(siringAuction));
|
|
|
|
// You can only send your own cat.
|
|
require(_owns(msg.sender, _tokenId));
|
|
|
|
// Reassign ownership, clear pending approvals, emit Transfer event.
|
|
_transfer(msg.sender, _to, _tokenId);
|
|
}
|
|
|
|
/// @notice Grant another address the right to transfer a specific Panda via
|
|
/// transferFrom(). This is the preferred flow for transfering NFTs to contracts.
|
|
/// @param _to The address to be granted transfer approval. Pass address(0) to
|
|
/// clear all approvals.
|
|
/// @param _tokenId The ID of the Panda that can be transferred if this call succeeds.
|
|
/// @dev Required for ERC-721 compliance.
|
|
function approve(
|
|
address _to,
|
|
uint256 _tokenId
|
|
)
|
|
external
|
|
whenNotPaused
|
|
{
|
|
// Only an owner can grant transfer approval.
|
|
require(_owns(msg.sender, _tokenId));
|
|
|
|
// Register the approval (replacing any previous approval).
|
|
_approve(_tokenId, _to);
|
|
|
|
// Emit approval event.
|
|
Approval(msg.sender, _to, _tokenId);
|
|
}
|
|
|
|
/// @notice Transfer a Panda owned by another address, for which the calling address
|
|
/// has previously been granted transfer approval by the owner.
|
|
/// @param _from The address that owns the Panda to be transfered.
|
|
/// @param _to The address that should take ownership of the Panda. Can be any address,
|
|
/// including the caller.
|
|
/// @param _tokenId The ID of the Panda to be transferred.
|
|
/// @dev Required for ERC-721 compliance.
|
|
function transferFrom(
|
|
address _from,
|
|
address _to,
|
|
uint256 _tokenId
|
|
)
|
|
external
|
|
whenNotPaused
|
|
{
|
|
// Safety check to prevent against an unexpected 0x0 default.
|
|
require(_to != address(0));
|
|
// Disallow transfers to this contract to prevent accidental misuse.
|
|
// The contract should never own any pandas (except very briefly
|
|
// after a gen0 cat is created and before it goes on auction).
|
|
require(_to != address(this));
|
|
// Check for approval and valid ownership
|
|
require(_approvedFor(msg.sender, _tokenId));
|
|
require(_owns(_from, _tokenId));
|
|
|
|
// Reassign ownership (also clears pending approvals and emits Transfer event).
|
|
_transfer(_from, _to, _tokenId);
|
|
}
|
|
|
|
/// @notice Returns the total number of Pandas currently in existence.
|
|
/// @dev Required for ERC-721 compliance.
|
|
function totalSupply() public view returns (uint) {
|
|
return pandas.length - 1;
|
|
}
|
|
|
|
/// @notice Returns the address currently assigned ownership of a given Panda.
|
|
/// @dev Required for ERC-721 compliance.
|
|
function ownerOf(uint256 _tokenId)
|
|
external
|
|
view
|
|
returns (address owner)
|
|
{
|
|
owner = pandaIndexToOwner[_tokenId];
|
|
|
|
require(owner != address(0));
|
|
}
|
|
|
|
/// @notice Returns a list of all Panda IDs assigned to an address.
|
|
/// @param _owner The owner whose Pandas we are interested in.
|
|
/// @dev This method MUST NEVER be called by smart contract code. First, it's fairly
|
|
/// expensive (it walks the entire Panda array looking for cats belonging to owner),
|
|
/// but it also returns a dynamic array, which is only supported for web3 calls, and
|
|
/// not contract-to-contract calls.
|
|
function tokensOfOwner(address _owner) external view returns(uint256[] ownerTokens) {
|
|
uint256 tokenCount = balanceOf(_owner);
|
|
|
|
if (tokenCount == 0) {
|
|
// Return an empty array
|
|
return new uint256[](0);
|
|
} else {
|
|
uint256[] memory result = new uint256[](tokenCount);
|
|
uint256 totalCats = totalSupply();
|
|
uint256 resultIndex = 0;
|
|
|
|
// We count on the fact that all cats have IDs starting at 1 and increasing
|
|
// sequentially up to the totalCat count.
|
|
uint256 catId;
|
|
|
|
for (catId = 1; catId <= totalCats; catId++) {
|
|
if (pandaIndexToOwner[catId] == _owner) {
|
|
result[resultIndex] = catId;
|
|
resultIndex++;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/// @dev Adapted from memcpy() by @arachnid (Nick Johnson <arachnid@notdot.net>)
|
|
/// This method is licenced under the Apache License.
|
|
/// Ref: https://github.com/Arachnid/solidity-stringutils/blob/2f6ca9accb48ae14c66f1437ec50ed19a0616f78/strings.sol
|
|
function _memcpy(uint _dest, uint _src, uint _len) private view {
|
|
// Copy word-length chunks while possible
|
|
for(; _len >= 32; _len -= 32) {
|
|
assembly {
|
|
mstore(_dest, mload(_src))
|
|
}
|
|
_dest += 32;
|
|
_src += 32;
|
|
}
|
|
|
|
// Copy remaining bytes
|
|
uint256 mask = 256 ** (32 - _len) - 1;
|
|
assembly {
|
|
let srcpart := and(mload(_src), not(mask))
|
|
let destpart := and(mload(_dest), mask)
|
|
mstore(_dest, or(destpart, srcpart))
|
|
}
|
|
}
|
|
|
|
/// @dev Adapted from toString(slice) by @arachnid (Nick Johnson <arachnid@notdot.net>)
|
|
/// This method is licenced under the Apache License.
|
|
/// Ref: https://github.com/Arachnid/solidity-stringutils/blob/2f6ca9accb48ae14c66f1437ec50ed19a0616f78/strings.sol
|
|
function _toString(bytes32[4] _rawBytes, uint256 _stringLength) private view returns (string) {
|
|
var outputString = new string(_stringLength);
|
|
uint256 outputPtr;
|
|
uint256 bytesPtr;
|
|
|
|
assembly {
|
|
outputPtr := add(outputString, 32)
|
|
bytesPtr := _rawBytes
|
|
}
|
|
|
|
_memcpy(outputPtr, bytesPtr, _stringLength);
|
|
|
|
return outputString;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// @title A facet of PandaCore that manages Panda siring, gestation, and birth.
|
|
/// @author Axiom Zen (https://www.axiomzen.co)
|
|
/// @dev See the PandaCore contract documentation to understand how the various contract facets are arranged.
|
|
contract PandaBreeding is PandaOwnership {
|
|
|
|
uint256 public constant GENSIS_TOTAL_COUNT = 100;
|
|
|
|
/// @dev The Pregnant event is fired when two cats successfully breed and the pregnancy
|
|
/// timer begins for the matron.
|
|
event Pregnant(address owner, uint256 matronId, uint256 sireId, uint256 cooldownEndBlock);
|
|
/// @dev The Abortion event is fired when two cats breed failed.
|
|
event Abortion(address owner, uint256 matronId, uint256 sireId);
|
|
|
|
/// @notice The minimum payment required to use breedWithAuto(). This fee goes towards
|
|
/// the gas cost paid by whatever calls giveBirth(), and can be dynamically updated by
|
|
/// the COO role as the gas price changes.
|
|
uint256 public autoBirthFee = 2 finney;
|
|
|
|
// Keeps track of number of pregnant pandas.
|
|
uint256 public pregnantPandas;
|
|
|
|
mapping(uint256 => address) childOwner;
|
|
|
|
|
|
/// @dev Update the address of the genetic contract, can only be called by the CEO.
|
|
/// @param _address An address of a GeneScience contract instance to be used from this point forward.
|
|
function setGeneScienceAddress(address _address) external onlyCEO {
|
|
GeneScienceInterface candidateContract = GeneScienceInterface(_address);
|
|
|
|
// NOTE: verify that a contract is what we expect - https://github.com/Lunyr/crowdsale-contracts/blob/cfadd15986c30521d8ba7d5b6f57b4fefcc7ac38/contracts/LunyrToken.sol#L117
|
|
require(candidateContract.isGeneScience());
|
|
|
|
// Set the new contract address
|
|
geneScience = candidateContract;
|
|
}
|
|
|
|
/// @dev Checks that a given kitten is able to breed. Requires that the
|
|
/// current cooldown is finished (for sires) and also checks that there is
|
|
/// no pending pregnancy.
|
|
function _isReadyToBreed(Panda _kit) internal view returns(bool) {
|
|
// In addition to checking the cooldownEndBlock, we also need to check to see if
|
|
// the cat has a pending birth; there can be some period of time between the end
|
|
// of the pregnacy timer and the birth event.
|
|
return (_kit.siringWithId == 0) && (_kit.cooldownEndBlock <= uint64(block.number));
|
|
}
|
|
|
|
/// @dev Check if a sire has authorized breeding with this matron. True if both sire
|
|
/// and matron have the same owner, or if the sire has given siring permission to
|
|
/// the matron's owner (via approveSiring()).
|
|
function _isSiringPermitted(uint256 _sireId, uint256 _matronId) internal view returns(bool) {
|
|
address matronOwner = pandaIndexToOwner[_matronId];
|
|
address sireOwner = pandaIndexToOwner[_sireId];
|
|
|
|
// Siring is okay if they have same owner, or if the matron's owner was given
|
|
// permission to breed with this sire.
|
|
return (matronOwner == sireOwner || sireAllowedToAddress[_sireId] == matronOwner);
|
|
}
|
|
|
|
/// @dev Set the cooldownEndTime for the given Panda, based on its current cooldownIndex.
|
|
/// Also increments the cooldownIndex (unless it has hit the cap).
|
|
/// @param _kitten A reference to the Panda in storage which needs its timer started.
|
|
function _triggerCooldown(Panda storage _kitten) internal {
|
|
// Compute an estimation of the cooldown time in blocks (based on current cooldownIndex).
|
|
_kitten.cooldownEndBlock = uint64((cooldowns[_kitten.cooldownIndex] / secondsPerBlock) + block.number);
|
|
|
|
|
|
// Increment the breeding count, clamping it at 13, which is the length of the
|
|
// cooldowns array. We could check the array size dynamically, but hard-coding
|
|
// this as a constant saves gas. Yay, Solidity!
|
|
if (_kitten.cooldownIndex < 8 && geneScience.getWizzType(_kitten.genes) != 1) {
|
|
_kitten.cooldownIndex += 1;
|
|
}
|
|
}
|
|
|
|
/// @notice Grants approval to another user to sire with one of your Pandas.
|
|
/// @param _addr The address that will be able to sire with your Panda. Set to
|
|
/// address(0) to clear all siring approvals for this Panda.
|
|
/// @param _sireId A Panda that you own that _addr will now be able to sire with.
|
|
function approveSiring(address _addr, uint256 _sireId)
|
|
external
|
|
whenNotPaused {
|
|
require(_owns(msg.sender, _sireId));
|
|
sireAllowedToAddress[_sireId] = _addr;
|
|
}
|
|
|
|
/// @dev Updates the minimum payment required for calling giveBirthAuto(). Can only
|
|
/// be called by the COO address. (This fee is used to offset the gas cost incurred
|
|
/// by the autobirth daemon).
|
|
function setAutoBirthFee(uint256 val) external onlyCOO {
|
|
autoBirthFee = val;
|
|
}
|
|
|
|
/// @dev Checks to see if a given Panda is pregnant and (if so) if the gestation
|
|
/// period has passed.
|
|
function _isReadyToGiveBirth(Panda _matron) private view returns(bool) {
|
|
return (_matron.siringWithId != 0) && (_matron.cooldownEndBlock <= uint64(block.number));
|
|
}
|
|
|
|
/// @notice Checks that a given kitten is able to breed (i.e. it is not pregnant or
|
|
/// in the middle of a siring cooldown).
|
|
/// @param _pandaId reference the id of the kitten, any user can inquire about it
|
|
function isReadyToBreed(uint256 _pandaId)
|
|
public
|
|
view
|
|
returns(bool) {
|
|
require(_pandaId > 0);
|
|
Panda storage kit = pandas[_pandaId];
|
|
return _isReadyToBreed(kit);
|
|
}
|
|
|
|
/// @dev Checks whether a panda is currently pregnant.
|
|
/// @param _pandaId reference the id of the kitten, any user can inquire about it
|
|
function isPregnant(uint256 _pandaId)
|
|
public
|
|
view
|
|
returns(bool) {
|
|
require(_pandaId > 0);
|
|
// A panda is pregnant if and only if this field is set
|
|
return pandas[_pandaId].siringWithId != 0;
|
|
}
|
|
|
|
/// @dev Internal check to see if a given sire and matron are a valid mating pair. DOES NOT
|
|
/// check ownership permissions (that is up to the caller).
|
|
/// @param _matron A reference to the Panda struct of the potential matron.
|
|
/// @param _matronId The matron's ID.
|
|
/// @param _sire A reference to the Panda struct of the potential sire.
|
|
/// @param _sireId The sire's ID
|
|
function _isValidMatingPair(
|
|
Panda storage _matron,
|
|
uint256 _matronId,
|
|
Panda storage _sire,
|
|
uint256 _sireId
|
|
)
|
|
private
|
|
view
|
|
returns(bool) {
|
|
// A Panda can't breed with itself!
|
|
if (_matronId == _sireId) {
|
|
return false;
|
|
}
|
|
|
|
// Pandas can't breed with their parents.
|
|
if (_matron.matronId == _sireId || _matron.sireId == _sireId) {
|
|
return false;
|
|
}
|
|
if (_sire.matronId == _matronId || _sire.sireId == _matronId) {
|
|
return false;
|
|
}
|
|
|
|
// We can short circuit the sibling check (below) if either cat is
|
|
// gen zero (has a matron ID of zero).
|
|
if (_sire.matronId == 0 || _matron.matronId == 0) {
|
|
return true;
|
|
}
|
|
|
|
// Pandas can't breed with full or half siblings.
|
|
if (_sire.matronId == _matron.matronId || _sire.matronId == _matron.sireId) {
|
|
return false;
|
|
}
|
|
if (_sire.sireId == _matron.matronId || _sire.sireId == _matron.sireId) {
|
|
return false;
|
|
}
|
|
|
|
// male should get breed with female
|
|
if (geneScience.getSex(_matron.genes) + geneScience.getSex(_sire.genes) != 1) {
|
|
return false;
|
|
}
|
|
|
|
// Everything seems cool! Let's get DTF.
|
|
return true;
|
|
}
|
|
|
|
/// @dev Internal check to see if a given sire and matron are a valid mating pair for
|
|
/// breeding via auction (i.e. skips ownership and siring approval checks).
|
|
function _canBreedWithViaAuction(uint256 _matronId, uint256 _sireId)
|
|
internal
|
|
view
|
|
returns(bool) {
|
|
Panda storage matron = pandas[_matronId];
|
|
Panda storage sire = pandas[_sireId];
|
|
return _isValidMatingPair(matron, _matronId, sire, _sireId);
|
|
}
|
|
|
|
/// @notice Checks to see if two cats can breed together, including checks for
|
|
/// ownership and siring approvals. Does NOT check that both cats are ready for
|
|
/// breeding (i.e. breedWith could still fail until the cooldowns are finished).
|
|
/// TODO: Shouldn't this check pregnancy and cooldowns?!?
|
|
/// @param _matronId The ID of the proposed matron.
|
|
/// @param _sireId The ID of the proposed sire.
|
|
function canBreedWith(uint256 _matronId, uint256 _sireId)
|
|
external
|
|
view
|
|
returns(bool) {
|
|
require(_matronId > 0);
|
|
require(_sireId > 0);
|
|
Panda storage matron = pandas[_matronId];
|
|
Panda storage sire = pandas[_sireId];
|
|
return _isValidMatingPair(matron, _matronId, sire, _sireId) &&
|
|
_isSiringPermitted(_sireId, _matronId);
|
|
}
|
|
|
|
function _exchangeMatronSireId(uint256 _matronId, uint256 _sireId) internal returns(uint256, uint256) {
|
|
if (geneScience.getSex(pandas[_matronId].genes) == 1) {
|
|
return (_sireId, _matronId);
|
|
} else {
|
|
return (_matronId, _sireId);
|
|
}
|
|
}
|
|
|
|
/// @dev Internal utility function to initiate breeding, assumes that all breeding
|
|
/// requirements have been checked.
|
|
function _breedWith(uint256 _matronId, uint256 _sireId, address _owner) internal {
|
|
// make id point real gender
|
|
(_matronId, _sireId) = _exchangeMatronSireId(_matronId, _sireId);
|
|
// Grab a reference to the Pandas from storage.
|
|
Panda storage sire = pandas[_sireId];
|
|
Panda storage matron = pandas[_matronId];
|
|
|
|
// Mark the matron as pregnant, keeping track of who the sire is.
|
|
matron.siringWithId = uint32(_sireId);
|
|
|
|
// Trigger the cooldown for both parents.
|
|
_triggerCooldown(sire);
|
|
_triggerCooldown(matron);
|
|
|
|
// Clear siring permission for both parents. This may not be strictly necessary
|
|
// but it's likely to avoid confusion!
|
|
delete sireAllowedToAddress[_matronId];
|
|
delete sireAllowedToAddress[_sireId];
|
|
|
|
// Every time a panda gets pregnant, counter is incremented.
|
|
pregnantPandas++;
|
|
|
|
childOwner[_matronId] = _owner;
|
|
|
|
// Emit the pregnancy event.
|
|
Pregnant(pandaIndexToOwner[_matronId], _matronId, _sireId, matron.cooldownEndBlock);
|
|
}
|
|
|
|
/// @notice Breed a Panda you own (as matron) with a sire that you own, or for which you
|
|
/// have previously been given Siring approval. Will either make your cat pregnant, or will
|
|
/// fail entirely. Requires a pre-payment of the fee given out to the first caller of giveBirth()
|
|
/// @param _matronId The ID of the Panda acting as matron (will end up pregnant if successful)
|
|
/// @param _sireId The ID of the Panda acting as sire (will begin its siring cooldown if successful)
|
|
function breedWithAuto(uint256 _matronId, uint256 _sireId)
|
|
external
|
|
payable
|
|
whenNotPaused {
|
|
// Checks for payment.
|
|
require(msg.value >= autoBirthFee);
|
|
|
|
// Caller must own the matron.
|
|
require(_owns(msg.sender, _matronId));
|
|
|
|
// Neither sire nor matron are allowed to be on auction during a normal
|
|
// breeding operation, but we don't need to check that explicitly.
|
|
// For matron: The caller of this function can't be the owner of the matron
|
|
// because the owner of a Panda on auction is the auction house, and the
|
|
// auction house will never call breedWith().
|
|
// For sire: Similarly, a sire on auction will be owned by the auction house
|
|
// and the act of transferring ownership will have cleared any oustanding
|
|
// siring approval.
|
|
// Thus we don't need to spend gas explicitly checking to see if either cat
|
|
// is on auction.
|
|
|
|
// Check that matron and sire are both owned by caller, or that the sire
|
|
// has given siring permission to caller (i.e. matron's owner).
|
|
// Will fail for _sireId = 0
|
|
require(_isSiringPermitted(_sireId, _matronId));
|
|
|
|
// Grab a reference to the potential matron
|
|
Panda storage matron = pandas[_matronId];
|
|
|
|
// Make sure matron isn't pregnant, or in the middle of a siring cooldown
|
|
require(_isReadyToBreed(matron));
|
|
|
|
// Grab a reference to the potential sire
|
|
Panda storage sire = pandas[_sireId];
|
|
|
|
// Make sure sire isn't pregnant, or in the middle of a siring cooldown
|
|
require(_isReadyToBreed(sire));
|
|
|
|
// Test that these cats are a valid mating pair.
|
|
require(_isValidMatingPair(
|
|
matron,
|
|
_matronId,
|
|
sire,
|
|
_sireId
|
|
));
|
|
|
|
// All checks passed, panda gets pregnant!
|
|
_breedWith(_matronId, _sireId, msg.sender);
|
|
}
|
|
|
|
/// @notice Have a pregnant Panda give birth!
|
|
/// @param _matronId A Panda ready to give birth.
|
|
/// @return The Panda ID of the new kitten.
|
|
/// @dev Looks at a given Panda and, if pregnant and if the gestation period has passed,
|
|
/// combines the genes of the two parents to create a new kitten. The new Panda is assigned
|
|
/// to the current owner of the matron. Upon successful completion, both the matron and the
|
|
/// new kitten will be ready to breed again. Note that anyone can call this function (if they
|
|
/// are willing to pay the gas!), but the new kitten always goes to the mother's owner.
|
|
function giveBirth(uint256 _matronId, uint256[2] _childGenes, uint256[2] _factors)
|
|
external
|
|
whenNotPaused
|
|
onlyCLevel
|
|
returns(uint256) {
|
|
// Grab a reference to the matron in storage.
|
|
Panda storage matron = pandas[_matronId];
|
|
|
|
// Check that the matron is a valid cat.
|
|
require(matron.birthTime != 0);
|
|
|
|
// Check that the matron is pregnant, and that its time has come!
|
|
require(_isReadyToGiveBirth(matron));
|
|
|
|
// Grab a reference to the sire in storage.
|
|
uint256 sireId = matron.siringWithId;
|
|
Panda storage sire = pandas[sireId];
|
|
|
|
// Determine the higher generation number of the two parents
|
|
uint16 parentGen = matron.generation;
|
|
if (sire.generation > matron.generation) {
|
|
parentGen = sire.generation;
|
|
}
|
|
|
|
// Call the sooper-sekret gene mixing operation.
|
|
//uint256[2] memory childGenes = geneScience.mixGenes(matron.genes, sire.genes,matron.generation,sire.generation, matron.cooldownEndBlock - 1);
|
|
uint256[2] memory childGenes = _childGenes;
|
|
|
|
uint256 kittenId = 0;
|
|
|
|
// birth failed
|
|
uint256 probability = (geneScience.getPureFromGene(matron.genes) + geneScience.getPureFromGene(sire.genes)) / 2 + _factors[0];
|
|
if (probability >= (parentGen + 1) * _factors[1]) {
|
|
probability = probability - (parentGen + 1) * _factors[1];
|
|
} else {
|
|
probability = 0;
|
|
}
|
|
if (parentGen == 0 && gen0CreatedCount == GEN0_TOTAL_COUNT) {
|
|
probability = 0;
|
|
}
|
|
if (uint256(keccak256(block.blockhash(block.number - 2), now)) % 100 < probability) {
|
|
// Make the new kitten!
|
|
address owner = childOwner[_matronId];
|
|
kittenId = _createPanda(_matronId, matron.siringWithId, parentGen + 1, childGenes, owner);
|
|
} else {
|
|
Abortion(pandaIndexToOwner[_matronId], _matronId, sireId);
|
|
}
|
|
// Make the new kitten!
|
|
//address owner = pandaIndexToOwner[_matronId];
|
|
//address owner = childOwner[_matronId];
|
|
//uint256 kittenId = _createPanda(_matronId, matron.siringWithId, parentGen + 1, childGenes, owner);
|
|
|
|
// Clear the reference to sire from the matron (REQUIRED! Having siringWithId
|
|
// set is what marks a matron as being pregnant.)
|
|
delete matron.siringWithId;
|
|
|
|
// Every time a panda gives birth counter is decremented.
|
|
pregnantPandas--;
|
|
|
|
// Send the balance fee to the person who made birth happen.
|
|
// <yes> <report> UNCHECKED_LL_CALLS
|
|
msg.sender.send(autoBirthFee);
|
|
|
|
delete childOwner[_matronId];
|
|
|
|
// return the new kitten's ID
|
|
return kittenId;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// @title Auction Core
|
|
/// @dev Contains models, variables, and internal methods for the auction.
|
|
/// @notice We omit a fallback function to prevent accidental sends to this contract.
|
|
contract ClockAuctionBase {
|
|
|
|
// Represents an auction on an NFT
|
|
struct Auction {
|
|
// Current owner of NFT
|
|
address seller;
|
|
// Price (in wei) at beginning of auction
|
|
uint128 startingPrice;
|
|
// Price (in wei) at end of auction
|
|
uint128 endingPrice;
|
|
// Duration (in seconds) of auction
|
|
uint64 duration;
|
|
// Time when auction started
|
|
// NOTE: 0 if this auction has been concluded
|
|
uint64 startedAt;
|
|
// is this auction for gen0 panda
|
|
uint64 isGen0;
|
|
}
|
|
|
|
// Reference to contract tracking NFT ownership
|
|
ERC721 public nonFungibleContract;
|
|
|
|
// Cut owner takes on each auction, measured in basis points (1/100 of a percent).
|
|
// Values 0-10,000 map to 0%-100%
|
|
uint256 public ownerCut;
|
|
|
|
// Map from token ID to their corresponding auction.
|
|
mapping (uint256 => Auction) tokenIdToAuction;
|
|
|
|
event AuctionCreated(uint256 tokenId, uint256 startingPrice, uint256 endingPrice, uint256 duration);
|
|
event AuctionSuccessful(uint256 tokenId, uint256 totalPrice, address winner);
|
|
event AuctionCancelled(uint256 tokenId);
|
|
|
|
/// @dev Returns true if the claimant owns the token.
|
|
/// @param _claimant - Address claiming to own the token.
|
|
/// @param _tokenId - ID of token whose ownership to verify.
|
|
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
|
|
return (nonFungibleContract.ownerOf(_tokenId) == _claimant);
|
|
}
|
|
|
|
/// @dev Escrows the NFT, assigning ownership to this contract.
|
|
/// Throws if the escrow fails.
|
|
/// @param _owner - Current owner address of token to escrow.
|
|
/// @param _tokenId - ID of token whose approval to verify.
|
|
function _escrow(address _owner, uint256 _tokenId) internal {
|
|
// it will throw if transfer fails
|
|
nonFungibleContract.transferFrom(_owner, this, _tokenId);
|
|
}
|
|
|
|
/// @dev Transfers an NFT owned by this contract to another address.
|
|
/// Returns true if the transfer succeeds.
|
|
/// @param _receiver - Address to transfer NFT to.
|
|
/// @param _tokenId - ID of token to transfer.
|
|
function _transfer(address _receiver, uint256 _tokenId) internal {
|
|
// it will throw if transfer fails
|
|
nonFungibleContract.transfer(_receiver, _tokenId);
|
|
}
|
|
|
|
/// @dev Adds an auction to the list of open auctions. Also fires the
|
|
/// AuctionCreated event.
|
|
/// @param _tokenId The ID of the token to be put on auction.
|
|
/// @param _auction Auction to add.
|
|
function _addAuction(uint256 _tokenId, Auction _auction) internal {
|
|
// Require that all auctions have a duration of
|
|
// at least one minute. (Keeps our math from getting hairy!)
|
|
require(_auction.duration >= 1 minutes);
|
|
|
|
tokenIdToAuction[_tokenId] = _auction;
|
|
|
|
AuctionCreated(
|
|
uint256(_tokenId),
|
|
uint256(_auction.startingPrice),
|
|
uint256(_auction.endingPrice),
|
|
uint256(_auction.duration)
|
|
);
|
|
}
|
|
|
|
/// @dev Cancels an auction unconditionally.
|
|
function _cancelAuction(uint256 _tokenId, address _seller) internal {
|
|
_removeAuction(_tokenId);
|
|
_transfer(_seller, _tokenId);
|
|
AuctionCancelled(_tokenId);
|
|
}
|
|
|
|
/// @dev Computes the price and transfers winnings.
|
|
/// Does NOT transfer ownership of token.
|
|
function _bid(uint256 _tokenId, uint256 _bidAmount)
|
|
internal
|
|
returns (uint256)
|
|
{
|
|
// Get a reference to the auction struct
|
|
Auction storage auction = tokenIdToAuction[_tokenId];
|
|
|
|
// Explicitly check that this auction is currently live.
|
|
// (Because of how Ethereum mappings work, we can't just count
|
|
// on the lookup above failing. An invalid _tokenId will just
|
|
// return an auction object that is all zeros.)
|
|
require(_isOnAuction(auction));
|
|
|
|
// Check that the bid is greater than or equal to the current price
|
|
uint256 price = _currentPrice(auction);
|
|
require(_bidAmount >= price);
|
|
|
|
// Grab a reference to the seller before the auction struct
|
|
// gets deleted.
|
|
address seller = auction.seller;
|
|
|
|
// The bid is good! Remove the auction before sending the fees
|
|
// to the sender so we can't have a reentrancy attack.
|
|
_removeAuction(_tokenId);
|
|
|
|
// Transfer proceeds to seller (if there are any!)
|
|
if (price > 0) {
|
|
// Calculate the auctioneer's cut.
|
|
// (NOTE: _computeCut() is guaranteed to return a
|
|
// value <= price, so this subtraction can't go negative.)
|
|
uint256 auctioneerCut = _computeCut(price);
|
|
uint256 sellerProceeds = price - auctioneerCut;
|
|
|
|
// NOTE: Doing a transfer() in the middle of a complex
|
|
// method like this is generally discouraged because of
|
|
// reentrancy attacks and DoS attacks if the seller is
|
|
// a contract with an invalid fallback function. We explicitly
|
|
// guard against reentrancy attacks by removing the auction
|
|
// before calling transfer(), and the only thing the seller
|
|
// can DoS is the sale of their own asset! (And if it's an
|
|
// accident, they can call cancelAuction(). )
|
|
seller.transfer(sellerProceeds);
|
|
}
|
|
|
|
// Calculate any excess funds included with the bid. If the excess
|
|
// is anything worth worrying about, transfer it back to bidder.
|
|
// NOTE: We checked above that the bid amount is greater than or
|
|
// equal to the price so this cannot underflow.
|
|
uint256 bidExcess = _bidAmount - price;
|
|
|
|
// Return the funds. Similar to the previous transfer, this is
|
|
// not susceptible to a re-entry attack because the auction is
|
|
// removed before any transfers occur.
|
|
msg.sender.transfer(bidExcess);
|
|
|
|
// Tell the world!
|
|
AuctionSuccessful(_tokenId, price, msg.sender);
|
|
|
|
return price;
|
|
}
|
|
|
|
|
|
|
|
/// @dev Removes an auction from the list of open auctions.
|
|
/// @param _tokenId - ID of NFT on auction.
|
|
function _removeAuction(uint256 _tokenId) internal {
|
|
delete tokenIdToAuction[_tokenId];
|
|
}
|
|
|
|
/// @dev Returns true if the NFT is on auction.
|
|
/// @param _auction - Auction to check.
|
|
function _isOnAuction(Auction storage _auction) internal view returns (bool) {
|
|
return (_auction.startedAt > 0);
|
|
}
|
|
|
|
/// @dev Returns current price of an NFT on auction. Broken into two
|
|
/// functions (this one, that computes the duration from the auction
|
|
/// structure, and the other that does the price computation) so we
|
|
/// can easily test that the price computation works correctly.
|
|
function _currentPrice(Auction storage _auction)
|
|
internal
|
|
view
|
|
returns (uint256)
|
|
{
|
|
uint256 secondsPassed = 0;
|
|
|
|
// A bit of insurance against negative values (or wraparound).
|
|
// Probably not necessary (since Ethereum guarnatees that the
|
|
// now variable doesn't ever go backwards).
|
|
if (now > _auction.startedAt) {
|
|
secondsPassed = now - _auction.startedAt;
|
|
}
|
|
|
|
return _computeCurrentPrice(
|
|
_auction.startingPrice,
|
|
_auction.endingPrice,
|
|
_auction.duration,
|
|
secondsPassed
|
|
);
|
|
}
|
|
|
|
/// @dev Computes the current price of an auction. Factored out
|
|
/// from _currentPrice so we can run extensive unit tests.
|
|
/// When testing, make this function public and turn on
|
|
/// `Current price computation` test suite.
|
|
function _computeCurrentPrice(
|
|
uint256 _startingPrice,
|
|
uint256 _endingPrice,
|
|
uint256 _duration,
|
|
uint256 _secondsPassed
|
|
)
|
|
internal
|
|
pure
|
|
returns (uint256)
|
|
{
|
|
// NOTE: We don't use SafeMath (or similar) in this function because
|
|
// all of our public functions carefully cap the maximum values for
|
|
// time (at 64-bits) and currency (at 128-bits). _duration is
|
|
// also known to be non-zero (see the require() statement in
|
|
// _addAuction())
|
|
if (_secondsPassed >= _duration) {
|
|
// We've reached the end of the dynamic pricing portion
|
|
// of the auction, just return the end price.
|
|
return _endingPrice;
|
|
} else {
|
|
// Starting price can be higher than ending price (and often is!), so
|
|
// this delta can be negative.
|
|
int256 totalPriceChange = int256(_endingPrice) - int256(_startingPrice);
|
|
|
|
// This multiplication can't overflow, _secondsPassed will easily fit within
|
|
// 64-bits, and totalPriceChange will easily fit within 128-bits, their product
|
|
// will always fit within 256-bits.
|
|
int256 currentPriceChange = totalPriceChange * int256(_secondsPassed) / int256(_duration);
|
|
|
|
// currentPriceChange can be negative, but if so, will have a magnitude
|
|
// less that _startingPrice. Thus, this result will always end up positive.
|
|
int256 currentPrice = int256(_startingPrice) + currentPriceChange;
|
|
|
|
return uint256(currentPrice);
|
|
}
|
|
}
|
|
|
|
/// @dev Computes owner's cut of a sale.
|
|
/// @param _price - Sale price of NFT.
|
|
function _computeCut(uint256 _price) internal view returns (uint256) {
|
|
// NOTE: We don't use SafeMath (or similar) in this function because
|
|
// all of our entry functions carefully cap the maximum values for
|
|
// currency (at 128-bits), and ownerCut <= 10000 (see the require()
|
|
// statement in the ClockAuction constructor). The result of this
|
|
// function is always guaranteed to be <= _price.
|
|
return _price * ownerCut / 10000;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* @title Pausable
|
|
* @dev Base contract which allows children to implement an emergency stop mechanism.
|
|
*/
|
|
contract Pausable is Ownable {
|
|
event Pause();
|
|
event Unpause();
|
|
|
|
bool public paused = false;
|
|
|
|
|
|
/**
|
|
* @dev modifier to allow actions only when the contract IS paused
|
|
*/
|
|
modifier whenNotPaused() {
|
|
require(!paused);
|
|
_;
|
|
}
|
|
|
|
/**
|
|
* @dev modifier to allow actions only when the contract IS NOT paused
|
|
*/
|
|
modifier whenPaused {
|
|
require(paused);
|
|
_;
|
|
}
|
|
|
|
/**
|
|
* @dev called by the owner to pause, triggers stopped state
|
|
*/
|
|
function pause() onlyOwner whenNotPaused returns (bool) {
|
|
paused = true;
|
|
Pause();
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @dev called by the owner to unpause, returns to normal state
|
|
*/
|
|
function unpause() onlyOwner whenPaused returns (bool) {
|
|
paused = false;
|
|
Unpause();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
/// @title Clock auction for non-fungible tokens.
|
|
/// @notice We omit a fallback function to prevent accidental sends to this contract.
|
|
contract ClockAuction is Pausable, ClockAuctionBase {
|
|
|
|
/// @dev The ERC-165 interface signature for ERC-721.
|
|
/// Ref: https://github.com/ethereum/EIPs/issues/165
|
|
/// Ref: https://github.com/ethereum/EIPs/issues/721
|
|
bytes4 constant InterfaceSignature_ERC721 = bytes4(0x9a20483d);
|
|
|
|
/// @dev Constructor creates a reference to the NFT ownership contract
|
|
/// and verifies the owner cut is in the valid range.
|
|
/// @param _nftAddress - address of a deployed contract implementing
|
|
/// the Nonfungible Interface.
|
|
/// @param _cut - percent cut the owner takes on each auction, must be
|
|
/// between 0-10,000.
|
|
function ClockAuction(address _nftAddress, uint256 _cut) public {
|
|
require(_cut <= 10000);
|
|
ownerCut = _cut;
|
|
|
|
ERC721 candidateContract = ERC721(_nftAddress);
|
|
require(candidateContract.supportsInterface(InterfaceSignature_ERC721));
|
|
nonFungibleContract = candidateContract;
|
|
}
|
|
|
|
/// @dev Remove all Ether from the contract, which is the owner's cuts
|
|
/// as well as any Ether sent directly to the contract address.
|
|
/// Always transfers to the NFT contract, but can be called either by
|
|
/// the owner or the NFT contract.
|
|
function withdrawBalance() external {
|
|
address nftAddress = address(nonFungibleContract);
|
|
|
|
require(
|
|
msg.sender == owner ||
|
|
msg.sender == nftAddress
|
|
);
|
|
// We are using this boolean method to make sure that even if one fails it will still work
|
|
// <yes> <report> UNCHECKED_LL_CALLS
|
|
bool res = nftAddress.send(this.balance);
|
|
}
|
|
|
|
/// @dev Creates and begins a new auction.
|
|
/// @param _tokenId - ID of token to auction, sender must be owner.
|
|
/// @param _startingPrice - Price of item (in wei) at beginning of auction.
|
|
/// @param _endingPrice - Price of item (in wei) at end of auction.
|
|
/// @param _duration - Length of time to move between starting
|
|
/// price and ending price (in seconds).
|
|
/// @param _seller - Seller, if not the message sender
|
|
function createAuction(
|
|
uint256 _tokenId,
|
|
uint256 _startingPrice,
|
|
uint256 _endingPrice,
|
|
uint256 _duration,
|
|
address _seller
|
|
)
|
|
external
|
|
whenNotPaused
|
|
{
|
|
// Sanity check that no inputs overflow how many bits we've allocated
|
|
// to store them in the auction struct.
|
|
require(_startingPrice == uint256(uint128(_startingPrice)));
|
|
require(_endingPrice == uint256(uint128(_endingPrice)));
|
|
require(_duration == uint256(uint64(_duration)));
|
|
|
|
require(_owns(msg.sender, _tokenId));
|
|
_escrow(msg.sender, _tokenId);
|
|
Auction memory auction = Auction(
|
|
_seller,
|
|
uint128(_startingPrice),
|
|
uint128(_endingPrice),
|
|
uint64(_duration),
|
|
uint64(now),
|
|
0
|
|
);
|
|
_addAuction(_tokenId, auction);
|
|
}
|
|
|
|
/// @dev Bids on an open auction, completing the auction and transferring
|
|
/// ownership of the NFT if enough Ether is supplied.
|
|
/// @param _tokenId - ID of token to bid on.
|
|
function bid(uint256 _tokenId)
|
|
external
|
|
payable
|
|
whenNotPaused
|
|
{
|
|
// _bid will throw if the bid or funds transfer fails
|
|
_bid(_tokenId, msg.value);
|
|
_transfer(msg.sender, _tokenId);
|
|
}
|
|
|
|
/// @dev Cancels an auction that hasn't been won yet.
|
|
/// Returns the NFT to original owner.
|
|
/// @notice This is a state-modifying function that can
|
|
/// be called while the contract is paused.
|
|
/// @param _tokenId - ID of token on auction
|
|
function cancelAuction(uint256 _tokenId)
|
|
external
|
|
{
|
|
Auction storage auction = tokenIdToAuction[_tokenId];
|
|
require(_isOnAuction(auction));
|
|
address seller = auction.seller;
|
|
require(msg.sender == seller);
|
|
_cancelAuction(_tokenId, seller);
|
|
}
|
|
|
|
/// @dev Cancels an auction when the contract is paused.
|
|
/// Only the owner may do this, and NFTs are returned to
|
|
/// the seller. This should only be used in emergencies.
|
|
/// @param _tokenId - ID of the NFT on auction to cancel.
|
|
function cancelAuctionWhenPaused(uint256 _tokenId)
|
|
whenPaused
|
|
onlyOwner
|
|
external
|
|
{
|
|
Auction storage auction = tokenIdToAuction[_tokenId];
|
|
require(_isOnAuction(auction));
|
|
_cancelAuction(_tokenId, auction.seller);
|
|
}
|
|
|
|
/// @dev Returns auction info for an NFT on auction.
|
|
/// @param _tokenId - ID of NFT on auction.
|
|
function getAuction(uint256 _tokenId)
|
|
external
|
|
view
|
|
returns
|
|
(
|
|
address seller,
|
|
uint256 startingPrice,
|
|
uint256 endingPrice,
|
|
uint256 duration,
|
|
uint256 startedAt
|
|
) {
|
|
Auction storage auction = tokenIdToAuction[_tokenId];
|
|
require(_isOnAuction(auction));
|
|
return (
|
|
auction.seller,
|
|
auction.startingPrice,
|
|
auction.endingPrice,
|
|
auction.duration,
|
|
auction.startedAt
|
|
);
|
|
}
|
|
|
|
/// @dev Returns the current price of an auction.
|
|
/// @param _tokenId - ID of the token price we are checking.
|
|
function getCurrentPrice(uint256 _tokenId)
|
|
external
|
|
view
|
|
returns (uint256)
|
|
{
|
|
Auction storage auction = tokenIdToAuction[_tokenId];
|
|
require(_isOnAuction(auction));
|
|
return _currentPrice(auction);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// @title Reverse auction modified for siring
|
|
/// @notice We omit a fallback function to prevent accidental sends to this contract.
|
|
contract SiringClockAuction is ClockAuction {
|
|
|
|
// @dev Sanity check that allows us to ensure that we are pointing to the
|
|
// right auction in our setSiringAuctionAddress() call.
|
|
bool public isSiringClockAuction = true;
|
|
|
|
// Delegate constructor
|
|
function SiringClockAuction(address _nftAddr, uint256 _cut) public
|
|
ClockAuction(_nftAddr, _cut) {}
|
|
|
|
/// @dev Creates and begins a new auction. Since this function is wrapped,
|
|
/// require sender to be PandaCore contract.
|
|
/// @param _tokenId - ID of token to auction, sender must be owner.
|
|
/// @param _startingPrice - Price of item (in wei) at beginning of auction.
|
|
/// @param _endingPrice - Price of item (in wei) at end of auction.
|
|
/// @param _duration - Length of auction (in seconds).
|
|
/// @param _seller - Seller, if not the message sender
|
|
function createAuction(
|
|
uint256 _tokenId,
|
|
uint256 _startingPrice,
|
|
uint256 _endingPrice,
|
|
uint256 _duration,
|
|
address _seller
|
|
)
|
|
external
|
|
{
|
|
// Sanity check that no inputs overflow how many bits we've allocated
|
|
// to store them in the auction struct.
|
|
require(_startingPrice == uint256(uint128(_startingPrice)));
|
|
require(_endingPrice == uint256(uint128(_endingPrice)));
|
|
require(_duration == uint256(uint64(_duration)));
|
|
|
|
require(msg.sender == address(nonFungibleContract));
|
|
_escrow(_seller, _tokenId);
|
|
Auction memory auction = Auction(
|
|
_seller,
|
|
uint128(_startingPrice),
|
|
uint128(_endingPrice),
|
|
uint64(_duration),
|
|
uint64(now),
|
|
0
|
|
);
|
|
_addAuction(_tokenId, auction);
|
|
}
|
|
|
|
/// @dev Places a bid for siring. Requires the sender
|
|
/// is the PandaCore contract because all bid methods
|
|
/// should be wrapped. Also returns the panda to the
|
|
/// seller rather than the winner.
|
|
function bid(uint256 _tokenId)
|
|
external
|
|
payable
|
|
{
|
|
require(msg.sender == address(nonFungibleContract));
|
|
address seller = tokenIdToAuction[_tokenId].seller;
|
|
// _bid checks that token ID is valid and will throw if bid fails
|
|
_bid(_tokenId, msg.value);
|
|
// We transfer the panda back to the seller, the winner will get
|
|
// the offspring
|
|
_transfer(seller, _tokenId);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// @title Clock auction modified for sale of pandas
|
|
/// @notice We omit a fallback function to prevent accidental sends to this contract.
|
|
contract SaleClockAuction is ClockAuction {
|
|
|
|
// @dev Sanity check that allows us to ensure that we are pointing to the
|
|
// right auction in our setSaleAuctionAddress() call.
|
|
bool public isSaleClockAuction = true;
|
|
|
|
// Tracks last 5 sale price of gen0 panda sales
|
|
uint256 public gen0SaleCount;
|
|
uint256[5] public lastGen0SalePrices;
|
|
uint256 public constant SurpriseValue = 10 finney;
|
|
|
|
uint256[] CommonPanda;
|
|
uint256[] RarePanda;
|
|
uint256 CommonPandaIndex;
|
|
uint256 RarePandaIndex;
|
|
|
|
// Delegate constructor
|
|
function SaleClockAuction(address _nftAddr, uint256 _cut) public
|
|
ClockAuction(_nftAddr, _cut) {
|
|
CommonPandaIndex = 1;
|
|
RarePandaIndex = 1;
|
|
}
|
|
|
|
/// @dev Creates and begins a new auction.
|
|
/// @param _tokenId - ID of token to auction, sender must be owner.
|
|
/// @param _startingPrice - Price of item (in wei) at beginning of auction.
|
|
/// @param _endingPrice - Price of item (in wei) at end of auction.
|
|
/// @param _duration - Length of auction (in seconds).
|
|
/// @param _seller - Seller, if not the message sender
|
|
function createAuction(
|
|
uint256 _tokenId,
|
|
uint256 _startingPrice,
|
|
uint256 _endingPrice,
|
|
uint256 _duration,
|
|
address _seller
|
|
)
|
|
external
|
|
{
|
|
// Sanity check that no inputs overflow how many bits we've allocated
|
|
// to store them in the auction struct.
|
|
require(_startingPrice == uint256(uint128(_startingPrice)));
|
|
require(_endingPrice == uint256(uint128(_endingPrice)));
|
|
require(_duration == uint256(uint64(_duration)));
|
|
|
|
require(msg.sender == address(nonFungibleContract));
|
|
_escrow(_seller, _tokenId);
|
|
Auction memory auction = Auction(
|
|
_seller,
|
|
uint128(_startingPrice),
|
|
uint128(_endingPrice),
|
|
uint64(_duration),
|
|
uint64(now),
|
|
0
|
|
);
|
|
_addAuction(_tokenId, auction);
|
|
}
|
|
|
|
function createGen0Auction(
|
|
uint256 _tokenId,
|
|
uint256 _startingPrice,
|
|
uint256 _endingPrice,
|
|
uint256 _duration,
|
|
address _seller
|
|
)
|
|
external
|
|
{
|
|
// Sanity check that no inputs overflow how many bits we've allocated
|
|
// to store them in the auction struct.
|
|
require(_startingPrice == uint256(uint128(_startingPrice)));
|
|
require(_endingPrice == uint256(uint128(_endingPrice)));
|
|
require(_duration == uint256(uint64(_duration)));
|
|
|
|
require(msg.sender == address(nonFungibleContract));
|
|
_escrow(_seller, _tokenId);
|
|
Auction memory auction = Auction(
|
|
_seller,
|
|
uint128(_startingPrice),
|
|
uint128(_endingPrice),
|
|
uint64(_duration),
|
|
uint64(now),
|
|
1
|
|
);
|
|
_addAuction(_tokenId, auction);
|
|
}
|
|
|
|
/// @dev Updates lastSalePrice if seller is the nft contract
|
|
/// Otherwise, works the same as default bid method.
|
|
function bid(uint256 _tokenId)
|
|
external
|
|
payable
|
|
{
|
|
// _bid verifies token ID size
|
|
uint64 isGen0 = tokenIdToAuction[_tokenId].isGen0;
|
|
uint256 price = _bid(_tokenId, msg.value);
|
|
_transfer(msg.sender, _tokenId);
|
|
|
|
// If not a gen0 auction, exit
|
|
if (isGen0 == 1) {
|
|
// Track gen0 sale prices
|
|
lastGen0SalePrices[gen0SaleCount % 5] = price;
|
|
gen0SaleCount++;
|
|
}
|
|
}
|
|
|
|
function createPanda(uint256 _tokenId,uint256 _type)
|
|
external
|
|
{
|
|
require(msg.sender == address(nonFungibleContract));
|
|
if (_type == 0) {
|
|
CommonPanda.push(_tokenId);
|
|
}else {
|
|
RarePanda.push(_tokenId);
|
|
}
|
|
}
|
|
|
|
function surprisePanda()
|
|
external
|
|
payable
|
|
{
|
|
bytes32 bHash = keccak256(block.blockhash(block.number),block.blockhash(block.number-1));
|
|
uint256 PandaIndex;
|
|
if (bHash[25] > 0xC8) {
|
|
require(uint256(RarePanda.length) >= RarePandaIndex);
|
|
PandaIndex = RarePandaIndex;
|
|
RarePandaIndex ++;
|
|
|
|
} else{
|
|
require(uint256(CommonPanda.length) >= CommonPandaIndex);
|
|
PandaIndex = CommonPandaIndex;
|
|
CommonPandaIndex ++;
|
|
}
|
|
_transfer(msg.sender,PandaIndex);
|
|
}
|
|
|
|
function packageCount() external view returns(uint256 common,uint256 surprise) {
|
|
common = CommonPanda.length + 1 - CommonPandaIndex;
|
|
surprise = RarePanda.length + 1 - RarePandaIndex;
|
|
}
|
|
|
|
function averageGen0SalePrice() external view returns (uint256) {
|
|
uint256 sum = 0;
|
|
for (uint256 i = 0; i < 5; i++) {
|
|
sum += lastGen0SalePrices[i];
|
|
}
|
|
return sum / 5;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// @title Clock auction modified for sale of pandas
|
|
/// @notice We omit a fallback function to prevent accidental sends to this contract.
|
|
contract SaleClockAuctionERC20 is ClockAuction {
|
|
|
|
|
|
event AuctionERC20Created(uint256 tokenId, uint256 startingPrice, uint256 endingPrice, uint256 duration, address erc20Contract);
|
|
|
|
// @dev Sanity check that allows us to ensure that we are pointing to the
|
|
// right auction in our setSaleAuctionAddress() call.
|
|
bool public isSaleClockAuctionERC20 = true;
|
|
|
|
mapping (uint256 => address) public tokenIdToErc20Address;
|
|
|
|
mapping (address => uint256) public erc20ContractsSwitcher;
|
|
|
|
mapping (address => uint256) public balances;
|
|
|
|
// Delegate constructor
|
|
function SaleClockAuctionERC20(address _nftAddr, uint256 _cut) public
|
|
ClockAuction(_nftAddr, _cut) {}
|
|
|
|
function erc20ContractSwitch(address _erc20address, uint256 _onoff) external{
|
|
require (msg.sender == address(nonFungibleContract));
|
|
|
|
require (_erc20address != address(0));
|
|
|
|
erc20ContractsSwitcher[_erc20address] = _onoff;
|
|
}
|
|
/// @dev Creates and begins a new auction.
|
|
/// @param _tokenId - ID of token to auction, sender must be owner.
|
|
/// @param _startingPrice - Price of item (in wei) at beginning of auction.
|
|
/// @param _endingPrice - Price of item (in wei) at end of auction.
|
|
/// @param _duration - Length of auction (in seconds).
|
|
/// @param _seller - Seller, if not the message sender
|
|
function createAuction(
|
|
uint256 _tokenId,
|
|
address _erc20Address,
|
|
uint256 _startingPrice,
|
|
uint256 _endingPrice,
|
|
uint256 _duration,
|
|
address _seller
|
|
)
|
|
external
|
|
{
|
|
// Sanity check that no inputs overflow how many bits we've allocated
|
|
// to store them in the auction struct.
|
|
require(_startingPrice == uint256(uint128(_startingPrice)));
|
|
require(_endingPrice == uint256(uint128(_endingPrice)));
|
|
require(_duration == uint256(uint64(_duration)));
|
|
|
|
require(msg.sender == address(nonFungibleContract));
|
|
|
|
require (erc20ContractsSwitcher[_erc20Address] > 0);
|
|
|
|
_escrow(_seller, _tokenId);
|
|
Auction memory auction = Auction(
|
|
_seller,
|
|
uint128(_startingPrice),
|
|
uint128(_endingPrice),
|
|
uint64(_duration),
|
|
uint64(now),
|
|
0
|
|
);
|
|
_addAuctionERC20(_tokenId, auction, _erc20Address);
|
|
tokenIdToErc20Address[_tokenId] = _erc20Address;
|
|
}
|
|
|
|
/// @dev Adds an auction to the list of open auctions. Also fires the
|
|
/// AuctionCreated event.
|
|
/// @param _tokenId The ID of the token to be put on auction.
|
|
/// @param _auction Auction to add.
|
|
function _addAuctionERC20(uint256 _tokenId, Auction _auction, address _erc20address) internal {
|
|
// Require that all auctions have a duration of
|
|
// at least one minute. (Keeps our math from getting hairy!)
|
|
require(_auction.duration >= 1 minutes);
|
|
|
|
tokenIdToAuction[_tokenId] = _auction;
|
|
|
|
AuctionERC20Created(
|
|
uint256(_tokenId),
|
|
uint256(_auction.startingPrice),
|
|
uint256(_auction.endingPrice),
|
|
uint256(_auction.duration),
|
|
_erc20address
|
|
);
|
|
}
|
|
|
|
function bid(uint256 _tokenId)
|
|
external
|
|
payable{
|
|
// do nothing
|
|
}
|
|
|
|
/// @dev Updates lastSalePrice if seller is the nft contract
|
|
/// Otherwise, works the same as default bid method.
|
|
function bidERC20(uint256 _tokenId,uint256 _amount)
|
|
external
|
|
{
|
|
// _bid verifies token ID size
|
|
address seller = tokenIdToAuction[_tokenId].seller;
|
|
address _erc20address = tokenIdToErc20Address[_tokenId];
|
|
require (_erc20address != address(0));
|
|
uint256 price = _bidERC20(_erc20address,msg.sender,_tokenId, _amount);
|
|
_transfer(msg.sender, _tokenId);
|
|
delete tokenIdToErc20Address[_tokenId];
|
|
}
|
|
|
|
function cancelAuction(uint256 _tokenId)
|
|
external
|
|
{
|
|
Auction storage auction = tokenIdToAuction[_tokenId];
|
|
require(_isOnAuction(auction));
|
|
address seller = auction.seller;
|
|
require(msg.sender == seller);
|
|
_cancelAuction(_tokenId, seller);
|
|
delete tokenIdToErc20Address[_tokenId];
|
|
}
|
|
|
|
function withdrawERC20Balance(address _erc20Address, address _to) external returns(bool res) {
|
|
require (balances[_erc20Address] > 0);
|
|
require(msg.sender == address(nonFungibleContract));
|
|
ERC20(_erc20Address).transfer(_to, balances[_erc20Address]);
|
|
}
|
|
|
|
/// @dev Computes the price and transfers winnings.
|
|
/// Does NOT transfer ownership of token.
|
|
function _bidERC20(address _erc20Address,address _buyerAddress, uint256 _tokenId, uint256 _bidAmount)
|
|
internal
|
|
returns (uint256)
|
|
{
|
|
// Get a reference to the auction struct
|
|
Auction storage auction = tokenIdToAuction[_tokenId];
|
|
|
|
// Explicitly check that this auction is currently live.
|
|
// (Because of how Ethereum mappings work, we can't just count
|
|
// on the lookup above failing. An invalid _tokenId will just
|
|
// return an auction object that is all zeros.)
|
|
require(_isOnAuction(auction));
|
|
|
|
|
|
require (_erc20Address != address(0) && _erc20Address == tokenIdToErc20Address[_tokenId]);
|
|
|
|
|
|
// Check that the bid is greater than or equal to the current price
|
|
uint256 price = _currentPrice(auction);
|
|
require(_bidAmount >= price);
|
|
|
|
// Grab a reference to the seller before the auction struct
|
|
// gets deleted.
|
|
address seller = auction.seller;
|
|
|
|
// The bid is good! Remove the auction before sending the fees
|
|
// to the sender so we can't have a reentrancy attack.
|
|
_removeAuction(_tokenId);
|
|
|
|
// Transfer proceeds to seller (if there are any!)
|
|
if (price > 0) {
|
|
// Calculate the auctioneer's cut.
|
|
// (NOTE: _computeCut() is guaranteed to return a
|
|
// value <= price, so this subtraction can't go negative.)
|
|
uint256 auctioneerCut = _computeCut(price);
|
|
uint256 sellerProceeds = price - auctioneerCut;
|
|
|
|
// Send Erc20 Token to seller should call Erc20 contract
|
|
// Reference to contract
|
|
require(ERC20(_erc20Address).transferFrom(_buyerAddress,seller,sellerProceeds));
|
|
if (auctioneerCut > 0){
|
|
require(ERC20(_erc20Address).transferFrom(_buyerAddress,address(this),auctioneerCut));
|
|
balances[_erc20Address] += auctioneerCut;
|
|
}
|
|
}
|
|
|
|
// Tell the world!
|
|
AuctionSuccessful(_tokenId, price, msg.sender);
|
|
|
|
return price;
|
|
}
|
|
}
|
|
|
|
|
|
/// @title Handles creating auctions for sale and siring of pandas.
|
|
/// This wrapper of ReverseAuction exists only so that users can create
|
|
/// auctions with only one transaction.
|
|
contract PandaAuction is PandaBreeding {
|
|
|
|
// @notice The auction contract variables are defined in PandaBase to allow
|
|
// us to refer to them in PandaOwnership to prevent accidental transfers.
|
|
// `saleAuction` refers to the auction for gen0 and p2p sale of pandas.
|
|
// `siringAuction` refers to the auction for siring rights of pandas.
|
|
|
|
/// @dev Sets the reference to the sale auction.
|
|
/// @param _address - Address of sale contract.
|
|
function setSaleAuctionAddress(address _address) external onlyCEO {
|
|
SaleClockAuction candidateContract = SaleClockAuction(_address);
|
|
|
|
// NOTE: verify that a contract is what we expect - https://github.com/Lunyr/crowdsale-contracts/blob/cfadd15986c30521d8ba7d5b6f57b4fefcc7ac38/contracts/LunyrToken.sol#L117
|
|
require(candidateContract.isSaleClockAuction());
|
|
|
|
// Set the new contract address
|
|
saleAuction = candidateContract;
|
|
}
|
|
|
|
function setSaleAuctionERC20Address(address _address) external onlyCEO {
|
|
SaleClockAuctionERC20 candidateContract = SaleClockAuctionERC20(_address);
|
|
|
|
// NOTE: verify that a contract is what we expect - https://github.com/Lunyr/crowdsale-contracts/blob/cfadd15986c30521d8ba7d5b6f57b4fefcc7ac38/contracts/LunyrToken.sol#L117
|
|
require(candidateContract.isSaleClockAuctionERC20());
|
|
|
|
// Set the new contract address
|
|
saleAuctionERC20 = candidateContract;
|
|
}
|
|
|
|
/// @dev Sets the reference to the siring auction.
|
|
/// @param _address - Address of siring contract.
|
|
function setSiringAuctionAddress(address _address) external onlyCEO {
|
|
SiringClockAuction candidateContract = SiringClockAuction(_address);
|
|
|
|
// NOTE: verify that a contract is what we expect - https://github.com/Lunyr/crowdsale-contracts/blob/cfadd15986c30521d8ba7d5b6f57b4fefcc7ac38/contracts/LunyrToken.sol#L117
|
|
require(candidateContract.isSiringClockAuction());
|
|
|
|
// Set the new contract address
|
|
siringAuction = candidateContract;
|
|
}
|
|
|
|
/// @dev Put a panda up for auction.
|
|
/// Does some ownership trickery to create auctions in one tx.
|
|
function createSaleAuction(
|
|
uint256 _pandaId,
|
|
uint256 _startingPrice,
|
|
uint256 _endingPrice,
|
|
uint256 _duration
|
|
)
|
|
external
|
|
whenNotPaused
|
|
{
|
|
// Auction contract checks input sizes
|
|
// If panda is already on any auction, this will throw
|
|
// because it will be owned by the auction contract.
|
|
require(_owns(msg.sender, _pandaId));
|
|
// Ensure the panda is not pregnant to prevent the auction
|
|
// contract accidentally receiving ownership of the child.
|
|
// NOTE: the panda IS allowed to be in a cooldown.
|
|
require(!isPregnant(_pandaId));
|
|
_approve(_pandaId, saleAuction);
|
|
// Sale auction throws if inputs are invalid and clears
|
|
// transfer and sire approval after escrowing the panda.
|
|
saleAuction.createAuction(
|
|
_pandaId,
|
|
_startingPrice,
|
|
_endingPrice,
|
|
_duration,
|
|
msg.sender
|
|
);
|
|
}
|
|
|
|
/// @dev Put a panda up for auction.
|
|
/// Does some ownership trickery to create auctions in one tx.
|
|
function createSaleAuctionERC20(
|
|
uint256 _pandaId,
|
|
address _erc20address,
|
|
uint256 _startingPrice,
|
|
uint256 _endingPrice,
|
|
uint256 _duration
|
|
)
|
|
external
|
|
whenNotPaused
|
|
{
|
|
// Auction contract checks input sizes
|
|
// If panda is already on any auction, this will throw
|
|
// because it will be owned by the auction contract.
|
|
require(_owns(msg.sender, _pandaId));
|
|
// Ensure the panda is not pregnant to prevent the auction
|
|
// contract accidentally receiving ownership of the child.
|
|
// NOTE: the panda IS allowed to be in a cooldown.
|
|
require(!isPregnant(_pandaId));
|
|
_approve(_pandaId, saleAuctionERC20);
|
|
// Sale auction throws if inputs are invalid and clears
|
|
// transfer and sire approval after escrowing the panda.
|
|
saleAuctionERC20.createAuction(
|
|
_pandaId,
|
|
_erc20address,
|
|
_startingPrice,
|
|
_endingPrice,
|
|
_duration,
|
|
msg.sender
|
|
);
|
|
}
|
|
|
|
function switchSaleAuctionERC20For(address _erc20address, uint256 _onoff) external onlyCOO{
|
|
saleAuctionERC20.erc20ContractSwitch(_erc20address,_onoff);
|
|
}
|
|
|
|
|
|
/// @dev Put a panda up for auction to be sire.
|
|
/// Performs checks to ensure the panda can be sired, then
|
|
/// delegates to reverse auction.
|
|
function createSiringAuction(
|
|
uint256 _pandaId,
|
|
uint256 _startingPrice,
|
|
uint256 _endingPrice,
|
|
uint256 _duration
|
|
)
|
|
external
|
|
whenNotPaused
|
|
{
|
|
// Auction contract checks input sizes
|
|
// If panda is already on any auction, this will throw
|
|
// because it will be owned by the auction contract.
|
|
require(_owns(msg.sender, _pandaId));
|
|
require(isReadyToBreed(_pandaId));
|
|
_approve(_pandaId, siringAuction);
|
|
// Siring auction throws if inputs are invalid and clears
|
|
// transfer and sire approval after escrowing the panda.
|
|
siringAuction.createAuction(
|
|
_pandaId,
|
|
_startingPrice,
|
|
_endingPrice,
|
|
_duration,
|
|
msg.sender
|
|
);
|
|
}
|
|
|
|
/// @dev Completes a siring auction by bidding.
|
|
/// Immediately breeds the winning matron with the sire on auction.
|
|
/// @param _sireId - ID of the sire on auction.
|
|
/// @param _matronId - ID of the matron owned by the bidder.
|
|
function bidOnSiringAuction(
|
|
uint256 _sireId,
|
|
uint256 _matronId
|
|
)
|
|
external
|
|
payable
|
|
whenNotPaused
|
|
{
|
|
// Auction contract checks input sizes
|
|
require(_owns(msg.sender, _matronId));
|
|
require(isReadyToBreed(_matronId));
|
|
require(_canBreedWithViaAuction(_matronId, _sireId));
|
|
|
|
// Define the current price of the auction.
|
|
uint256 currentPrice = siringAuction.getCurrentPrice(_sireId);
|
|
require(msg.value >= currentPrice + autoBirthFee);
|
|
|
|
// Siring auction will throw if the bid fails.
|
|
siringAuction.bid.value(msg.value - autoBirthFee)(_sireId);
|
|
_breedWith(uint32(_matronId), uint32(_sireId), msg.sender);
|
|
}
|
|
|
|
/// @dev Transfers the balance of the sale auction contract
|
|
/// to the PandaCore contract. We use two-step withdrawal to
|
|
/// prevent two transfer calls in the auction bid function.
|
|
function withdrawAuctionBalances() external onlyCLevel {
|
|
saleAuction.withdrawBalance();
|
|
siringAuction.withdrawBalance();
|
|
}
|
|
|
|
|
|
function withdrawERC20Balance(address _erc20Address, address _to) external onlyCLevel {
|
|
require(saleAuctionERC20 != address(0));
|
|
saleAuctionERC20.withdrawERC20Balance(_erc20Address,_to);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// @title all functions related to creating kittens
|
|
contract PandaMinting is PandaAuction {
|
|
|
|
// Limits the number of cats the contract owner can ever create.
|
|
//uint256 public constant PROMO_CREATION_LIMIT = 5000;
|
|
uint256 public constant GEN0_CREATION_LIMIT = 45000;
|
|
|
|
|
|
// Constants for gen0 auctions.
|
|
uint256 public constant GEN0_STARTING_PRICE = 100 finney;
|
|
uint256 public constant GEN0_AUCTION_DURATION = 1 days;
|
|
uint256 public constant OPEN_PACKAGE_PRICE = 10 finney;
|
|
|
|
|
|
// Counts the number of cats the contract owner has created.
|
|
//uint256 public promoCreatedCount;
|
|
|
|
|
|
/// @dev we can create promo kittens, up to a limit. Only callable by COO
|
|
/// @param _genes the encoded genes of the kitten to be created, any value is accepted
|
|
/// @param _owner the future owner of the created kittens. Default to contract COO
|
|
function createWizzPanda(uint256[2] _genes, uint256 _generation, address _owner) external onlyCOO {
|
|
address pandaOwner = _owner;
|
|
if (pandaOwner == address(0)) {
|
|
pandaOwner = cooAddress;
|
|
}
|
|
|
|
_createPanda(0, 0, _generation, _genes, pandaOwner);
|
|
}
|
|
|
|
/// @dev create pandaWithGenes
|
|
/// @param _genes panda genes
|
|
/// @param _type 0 common 1 rare
|
|
function createPanda(uint256[2] _genes,uint256 _generation,uint256 _type)
|
|
external
|
|
payable
|
|
onlyCOO
|
|
whenNotPaused
|
|
{
|
|
require(msg.value >= OPEN_PACKAGE_PRICE);
|
|
uint256 kittenId = _createPanda(0, 0, _generation, _genes, saleAuction);
|
|
saleAuction.createPanda(kittenId,_type);
|
|
}
|
|
|
|
//function buyPandaERC20(address _erc20Address, address _buyerAddress, uint256 _pandaID, uint256 _amount)
|
|
//external
|
|
//onlyCOO
|
|
//whenNotPaused {
|
|
// saleAuctionERC20.bid(_erc20Address, _buyerAddress, _pandaID, _amount);
|
|
//}
|
|
|
|
/// @dev Creates a new gen0 panda with the given genes and
|
|
/// creates an auction for it.
|
|
//function createGen0Auction(uint256[2] _genes) external onlyCOO {
|
|
// require(gen0CreatedCount < GEN0_CREATION_LIMIT);
|
|
//
|
|
// uint256 pandaId = _createPanda(0, 0, 0, _genes, address(this));
|
|
// _approve(pandaId, saleAuction);
|
|
//
|
|
// saleAuction.createAuction(
|
|
// pandaId,
|
|
// _computeNextGen0Price(),
|
|
// 0,
|
|
// GEN0_AUCTION_DURATION,
|
|
// address(this)
|
|
// );
|
|
//
|
|
// gen0CreatedCount++;
|
|
//}
|
|
|
|
function createGen0Auction(uint256 _pandaId) external onlyCOO {
|
|
require(_owns(msg.sender, _pandaId));
|
|
//require(pandas[_pandaId].generation==1);
|
|
|
|
_approve(_pandaId, saleAuction);
|
|
|
|
saleAuction.createGen0Auction(
|
|
_pandaId,
|
|
_computeNextGen0Price(),
|
|
0,
|
|
GEN0_AUCTION_DURATION,
|
|
msg.sender
|
|
);
|
|
}
|
|
|
|
/// @dev Computes the next gen0 auction starting price, given
|
|
/// the average of the past 5 prices + 50%.
|
|
function _computeNextGen0Price() internal view returns(uint256) {
|
|
uint256 avePrice = saleAuction.averageGen0SalePrice();
|
|
|
|
// Sanity check to ensure we don't overflow arithmetic
|
|
require(avePrice == uint256(uint128(avePrice)));
|
|
|
|
uint256 nextPrice = avePrice + (avePrice / 2);
|
|
|
|
// We never auction for less than starting price
|
|
if (nextPrice < GEN0_STARTING_PRICE) {
|
|
nextPrice = GEN0_STARTING_PRICE;
|
|
}
|
|
|
|
return nextPrice;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// @title CryptoPandas: Collectible, breedable, and oh-so-adorable cats on the Ethereum blockchain.
|
|
/// @author Axiom Zen (https://www.axiomzen.co)
|
|
/// @dev The main CryptoPandas contract, keeps track of kittens so they don't wander around and get lost.
|
|
contract PandaCore is PandaMinting {
|
|
|
|
// This is the main CryptoPandas contract. In order to keep our code seperated into logical sections,
|
|
// we've broken it up in two ways. First, we have several seperately-instantiated sibling contracts
|
|
// that handle auctions and our super-top-secret genetic combination algorithm. The auctions are
|
|
// seperate since their logic is somewhat complex and there's always a risk of subtle bugs. By keeping
|
|
// them in their own contracts, we can upgrade them without disrupting the main contract that tracks
|
|
// panda ownership. The genetic combination algorithm is kept seperate so we can open-source all of
|
|
// the rest of our code without making it _too_ easy for folks to figure out how the genetics work.
|
|
// Don't worry, I'm sure someone will reverse engineer it soon enough!
|
|
//
|
|
// Secondly, we break the core contract into multiple files using inheritence, one for each major
|
|
// facet of functionality of CK. This allows us to keep related code bundled together while still
|
|
// avoiding a single giant file with everything in it. The breakdown is as follows:
|
|
//
|
|
// - PandaBase: This is where we define the most fundamental code shared throughout the core
|
|
// functionality. This includes our main data storage, constants and data types, plus
|
|
// internal functions for managing these items.
|
|
//
|
|
// - PandaAccessControl: This contract manages the various addresses and constraints for operations
|
|
// that can be executed only by specific roles. Namely CEO, CFO and COO.
|
|
//
|
|
// - PandaOwnership: This provides the methods required for basic non-fungible token
|
|
// transactions, following the draft ERC-721 spec (https://github.com/ethereum/EIPs/issues/721).
|
|
//
|
|
// - PandaBreeding: This file contains the methods necessary to breed cats together, including
|
|
// keeping track of siring offers, and relies on an external genetic combination contract.
|
|
//
|
|
// - PandaAuctions: Here we have the public methods for auctioning or bidding on cats or siring
|
|
// services. The actual auction functionality is handled in two sibling contracts (one
|
|
// for sales and one for siring), while auction creation and bidding is mostly mediated
|
|
// through this facet of the core contract.
|
|
//
|
|
// - PandaMinting: This final facet contains the functionality we use for creating new gen0 cats.
|
|
// the community is new), and all others can only be created and then immediately put up
|
|
// for auction via an algorithmically determined starting price. Regardless of how they
|
|
// are created, there is a hard limit of 50k gen0 cats. After that, it's all up to the
|
|
// community to breed, breed, breed!
|
|
|
|
// Set in case the core contract is broken and an upgrade is required
|
|
address public newContractAddress;
|
|
|
|
|
|
/// @notice Creates the main CryptoPandas smart contract instance.
|
|
function PandaCore() public {
|
|
// Starts paused.
|
|
paused = true;
|
|
|
|
// the creator of the contract is the initial CEO
|
|
ceoAddress = msg.sender;
|
|
|
|
// the creator of the contract is also the initial COO
|
|
cooAddress = msg.sender;
|
|
|
|
// move these code to init(), so we not excceed gas limit
|
|
//uint256[2] memory _genes = [uint256(-1),uint256(-1)];
|
|
|
|
//wizzPandaQuota[1] = 100;
|
|
|
|
//_createPanda(0, 0, 0, _genes, address(0));
|
|
}
|
|
|
|
/// init contract
|
|
function init() external onlyCEO whenPaused {
|
|
// make sure init() only run once
|
|
require(pandas.length == 0);
|
|
// start with the mythical kitten 0 - so we don't have generation-0 parent issues
|
|
uint256[2] memory _genes = [uint256(-1),uint256(-1)];
|
|
|
|
wizzPandaQuota[1] = 100;
|
|
_createPanda(0, 0, 0, _genes, address(0));
|
|
}
|
|
|
|
/// @dev Used to mark the smart contract as upgraded, in case there is a serious
|
|
/// breaking bug. This method does nothing but keep track of the new contract and
|
|
/// emit a message indicating that the new address is set. It's up to clients of this
|
|
/// contract to update to the new contract address in that case. (This contract will
|
|
/// be paused indefinitely if such an upgrade takes place.)
|
|
/// @param _v2Address new address
|
|
function setNewAddress(address _v2Address) external onlyCEO whenPaused {
|
|
// See README.md for updgrade plan
|
|
newContractAddress = _v2Address;
|
|
ContractUpgrade(_v2Address);
|
|
}
|
|
|
|
|
|
/// @notice No tipping!
|
|
/// @dev Reject all Ether from being sent here, unless it's from one of the
|
|
/// two auction contracts. (Hopefully, we can prevent user accidents.)
|
|
function() external payable {
|
|
require(
|
|
msg.sender == address(saleAuction) ||
|
|
msg.sender == address(siringAuction)
|
|
);
|
|
}
|
|
|
|
/// @notice Returns all the relevant information about a specific panda.
|
|
/// @param _id The ID of the panda of interest.
|
|
function getPanda(uint256 _id)
|
|
external
|
|
view
|
|
returns (
|
|
bool isGestating,
|
|
bool isReady,
|
|
uint256 cooldownIndex,
|
|
uint256 nextActionAt,
|
|
uint256 siringWithId,
|
|
uint256 birthTime,
|
|
uint256 matronId,
|
|
uint256 sireId,
|
|
uint256 generation,
|
|
uint256[2] genes
|
|
) {
|
|
Panda storage kit = pandas[_id];
|
|
|
|
// if this variable is 0 then it's not gestating
|
|
isGestating = (kit.siringWithId != 0);
|
|
isReady = (kit.cooldownEndBlock <= block.number);
|
|
cooldownIndex = uint256(kit.cooldownIndex);
|
|
nextActionAt = uint256(kit.cooldownEndBlock);
|
|
siringWithId = uint256(kit.siringWithId);
|
|
birthTime = uint256(kit.birthTime);
|
|
matronId = uint256(kit.matronId);
|
|
sireId = uint256(kit.sireId);
|
|
generation = uint256(kit.generation);
|
|
genes = kit.genes;
|
|
}
|
|
|
|
/// @dev Override unpause so it requires all external contract addresses
|
|
/// to be set before contract can be unpaused. Also, we can't have
|
|
/// newContractAddress set either, because then the contract was upgraded.
|
|
/// @notice This is public rather than external so we can call super.unpause
|
|
/// without using an expensive CALL.
|
|
function unpause() public onlyCEO whenPaused {
|
|
require(saleAuction != address(0));
|
|
require(siringAuction != address(0));
|
|
require(geneScience != address(0));
|
|
require(newContractAddress == address(0));
|
|
|
|
// Actually unpause the contract.
|
|
super.unpause();
|
|
}
|
|
|
|
// @dev Allows the CFO to capture the balance available to the contract.
|
|
function withdrawBalance() external onlyCFO {
|
|
uint256 balance = this.balance;
|
|
// Subtract all the currently pregnant kittens we have, plus 1 of margin.
|
|
uint256 subtractFees = (pregnantPandas + 1) * autoBirthFee;
|
|
|
|
if (balance > subtractFees) {
|
|
// <yes> <report> UNCHECKED_LL_CALLS
|
|
cfoAddress.send(balance - subtractFees);
|
|
}
|
|
}
|
|
} |