Skip to content

Instantly share code, notes, and snippets.

@SibghatUllah1997

SibghatUllah1997/BITTUP.sol

Created May 5, 2021 15:31
Show Gist options
  • Save SibghatUllah1997/93344aef74111f5fbe2effebfd9abaa2 to your computer and use it in GitHub Desktop.
Save SibghatUllah1997/93344aef74111f5fbe2effebfd9abaa2 to your computer and use it in GitHub Desktop.
Download ZIP
Created using remix-ide: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://remix.ethereum.org/#version=soljson-v0.5.17+commit.d19bba13.js&optimize=true&runs=200&gist=
Raw
birb.sol
//SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 internal _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18.
*
* To select a different value for {decimals}, use {_setupDecimals}.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
* called.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Sets {decimals} to a value other than the default one of 18.
*
* WARNING: This function should only be called from the constructor. Most
* applications that interact with token contracts will not expect
* {decimals} to ever change, and may work incorrectly if it does.
*/
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IPancakePair {
function sync() external;
}
interface IPancakeFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract BIRBToken is ERC20, Ownable {
using SafeMath for uint256;
uint256 public lastHatchTime;
uint256 public totalHatched;
uint256 public constant HATCH_RATE = 6;
uint256 public constant HATCH_REWARD = 1;
uint256 public constant POOL_REWARD = 48;
uint256 public lastRewardTime;
uint256 public rewardNest;
mapping (address => uint256) public claimedRewards;
mapping (address => uint256) public unclaimedRewards;
mapping (uint256 => address) public topHolder;
uint256 public constant MAX_TOP_HOLDERS = 200;
uint256 internal totalTopHolders;
address public pauser;
bool public paused;
ERC20 internal WBNB = ERC20(0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd);
IPancakeFactory public pancakeSwapFactory = IPancakeFactory(0x1d6889b69b45a173D391AC6482406581FB3DA210);
address public pancakeSwapPool;
modifier onlyPauser() {
require(pauser == _msgSender(), "BIRBToken: caller is not the pauser.");
_;
}
modifier whenNotPaused() {
require(!paused, "BIRBToken: paused");
_;
}
modifier when3DaysBetweenLastSnapshot() {
require((now - lastRewardTime) >= 15 minutes, "BIRBToken: not enough days since last snapshot taken.");
_;
}
event MintNewSupply(address user, uint newSupply);
event PoolHatched(address user, uint256 hatchAmount, uint256 newTotalSupply, uint256 newPancakeSwapPoolSupply, uint256 userReward, uint256 newNestReward);
event UnclaimedRewardsDistribution(uint256 totalTopHolders, uint256 totalPayout, uint256 snapshot);
event RewardClaimed(address indexed topHolderAddress, uint256 claimedReward);
event PancakePoolCreated(address pancakeSwapPoole, address WETH, address createdBy);
event newPauserAdded(address newPauserAddress, address updatedBy);
event contractPaused(bool status, address updatedBy);
event contractUnPaused(bool status, uint256 lastHatchTime, uint256 lastRewardTime, uint256 rewardNest, address updatedBy);
constructor()
public
Ownable()
ERC20("BIRB Token", "BIRB")
{
_mint(msg.sender, 100000000000000000000);
setPauser(msg.sender);
paused = true;
}
function mintTokens(uint256 newSupply) external onlyOwner {
_mint(msg.sender, newSupply);
emit MintNewSupply(msg.sender,newSupply);
}
function setPancakeSwapPool() external onlyOwner {
require(pancakeSwapPool == address(0), "BIRBToken: Pool already created");
pancakeSwapPool = pancakeSwapFactory.createPair(address(WBNB), address(this));
emit PancakePoolCreated(pancakeSwapPool, address(WBNB), msg.sender);
}
function setPauser(address newPauser) public onlyOwner {
require(newPauser != address(0), "BIRBToken: pauser is the zero address.");
pauser = newPauser;
emit newPauserAdded(newPauser, msg.sender);
}
function unpause() external onlyPauser {
paused = false;
lastHatchTime = now;
lastRewardTime = now;
rewardNest = 0;
emit contractUnPaused(paused, lastHatchTime, lastRewardTime, rewardNest, msg.sender);
}
function pause() external onlyPauser {
paused = true;
emit contractPaused(paused, msg.sender);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
require(!paused || msg.sender == pauser, "BIRBToken: token transfer while paused and not pauser role.");
}
function getInfoFor(address addr) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
return (
balanceOf(addr),
claimedRewards[addr],
balanceOf(pancakeSwapPool),
_totalSupply,
totalHatched,
getHatchAmount(),
lastHatchTime,
lastRewardTime,
rewardNest
);
}
function hatchNest() external {
uint256 hatchAmount = getHatchAmount();
require(hatchAmount >= 1 ether, "hatchNest: min grill amount not reached.");
lastHatchTime = now;
uint256 userReward = hatchAmount.mul(HATCH_REWARD).div(100);
uint256 poolReward = hatchAmount.mul(POOL_REWARD).div(100);
uint256 finalHatch = hatchAmount.sub(userReward).sub(poolReward);
_totalSupply = _totalSupply.sub(finalHatch);
_balances[pancakeSwapPool] = _balances[pancakeSwapPool].sub(hatchAmount);
totalHatched = totalHatched.add(finalHatch);
rewardNest = rewardNest.add(poolReward);
_balances[msg.sender] = _balances[msg.sender].add(userReward);
IPancakePair(pancakeSwapPool).sync();
emit PoolHatched(msg.sender, hatchAmount, _totalSupply, balanceOf(pancakeSwapPool), userReward, poolReward);
}
function getHatchAmount() public view returns (uint256) {
if (paused) return 0;
require((now - lastHatchTime) >= 600, "BIRBToken: Already Hatched");
uint256 tokensInPancakeSwap = balanceOf(pancakeSwapPool);
return (tokensInPancakeSwap.mul(HATCH_RATE).div(100));
}
function updateTopHolders(address[] calldata holders) external onlyOwner when3DaysBetweenLastSnapshot {
require(holders.length > 0, "BIRBToken: No Holder addresses found");
totalTopHolders = holders.length < MAX_TOP_HOLDERS ? holders.length : MAX_TOP_HOLDERS;
uint256 toPayout = rewardNest.div(totalTopHolders);
uint256 totalPayoutSent = rewardNest;
for (uint256 i = 0; i < totalTopHolders; i++) {
topHolder[i] = holders[i];
unclaimedRewards[holders[i]] = unclaimedRewards[holders[i]].add(toPayout);
}
lastRewardTime = now;
rewardNest = 0;
emit UnclaimedRewardsDistribution(totalTopHolders, totalPayoutSent, now);
}
function claimRewards() external {
require(paused == false, "BIRBToken: Contract is paused");
require(unclaimedRewards[msg.sender] > 0, "BIRBToken: Nothing left to claim.");
uint256 unclaimedReward = unclaimedRewards[msg.sender];
unclaimedRewards[msg.sender] = 0;
claimedRewards[msg.sender] = claimedRewards[msg.sender].add(unclaimedReward);
_balances[msg.sender] = _balances[msg.sender].add(unclaimedReward);
emit RewardClaimed(msg.sender, unclaimedReward);
}
}
Raw
birbeth.sol
//SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 internal _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18.
*
* To select a different value for {decimals}, use {_setupDecimals}.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
* called.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Sets {decimals} to a value other than the default one of 18.
*
* WARNING: This function should only be called from the constructor. Most
* applications that interact with token contracts will not expect
* {decimals} to ever change, and may work incorrectly if it does.
*/
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IPancakePair {
function sync() external;
}
interface IPancakeFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract BIRBToken is ERC20, Ownable {
using SafeMath for uint256;
uint256 public lastHatchTime;
uint256 public totalHatched;
uint256 public constant HATCH_RATE = 6;
uint256 public constant HATCH_REWARD = 1;
uint256 public constant POOL_REWARD = 48;
uint256 public lastRewardTime;
uint256 public rewardNest;
mapping (address => uint256) public claimedRewards;
mapping (address => uint256) public unclaimedRewards;
mapping (uint256 => address) public topHolder;
//changed from 50 to 200
uint256 public constant MAX_TOP_HOLDERS = 200;
uint256 internal totalTopHolders;
address public pauser;
bool public paused;
ERC20 internal WBNB = ERC20(0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd);
IPancakeFactory public pancakeSwapFactory = IPancakeFactory(0x1d6889b69b45a173D391AC6482406581FB3DA210);
address public pancakeSwapPool;
modifier onlyPauser() {
require(pauser == _msgSender(), "BIRBToken: caller is not the pauser.");
_;
}
modifier whenNotPaused() {
require(!paused, "BIRBToken: paused");
_;
}
modifier when3DaysBetweenLastSnapshot() {
require((now - lastRewardTime) >= 3 minutes, "BIRBToken: not enough days since last snapshot taken.");
_;
}
event MintNewSupply(address user, uint newSupply);
event PoolHatched(address user, uint256 hatchAmount, uint256 newTotalSupply, uint256 newPancakeSwapPoolSupply, uint256 userReward, uint256 newNestReward);
event UnclaimedRewardsDistribution(uint256 totalTopHolders, uint256 totalPayout, uint256 snapshot);
event RewardClaimed(address indexed topHolderAddress, uint256 claimedReward);
event PancakePoolCreated(address pancakeSwapPoole, address WETH, address createdBy);
event newPauserAdded(address newPauserAddress, address updatedBy);
event contractPaused(bool status, address updatedBy);
event contractUnPaused(bool status, uint256 lastHatchTime, uint256 lastRewardTime, uint256 rewardNest, address updatedBy);
constructor()
public
Ownable()
ERC20("BIRB Token", "BIRB")
{
_mint(msg.sender, 100000000000000000000);
setPauser(msg.sender);
paused = true;
}
function mintTokens(uint256 newSupply) external onlyOwner {
_mint(msg.sender, newSupply);
emit MintNewSupply(msg.sender,newSupply);
}
function setPancakeSwapPool() external onlyOwner {
require(pancakeSwapPool == address(0), "BIRBToken: Pool already created");
pancakeSwapPool = pancakeSwapFactory.createPair(address(WBNB), address(this));
emit PancakePoolCreated(pancakeSwapPool, address(WBNB), msg.sender);
}
function setPauser(address newPauser) public onlyOwner {
require(newPauser != address(0), "BIRBToken: pauser is the zero address.");
pauser = newPauser;
emit newPauserAdded(newPauser, msg.sender);
}
function unpause() external onlyPauser {
paused = false;
lastHatchTime = now;
lastRewardTime = now;
rewardNest = 0;
emit contractUnPaused(paused, lastHatchTime, lastRewardTime, rewardNest, msg.sender);
}
function pause() external onlyPauser {
paused = true;
emit contractPaused(paused, msg.sender);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
require(!paused || msg.sender == pauser, "BIRBToken: token transfer while paused and not pauser role.");
}
function getInfoFor(address addr) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
return (
balanceOf(addr),
claimedRewards[addr],
balanceOf(pancakeSwapPool),
_totalSupply,
totalHatched,
getHatchAmount(),
lastHatchTime,
lastRewardTime,
rewardNest
);
}
function hatchNest() external {
uint256 hatchAmount = getHatchAmount();
require(hatchAmount >= 1 ether, "hatchNest: min grill amount not reached.");
lastHatchTime = now;
uint256 userReward = hatchAmount.mul(HATCH_REWARD).div(100);
uint256 poolReward = hatchAmount.mul(POOL_REWARD).div(100);
uint256 finalHatch = hatchAmount.sub(userReward).sub(poolReward);
_totalSupply = _totalSupply.sub(finalHatch);
_balances[pancakeSwapPool] = _balances[pancakeSwapPool].sub(hatchAmount);
totalHatched = totalHatched.add(finalHatch);
rewardNest = rewardNest.add(poolReward);
_balances[msg.sender] = _balances[msg.sender].add(userReward);
IPancakePair(pancakeSwapPool).sync();
emit PoolHatched(msg.sender, hatchAmount, _totalSupply, balanceOf(pancakeSwapPool), userReward, poolReward);
}
function getHatchAmount() public view returns (uint256) {
if (paused) return 0;
require((now - lastHatchTime) >= 3 minutes, "BIRBToken: Already Hatched");
uint256 tokensInPancakeSwap = balanceOf(pancakeSwapPool);
return (tokensInPancakeSwap.mul(HATCH_RATE).div(100));
}
function updateTopHolders(address[] calldata holders) external onlyOwner when3DaysBetweenLastSnapshot {
require(holders.length > 0, "BIRBToken: No Holder addresses found");
totalTopHolders = holders.length < MAX_TOP_HOLDERS ? holders.length : MAX_TOP_HOLDERS;
uint256 toPayout = rewardNest.div(totalTopHolders);
uint256 totalPayoutSent = rewardNest;
for (uint256 i = 0; i < totalTopHolders; i++) {
topHolder[i] = holders[i];
unclaimedRewards[holders[i]] = unclaimedRewards[holders[i]].add(toPayout);
}
lastRewardTime = now;
rewardNest = 0;
emit UnclaimedRewardsDistribution(totalTopHolders, totalPayoutSent, now);
}
function claimRewards() external {
require(paused == false, "BIRBToken: Contract is paused");
require(unclaimedRewards[msg.sender] > 0, "BIRBToken: Nothing left to claim.");
uint256 unclaimedReward = unclaimedRewards[msg.sender];
unclaimedRewards[msg.sender] = 0;
claimedRewards[msg.sender] = claimedRewards[msg.sender].add(unclaimedReward);
_balances[msg.sender] = _balances[msg.sender].add(unclaimedReward);
emit RewardClaimed(msg.sender, unclaimedReward);
}
}
Raw
BITTUP.sol
/**
*Submitted for verification at Etherscan.io on 2020-07-05
*/
pragma solidity ^0.5.12;
contract LC4 {
string public name = "LC4";
string public symbol = "LC4";
uint8 public constant decimals = 8;
uint256 totalSupply_ = 2100000000000000;
address private _owner;
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Transfer(address indexed from, address indexed to, uint tokens);
event NameChanged(string newName, address by);
event SymbolChanged(string newName, address by);
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
using SafeMath for uint256;
constructor() public {
_owner = msg.sender;
balances[0x70b039A62E73Ad23e64ADA6eA9c60d3801191128] = totalSupply_;
emit Transfer(address(0), 0x70b039A62E73Ad23e64ADA6eA9c60d3801191128, totalSupply_);
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function balanceOf(address tokenOwner) public view returns (uint) {
return balances[tokenOwner];
}
function transfer(address receiver, uint numTokens) public returns (bool) {
require(numTokens <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(numTokens);
balances[receiver] = balances[receiver].add(numTokens);
emit Transfer(msg.sender, receiver, numTokens);
return true;
}
function approve(address delegate, uint numTokens) public returns (bool) {
allowed[msg.sender][delegate] = numTokens;
emit Approval(msg.sender, delegate, numTokens);
return true;
}
function allowance(address owner, address delegate) public view returns (uint) {
return allowed[owner][delegate];
}
function transferFrom(address owner, address buyer, uint numTokens) public returns (bool) {
require(numTokens <= balances[owner]);
require(numTokens <= allowed[owner][msg.sender]);
balances[owner] = balances[owner].sub(numTokens);
allowed[owner][msg.sender] = allowed[owner][msg.sender].sub(numTokens);
balances[buyer] = balances[buyer].add(numTokens);
emit Transfer(owner, buyer, numTokens);
return true;
}
function changeName(string memory _name) public onlyOwner{
name = _name;
emit NameChanged(_name, msg.sender);
}
function changeSymbol(string memory _symbol) public onlyOwner{
symbol = _symbol;
emit SymbolChanged(_symbol, msg.sender);
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(isOwner(), "caller is not the owner");
_;
}
/**
* @dev Returns true if the caller is the current owner.
*/
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
Raw
Chimera.sol
pragma solidity ^0.4.24;
/**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
/**
* @dev Adds two numbers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
/**
* @dev Divides two numbers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC165 {
/**
* @notice Query if a contract implements an interface
* @param interfaceId The interface identifier, as specified in ERC-165
* @dev Interface identification is specified in ERC-165. This function
* uses less than 30,000 gas.
*/
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool);
}
interface ISuperRare {
/**
* @notice A descriptive name for a collection of NFTs in this contract
*/
function name() external pure returns (string _name);
/**
* @notice An abbreviated name for NFTs in this contract
*/
function symbol() external pure returns (string _symbol);
/**
* @dev Returns whether the creator is whitelisted
* @param _creator address to check
* @return bool
*/
function isWhitelisted(address _creator) external view returns (bool);
/**
* @notice A distinct Uniform Resource Identifier (URI) for a given asset.
* @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC
* 3986. The URI may point to a JSON file that conforms to the "ERC721
* Metadata JSON Schema".
*/
function tokenURI(uint256 _tokenId) external view returns (string);
/**
* @dev Gets the creator of the token
* @param _tokenId uint256 ID of the token
* @return address of the creator
*/
function creatorOfToken(uint256 _tokenId) external view returns (address);
/**
* @dev Gets the total amount of tokens stored by the contract
* @return uint256 representing the total amount of tokens
*/
function totalSupply() external view returns (uint256);
}
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
contract IERC721Receiver {
/**
* @notice Handle the receipt of an NFT
* @dev The ERC721 smart contract calls this function on the recipient
* after a `safeTransfer`. This function MUST return the function selector,
* otherwise the caller will revert the transaction. The selector to be
* returned can be obtained as `this.onERC721Received.selector`. This
* function MAY throw to revert and reject the transfer.
* Note: the ERC721 contract address is always the message sender.
* @param operator The address which called `safeTransferFrom` function
* @param from The address which previously owned the token
* @param tokenId The NFT identifier which is being transferred
* @param data Additional data with no specified format
* @return `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes data
)
public
returns(bytes4);
}
contract IERC721 is IERC165 {
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
event Approval(
address indexed owner,
address indexed approved,
uint256 indexed tokenId
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId)
public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator)
public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId)
public;
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes data
)
public;
}
contract IERC721Creator is IERC721 {
/**
* @dev Gets the creator of the token
* @param _tokenId uint256 ID of the token
* @return address of the creator
*/
function tokenCreator(uint256 _tokenId) public view returns (address);
}
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/
contract IERC721Metadata is IERC721 {
function name() external view returns (string);
function symbol() external view returns (string);
function tokenURI(uint256 tokenId) external view returns (string,uint);
}
/**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(
address owner,
uint256 index
)
public
view
returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
/**
* Utility library of inline functions on addresses
*/
library Address {
/**
* Returns whether the target address is a contract
* @dev This function will return false if invoked during the constructor of a contract,
* as the code is not actually created until after the constructor finishes.
* @param account address of the account to check
* @return whether the target address is a contract
*/
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
/**
* @title ERC165
* @author Matt Condon (@shrugs)
* @dev Implements ERC165 using a lookup table.
*/
contract ERC165 is IERC165 {
bytes4 private constant _InterfaceId_ERC165 = 0x01ffc9a7;
/**
* 0x01ffc9a7 ===
* bytes4(keccak256('supportsInterface(bytes4)'))
*/
/**
* @dev a mapping of interface id to whether or not it's supported
*/
mapping(bytes4 => bool) private _supportedInterfaces;
/**
* @dev A contract implementing SupportsInterfaceWithLookup
* implement ERC165 itself
*/
constructor()
internal
{
_registerInterface(_InterfaceId_ERC165);
}
/**
* @dev implement supportsInterface(bytes4) using a lookup table
*/
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool)
{
return _supportedInterfaces[interfaceId];
}
/**
* @dev internal method for registering an interface
*/
function _registerInterface(bytes4 interfaceId)
internal
{
require(interfaceId != 0xffffffff);
_supportedInterfaces[interfaceId] = true;
}
}
/**
* @title ERC721 Non-Fungible Token Standard basic implementation
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
// Mapping from token ID to owner
mapping (uint256 => address) private _tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) private _ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _InterfaceId_ERC721 = 0x80ac58cd;
/*
* 0x80ac58cd ===
* bytes4(keccak256('balanceOf(address)')) ^
* bytes4(keccak256('ownerOf(uint256)')) ^
* bytes4(keccak256('approve(address,uint256)')) ^
* bytes4(keccak256('getApproved(uint256)')) ^
* bytes4(keccak256('setApprovalForAll(address,bool)')) ^
* bytes4(keccak256('isApprovedForAll(address,address)')) ^
* bytes4(keccak256('transferFrom(address,address,uint256)')) ^
* bytes4(keccak256('safeTransferFrom(address,address,uint256)')) ^
* bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)'))
*/
constructor()
public
{
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_InterfaceId_ERC721);
}
/**
* @dev Gets the balance of the specified address
* @param owner address to query the balance of
* @return uint256 representing the amount owned by the passed address
*/
function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0));
return _ownedTokensCount[owner];
}
/**
* @dev Gets the owner of the specified token ID
* @param tokenId uint256 ID of the token to query the owner of
* @return owner address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 tokenId) public view returns (address) {
address owner = _tokenOwner[tokenId];
require(owner != address(0));
return owner;
}
/**
* @dev Approves another address to transfer the given token ID
* The zero address indicates there is no approved address.
* There can only be one approved address per token at a given time.
* Can only be called by the token owner or an approved operator.
* @param to address to be approved for the given token ID
* @param tokenId uint256 ID of the token to be approved
*/
function approve(address to, uint256 tokenId) public {
address owner = ownerOf(tokenId);
require(to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
/**
* @dev Gets the approved address for a token ID, or zero if no address set
* Reverts if the token ID does not exist.
* @param tokenId uint256 ID of the token to query the approval of
* @return address currently approved for the given token ID
*/
function getApproved(uint256 tokenId) public view returns (address) {
require(_exists(tokenId));
return _tokenApprovals[tokenId];
}
/**
* @dev Sets or unsets the approval of a given operator
* An operator is allowed to transfer all tokens of the sender on their behalf
* @param to operator address to set the approval
* @param approved representing the status of the approval to be set
*/
function setApprovalForAll(address to, bool approved) public {
require(to != msg.sender);
_operatorApprovals[msg.sender][to] = approved;
emit ApprovalForAll(msg.sender, to, approved);
}
/**
* @dev Tells whether an operator is approved by a given owner
* @param owner owner address which you want to query the approval of
* @param operator operator address which you want to query the approval of
* @return bool whether the given operator is approved by the given owner
*/
function isApprovedForAll(
address owner,
address operator
)
public
view
returns (bool)
{
return _operatorApprovals[owner][operator];
}
/**
* @dev Transfers the ownership of a given token ID to another address
* Usage of this method is discouraged, use `safeTransferFrom` whenever possible
* Requires the msg sender to be the owner, approved, or operator
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
*/
function transferFrom(
address from,
address to,
uint256 tokenId
)
public
{
require(_isApprovedOrOwner(msg.sender, tokenId));
require(to != address(0));
_clearApproval(from, tokenId);
_removeTokenFrom(from, tokenId);
_addTokenTo(to, tokenId);
emit Transfer(from, to, tokenId);
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
*
* Requires the msg sender to be the owner, approved, or operator
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
)
public
{
// solium-disable-next-line arg-overflow
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* Requires the msg sender to be the owner, approved, or operator
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes data to send along with a safe transfer check
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes _data
)
public
{
transferFrom(from, to, tokenId);
// solium-disable-next-line arg-overflow
require(_checkOnERC721Received(from, to, tokenId, _data));
}
/**
* @dev Returns whether the specified token exists
* @param tokenId uint256 ID of the token to query the existence of
* @return whether the token exists
*/
function _exists(uint256 tokenId) internal view returns (bool) {
address owner = _tokenOwner[tokenId];
return owner != address(0);
}
/**
* @dev Returns whether the given spender can transfer a given token ID
* @param spender address of the spender to query
* @param tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
function _isApprovedOrOwner(
address spender,
uint256 tokenId
)
internal
view
returns (bool)
{
address owner = ownerOf(tokenId);
// Disable solium check because of
// https://github.com/duaraghav8/Solium/issues/175
// solium-disable-next-line operator-whitespace
return (
spender == owner ||
getApproved(tokenId) == spender ||
isApprovedForAll(owner, spender)
);
}
/**
* @dev Internal function to mint a new token
* Reverts if the given token ID already exists
* @param to The address that will own the minted token
* @param tokenId uint256 ID of the token to be minted by the msg.sender
*/
function _mint(address to, uint256 tokenId) internal {
require(to != address(0));
_addTokenTo(to, tokenId);
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Internal function to burn a specific token
* Reverts if the token does not exist
* @param tokenId uint256 ID of the token being burned by the msg.sender
*/
function _burn(address owner, uint256 tokenId) internal {
_clearApproval(owner, tokenId);
_removeTokenFrom(owner, tokenId);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Internal function to add a token ID to the list of a given address
* Note that this function is left internal to make ERC721Enumerable possible, but is not
* intended to be called by custom derived contracts: in particular, it emits no Transfer event.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenTo(address to, uint256 tokenId) internal {
require(_tokenOwner[tokenId] == address(0));
_tokenOwner[tokenId] = to;
_ownedTokensCount[to] = _ownedTokensCount[to].add(1);
}
/**
* @dev Internal function to remove a token ID from the list of a given address
* Note that this function is left internal to make ERC721Enumerable possible, but is not
* intended to be called by custom derived contracts: in particular, it emits no Transfer event,
* and doesn't clear approvals.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFrom(address from, uint256 tokenId) internal {
require(ownerOf(tokenId) == from);
_ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
_tokenOwner[tokenId] = address(0);
}
/**
* @dev Internal function to invoke `onERC721Received` on a target address
* The call is not executed if the target address is not a contract
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes _data
)
internal
returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes4 retval = IERC721Receiver(to).onERC721Received(
msg.sender, from, tokenId, _data);
return (retval == _ERC721_RECEIVED);
}
/**
* @dev Private function to clear current approval of a given token ID
* Reverts if the given address is not indeed the owner of the token
* @param owner owner of the token
* @param tokenId uint256 ID of the token to be transferred
*/
function _clearApproval(address owner, uint256 tokenId) private {
require(ownerOf(tokenId) == owner);
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
}
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of` the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _InterfaceId_ERC721Enumerable = 0x780e9d63;
/**
* 0x780e9d63 ===
* bytes4(keccak256('totalSupply()')) ^
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
* bytes4(keccak256('tokenByIndex(uint256)'))
*/
/**
* @dev Constructor function
*/
constructor() public {
// register the supported interface to conform to ERC721 via ERC165
_registerInterface(_InterfaceId_ERC721Enumerable);
}
/**
* @dev Gets the token ID at a given index of the tokens list of the requested owner
* @param owner address owning the tokens list to be accessed
* @param index uint256 representing the index to be accessed of the requested tokens list
* @return uint256 token ID at the given index of the tokens list owned by the requested address
*/
function tokenOfOwnerByIndex(
address owner,
uint256 index
)
public
view
returns (uint256)
{
require(index < balanceOf(owner));
return _ownedTokens[owner][index];
}
/**
* @dev Gets the total amount of tokens stored by the contract
* @return uint256 representing the total amount of tokens
*/
function totalSupply() public view returns (uint256) {
return _allTokens.length;
}
/**
* @dev Gets the token ID at a given index of all the tokens in this contract
* Reverts if the index is greater or equal to the total number of tokens
* @param index uint256 representing the index to be accessed of the tokens list
* @return uint256 token ID at the given index of the tokens list
*/
function tokenByIndex(uint256 index) public view returns (uint256) {
require(index < totalSupply());
return _allTokens[index];
}
/**
* @dev Internal function to add a token ID to the list of a given address
* This function is internal due to language limitations, see the note in ERC721.sol.
* It is not intended to be called by custom derived contracts: in particular, it emits no Transfer event.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenTo(address to, uint256 tokenId) internal {
super._addTokenTo(to, tokenId);
uint256 length = _ownedTokens[to].length;
_ownedTokens[to].push(tokenId);
_ownedTokensIndex[tokenId] = length;
}
/**
* @dev Internal function to remove a token ID from the list of a given address
* This function is internal due to language limitations, see the note in ERC721.sol.
* It is not intended to be called by custom derived contracts: in particular, it emits no Transfer event,
* and doesn't clear approvals.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFrom(address from, uint256 tokenId) internal {
super._removeTokenFrom(from, tokenId);
// To prevent a gap in the array, we store the last token in the index of the token to delete, and
// then delete the last slot.
uint256 tokenIndex = _ownedTokensIndex[tokenId];
uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
uint256 lastToken = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastToken;
// This also deletes the contents at the last position of the array
_ownedTokens[from].length--;
// Note that this will handle single-element arrays. In that case, both tokenIndex and lastTokenIndex are going to
// be zero. Then we can make sure that we will remove tokenId from the ownedTokens list since we are first swapping
// the lastToken to the first position, and then dropping the element placed in the last position of the list
_ownedTokensIndex[tokenId] = 0;
_ownedTokensIndex[lastToken] = tokenIndex;
}
/**
* @dev Internal function to mint a new token
* Reverts if the given token ID already exists
* @param to address the beneficiary that will own the minted token
* @param tokenId uint256 ID of the token to be minted by the msg.sender
*/
function _mint(address to, uint256 tokenId) internal {
super._mint(to, tokenId);
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
/**
* @dev Internal function to burn a specific token
* Reverts if the token does not exist
* @param owner owner of the token to burn
* @param tokenId uint256 ID of the token being burned by the msg.sender
*/
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
// Reorg all tokens array
uint256 tokenIndex = _allTokensIndex[tokenId];
uint256 lastTokenIndex = _allTokens.length.sub(1);
uint256 lastToken = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastToken;
_allTokens[lastTokenIndex] = 0;
_allTokens.length--;
_allTokensIndex[tokenId] = 0;
_allTokensIndex[lastToken] = tokenIndex;
}
}
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
//Enum for storing token type whether it is physical or Digital
enum TokenType {PHYSICAL, DIGITAL}
struct tokenMetadata{
string uri;
TokenType tokenType;
}
//mapping to hold token Metadata
mapping(uint256 => tokenMetadata) private _tokenURI;
// Optional mapping for token URIs
// mapping(uint256 => string) private _tokenURIs;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
/**
* 0x5b5e139f ===
* bytes4(keccak256('name()')) ^
* bytes4(keccak256('symbol()')) ^
* bytes4(keccak256('tokenURI(uint256)'))
*/
/**
* @dev Constructor function
*/
constructor(string name, string symbol) public {
_name = name;
_symbol = symbol;
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(InterfaceId_ERC721Metadata);
}
/**
* @dev Gets the token name
* @return string representing the token name
*/
function name() external view returns (string) {
return _name;
}
/**
* @dev Gets the token symbol
* @return string representing the token symbol
*/
function symbol() external view returns (string) {
return _symbol;
}
/**
* @dev Returns an URI for a given token ID
* Throws if the token ID does not exist. May return an empty string.
* @param tokenId uint256 ID of the token to query
*/
function tokenURI(uint256 tokenId) external view returns (string ,uint) {
require(_exists(tokenId));
//issue, if it is true, delete the comment
return (_tokenURI[tokenId].uri,uint(_tokenURI[tokenId].tokenType));
}
/**
* @dev Internal function to set the token URI for a given token
* Reverts if the token ID does not exist
* @param tokenId uint256 ID of the token to set its URI
* @param uri string URI to assign
*/
function _setTokenURI(uint256 tokenId, string uri, TokenType _tokenType) internal {
require(_exists(tokenId));
_tokenURI[tokenId].uri = uri;
_tokenURI[tokenId].tokenType= _tokenType;
}
/**
* @dev Internal function to burn a specific token
* Reverts if the token does not exist
* @param owner owner of the token to burn
* @param tokenId uint256 ID of the token being burned by the msg.sender
*/
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
//help
// Clear metadata (if any)
if (bytes(_tokenURI[tokenId].uri ).length != 0) {
delete _tokenURI[tokenId];
}
}
}
/**
* @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 private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
/**
* @return the address of the owner.
*/
function owner() public view returns(address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(isOwner());
_;
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
/**
* @dev Allows the current owner to relinquish control of the contract.
* @notice Renouncing to ownership will leave the contract without an owner.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
*/
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @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) public onlyOwner {
_transferOwnership(newOwner);
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Whitelist is Ownable {
// Mapping of address to boolean indicating whether the address is whitelisted
mapping(address => bool) private whitelistMap;
// flag controlling whether whitelist is enabled.
bool private whitelistEnabled = true;
event AddToWhitelist(address indexed _newAddress);
event RemoveFromWhitelist(address indexed _removedAddress);
/**
* @dev Enable or disable the whitelist
* @param _enabled bool of whether to enable the whitelist.
*/
function enableWhitelist(bool _enabled) public onlyOwner {
whitelistEnabled = _enabled;
}
/**
* @dev Adds the provided address to the whitelist
* @param _newAddress address to be added to the whitelist
*/
function addToWhitelist(address _newAddress) public onlyOwner {
_whitelist(_newAddress);
emit AddToWhitelist(_newAddress);
}
/**
* @dev Removes the provided address to the whitelist
* @param _removedAddress address to be removed from the whitelist
*/
function removeFromWhitelist(address _removedAddress) public onlyOwner {
_unWhitelist(_removedAddress);
emit RemoveFromWhitelist(_removedAddress);
}
/**
* @dev Returns whether the address is whitelisted
* @param _address address to check
* @return bool
*/
function isWhitelisted(address _address) public view returns (bool) {
if (whitelistEnabled) {
return whitelistMap[_address];
} else {
return true;
}
}
/**
* @dev Internal function for removing an address from the whitelist
* @param _removedAddress address to unwhitelisted
*/
function _unWhitelist(address _removedAddress) internal {
whitelistMap[_removedAddress] = false;
}
/**
* @dev Internal function for adding the provided address to the whitelist
* @param _newAddress address to be added to the whitelist
*/
function _whitelist(address _newAddress) internal {
whitelistMap[_newAddress] = true;
}
}
/**
* @title Full ERC721 Token
* This implementation includes all the required and some optional functionality of the ERC721 standard
* Moreover, it includes approve all functionality using operator terminology
* @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor(string name, string symbol) ERC721Metadata(name, symbol)
public
{
}
}
contract Chimera is ERC721Full, IERC721Creator, Ownable, Whitelist {
using SafeMath for uint256;
// Mapping from token ID to the creator's address.
mapping(uint256 => address) private tokenCreators;
// Counter for creating token IDs
uint256 private idCounter;
// Old SuperRare contract to look up token details.
// ISuperRare private oldSuperRare;
// Event indicating metadata was updated.
event TokenURIUpdated(uint256 indexed _tokenId, string _uri);
constructor(
string _name,
string _symbol
// address _oldSuperRare
) public
ERC721Full(_name, _symbol)
{
// Get reference to old SR contract.
// oldSuperRare = ISuperRare(_oldSuperRare);
// uint256 oldSupply = oldSuperRare.totalSupply();
// Set id counter to be continuous with SuperRare.
//idCounter = oldSupply + 1;
}
/**
* @dev Whitelists a bunch of addresses.
* @param _whitelistees address[] of addresses to whitelist.
*/
function initWhitelist(address[] _whitelistees) public onlyOwner {
// Add all whitelistees.
for (uint256 i = 0; i < _whitelistees.length; i++) {
address creator = _whitelistees[i];
if (!isWhitelisted(creator)) {
_whitelist(creator);
}
}
}
/**
* @dev Checks that the token is owned by the sender.
* @param _tokenId uint256 ID of the token.
*/
modifier onlyTokenOwner(uint256 _tokenId) {
address owner = ownerOf(_tokenId);
require(owner == msg.sender, "must be the owner of the token");
_;
}
/**
* @dev Checks that the token was created by the sender.
* @param _tokenId uint256 ID of the token.
*/
modifier onlyTokenCreator(uint256 _tokenId) {
address creator = tokenCreator(_tokenId);
require(creator == msg.sender, "must be the creator of the token");
_;
}
/**
* @dev Adds a new unique token to the supply.
* @param _uri string metadata uri associated with the token.
*/
function addNewToken(string _uri, TokenType _tokenType) public {
require(isWhitelisted(msg.sender), "must be whitelisted to create tokens");
_createToken(_uri, _tokenType, msg.sender);
}
/**
* @dev Adds a new unique physical Token to the supply.
* @param _uri string metadata uri associated with the token.
*/
// function addNewPhysicalToken(string _uri) public {
// require(isWhitelisted(msg.sender), "must be whitelisted to create tokens");
// _createToken(_uri, msg.sender);
// }
/**
* @dev Deletes the token with the provided ID.
* @param _tokenId uint256 ID of the token.
*/
function deleteToken(uint256 _tokenId) public onlyTokenOwner(_tokenId) {
_burn(msg.sender, _tokenId);
}
/**
* @dev Updates the token metadata if the owner is also the
* creator.
* @param _tokenId uint256 ID of the token.
* @param _uri string metadata URI.
*/
function updateTokenMetadata(uint256 _tokenId, string _uri, TokenType _tokenType)
public
onlyTokenOwner(_tokenId)
onlyTokenCreator(_tokenId)
{
_setTokenURI(_tokenId, _uri, _tokenType);
emit TokenURIUpdated(_tokenId, _uri);
}
/**
* @dev Gets the creator of the token.
* @param _tokenId uint256 ID of the token.
* @return address of the creator.
*/
function tokenCreator(uint256 _tokenId) public view returns (address) {
return tokenCreators[_tokenId];
}
/**
* @dev Internal function for setting the token's creator.
* @param _tokenId uint256 id of the token.
* @param _creator address of the creator of the token.
*/
function _setTokenCreator(uint256 _tokenId, address _creator) internal {
tokenCreators[_tokenId] = _creator;
}
/**
* @dev Internal function creating a new token.
* @param _uri string metadata uri associated with the token
* @param _creator address of the creator of the token.
*/
function _createToken(string _uri, TokenType _tokenType, address _creator) internal returns (uint256) {
uint256 newId = idCounter;
idCounter++;
_mint(_creator, newId);
_setTokenURI(newId, _uri, _tokenType);
_setTokenCreator(newId, _creator);
return newId;
}
}
Raw
chimerasource.sol
// contracts/MyContract.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
// import '@openzeppelin/contracts-upgradeable/proxy/Initializable.sol';
// import '@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol';
// import '@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol';
// import '@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol';
import "https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.4/contracts/access/OwnableUpgradeable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.4/contracts/proxy/Initializable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.4/contracts/token/ERC721/ERC721Upgradeable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.4/contracts/math/SafeMathUpgradeable.sol";
//last contract inheritance
//contract Chimera is Initializable, ERC721Upgradeable, IERC721Creator, Ownable, Whitelist
contract Whitelist is Initializable, OwnableUpgradeable {
function initialize() public initializer {
__Ownable_init();
}
// Mapping of address to boolean indicating whether the address is whitelisted
mapping(address => bool) private whitelistMap;
// flag controlling whether whitelist is enabled.
bool private whitelistEnabled = true;
event AddToWhitelist(address indexed _newAddress);
event RemoveFromWhitelist(address indexed _removedAddress);
/**
* @dev Enable or disable the whitelist
* @param _enabled bool of whether to enable the whitelist.
*/
function enableWhitelist(bool _enabled) public onlyOwner {
whitelistEnabled = _enabled;
}
/**
* @dev Adds the provided address to the whitelist
* @param _newAddress address to be added to the whitelist
*/
function addToWhitelist(address _newAddress) public onlyOwner {
_whitelist(_newAddress);
emit AddToWhitelist(_newAddress);
}
/**
* @dev Removes the provided address to the whitelist
* @param _removedAddress address to be removed from the whitelist
*/
function removeFromWhitelist(address _removedAddress) public onlyOwner {
_unWhitelist(_removedAddress);
emit RemoveFromWhitelist(_removedAddress);
}
/**
* @dev Returns whether the address is whitelisted
* @param _address address to check
* @return bool
*/
function isWhitelisted(address _address) public view returns (bool) {
if (whitelistEnabled) {
return whitelistMap[_address];
} else {
return true;
}
}
/**
* @dev Internal function for removing an address from the whitelist
* @param _removedAddress address to unwhitelisted
*/
function _unWhitelist(address _removedAddress) internal {
whitelistMap[_removedAddress] = false;
}
/**
* @dev Internal function for adding the provided address to the whitelist
* @param _newAddress address to be added to the whitelist
*/
function _whitelist(address _newAddress) internal {
whitelistMap[_newAddress] = true;
}
}
contract Chimera is Initializable, ERC721Upgradeable, OwnableUpgradeable, Whitelist {
using SafeMathUpgradeable for uint256;
string private _name;
string private _symbol;
uint8 private _decimals;
// Mapping from token ID to the creator's address.
mapping(uint256 => address) private tokenCreators;
//Enum for storing token type whether it is physical or Digital
enum TokenType {DIGITAL,PHYSICAL}
//Enum for storing token sale type PRIMARY or SECONDARY
enum TokenSaleType {PRIMARY,SECONDARY}
struct tokenTypeStruct{
TokenType tokenType;
TokenSaleType tokensaleType;
}
//mapping to hold token Type
mapping(uint256 => tokenTypeStruct) private tokentypes;
// Counter for creating token IDs
uint256 private idCounter;
// Event indicating metadata was updated.
event TokenURIUpdated(uint256 indexed _tokenId, string _uri, TokenType _tokenType);
function initialize(string memory name, string memory symbol) public initializer {
//ERC721Upgradeable.__ERC721_init(name , symbol);
Whitelist.initialize();
__Ownable_init();
__ERC721_init(name , symbol);
}
/**
* @dev Whitelists a bunch of addresses.
* @param _whitelistees address[] of addresses to whitelist.
*/
function initWhitelist(address[] memory _whitelistees) public onlyOwner {
// Add all whitelistees.
for (uint256 i = 0; i < _whitelistees.length; i++) {
address creator = _whitelistees[i];
if (!isWhitelisted(creator)) {
_whitelist(creator);
}
}
}
/**
* @dev Checks that the token is owned by the sender.
* @param _tokenId uint256 ID of the token.
*/
modifier onlyTokenOwner(uint256 _tokenId) {
address owner = ownerOf(_tokenId);
require(owner == msg.sender, "must be the owner of the token");
_;
}
/**
* @dev Checks that the token was created by the sender.
* @param _tokenId uint256 ID of the token.
*/
modifier onlyTokenCreator(uint256 _tokenId) {
address creator = tokenCreator(_tokenId);
require(creator == msg.sender, "must be the creator of the token");
_;
}
/**
* @dev Adds a new unique token to the supply.
* @param _uri string metadata uri associated with the token.
* param _tokenType of the token to make it PHYSICAL or DIGITAL
*/
function addNewToken(string memory _uri, TokenType _tokenType) public {
require(isWhitelisted(msg.sender), "must be whitelisted to create tokens");
_createToken(_uri, msg.sender, _tokenType);
}
/**
* @dev Deletes the token with the provided ID.
* @param _tokenId uint256 ID of the token.
// */
function deleteToken(uint256 _tokenId) public onlyTokenOwner(_tokenId) {
_burn( _tokenId);
}
/**
* @dev Updates the token metadata if the owner is also the
* creator.
* @param _tokenId uint256 ID of the token.
* @param _uri string metadata URI.
* param _tokenType of the token PHYSICAL or DIGITAL 0,1
*/
function updateTokenMetadata(uint256 _tokenId, string memory _uri,TokenType _tokenType )
public
onlyTokenOwner(_tokenId)
onlyTokenCreator(_tokenId)
{
_setTokenURI(_tokenId, _uri);
_setTokenType(_tokenId,_tokenType);
emit TokenURIUpdated(_tokenId, _uri, _tokenType);
}
/**
* @dev Gets the creator of the token.
* @param _tokenId uint256 ID of the token.
* @return address of the creator.
*/
function tokenCreator(uint256 _tokenId) public view returns (address) {
return tokenCreators[_tokenId];
}
/**
* @dev Gets the Type of the token.
* @param _tokenId uint256 ID of the token.
* @return _tokentype of the token PHYSICAL or DIGITAL.
*/
function tokenType(uint256 _tokenId) public view returns (TokenType _tokentype) {
return tokentypes[_tokenId].tokenType;
}
/**
* @dev Gets the Sale Type of the token.
* @param _tokenId uint256 ID of the token.
* @return _tokensaleType of the token PHYSICAL or DIGITAL.
*/
function getTokenSaleType(uint256 _tokenId) public view returns (TokenSaleType _tokensaleType) {
return tokentypes[_tokenId].tokensaleType;
}
/**
* @dev Internal function for setting the token's creator.
* @param _tokenId uint256 id of the token.
* @param _creator address of the creator of the token.
*/
function _setTokenCreator(uint256 _tokenId, address _creator) internal {
tokenCreators[_tokenId] = _creator;
}
/**
* @dev Internal function for setting the token Type.
* @param _tokenId uint256 id of the token.
* @param _tokenType 0,1 DIGITAL,PHYSICAL of the creator of the token.
*/
function _setTokenType(uint256 _tokenId, TokenType _tokenType ) internal{
tokentypes[_tokenId].tokenType = _tokenType;
}
// function _setTokenSaleType(uint256 _tokenId ) internal returns(TokenSaleType _tokensaleType){
// TokenSaleType tokensaleType = TokenSaleType.PRIMARY;
// tokentypes[_tokenId].tokensaleType = tokensaleType;
// return tokentypes[_tokenId].tokensaleType;
// }
/**
* @dev Internal function creating a new token.
* @param _uri string metadata uri associated with the token
* @param _creator address of the creator of the token.
* @param _tokenType of the token
*/
function _createToken(string memory _uri, address _creator,TokenType _tokenType ) internal returns (uint256) {
uint256 newId = idCounter;
idCounter++;
_mint(_creator, newId);
_setTokenURI(newId, _uri);
_setTokenCreator(newId, _creator);
_setTokenType(newId,_tokenType);
//_setTokenSaleType(newId);
return newId;
}
}
Raw
IERC721Creator.sol
pragma solidity 0.6.12;
/**
* @title IERC721 Non-Fungible Token Creator basic interface
*/
interface IERC721Creator {
/**
* @dev Gets the creator of the token
* @param _tokenId uint256 ID of the token
* @return address of the creator
*/
function tokenCreator(uint256 _tokenId)
external
view
returns (address payable);
}
Raw
IERC721CreatorRoyalty.sol
pragma solidity 0.6.12;
import "./IERC721TokenCreator.sol";
/**
* @title IERC721CreatorRoyalty Token level royalty interface.
*/
interface IERC721CreatorRoyalty is IERC721TokenCreator {
/**
* @dev Get the royalty fee percentage for a specific ERC721 contract.
* @param _contractAddress address ERC721Contract address.
* @param _tokenId uint256 token ID.
* @return uint8 wei royalty fee.
*/
function getERC721TokenRoyaltyPercentage(
address _contractAddress,
uint256 _tokenId
) external view returns (uint8);
/**
* @dev Utililty function to calculate the royalty fee for a token.
* @param _contractAddress address ERC721Contract address.
* @param _tokenId uint256 token ID.
* @param _amount uint256 wei amount.
* @return uint256 wei fee.
*/
function calculateRoyaltyFee(
address _contractAddress,
uint256 _tokenId,
uint256 _amount
) external view returns (uint256);
}
Raw
IERC721TokenCreator.sol
pragma solidity 0.6.12;
/**
* @title IERC721 Non-Fungible Token Creator basic interface
*/
interface IERC721TokenCreator {
/**
* @dev Gets the creator of the token
* @param _contractAddress address of the ERC721 contract
* @param _tokenId uint256 ID of the token
* @return address of the creator
*/
function tokenCreator(address _contractAddress, uint256 _tokenId)
external
view
returns (address payable);
}
Raw
IMarketplaceSettings.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
/**
* @title IMarketplaceSettings Settings governing a marketplace.
*/
interface IMarketplaceSettings {
/////////////////////////////////////////////////////////////////////////
// Marketplace Min and Max Values
/////////////////////////////////////////////////////////////////////////
/**
* @dev Get the max value to be used with the marketplace.
* @return uint256 wei value.
*/
function getMarketplaceMaxValue() external view returns (uint256);
/**
* @dev Get the max value to be used with the marketplace.
* @return uint256 wei value.
*/
function getMarketplaceMinValue() external view returns (uint256);
/////////////////////////////////////////////////////////////////////////
// Marketplace Fee
/////////////////////////////////////////////////////////////////////////
/**
* @dev Get the marketplace fee percentage.
* @return uint8 wei fee.
*/
function getMarketplaceFeePercentage() external view returns (uint8);
/**
* @dev Utility function for calculating the marketplace fee for given amount of wei.
* @param _amount uint256 wei amount.
* @return uint256 wei fee.
*/
function calculateMarketplaceFee(uint256 _amount)
external
view
returns (uint256);
/////////////////////////////////////////////////////////////////////////
// Primary Sale Fee
/////////////////////////////////////////////////////////////////////////
/**
* @dev Get the primary sale fee percentage for a specific ERC721 contract.
* @param _contractAddress address ERC721Contract address.
* @return uint8 wei primary sale fee.
*/
function getERC721ContractPrimarySaleFeePercentage(address _contractAddress)
external
view
returns (uint8);
/**
* @dev Utility function for calculating the primary sale fee for given amount of wei
* @param _contractAddress address ERC721Contract address.
* @param _amount uint256 wei amount.
* @return uint256 wei fee.
*/
function calculatePrimarySaleFee(address _contractAddress, uint256 _amount)
external
view
returns (uint256);
//chimera
/////////////////////////////////////////////////////////////////////////
// secondary Sale Fee
/////////////////////////////////////////////////////////////////////////
/**
* @dev Get the secondary sale fee percentage for a specific ERC721 contract.
* @param _contractAddress address ERC721Contract address.
* @return uint8 wei secondary sale fee.
*/
function getERC721ContractSecondarySaleFeePercentage(address _contractAddress)
external
view
returns (uint8);
/**
* @dev Utility function for calculating the secondary sale fee for given amount of wei
* @param _contractAddress address ERC721Contract address.
* @param _amount uint256 wei amount.
* @return uint256 wei fee.
*/
function calculateSecondarySaleFee(address _contractAddress, uint256 _amount)
external
view
returns (uint256);
/**
* @dev Check whether the ERC721 token has sold at least once.
* @param _contractAddress address ERC721Contract address.
* @param _tokenId uint256 token ID.
* @return bool of whether the token has sold.
*/
function hasERC721TokenSold(address _contractAddress, uint256 _tokenId)
external
view
returns (bool);
/**
* @dev Mark a token as sold.
* Requirements:
*
* - `_contractAddress` cannot be the zero address.
* @param _contractAddress address ERC721Contract address.
* @param _tokenId uint256 token ID.
* @param _hasSold bool of whether the token should be marked sold or not.
*/
function markERC721Token(
address _contractAddress,
uint256 _tokenId,
bool _hasSold
) external;
}
Raw
ISendValueProxy.sol
pragma solidity 0.6.12;
interface ISendValueProxy {
function sendValue(address payable _to) external payable;
}
Raw
ISupeRare.sol
pragma solidity 0.6.12;
/**
* @dev Interface for interacting with the SupeRare contract that holds SuperRare beta tokens.
*/
interface ISupeRare {
/**
* @notice A descriptive name for a collection of NFTs in this contract
*/
function name() external pure returns (string memory _name);
/**
* @notice An abbreviated name for NFTs in this contract
*/
function symbol() external pure returns (string memory _symbol);
/**
* @dev Returns whether the creator is whitelisted
* @param _creator address to check
* @return bool
*/
function isWhitelisted(address _creator) external view returns (bool);
/**
* @notice A distinct Uniform Resource Identifier (URI) for a given asset.
* @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC
* 3986. The URI may point to a JSON file that conforms to the "ERC721
* Metadata JSON Schema".
*/
function tokenURI(uint256 _tokenId) external view returns (string memory);
/**
* @dev Gets the creator of the token
* @param _tokenId uint256 ID of the token
* @return address of the creator
*/
function creatorOfToken(uint256 _tokenId)
external
view
returns (address payable);
/**
* @dev Gets the total amount of tokens stored by the contract
* @return uint256 representing the total amount of tokens
*/
function totalSupply() external view returns (uint256);
/**
* @dev Gets the owner of the specified token ID
* @param _tokenId uint256 ID of the token to query the owner of
* @return owner address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 _tokenId) external view returns (address);
}
Raw
MarketplaceSettings.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "./IMarketplaceSettings.sol";
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/access/OwnableUpgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/access/AccessControlUpgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/math/SafeMathUpgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/proxy/Initializable.sol';
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/solc-0.6/contracts/access/Ownable.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/solc-0.6/contracts/access/AccessControl.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/solc-0.6/contracts/math/SafeMath.sol";
/**
* @title MarketplaceSettings Settings governing the marketplace fees.
*/
contract MarketplaceSettings is Initializable, OwnableUpgradeable, AccessControlUpgradeable, IMarketplaceSettings {
using SafeMathUpgradeable for uint256;
/////////////////////////////////////////////////////////////////////////
// Constants
/////////////////////////////////////////////////////////////////////////
bytes32 public constant TOKEN_MARK_ROLE = "TOKEN_MARK_ROLE";
/////////////////////////////////////////////////////////////////////////
// State Variables
/////////////////////////////////////////////////////////////////////////
// Max wei value within the marketplace
uint256 private maxValue;
// Min wei value within the marketplace
uint256 private minValue;
// Percentage fee for the marketplace, 3 == 3%
uint8 private marketplaceFeePercentage;
// Mapping of ERC721 contract to the primary sale fee. If primary sale fee is 0 for an origin contract then primary sale fee is ignored. 1 == 1%
mapping(address => uint8) private primarySaleFees;
//chimera
// Mapping of ERC721 contract to the secondary sale fee. If secondary sale fee is 0 for an origin contract then secondary sale fee is ignored. 1 == 1%
mapping(address => uint8) private secondarySaleFees;
// Mapping of ERC721 contract to mapping of token ID to whether the token has been sold before.
mapping(address => mapping(uint256 => bool)) private soldTokens;
/////////////////////////////////////////////////////////////////////////
// Constructor
/////////////////////////////////////////////////////////////////////////
/**
* @dev Initializes the contract maxValue, minValues, and marketplaceFeePercentage to default settings.
* Also, sets the roles for the contract to the owner.
*/
// constructor() public {
// maxValue = 2**254; // 2 ^ 254 is max amount, prevents any overflow issues.
// minValue = 1000; // all amounts must be greater than 1000 Wei.
// marketplaceFeePercentage = 3; // 3% marketplace fee on all txs.
// _setupRole(AccessControl.DEFAULT_ADMIN_ROLE, owner());
// grantRole(TOKEN_MARK_ROLE, owner());
// }
/////////////////////////////////////////////////////////////////////////
// initializer
/////////////////////////////////////////////////////////////////////////
/**
* @dev Initializes the contract maxValue, minValues, and marketplaceFeePercentage to default settings.
* Also, sets the roles for the contract to the owner.
*/
function initialize() public initializer {
__Ownable_init();
__AccessControl_init();
maxValue = 2**254; // 2 ^ 254 is max amount, prevents any overflow issues.
minValue = 1000; // all amounts must be greater than 1000 Wei.
marketplaceFeePercentage = 3; // 3% marketplace fee on all txs.
_setupRole(AccessControlUpgradeable.DEFAULT_ADMIN_ROLE, owner());
grantRole(TOKEN_MARK_ROLE, owner());
}
/////////////////////////////////////////////////////////////////////////
// grantMarketplaceMarkTokenAccess
/////////////////////////////////////////////////////////////////////////
/**
* @dev Grants a marketplace contract access to marke
* @param _account address of the account that can perform the token mark role.
*/
function grantMarketplaceAccess(address _account) external {
require(
hasRole(AccessControlUpgradeable.DEFAULT_ADMIN_ROLE, msg.sender),
"grantMarketplaceAccess::Must be admin to call method"
);
grantRole(TOKEN_MARK_ROLE, _account);
}
/////////////////////////////////////////////////////////////////////////
// getMarketplaceMaxValue
/////////////////////////////////////////////////////////////////////////
/**
* @dev Get the max value to be used with the marketplace.
* @return uint256 wei value.
*/
function getMarketplaceMaxValue() external override view returns (uint256) {
return maxValue;
}
/////////////////////////////////////////////////////////////////////////
// setMarketplaceMaxValue
/////////////////////////////////////////////////////////////////////////
/**
* @dev Set the maximum value of the marketplace settings.
* @param _maxValue uint256 maximum wei value.
*/
function setMarketplaceMaxValue(uint256 _maxValue) external onlyOwner {
maxValue = _maxValue;
}
/////////////////////////////////////////////////////////////////////////
// getMarketplaceMinValue
/////////////////////////////////////////////////////////////////////////
/**
* @dev Get the max value to be used with the marketplace.
* @return uint256 wei value.
*/
function getMarketplaceMinValue() external override view returns (uint256) {
return minValue;
}
/////////////////////////////////////////////////////////////////////////
// setMarketplaceMinValue
/////////////////////////////////////////////////////////////////////////
/**
* @dev Set the minimum value of the marketplace settings.
* @param _minValue uint256 minimum wei value.
*/
function setMarketplaceMinValue(uint256 _minValue) external onlyOwner {
minValue = _minValue;
}
/////////////////////////////////////////////////////////////////////////
// getMarketplaceFeePercentage
/////////////////////////////////////////////////////////////////////////
/**
* @dev Get the marketplace fee percentage.
* @return uint8 wei fee.
*/
function getMarketplaceFeePercentage()
external
override
view
returns (uint8)
{
return marketplaceFeePercentage;
}
/////////////////////////////////////////////////////////////////////////
// setMarketplaceFeePercentage
/////////////////////////////////////////////////////////////////////////
/**
* @dev Set the marketplace fee percentage.
* Requirements:
* - `_percentage` must be <= 100.
* @param _percentage uint8 percentage fee.
*/
function setMarketplaceFeePercentage(uint8 _percentage) external onlyOwner {
require(
_percentage <= 100,
"setMarketplaceFeePercentage::_percentage must be <= 100"
);
marketplaceFeePercentage = _percentage;
}
/////////////////////////////////////////////////////////////////////////
// calculateMarketplaceFee
/////////////////////////////////////////////////////////////////////////
/**
* @dev Utility function for calculating the marketplace fee for given amount of wei.
* @param _amount uint256 wei amount.
* @return uint256 wei fee.
*/
function calculateMarketplaceFee(uint256 _amount)
external
override
view
returns (uint256)
{
return _amount.mul(marketplaceFeePercentage).div(100);
}
/////////////////////////////////////////////////////////////////////////
// getERC721ContractPrimarySaleFeePercentage
/////////////////////////////////////////////////////////////////////////
/**
* @dev Get the primary sale fee percentage for a specific ERC721 contract.
* @param _contractAddress address ERC721Contract address.
* @return uint8 wei primary sale fee.
*/
function getERC721ContractPrimarySaleFeePercentage(address _contractAddress)
external
override
view
returns (uint8)
{
return primarySaleFees[_contractAddress];
}
/////////////////////////////////////////////////////////////////////////
// setERC721ContractPrimarySaleFeePercentage
/////////////////////////////////////////////////////////////////////////
/**
* @dev Set the primary sale fee percentage for a specific ERC721 contract.
* Requirements:
*
* - `_contractAddress` cannot be the zero address.
* - `_percentage` must be <= 100.
* @param _contractAddress address ERC721Contract address.
* @param _percentage uint8 percentage fee for the ERC721 contract.
*/
function setERC721ContractPrimarySaleFeePercentage(
address _contractAddress,
uint8 _percentage
) external onlyOwner {
require(
_percentage <= 100,
"setERC721ContractPrimarySaleFeePercentage::_percentage must be <= 100"
);
primarySaleFees[_contractAddress] = _percentage;
}
/////////////////////////////////////////////////////////////////////////
// calculatePrimarySaleFee
/////////////////////////////////////////////////////////////////////////
/**
* @dev Utility function for calculating the primary sale fee for given amount of wei
* @param _contractAddress address ERC721Contract address.
* @param _amount uint256 wei amount.
* @return uint256 wei fee.
*/
function calculatePrimarySaleFee(address _contractAddress, uint256 _amount)
external
override
view
returns (uint256)
{
return _amount.mul(primarySaleFees[_contractAddress]).div(100);
}
//chimera
/////////////////////////////////////////////////////////////////////////
// getERC721ContractSecondarySaleFeePercentage
/////////////////////////////////////////////////////////////////////////
/**
* @dev Get the secondary sale fee percentage for a specific ERC721 contract.
* @param _contractAddress address ERC721Contract address.
* @return uint8 wei primary sale fee.
*/
function getERC721ContractSecondarySaleFeePercentage(address _contractAddress)
external
override
view
returns (uint8)
{
return secondarySaleFees[_contractAddress];
}
/////////////////////////////////////////////////////////////////////////
// setERC721ContractSecondarySaleFeePercentage
/////////////////////////////////////////////////////////////////////////
/**
* @dev Set the secondary sale fee percentage for a specific ERC721 contract.
* Requirements:
*
* - `_contractAddress` cannot be the zero address.
* - `_percentage` must be <= 100.
* @param _contractAddress address ERC721Contract address.
* @param _percentage uint8 percentage fee for the ERC721 contract.
*/
function setERC721ContractSecondarySaleFeePercentage(
address _contractAddress,
uint8 _percentage
) external onlyOwner {
require(
_percentage <= 100,
"setERC721ContractSecondarySaleFeePercentage::_percentage must be <= 100"
);
secondarySaleFees[_contractAddress] = _percentage;
}
/////////////////////////////////////////////////////////////////////////
// calculateSecondarySaleFee
/////////////////////////////////////////////////////////////////////////
/**
* @dev Utility function for calculating the secondary sale fee for given amount of wei
* @param _contractAddress address ERC721Contract address.
* @param _amount uint256 wei amount.
* @return uint256 wei fee.
*/
function calculateSecondarySaleFee(address _contractAddress, uint256 _amount)
external
override
view
returns (uint256)
{
return _amount.mul(secondarySaleFees[_contractAddress]).div(100);
}
/////////////////////////////////////////////////////////////////////////
// hasERC721TokenSold
/////////////////////////////////////////////////////////////////////////
/**
* @dev Check whether the ERC721 token has sold at least once.
* @param _contractAddress address ERC721Contract address.
* @param _tokenId uint256 token ID.
* @return bool of whether the token has sold.
*/
function hasERC721TokenSold(address _contractAddress, uint256 _tokenId)
external
override
view
returns (bool)
{
return soldTokens[_contractAddress][_tokenId];
}
/////////////////////////////////////////////////////////////////////////
// markERC721TokenAsSold
/////////////////////////////////////////////////////////////////////////
/**
* @dev Mark a token as sold.
* Requirements:
*
* - `_contractAddress` cannot be the zero address.
* @param _contractAddress address ERC721Contract address.
* @param _tokenId uint256 token ID.
* @param _hasSold bool of whether the token should be marked sold or not.
*/
function markERC721Token(
address _contractAddress,
uint256 _tokenId,
bool _hasSold
) external override {
require(
hasRole(TOKEN_MARK_ROLE, msg.sender),
"markERC721Token::Must have TOKEN_MARK_ROLE role to call method"
);
soldTokens[_contractAddress][_tokenId] = _hasSold;
}
/////////////////////////////////////////////////////////////////////////
// markTokensAsSold
/////////////////////////////////////////////////////////////////////////
/**
* @dev Function to set an array of tokens for a contract as sold, thus not being subject to the primary sale fee, if one exists.
* @param _originContract address of ERC721 contract.
* @param _tokenIds uint256[] array of token ids.
*/
function markTokensAsSold(
address _originContract,
uint256[] calldata _tokenIds
) external {
require(
hasRole(TOKEN_MARK_ROLE, msg.sender),
"markERC721Token::Must have TOKEN_MARK_ROLE role to call method"
);
// limit to batches of 2000
require(
_tokenIds.length <= 2000,
"markTokensAsSold::Attempted to mark more than 2000 tokens as sold"
);
// Mark provided tokens as sold.
for (uint256 i = 0; i < _tokenIds.length; i++) {
soldTokens[_originContract][_tokenIds[i]] = true;
}
}
}
Raw
MaybeSendValue.sol
pragma solidity 0.6.12;
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/proxy/Initializable.sol';
import "./SendValueProxy.sol";
/**
* @dev Contract with a ISendValueProxy that will catch reverts when attempting to transfer funds.
*/
contract MaybeSendValue is Initializable {
SendValueProxy proxy;
// constructor() internal {
// proxy = new SendValueProxy();
// }
function SendValueProxyInitialize() public initializer {
proxy = new SendValueProxy();
}
/**
* @dev Maybe send some wei to the address via a proxy. Returns true on success and false if transfer fails.
* @param _to address to send some value to.
* @param _value uint256 amount to send.
*/
// function maybeSendValue(address payable _to, uint256 _value)
// internal
// returns (bool)
// {
// // Call sendValue on the proxy contract and forward the mesg.value.
// /* solium-disable-next-line */
// // (bool success, bytes memory _) = address(proxy).call.value(_value)(
// // abi.encodeWithSignature("sendValue(address)", _to)
// // );
// (bool success, bytes memory _) = address(proxy).call{value:(_value)}(
// abi.encodeWithSignature("sendValue(address)", _to)
// );
// return success;
// }
/**
* @dev Maybe send some wei to the address via a proxy. Returns true on success and false if transfer fails.
* @param _to address to send some value to.
* @param _value uint256 amount to send.
*/
function maybeSendValue(address payable _to, uint256 _value)
internal
returns (bool)
{
_to.transfer(_value);
return true;
}
}
Raw
pancake.sol
//SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//import "@pancakeswap/pancake-swap-lib/contracts/token/BEP20/BEP20.sol";
import "https://github.com/pancakeswap/pancake-swap-lib/blob/master/contracts/token/BEP20/BEP20.sol";
// NiftToken with Governance.
contract NiftToken is BEP20("NiftySwap Token", "NIFT") {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping(address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH =
keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping(address => uint256) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(
address indexed delegator,
address indexed fromDelegate,
address indexed toDelegate
);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(
address indexed delegate,
uint256 previousBalance,
uint256 newBalance
);
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegator The address to get delegatee for
*/
function delegates(address delegator) external view returns (address) {
return _delegates[delegator];
}
/**
* @notice Delegate votes from `msg.sender` to `delegatee`
* @param delegatee The address to delegate votes to
*/
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
/**
* @notice Delegates votes from signatory to `delegatee`
* @param delegatee The address to delegate votes to
* @param nonce The contract state required to match the signature
* @param expiry The time at which to expire the signature
* @param v The recovery byte of the signature
* @param r Half of the ECDSA signature pair
* @param s Half of the ECDSA signature pair
*/
function delegateBySig(
address delegatee,
uint256 nonce,
uint256 expiry,
uint8 v,
bytes32 r,
bytes32 s
) external {
bytes32 domainSeparator =
keccak256(
abi.encode(
DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)
)
);
bytes32 structHash =
keccak256(
abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry)
);
bytes32 digest =
keccak256(
abi.encodePacked("\x19\x01", domainSeparator, structHash)
);
address signatory = ecrecover(digest, v, r, s);
require(
signatory != address(0),
"NIFT::delegateBySig: invalid signature"
);
require(
nonce == nonces[signatory]++,
"NIFT::delegateBySig: invalid nonce"
);
require(now <= expiry, "NIFT::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
/**
* @notice Gets the current votes balance for `account`
* @param account The address to get votes balance
* @return The number of current votes for `account`
*/
function getCurrentVotes(address account) external view returns (uint256) {
uint32 nCheckpoints = numCheckpoints[account];
return
nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
/**
* @notice Determine the prior number of votes for an account as of a block number
* @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
* @param account The address of the account to check
* @param blockNumber The block number to get the vote balance at
* @return The number of votes the account had as of the given block
*/
function getPriorVotes(address account, uint256 blockNumber)
external
view
returns (uint256)
{
require(
blockNumber < block.number,
"NIFT::getPriorVotes: not yet determined"
);
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying NIFTs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(
address srcRep,
address dstRep,
uint256 amount
) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld =
srcRepNum > 0
? checkpoints[srcRep][srcRepNum - 1].votes
: 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld =
dstRepNum > 0
? checkpoints[dstRep][dstRepNum - 1].votes
: 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(
address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes
) internal {
uint32 blockNumber =
safe32(
block.number,
"NIFT::_writeCheckpoint: block number exceeds 32 bits"
);
if (
nCheckpoints > 0 &&
checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber
) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(
blockNumber,
newVotes
);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint256 n, string memory errorMessage)
internal
pure
returns (uint32)
{
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint256) {
uint256 chainId;
assembly {
chainId := chainid()
}
return chainId;
}
}
//
Raw
Payments.sol
pragma solidity 0.6.12;
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/math/SafeMathUpgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/proxy/Initializable.sol';
import "./SendValueOrEscrow.sol";
/**
* @title Payments contract for SuperRare Marketplaces.
*/
contract Payments is Initializable ,SendValueOrEscrow {
using SafeMathUpgradeable for uint256;
using SafeMathUpgradeable for uint8;
//primaryEvents
event PrimarymarketplacePayment(address indexed _marketplacePayee,uint indexed _marketplacePayment);
event PrimarySalePayment(address indexed _primarySalePayee,uint primarySalePayment);
event PrimarypayeePayment(address indexed _payee,uint payeePayment);
//SecondaryEvents
event SecondarymarketplacePayment(address indexed _marketplacePayee,uint indexed _marketplacePayment);
event SecondarySalePayment(address indexed _secondarySalePayee,uint primarySalePayment);
event SecondarypayeePayment(address indexed _payee,uint payeePayment);
function initializePayment() public initializer {
SendValueOrEscrow.initialize();
}
/////////////////////////////////////////////////////////////////////////
// refund
/////////////////////////////////////////////////////////////////////////
/**
* @dev Internal function to refund an address. Typically for canceled bids or offers.
* Requirements:
*
* - _payee cannot be the zero address
*
* @param _marketplacePercentage uint8 percentage of the fee for the marketplace.
* @param _amount uint256 value to be split.
* @param _payee address seller of the token.
*/
function refund(
uint8 _marketplacePercentage,
address payable _payee,
uint256 _amount
) internal {
require(
_payee != address(0),
"refund::no payees can be the zero address"
);
if (_amount > 0) {
SendValueOrEscrow.sendValueOrEscrow(
_payee,
_amount.add(
calcPercentagePayment(_amount, _marketplacePercentage)
)
);
}
}
/////////////////////////////////////////////////////////////////////////
// payout Primay
/////////////////////////////////////////////////////////////////////////
/**
* @dev Internal function to pay the seller, creator, and maintainer.
* Requirements:
*
* - _marketplacePercentage + _royaltyPercentage + _primarySalePercentage <= 100
* - no payees can be the zero address
*
* @param _amount uint256 value to be split.
* @param _isPrimarySale bool of whether this is a primary sale.
* @param _marketplacePercentage uint8 percentage of the fee for the marketplace.
* @param _royaltyPercentage uint8 percentage of the fee for the royalty.
* @param _primarySalePercentage uint8 percentage primary sale fee for the marketplace.
* @param _payee address seller of the token.
* @param _marketplacePayee address seller of the token.
* @param _royaltyPayee address seller of the token.
* @param _primarySalePayee address seller of the token.
*/
function payoutPrimary(
uint256 _amount,
bool _isPrimarySale,
uint8 _marketplacePercentage,
uint8 _royaltyPercentage,
uint8 _primarySalePercentage,
address payable _payee,
address payable _marketplacePayee,
address payable _royaltyPayee,
address payable _primarySalePayee
) internal {
require(
_marketplacePercentage <= 100,
"payout::marketplace percentage cannot be above 100"
);
require(
_royaltyPercentage.add(_primarySalePercentage) <= 100,
"payout::percentages cannot go beyond 100"
);
require(
_payee != address(0) &&
_primarySalePayee != address(0) &&
_marketplacePayee != address(0) &&
_royaltyPayee != address(0),
"payout::no payees can be the zero address"
);
// Note:: Solidity is kind of terrible in that there is a limit to local
// variables that can be put into the stack. The real pain is that
// one can put structs, arrays, or mappings into memory but not basic
// data types. Hence our payments array that stores these values.
uint256[4] memory payments;
// uint256 marketplacePayment
payments[0] = calcPercentagePayment(_amount, _marketplacePercentage);
// uint256 royaltyPayment
// payments[1] = calcRoyaltyPayment(
// _isPrimarySale,
// _amount,
// _royaltyPercentage
// );
// uint256 primarySalePayment
payments[2] = calcPrimarySalePayment(
_isPrimarySale,
_amount,
_primarySalePercentage
);
// uint256 payeePayment
payments[3] = _amount.sub(payments[2]);
// marketplacePayment
if (payments[0] > 0) {
SendValueOrEscrow.sendValueOrEscrow(_marketplacePayee, payments[0]);
emit PrimarymarketplacePayment(_marketplacePayee,payments[0]);
}
// royaltyPayment
// if (payments[1] > 0) {
// SendValueOrEscrow.sendValueOrEscrow(_royaltyPayee, payments[1]);
// }
// primarySalePayment
if (payments[2] > 0) {
SendValueOrEscrow.sendValueOrEscrow(_primarySalePayee, payments[2]);
emit PrimarySalePayment(_primarySalePayee, payments[2]);
}
// payeePayment
if (payments[3] > 0) {
SendValueOrEscrow.sendValueOrEscrow(_payee, payments[3]);
emit PrimarypayeePayment(_payee, payments[3]);
}
}
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
// payout With Secondary Fee
/////////////////////////////////////////////////////////////////////////
/**
* @dev Internal function to pay the seller, creator, and maintainer.
* Requirements:
*
* - _marketplacePercentage + _royaltyPercentage + _secondarySalePercentage <= 100
* - no payees can be the zero address
*
* @param _amount uint256 value to be split.
* @param _isPrimarySale bool of whether this is a primary sale.
* @param _marketplacePercentage uint8 percentage of the fee for the marketplace.
* @param _royaltyPercentage uint8 percentage of the fee for the royalty.
* @param _secondarySalePercentage uint8 percentage primary sale fee for the marketplace.
* @param _payee address seller of the token.
* @param _marketplacePayee address seller of the token.
* @param _royaltyPayee address seller of the token.
* @param _secondarySalePayee address seller of the token.
*/
function payoutSecondary(
uint256 _amount,
bool _isPrimarySale, //false
uint8 _marketplacePercentage,
uint8 _royaltyPercentage,
uint8 _secondarySalePercentage,
address payable _payee,
address payable _marketplacePayee,
address payable _royaltyPayee,
address payable _secondarySalePayee
) internal {
require(
_marketplacePercentage <= 100,
"payout::marketplace percentage cannot be above 100"
);
require(
_royaltyPercentage.add(_secondarySalePercentage) <= 100,
"payout::percentages cannot go beyond 100"
);
require(
_payee != address(0) &&
_secondarySalePayee != address(0) &&
_marketplacePayee != address(0) &&
_royaltyPayee != address(0),
"payout::no payees can be the zero address"
);
// Note:: Solidity is kind of terrible in that there is a limit to local
// variables that can be put into the stack. The real pain is that
// one can put structs, arrays, or mappings into memory but not basic
// data types. Hence our payments array that stores these values.
uint256[4] memory payments;
// uint256 marketplacePayment
payments[0] = calcPercentagePayment(_amount, _marketplacePercentage);
// uint256 royaltyPayment
// payments[1] = calcRoyaltyPayment(
// _isPrimarySale,
// _amount,
// _royaltyPercentage
// );
// uint256 SecondarySalePayment
payments[2] = calcSecondarySalePayment(
_isPrimarySale,
_amount,
_secondarySalePercentage
);
// uint256 payeePayment
payments[3] = _amount.sub(payments[2]);
// marketplacePayment
if (payments[0] > 0) {
SendValueOrEscrow.sendValueOrEscrow(_marketplacePayee, payments[0]);
emit SecondarymarketplacePayment(_marketplacePayee,payments[0] );
}
// // royaltyPayment
// if (payments[1] > 0) {
// SendValueOrEscrow.sendValueOrEscrow(_royaltyPayee, payments[1]);
// }
// primarySalePayment
if (payments[2] > 0) {
SendValueOrEscrow.sendValueOrEscrow(_secondarySalePayee, payments[2]);
emit SecondarySalePayment(_secondarySalePayee, payments[2]);
}
// payeePayment
if (payments[3] > 0) {
SendValueOrEscrow.sendValueOrEscrow(_payee, payments[3]);
emit SecondarypayeePayment(_payee,payments[3]);
}
}
/////////////////////////////////////////////////////////////////////////
// calcRoyaltyPayment
/////////////////////////////////////////////////////////////////////////
/**
* @dev Private function to calculate Royalty amount.
* If primary sale: 0
* If no royalty percentage: 0
* otherwise: royalty in wei
* @param _isPrimarySale bool of whether this is a primary sale
* @param _amount uint256 value to be split
* @param _percentage uint8 royalty percentage
* @return uint256 wei value owed for royalty
*/
function calcRoyaltyPayment(
bool _isPrimarySale,
uint256 _amount,
uint8 _percentage
) private pure returns (uint256) {
if (_isPrimarySale) {
return 0;
}
return calcPercentagePayment(_amount, _percentage);
}
/////////////////////////////////////////////////////////////////////////
// calcPrimarySalePayment
/////////////////////////////////////////////////////////////////////////
/**
* @dev Private function to calculate PrimarySale amount.
* If not primary sale: 0
* otherwise: primary sale in wei
* @param _isPrimarySale bool of whether this is a primary sale
* @param _amount uint256 value to be split
* @param _percentage uint8 royalty percentage
* @return uint256 wei value owed for primary sale
*/
function calcPrimarySalePayment(
bool _isPrimarySale,
uint256 _amount,
uint8 _percentage
) private pure returns (uint256) {
if (_isPrimarySale) {
return calcPercentagePayment(_amount, _percentage);
}
return 0;
}
/////////////////////////////////////////////////////////////////////////
// calcSecondarySalePayment
/////////////////////////////////////////////////////////////////////////
/**
* @dev Private function to calculate PrimarySale amount.
* If not primary sale: 0
* otherwise: primary sale in wei
* @param _isPrimarySale bool of whether this is a primary sale
* @param _amount uint256 value to be split
* @param _percentage uint8 royalty percentage
* @return uint256 wei value owed for primary sale
*/
function calcSecondarySalePayment(
bool _isPrimarySale,
uint256 _amount,
uint8 _percentage
) private pure returns (uint256) {
if (!_isPrimarySale) {
return calcPercentagePayment(_amount, _percentage);
}
return 0;
}
/////////////////////////////////////////////////////////////////////////
// calcPercentagePayment
/////////////////////////////////////////////////////////////////////////
/**
* @dev Internal function to calculate percentage value.
* @param _amount uint256 wei value
* @param _percentage uint8 percentage
* @return uint256 wei value based on percentage.
*/
function calcPercentagePayment(uint256 _amount, uint8 _percentage)
internal
pure
returns (uint256)
{
return _amount.mul(_percentage).div(100);
}
}
Raw
SendValueOrEscrow.sol
pragma solidity 0.6.12;
import "https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/payment/PullPaymentUpgradeable.sol";
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/proxy/Initializable.sol';
import "./MaybeSendValue.sol";
/**
* @dev Contract to make payments. If a direct transfer fails, it will store the payment in escrow until the address decides to pull the payment.
*/
contract SendValueOrEscrow is MaybeSendValue, PullPaymentUpgradeable {
/////////////////////////////////////////////////////////////////////////
// Events
/////////////////////////////////////////////////////////////////////////
event SendValue(address indexed _payee, uint256 amount);
//initializer
function initialize() public initializer {
__PullPayment_init();
}
/////////////////////////////////////////////////////////////////////////
// sendValueOrEscrow
/////////////////////////////////////////////////////////////////////////
/**
* @dev Send some value to an address.
* @param _to address to send some value to.
* @param _value uint256 amount to send.
*/
function sendValueOrEscrow(address payable _to, uint256 _value) internal {
// attempt to make the transfer
bool successfulTransfer = MaybeSendValue.maybeSendValue(_to, _value);
// if it fails, transfer it into escrow for them to redeem at their will.
if (!successfulTransfer) {
_asyncTransfer(_to, _value);
}
emit SendValue(_to, _value);
}
}
Raw
SendValueProxy.sol
pragma solidity 0.6.12;
import "./ISendValueProxy.sol";
/**
* @dev Contract that attempts to send value to an address.
*/
contract SendValueProxy is ISendValueProxy {
/**
* @dev Send some wei to the address.
* @param _to address to send some value to.
*/
function sendValue(address payable _to) external override payable {
// Note that `<address>.transfer` limits gas sent to receiver. It may
// not support complex contract operations in the future.
_to.transfer(msg.value);
}
}
Raw
SuperRareAuctionHouse.sol
pragma solidity 0.6.12;
import "https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/token/ERC721/IERC721Upgradeable.sol";
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/math/SafeMathUpgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/access/OwnableUpgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/proxy/Initializable.sol';
import "./IERC721CreatorRoyalty.sol";
import "./IMarketplaceSettings.sol";
import "./Payments.sol";
contract SuperRareAuctionHouse is Initializable, OwnableUpgradeable, Payments {
using SafeMathUpgradeable for uint256;
/////////////////////////////////////////////////////////////////////////
// Constants
/////////////////////////////////////////////////////////////////////////
// Types of Auctions
bytes32 public constant COLDIE_AUCTION = "COLDIE_AUCTION";
bytes32 public constant SCHEDULED_AUCTION = "SCHEDULED_AUCTION";
bytes32 public constant NO_AUCTION = bytes32(0);
/////////////////////////////////////////////////////////////////////////
// Structs
/////////////////////////////////////////////////////////////////////////
// A reserve auction.
struct Auction {
address payable auctionCreator;
uint256 creationBlock;
uint256 lengthOfAuction;
uint256 startingBlock;
uint256 reservePrice;
uint256 minimumBid;
bytes32 auctionType;
}
// The active bid for a given token, contains the bidder, the marketplace fee at the time of the bid, and the amount of wei placed on the token
struct ActiveBid {
address payable bidder;
uint8 marketplaceFee;
uint256 amount;
}
/////////////////////////////////////////////////////////////////////////
// State Variables
/////////////////////////////////////////////////////////////////////////
// Marketplace Settings Interface
IMarketplaceSettings public iMarketSettings;
// Creator Royalty Interface
IERC721CreatorRoyalty public iERC721CreatorRoyalty;
// Mapping from ERC721 contract to mapping of tokenId to Auctions.
mapping(address => mapping(uint256 => Auction)) private auctions;
// Mapping of ERC721 contract to mapping of token ID to the current bid amount.
mapping(address => mapping(uint256 => ActiveBid)) private currentBids;
// Number of blocks to begin refreshing auction lengths
uint256 public auctionLengthExtension;
// Max Length that an auction can be
uint256 public maxLength;
// A minimum increase in bid amount when out bidding someone.
uint8 public minimumBidIncreasePercentage; // 10 = 10%
/////////////////////////////////////////////////////////////////////////
// Events
/////////////////////////////////////////////////////////////////////////
event NewColdieAuction(
address indexed _contractAddress,
uint256 indexed _tokenId,
address indexed _auctionCreator,
uint256 _reservePrice,
uint256 _lengthOfAuction
);
event CancelAuction(
address indexed _contractAddress,
uint256 indexed _tokenId,
address indexed _auctionCreator
);
event NewScheduledAuction(
address indexed _contractAddress,
uint256 indexed _tokenId,
address indexed _auctionCreator,
uint256 _startingBlock,
uint256 _minimumBid,
uint256 _lengthOfAuction
);
event AuctionBid(
address indexed _contractAddress,
address indexed _bidder,
uint256 indexed _tokenId,
uint256 _amount,
bool _startedAuction,
uint256 _newAuctionLength,
address _previousBidder
);
event AuctionSettled(
address indexed _contractAddress,
address indexed _bidder,
address _seller,
uint256 indexed _tokenId,
uint256 _amount
);
/////////////////////////////////////////////////////////////////////////
// Constructor
/////////////////////////////////////////////////////////////////////////
/**
* @dev Initializes the contract setting the market settings and creator royalty interfaces.
* @param _iMarketSettings address to set as iMarketSettings.
* @param _iERC721CreatorRoyalty address to set as iERC721CreatorRoyalty.
*/
// constructor(address _iMarketSettings, address _iERC721CreatorRoyalty)
// public
// {
// maxLength = 43200; // ~ 7 days == 7 days * 24 hours * 3600s / 14s per block
// auctionLengthExtension = 65; // ~ 15 min == 15 min * 60s / 14s per block
// require(
// _iMarketSettings != address(0),
// "constructor::Cannot have null address for _iMarketSettings"
// );
// require(
// _iERC721CreatorRoyalty != address(0),
// "constructor::Cannot have null address for _iERC721CreatorRoyalty"
// );
// // Set iMarketSettings
// iMarketSettings = IMarketplaceSettings(_iMarketSettings);
// // Set iERC721CreatorRoyalty
// iERC721CreatorRoyalty = IERC721CreatorRoyalty(_iERC721CreatorRoyalty);
// minimumBidIncreasePercentage = 10;
// }
//function initialize(uint256 _x) public initializer
/////////////////////////////////////////////////////////////////////////
// initializer
/////////////////////////////////////////////////////////////////////////
/**
* @dev Initializes the contract setting the market settings and creator royalty interfaces.
* @param _iMarketSettings address to set as iMarketSettings.
* @param _iERC721CreatorRoyalty address to set as iERC721CreatorRoyalty.
*/
function initialize(address _iMarketSettings, address _iERC721CreatorRoyalty) public initializer
{
maxLength = 43200; // ~ 7 days == 7 days * 24 hours * 3600s / 14s per block
auctionLengthExtension = 65; // ~ 15 min == 15 min * 60s / 14s per block
require(
_iMarketSettings != address(0),
"constructor::Cannot have null address for _iMarketSettings"
);
require(
_iERC721CreatorRoyalty != address(0),
"constructor::Cannot have null address for _iERC721CreatorRoyalty"
);
__Ownable_init();
// Set iMarketSettings
iMarketSettings = IMarketplaceSettings(_iMarketSettings);
// Set iERC721CreatorRoyalty
iERC721CreatorRoyalty = IERC721CreatorRoyalty(_iERC721CreatorRoyalty);
minimumBidIncreasePercentage = 10;
}
/////////////////////////////////////////////////////////////////////////
// setIMarketplaceSettings
/////////////////////////////////////////////////////////////////////////
/**
* @dev Admin function to set the marketplace settings.
* Rules:
* - only owner
* - _address != address(0)
* @param _address address of the IMarketplaceSettings.
*/
function setMarketplaceSettings(address _address) public onlyOwner {
require(
_address != address(0),
"setMarketplaceSettings::Cannot have null address for _iMarketSettings"
);
iMarketSettings = IMarketplaceSettings(_address);
}
/////////////////////////////////////////////////////////////////////////
// setIERC721CreatorRoyalty
/////////////////////////////////////////////////////////////////////////
/**
* @dev Admin function to set the IERC721CreatorRoyalty.
* Rules:
* - only owner
* - _address != address(0)
* @param _address address of the IERC721CreatorRoyalty.
*/
function setIERC721CreatorRoyalty(address _address) public onlyOwner {
require(
_address != address(0),
"setIERC721CreatorRoyalty::Cannot have null address for _iERC721CreatorRoyalty"
);
iERC721CreatorRoyalty = IERC721CreatorRoyalty(_address);
}
/////////////////////////////////////////////////////////////////////////
// setMaxLength
/////////////////////////////////////////////////////////////////////////
/**
* @dev Admin function to set the maxLength of an auction.
* Rules:
* - only owner
* - _maxLangth > 0
* @param _maxLength uint256 max length of an auction.
*/
function setMaxLength(uint256 _maxLength) public onlyOwner {
require(
_maxLength > 0,
"setMaxLength::_maxLength must be greater than 0"
);
maxLength = _maxLength;
}
/////////////////////////////////////////////////////////////////////////
// setMinimumBidIncreasePercentage
/////////////////////////////////////////////////////////////////////////
/**
* @dev Admin function to set the minimum bid increase percentage.
* Rules:
* - only owner
* @param _percentage uint8 to set as the new percentage.
*/
function setMinimumBidIncreasePercentage(uint8 _percentage)
public
onlyOwner
{
minimumBidIncreasePercentage = _percentage;
}
/////////////////////////////////////////////////////////////////////////
// setAuctionLengthExtension
/////////////////////////////////////////////////////////////////////////
/**
* @dev Admin function to set the auctionLengthExtension of an auction.
* Rules:
* - only owner
* - _auctionLengthExtension > 0
* @param _auctionLengthExtension uint256 max length of an auction.
*/
function setAuctionLengthExtension(uint256 _auctionLengthExtension)
public
onlyOwner
{
require(
_auctionLengthExtension > 0,
"setAuctionLengthExtension::_auctionLengthExtension must be greater than 0"
);
auctionLengthExtension = _auctionLengthExtension;
}
/////////////////////////////////////////////////////////////////////////
// createColdieAuction
/////////////////////////////////////////////////////////////////////////
/**
* @dev create a reserve auction token contract address, token id, price
* Rules:
* - Cannot create an auction if contract isn't approved by owner
* - lengthOfAuction (in blocks) > 0
* - lengthOfAuction (in blocks) <= maxLength
* - Reserve price must be >= 0
* - Must be owner of the token
* - Cannot have a current auction going
* @param _contractAddress address of ERC721 contract.
* @param _tokenId uint256 id of the token.
* @param _reservePrice uint256 Wei value of the reserve price.
* @param _lengthOfAuction uint256 length of auction in blocks.
*/
function createColdieAuction(
address _contractAddress,
uint256 _tokenId,
uint256 _reservePrice,
uint256 _lengthOfAuction
) public {
// Rules
_requireOwnerApproval(_contractAddress, _tokenId);
_requireOwnerAsSender(_contractAddress, _tokenId);
require(
_lengthOfAuction <= maxLength,
"createColdieAuction::Cannot have auction longer than maxLength"
);
require(
auctions[_contractAddress][_tokenId].auctionType == NO_AUCTION ||
(msg.sender !=
auctions[_contractAddress][_tokenId].auctionCreator),
"createColdieAuction::Cannot have a current auction"
);
require(
_lengthOfAuction > 0,
"createColdieAuction::_lengthOfAuction must be > 0"
);
require(
_reservePrice >= 0,
"createColdieAuction::_reservePrice must be >= 0"
);
require(
_reservePrice <= iMarketSettings.getMarketplaceMaxValue(),
"createColdieAuction::Cannot set reserve price higher than max value"
);
// Create the auction
auctions[_contractAddress][_tokenId] = Auction(
msg.sender,
block.number,
_lengthOfAuction,
0,
_reservePrice,
0,
COLDIE_AUCTION
);
emit NewColdieAuction(
_contractAddress,
_tokenId,
msg.sender,
_reservePrice,
_lengthOfAuction
);
}
/////////////////////////////////////////////////////////////////////////
// cancelAuction
/////////////////////////////////////////////////////////////////////////
/**
* @dev cancel an auction
* Rules:
* - Must have an auction for the token
* - Auction cannot have started
* - Must be the creator of the auction
* - Must return token to owner if escrowed
* @param _contractAddress address of ERC721 contract.
* @param _tokenId uint256 id of the token.
*/
function cancelAuction(address _contractAddress, uint256 _tokenId)
external
{
require(
auctions[_contractAddress][_tokenId].auctionType != NO_AUCTION,
"cancelAuction::Must have a current auction"
);
require(
auctions[_contractAddress][_tokenId].startingBlock == 0 ||
auctions[_contractAddress][_tokenId].startingBlock >
block.number,
"cancelAuction::auction cannot be started"
);
require(
auctions[_contractAddress][_tokenId].auctionCreator == msg.sender,
"cancelAuction::must be the creator of the auction"
);
Auction memory auction = auctions[_contractAddress][_tokenId];
auctions[_contractAddress][_tokenId] = Auction(
address(0),
0,
0,
0,
0,
0,
NO_AUCTION
);
// Return the token if this contract escrowed it
IERC721Upgradeable erc721 = IERC721Upgradeable(_contractAddress);
if (erc721.ownerOf(_tokenId) == address(this)) {
erc721.transferFrom(address(this), msg.sender, _tokenId);
}
emit CancelAuction(_contractAddress, _tokenId, auction.auctionCreator);
}
/////////////////////////////////////////////////////////////////////////
// createScheduledAuction
/////////////////////////////////////////////////////////////////////////
/**
* @dev create a scheduled auction token contract address, token id
* Rules:
* - lengthOfAuction (in blocks) > 0
* - startingBlock > currentBlock
* - Cannot create an auction if contract isn't approved by owner
* - Minimum bid must be >= 0
* - Must be owner of the token
* - Cannot have a current auction going for this token
* @param _contractAddress address of ERC721 contract.
* @param _tokenId uint256 id of the token.
* @param _minimumBid uint256 Wei value of the reserve price.
* @param _lengthOfAuction uint256 length of auction in blocks.
* @param _startingBlock uint256 block number to start the auction on.
*/
function createScheduledAuction(
address _contractAddress,
uint256 _tokenId,
uint256 _minimumBid,
uint256 _lengthOfAuction,
uint256 _startingBlock
) external {
require(
_lengthOfAuction > 0,
"createScheduledAuction::_lengthOfAuction must be greater than 0"
);
require(
_lengthOfAuction <= maxLength,
"createScheduledAuction::Cannot have auction longer than maxLength"
);
require(
_startingBlock > block.number,
"createScheduledAuction::_startingBlock must be greater than block.number"
);
require(
_minimumBid <= iMarketSettings.getMarketplaceMaxValue(),
"createScheduledAuction::Cannot set minimum bid higher than max value"
);
_requireOwnerApproval(_contractAddress, _tokenId);
_requireOwnerAsSender(_contractAddress, _tokenId);
require(
auctions[_contractAddress][_tokenId].auctionType == NO_AUCTION ||
(msg.sender !=
auctions[_contractAddress][_tokenId].auctionCreator),
"createScheduledAuction::Cannot have a current auction"
);
// Create the scheduled auction.
auctions[_contractAddress][_tokenId] = Auction(
msg.sender,
block.number,
_lengthOfAuction,
_startingBlock,
0,
_minimumBid,
SCHEDULED_AUCTION
);
// Transfer the token to this contract to act as escrow.
IERC721Upgradeable erc721 = IERC721Upgradeable(_contractAddress);
erc721.transferFrom(msg.sender, address(this), _tokenId);
emit NewScheduledAuction(
_contractAddress,
_tokenId,
msg.sender,
_startingBlock,
_minimumBid,
_lengthOfAuction
);
}
/////////////////////////////////////////////////////////////////////////
// bid
/////////////////////////////////////////////////////////////////////////
/**
* @dev Bid on artwork with an auction.
* Rules:
* - if auction creator is still owner, owner must have contract approved
* - There must be a running auction or a reserve price auction for the token
* - bid > 0
* - if startingBlock - block.number < auctionLengthExtension
* - then auctionLength = Starting block - (currentBlock + extension)
* - Auction creator != bidder
* - bid >= minimum bid
* - bid >= reserve price
* - block.number < startingBlock + lengthOfAuction
* - bid > current bid
* - if previous bid then returned
* @param _contractAddress address of ERC721 contract.
* @param _tokenId uint256 id of the token.
* @param _amount uint256 Wei value of the bid.
*/
function bid(
address _contractAddress,
uint256 _tokenId,
uint256 _amount
) external payable {
Auction memory auction = auctions[_contractAddress][_tokenId];
// Must have existing auction.
require(
auction.auctionType != NO_AUCTION,
"bid::Must have existing auction"
);
// Must have existing auction.
require(
auction.auctionCreator != msg.sender,
"bid::Cannot bid on your own auction"
);
// Must have pending coldie auction or running auction.
require(
auction.startingBlock <= block.number,
"bid::Must have a running auction or pending coldie auction"
);
// Check that bid is greater than 0.
require(_amount > 0, "bid::Cannot bid 0 Wei.");
// Check that bid is less than max value.
require(
_amount <= iMarketSettings.getMarketplaceMaxValue(),
"bid::Cannot bid higher than max value"
);
// Check that bid is larger than min value.
require(
_amount >= iMarketSettings.getMarketplaceMinValue(),
"bid::Cannot bid lower than min value"
);
// Check that bid is larger than minimum bid value or the reserve price.
require(
(_amount >= auction.reservePrice && auction.minimumBid == 0) ||
(_amount >= auction.minimumBid && auction.reservePrice == 0),
"bid::Cannot bid lower than reserve or minimum bid"
);
// Auction cannot have ended.
require(
auction.startingBlock == 0 ||
block.number <
auction.startingBlock.add(auction.lengthOfAuction),
"bid::Cannot have ended"
);
// Check that enough ether was sent.
uint256 requiredCost =
_amount.add(iMarketSettings.calculateMarketplaceFee(_amount));
require(requiredCost == msg.value, "bid::Must bid the correct amount.");
// If owner of token is auction creator make sure they have contract approved
IERC721Upgradeable erc721 = IERC721Upgradeable(_contractAddress);
address owner = erc721.ownerOf(_tokenId);
// Check that token is owned by creator or by this contract
require(
auction.auctionCreator == owner || owner == address(this),
"bid::Cannot bid on auction if auction creator is no longer owner."
);
if (auction.auctionCreator == owner) {
_requireOwnerApproval(_contractAddress, _tokenId);
}
ActiveBid memory currentBid = currentBids[_contractAddress][_tokenId];
// Must bid higher than current bid.
require(
_amount > currentBid.amount &&
_amount >=
currentBid.amount.add(
currentBid.amount.mul(minimumBidIncreasePercentage).div(100)
),
"bid::must bid higher than previous bid + minimum percentage increase."
);
// Return previous bid
// We do this here because it clears the bid for the refund. This makes it safe from reentrence.
if (currentBid.amount != 0) {
_refundBid(_contractAddress, _tokenId);
}
// Set the new bid
currentBids[_contractAddress][_tokenId] = ActiveBid(
msg.sender,
iMarketSettings.getMarketplaceFeePercentage(),
_amount
);
// If is a pending coldie auction, start the auction
if (auction.startingBlock == 0) {
auctions[_contractAddress][_tokenId].startingBlock = block.number;
erc721.transferFrom(
auction.auctionCreator,
address(this),
_tokenId
);
emit AuctionBid(
_contractAddress,
msg.sender,
_tokenId,
_amount,
true,
0,
currentBid.bidder
);
}
// If the time left for the auction is less than the extension limit bump the length of the auction.
else if (
(auction.startingBlock.add(auction.lengthOfAuction)).sub(
block.number
) < auctionLengthExtension
) {
auctions[_contractAddress][_tokenId].lengthOfAuction = (
block.number.add(auctionLengthExtension)
)
.sub(auction.startingBlock);
emit AuctionBid(
_contractAddress,
msg.sender,
_tokenId,
_amount,
false,
auctions[_contractAddress][_tokenId].lengthOfAuction,
currentBid.bidder
);
}
// Otherwise, it's a normal bid
else {
emit AuctionBid(
_contractAddress,
msg.sender,
_tokenId,
_amount,
false,
0,
currentBid.bidder
);
}
}
/////////////////////////////////////////////////////////////////////////
// settleAuction
/////////////////////////////////////////////////////////////////////////
/**
* @dev Settles the auction, transferring the auctioned token to the bidder and the bid to auction creator.
* Rules:
* - There must be an unsettled auction for the token
* - current bidder becomes new owner
* - auction creator gets paid
* - there is no longer an auction for the token
* @param _contractAddress address of ERC721 contract.
* @param _tokenId uint256 id of the token.
*/
function settleAuction(address _contractAddress, uint256 _tokenId)
external
{
Auction memory auction = auctions[_contractAddress][_tokenId];
require(
auction.auctionType != NO_AUCTION && auction.startingBlock != 0,
"settleAuction::Must have a current auction that has started"
);
require(
block.number >= auction.startingBlock.add(auction.lengthOfAuction),
"settleAuction::Can only settle ended auctions."
);
ActiveBid memory currentBid = currentBids[_contractAddress][_tokenId];
currentBids[_contractAddress][_tokenId] = ActiveBid(address(0), 0, 0);
auctions[_contractAddress][_tokenId] = Auction(
address(0),
0,
0,
0,
0,
0,
NO_AUCTION
);
IERC721Upgradeable erc721 = IERC721Upgradeable(_contractAddress);
// If there were no bids then end the auction and return the token to its original owner.
if (currentBid.bidder == address(0)) {
// Transfer the token to back to original owner.
erc721.transferFrom(
address(this),
auction.auctionCreator,
_tokenId
);
emit AuctionSettled(
_contractAddress,
address(0),
auction.auctionCreator,
_tokenId,
0
);
return;
}
// Transfer the token to the winner of the auction.
erc721.transferFrom(address(this), currentBid.bidder, _tokenId);
address payable owner = _makePayable(owner());
Payments.payoutPrimary(
currentBid.amount,
!iMarketSettings.hasERC721TokenSold(_contractAddress, _tokenId),
currentBid.marketplaceFee,
iERC721CreatorRoyalty.getERC721TokenRoyaltyPercentage(
_contractAddress,
_tokenId
),
iMarketSettings.getERC721ContractPrimarySaleFeePercentage(
_contractAddress
),
auction.auctionCreator,
owner,
iERC721CreatorRoyalty.tokenCreator(_contractAddress, _tokenId),
owner
);
iMarketSettings.markERC721Token(_contractAddress, _tokenId, true);
emit AuctionSettled(
_contractAddress,
currentBid.bidder,
auction.auctionCreator,
_tokenId,
currentBid.amount
);
}
/////////////////////////////////////////////////////////////////////////
// getAuctionDetails
/////////////////////////////////////////////////////////////////////////
/**
* @dev Get current auction details for a token
* Rules:
* - Return empty when there's no auction
* @param _contractAddress address of ERC721 contract.
* @param _tokenId uint256 id of the token.
*/
function getAuctionDetails(address _contractAddress, uint256 _tokenId)
external
view
returns (
bytes32,
uint256,
address,
uint256,
uint256,
uint256,
uint256
)
{
Auction memory auction = auctions[_contractAddress][_tokenId];
return (
auction.auctionType,
auction.creationBlock,
auction.auctionCreator,
auction.lengthOfAuction,
auction.startingBlock,
auction.minimumBid,
auction.reservePrice
);
}
/////////////////////////////////////////////////////////////////////////
// getCurrentBid
/////////////////////////////////////////////////////////////////////////
/**
* @dev Get the current bid
* Rules:
* - Return empty when there's no bid
* @param _contractAddress address of ERC721 contract.
* @param _tokenId uint256 id of the token.
*/
function getCurrentBid(address _contractAddress, uint256 _tokenId)
external
view
returns (address, uint256)
{
return (
currentBids[_contractAddress][_tokenId].bidder,
currentBids[_contractAddress][_tokenId].amount
);
}
/////////////////////////////////////////////////////////////////////////
// _requireOwnerApproval
/////////////////////////////////////////////////////////////////////////
/**
* @dev Require that the owner have the SuperRareAuctionHouse approved.
* @param _contractAddress address of ERC721 contract.
* @param _tokenId uint256 id of the token.
*/
function _requireOwnerApproval(address _contractAddress, uint256 _tokenId)
internal
view
{
IERC721Upgradeable erc721 = IERC721Upgradeable(_contractAddress);
address owner = erc721.ownerOf(_tokenId);
require(
erc721.isApprovedForAll(owner, address(this)),
"owner must have approved contract"
);
}
/////////////////////////////////////////////////////////////////////////
// _requireOwnerAsSender
/////////////////////////////////////////////////////////////////////////
/**
* @dev Require that the owner be the sender.
* @param _contractAddress address of ERC721 contract.
* @param _tokenId uint256 id of the token.
*/
function _requireOwnerAsSender(address _contractAddress, uint256 _tokenId)
internal
view
{
IERC721Upgradeable erc721 = IERC721Upgradeable(_contractAddress);
address owner = erc721.ownerOf(_tokenId);
require(owner == msg.sender, "owner must be message sender");
}
/////////////////////////////////////////////////////////////////////////
// _refundBid
/////////////////////////////////////////////////////////////////////////
/**
* @dev Internal function to return an existing bid on a token to the
* bidder and reset bid.
* @param _contractAddress address of ERC721 contract.
* @param _tokenId uin256 id of the token.
*/
function _refundBid(address _contractAddress, uint256 _tokenId) internal {
ActiveBid memory currentBid = currentBids[_contractAddress][_tokenId];
if (currentBid.bidder == address(0)) {
return;
}
currentBids[_contractAddress][_tokenId] = ActiveBid(address(0), 0, 0);
// refund the bidder
Payments.refund(
currentBid.marketplaceFee,
currentBid.bidder,
currentBid.amount
);
}
/////////////////////////////////////////////////////////////////////////
// _makePayable
/////////////////////////////////////////////////////////////////////////
/**
* @dev Internal function to set a bid.
* @param _address non-payable address
* @return payable address
*/
function _makePayable(address _address)
internal
pure
returns (address payable)
{
return address(uint160(_address));
}
}
Raw
SuperRareLegacy.sol
pragma solidity 0.6.12;
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/token/ERC721/ERC721Upgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/access/OwnableUpgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/math/SafeMathUpgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/proxy/Initializable.sol';
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/solc-0.6/contracts/token/ERC721/ERC721.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/solc-0.6/contracts/access/Ownable.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/solc-0.6/contracts/math/SafeMath.sol";
import "./ISupeRare.sol";
import "./IERC721Creator.sol";
/**
* @title SuperRare Legacy Tokens
* @dev This contract acts the new SuperRare Legacy contract (formerly known as SupeRare).
* It is used to upgrade SupeRare tokens to make them fully ERC721 compliant.
*
* Steps for upgrading:
* 1.) As the token owner, make sure you are the `preUpgradeOwner` to ensure you are the receiver of the new token.
* 2.) Transfer your old token to this contract's address.
* 3.) Boom! You're now the owner of the upgraded token.
*
*/
contract SuperRareLegacy is ERC721Upgradeable, IERC721Creator, OwnableUpgradeable {
using SafeMathUpgradeable for uint256;
/////////////////////////////////////////////////////////////////////////
// State Variables
/////////////////////////////////////////////////////////////////////////
// Old SuperRare contract to look up token details.
ISupeRare private oldSuperRare;
// Mapping from token ID to the pre upgrade token owner.
mapping(uint256 => address) private _tokenOwnerPreUpgrade;
// Boolean for when minting has completed.
bool private _mintingCompleted;
/////////////////////////////////////////////////////////////////////////
// Constructor
/////////////////////////////////////////////////////////////////////////
// constructor(
// string memory _name,
// string memory _symbol,
// address _oldSuperRare
// ) public ERC721(_name, _symbol) {
// require(
// _oldSuperRare != address(0),
// "constructor::Cannot have null address for _oldSuperRare"
// );
// // Set old SuperRare.
// oldSuperRare = ISupeRare(_oldSuperRare);
// // Mark minting as not completed
// _mintingCompleted = false;
// }
/////////////////////////////////////////////////////////////////////////
// Initializer
/////////////////////////////////////////////////////////////////////////
function initialize(string memory _name, string memory _symbol) public initializer
// constructor(string memory _name, string memory _symbol, address _oldSuperRare) public ERC721Upgradeable(_name, _symbol)
{
//initialize base Initializer function
__Ownable_init();
__ERC721_init(_name,_symbol );
// Set old SuperRare.
oldSuperRare = ISupeRare(_oldSuperRare);
// Mark minting as not completed
_mintingCompleted = false;
}
/////////////////////////////////////////////////////////////////////////
// Admin Methods
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
// mintLegacyTokens
/////////////////////////////////////////////////////////////////////////
/**
* @dev Mints the legacy tokens without emitting any events.
* @param _tokenIds uint256 array of token ids to mint.
*/
function mintLegacyTokens(uint256[] calldata _tokenIds) external onlyOwner {
require(
!_mintingCompleted,
"SuperRareLegacy: Cannot mint tokens once minting has completed."
);
for (uint256 i = 0; i < _tokenIds.length; i++) {
_createLegacyToken(_tokenIds[i]);
}
}
/////////////////////////////////////////////////////////////////////////
// markMintingCompleted
/////////////////////////////////////////////////////////////////////////
/**
* @dev Marks _mintedCompleted as true which forever prevents any more minting.
*/
function markMintingCompleted() external onlyOwner {
require(
!_mintingCompleted,
"SuperRareLegacy: Cannot mark completed if already completed."
);
_mintingCompleted = true;
}
/////////////////////////////////////////////////////////////////////////
// Public Methods
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
// ownerOf
/////////////////////////////////////////////////////////////////////////
/**
* @dev Returns the owner of the NFT specified by `tokenId`
* @param _tokenId uint256 token id to get the owner of.
* @return owner address of the token owner.
*/
function ownerOf(uint256 _tokenId)
public
override
view
returns (address owner)
{
if (!isUpgraded((_tokenId))) {
return address(this);
}
return ERC721Upgradeable.ownerOf(_tokenId);
}
/////////////////////////////////////////////////////////////////////////
// preUpgradeOwnerOf
/////////////////////////////////////////////////////////////////////////
/**
* @dev Returns the pre-upgrade token owner of the NFT specified by `tokenId`.
* This owner will become the owner of the upgraded token.
* @param _tokenId uint256 token id to get the pre-upgrade owner of.
* @return address of the token pre-upgrade owner.
*/
function preUpgradeOwnerOf(uint256 _tokenId) public view returns (address) {
address preUpgradeOwner = _tokenOwnerPreUpgrade[_tokenId];
require(
preUpgradeOwner != address(0),
"SuperRareLegacy: pre-upgrade owner query for nonexistent token"
);
return preUpgradeOwner;
}
/////////////////////////////////////////////////////////////////////////
// isUpgraded
/////////////////////////////////////////////////////////////////////////
/**
* @dev Returns whether the token has been upgraded.
* @param _tokenId uint256 token id to get the owner of.
* @return bool of whether the token has been upgraded.
*/
function isUpgraded(uint256 _tokenId) public view returns (bool) {
address ownerOnOldSuperRare = oldSuperRare.ownerOf(_tokenId);
return address(this) == ownerOnOldSuperRare;
}
/////////////////////////////////////////////////////////////////////////
// refreshPreUpgradeOwnerOf
/////////////////////////////////////////////////////////////////////////
/**
* @dev Refreshes the pre-upgrade token owner. Useful in the event of a
* non-upgraded token transferring ownership. Throws if token has upgraded
* or if there is nothing to refresh.
* @param _tokenId uint256 token id to refresh the pre-upgrade token owner.
*/
function refreshPreUpgradeOwnerOf(uint256 _tokenId) external {
require(
!isUpgraded(_tokenId),
"SuperRareLegacy: cannot refresh an upgraded token"
);
address ownerOnOldSuperRare = oldSuperRare.ownerOf(_tokenId);
address outdatedOwner = preUpgradeOwnerOf(_tokenId);
require(
ownerOnOldSuperRare != outdatedOwner,
"SuperRareLegacy: cannot refresh when pre-upgrade owners match"
);
// _transferFromNoEvent(outdatedOwner, ownerOnOldSuperRare, _tokenId);
_tokenOwnerPreUpgrade[_tokenId] = ownerOnOldSuperRare;
}
/////////////////////////////////////////////////////////////////////////
// tokenCreator
/////////////////////////////////////////////////////////////////////////
/**
* @dev Refreshes the pre-upgrade token owner. Useful in the event of a
* non-upgraded token transferring ownership. Throws if token has upgraded
* or if there is nothing to refresh.
* @param _tokenId uint256 token id to refresh the pre-upgrade token owner.
* @return address of the token pre-upgrade owner.
*/
function tokenCreator(uint256 _tokenId)
external
override
view
returns (address payable)
{
return oldSuperRare.creatorOfToken(_tokenId);
}
/////////////////////////////////////////////////////////////////////////
// tokenURI
/////////////////////////////////////////////////////////////////////////
/**
* @dev Returns the URI for a given token ID. May return an empty string.
* If the token's URI is non-empty and a base URI was set
* Reverts if the token ID does not exist.
* @param tokenId uint256 token id to refresh the pre-upgrade token owner.
* @return string URI of the given token ID.
*/
function tokenURI(uint256 tokenId)
public
override
view
returns (string memory)
{
require(
_exists(tokenId),
"SuperRareLegacy: URI query for nonexistent token"
);
return oldSuperRare.tokenURI(tokenId);
}
/////////////////////////////////////////////////////////////////////////
// Internal Methods
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
// _createLegacyToken
/////////////////////////////////////////////////////////////////////////
/**
* @dev Mints a legacy token with the appropriate metadata and owner.
* @param _tokenId uint256 token id to get the owner of.
*/
function _createLegacyToken(uint256 _tokenId) internal {
address ownerOnOldSuperRare = oldSuperRare.ownerOf(_tokenId);
//_mintWithNoEvent(ownerOnOldSuperRare, _tokenId);
_tokenOwnerPreUpgrade[_tokenId] = ownerOnOldSuperRare;
}
}
Raw
SuperRareMarketAuctionV2.sol
pragma solidity 0.6.12;
import "https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/token/ERC721/IERC721Upgradeable.sol";
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/math/SafeMathUpgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/access/OwnableUpgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/access/AccessControlUpgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/proxy/Initializable.sol';
import "./IERC721CreatorRoyalty.sol";
import "./IMarketplaceSettings.sol";
import "./Payments.sol";
contract SuperRareMarketAuctionV2 is Initializable, OwnableUpgradeable, AccessControlUpgradeable ,Payments {
using SafeMathUpgradeable for uint256;
/////////////////////////////////////////////////////////////////////////
// Structs
/////////////////////////////////////////////////////////////////////////
// The active bid for a given token, contains the bidder, the marketplace fee at the time of the bid, and the amount of wei placed on the token
struct ActiveBid {
address payable bidder;
uint8 marketplaceFee;
uint256 amount;
}
// The sale price for a given token containing the seller and the amount of wei to be sold for
struct SalePrice {
address payable seller;
uint256 amount;
}
/////////////////////////////////////////////////////////////////////////
// Constants
/////////////////////////////////////////////////////////////////////////
bytes32 public constant TOKEN_COLLECTOR_ROLE = "TOKEN_COLLECTOR_ROLE";
/////////////////////////////////////////////////////////////////////////
// State Variables
/////////////////////////////////////////////////////////////////////////
// Marketplace Settings Interface
IMarketplaceSettings public iMarketplaceSettings;
// Creator Royalty Interface
IERC721CreatorRoyalty public iERC721CreatorRoyalty;
// Mapping from ERC721 contract to mapping of tokenId to sale price.
mapping(address => mapping(uint256 => SalePrice)) private tokenPrices;
// Mapping of ERC721 contract to mapping of token ID to the current bid amount.
mapping(address => mapping(uint256 => ActiveBid)) private tokenCurrentBids;
// A minimum increase in bid amount when out bidding someone.
uint8 public minimumBidIncreasePercentage; // 10 = 10%
/////////////////////////////////////////////////////////////////////////////
// Events
/////////////////////////////////////////////////////////////////////////////
event Sold(
address indexed _originContract,
address indexed _buyer,
address indexed _seller,
uint256 _amount,
uint256 _tokenId
);
event SetSalePrice(
address indexed _originContract,
uint256 _amount,
uint256 _tokenId
);
event Bid(
address indexed _originContract,
address indexed _bidder,
uint256 _amount,
uint256 _tokenId
);
event AcceptBid(
address indexed _originContract,
address indexed _bidder,
address indexed _seller,
uint256 _amount,
uint256 _tokenId
);
event CancelBid(
address indexed _originContract,
address indexed _bidder,
uint256 _amount,
uint256 _tokenId
);
event collectorRoleGrantedTo(
address _collector
);
event collectorRoleRevokedTo(
address _collector
);
/////////////////////////////////////////////////////////////////////////
// initialize
/////////////////////////////////////////////////////////////////////////
/**
* @dev Initializes the contract setting the market settings and creator royalty interfaces.
* @param _iMarketSettings address to set as iMarketplaceSettings.
* @param _iERC721CreatorRoyalty address to set as iERC721CreatorRoyalty.
*/
function initialize(address _iMarketSettings, address _iERC721CreatorRoyalty) public initializer {
require(
_iMarketSettings != address(0),
"constructor::Cannot have null address for _iMarketSettings"
);
require(
_iERC721CreatorRoyalty != address(0),
"constructor::Cannot have null address for _iERC721CreatorRoyalty"
);
__Ownable_init();
__AccessControl_init();
Payments.initializePayment();
// Grant the contract deployer the default admin role: it will be able
// to grant and revoke any roles
_setupRole(AccessControlUpgradeable.DEFAULT_ADMIN_ROLE, owner());
// Set iMarketSettings
iMarketplaceSettings = IMarketplaceSettings(_iMarketSettings);
// Set iERC721CreatorRoyalty
iERC721CreatorRoyalty = IERC721CreatorRoyalty(_iERC721CreatorRoyalty);
minimumBidIncreasePercentage = 10;
}
//Grant Role to Collectors
function grantCollectorRole(address _collector) onlyOwner private {
grantRole(TOKEN_COLLECTOR_ROLE, _collector);
emit collectorRoleGrantedTo(_collector);
}
//revoke roles
function revokeCollectorRole(address _collector) onlyOwner private{
revokeRole(TOKEN_COLLECTOR_ROLE, _collector);
emit collectorRoleRevokedTo(_collector);
}
/////////////////////////////////////////////////////////////////////////
// setIMarketplaceSettings
/////////////////////////////////////////////////////////////////////////
/**
* @dev Admin function to set the marketplace settings.
* Rules:
* - only owner
* - _address != address(0)
* @param _address address of the IMarketplaceSettings.
*/
function setMarketplaceSettings(address _address) public onlyOwner {
require(
_address != address(0),
"setMarketplaceSettings::Cannot have null address for _iMarketSettings"
);
iMarketplaceSettings = IMarketplaceSettings(_address);
}
/////////////////////////////////////////////////////////////////////////
// setIERC721CreatorRoyalty
/////////////////////////////////////////////////////////////////////////
/**
* @dev Admin function to set the IERC721CreatorRoyalty.
* Rules:
* - only owner
* - _address != address(0)
* @param _address address of the IERC721CreatorRoyalty.
*/
function setIERC721CreatorRoyalty(address _address) public onlyOwner {
require(
_address != address(0),
"setIERC721CreatorRoyalty::Cannot have null address for _iERC721CreatorRoyalty"
);
iERC721CreatorRoyalty = IERC721CreatorRoyalty(_address);
}
/////////////////////////////////////////////////////////////////////////
// setMinimumBidIncreasePercentage
/////////////////////////////////////////////////////////////////////////
/**
* @dev Admin function to set the minimum bid increase percentage.
* Rules:
* - only owner
* @param _percentage uint8 to set as the new percentage.
*/
function setMinimumBidIncreasePercentage(uint8 _percentage)
public
onlyOwner
{
minimumBidIncreasePercentage = _percentage;
}
/////////////////////////////////////////////////////////////////////////
// Modifiers (as functions)
/////////////////////////////////////////////////////////////////////////
/**
* @dev Checks that the token owner is approved for the ERC721Market
* @param _originContract address of the contract storing the token.
* @param _tokenId uint256 ID of the token
*/
function ownerMustHaveMarketplaceApproved(
address _originContract,
uint256 _tokenId
) internal view {
IERC721Upgradeable erc721 = IERC721Upgradeable(_originContract);
address owner = erc721.ownerOf(_tokenId);
require(
erc721.isApprovedForAll(owner, address(this)),
"owner must have approved contract"
);
}
/**
* @dev Checks that the token is owned by the sender
* @param _originContract address of the contract storing the token.
* @param _tokenId uint256 ID of the token
*/
function senderMustBeTokenOwner(address _originContract, uint256 _tokenId)
internal
view
{
IERC721Upgradeable erc721 = IERC721Upgradeable(_originContract);
require(
erc721.ownerOf(_tokenId) == msg.sender,
"sender must be the token owner"
);
}
/////////////////////////////////////////////////////////////////////////
// setSalePrice
/////////////////////////////////////////////////////////////////////////
/**
* @dev Set the token for sale. The owner of the token must be the sender and have the marketplace approved.
* @param _originContract address of the contract storing the token.
* @param _tokenId uint256 ID of the token
* @param _amount uint256 wei value that the item is for sale
*/
function setSalePrice(
address _originContract,
uint256 _tokenId,
uint256 _amount
) external {
// The owner of the token must have the marketplace approved
ownerMustHaveMarketplaceApproved(_originContract, _tokenId);
// The sender must be the token owner
senderMustBeTokenOwner(_originContract, _tokenId);
if (_amount == 0) {
// Set not for sale and exit
_resetTokenPrice(_originContract, _tokenId);
emit SetSalePrice(_originContract, _amount, _tokenId);
return;
}
tokenPrices[_originContract][_tokenId] = SalePrice(msg.sender, _amount);
emit SetSalePrice(_originContract, _amount, _tokenId);
}
/////////////////////////////////////////////////////////////////////////
// safeBuy
/////////////////////////////////////////////////////////////////////////
/**
* @dev Purchase the token with the expected amount. The current token owner must have the marketplace approved.
* @param _originContract address of the contract storing the token.
* @param _tokenId uint256 ID of the token
* @param _amount uint256 wei amount expecting to purchase the token for.
*/
function safeBuy(
address _originContract,
uint256 _tokenId,
uint256 _amount
) external payable {
// Make sure the tokenPrice is the expected amount
require(
tokenPrices[_originContract][_tokenId].amount == _amount,
"safeBuy::Purchase amount must equal expected amount"
);
buy(_originContract, _tokenId);
}
/////////////////////////////////////////////////////////////////////////
// buy
/////////////////////////////////////////////////////////////////////////
/**
* @dev Purchases the token if it is for sale.
* @param _originContract address of the contract storing the token.
* @param _tokenId uint256 ID of the token.
*/
function buy(address _originContract, uint256 _tokenId) public payable {
require(hasRole(TOKEN_COLLECTOR_ROLE, msg.sender), "You are not allowed to collect Art");
// The owner of the token must have the marketplace approved
ownerMustHaveMarketplaceApproved(_originContract, _tokenId);
// Check that the person who set the price still owns the token.
require(
_priceSetterStillOwnsTheToken(_originContract, _tokenId),
"buy::Current token owner must be the person to have the latest price."
);
SalePrice memory sp = tokenPrices[_originContract][_tokenId];
// Check that token is for sale.
require(sp.amount > 0, "buy::Tokens priced at 0 are not for sale.");
// Check that enough ether was sent.
require(
tokenPriceFeeIncluded(_originContract, _tokenId) == msg.value,
"buy::Must purchase the token for the correct price(buy)"
);
// Get token contract details.
IERC721Upgradeable erc721 = IERC721Upgradeable(_originContract);
address tokenOwner = erc721.ownerOf(_tokenId);
// Wipe the token price.
_resetTokenPrice(_originContract, _tokenId);
// Transfer token.
erc721.safeTransferFrom(tokenOwner, msg.sender, _tokenId);
// if the buyer had an existing bid, return it
if (_addressHasBidOnToken(msg.sender, _originContract, _tokenId)) {
_refundBid(_originContract, _tokenId);
}
//Made 2 types of Payments in Payments.sol Primary and secondary
// Payout all parties.
address payable owner = _makePayable(owner());
if(!iMarketplaceSettings.hasERC721TokenSold(_originContract, _tokenId)){
Payments.payoutPrimary(
sp.amount,
!iMarketplaceSettings.hasERC721TokenSold(_originContract, _tokenId),
iMarketplaceSettings.getMarketplaceFeePercentage(),
iERC721CreatorRoyalty.getERC721TokenRoyaltyPercentage(
_originContract,
_tokenId
),
iMarketplaceSettings.getERC721ContractPrimarySaleFeePercentage(
_originContract
),
_makePayable(tokenOwner),
owner,
iERC721CreatorRoyalty.tokenCreator(_originContract, _tokenId),
owner
);
// Set token as sold
iMarketplaceSettings.markERC721Token(_originContract, _tokenId, true);
emit Sold(_originContract, msg.sender, tokenOwner, sp.amount, _tokenId);
}
else{
Payments.payoutSecondary(
sp.amount,
!iMarketplaceSettings.hasERC721TokenSold(_originContract, _tokenId),
iMarketplaceSettings.getMarketplaceFeePercentage(),
iERC721CreatorRoyalty.getERC721TokenRoyaltyPercentage(
_originContract,
_tokenId
),
iMarketplaceSettings.getERC721ContractSecondarySaleFeePercentage(
_originContract
),
_makePayable(tokenOwner),
owner,
iERC721CreatorRoyalty.tokenCreator(_originContract, _tokenId),
owner
);
// Set token as sold
iMarketplaceSettings.markERC721Token(_originContract, _tokenId, true);
emit Sold(_originContract, msg.sender, tokenOwner, sp.amount, _tokenId);
}
}
/////////////////////////////////////////////////////////////////////////
// tokenPrice
/////////////////////////////////////////////////////////////////////////
/**
* @dev Gets the sale price of the token
* @param _originContract address of the contract storing the token.
* @param _tokenId uint256 ID of the token
* @return uint256 sale price of the token
*/
function tokenPrice(address _originContract, uint256 _tokenId)
external
view
returns (uint256)
{
// The owner of the token must have the marketplace approved
ownerMustHaveMarketplaceApproved(_originContract, _tokenId); // TODO: Make sure to write test to verify that this returns 0 when it fails
if (_priceSetterStillOwnsTheToken(_originContract, _tokenId)) {
return tokenPrices[_originContract][_tokenId].amount;
}
return 0;
}
/////////////////////////////////////////////////////////////////////////
// tokenPriceFeeIncluded
/////////////////////////////////////////////////////////////////////////
/**
* @dev Gets the sale price of the token including the marketplace fee.
* @param _originContract address of the contract storing the token.
* @param _tokenId uint256 ID of the token
* @return uint256 sale price of the token including the fee.
*/
function tokenPriceFeeIncluded(address _originContract, uint256 _tokenId)
public
view
returns (uint256)
{
// The owner of the token must have the marketplace approved
ownerMustHaveMarketplaceApproved(_originContract, _tokenId); // TODO: Make sure to write test to verify that this returns 0 when it fails
if (_priceSetterStillOwnsTheToken(_originContract, _tokenId)) {
return
tokenPrices[_originContract][_tokenId].amount.add(
iMarketplaceSettings.calculateMarketplaceFee(
tokenPrices[_originContract][_tokenId].amount
)
);
}
return 0;
}
/////////////////////////////////////////////////////////////////////////
// bid
/////////////////////////////////////////////////////////////////////////
/**
* @dev Bids on the token, replacing the bid if the bid is higher than the current bid. You cannot bid on a token you already own.
* @param _newBidAmount uint256 value in wei to bid.
* @param _originContract address of the contract storing the token.
* @param _tokenId uint256 ID of the token
*/
function bid(
uint256 _newBidAmount,
address _originContract,
uint256 _tokenId
) external payable {
require(hasRole(TOKEN_COLLECTOR_ROLE, msg.sender), "You are not allowed to collect Art");
// Check that bid is greater than 0.
require(_newBidAmount > 0, "bid::Cannot bid 0 Wei.");
// Check that bid is higher than previous bid
uint256 currentBidAmount =
tokenCurrentBids[_originContract][_tokenId].amount;
require(
_newBidAmount > currentBidAmount &&
_newBidAmount >=
currentBidAmount.add(
currentBidAmount.mul(minimumBidIncreasePercentage).div(100)
),
"bid::Must place higher bid than existing bid + minimum percentage."
);
// Check that enough ether was sent.
uint256 requiredCost =
_newBidAmount.add(
iMarketplaceSettings.calculateMarketplaceFee(_newBidAmount)
);
require(
requiredCost == msg.value,
"bid::Must purchase the token for the correct price."
);
// Check that bidder is not owner.
IERC721Upgradeable erc721 = IERC721Upgradeable(_originContract);
address tokenOwner = erc721.ownerOf(_tokenId);
require(tokenOwner != msg.sender, "bid::Bidder cannot be owner.");
// Refund previous bidder.
_refundBid(_originContract, _tokenId);
// Set the new bid.
_setBid(_newBidAmount, msg.sender, _originContract, _tokenId);
emit Bid(_originContract, msg.sender, _newBidAmount, _tokenId);
}
/////////////////////////////////////////////////////////////////////////
// safeAcceptBid
/////////////////////////////////////////////////////////////////////////
/**
* @dev Accept the bid on the token with the expected bid amount.
* @param _originContract address of the contract storing the token.
* @param _tokenId uint256 ID of the token
* @param _amount uint256 wei amount of the bid
*/
function safeAcceptBid(
address _originContract,
uint256 _tokenId,
uint256 _amount
) external {
// Make sure accepting bid is the expected amount
require(
tokenCurrentBids[_originContract][_tokenId].amount == _amount,
"safeAcceptBid::Bid amount must equal expected amount"
);
acceptBid(_originContract, _tokenId);
}
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
// acceptBid
/////////////////////////////////////////////////////////////////////////
/**
* @dev Accept the bid on the token.
* @param _originContract address of the contract storing the token.
* @param _tokenId uint256 ID of the token
*/
function acceptBid(address _originContract, uint256 _tokenId) public {
// The owner of the token must have the marketplace approved
ownerMustHaveMarketplaceApproved(_originContract, _tokenId);
// The sender must be the token owner
senderMustBeTokenOwner(_originContract, _tokenId);
// Check that a bid exists.
require(
_tokenHasBid(_originContract, _tokenId),
"acceptBid::Cannot accept a bid when there is none."
);
// Get current bid on token
ActiveBid memory currentBid =
tokenCurrentBids[_originContract][_tokenId];
// Wipe the token price and bid.
_resetTokenPrice(_originContract, _tokenId);
_resetBid(_originContract, _tokenId);
// Transfer token.
IERC721Upgradeable erc721 = IERC721Upgradeable(_originContract);
erc721.safeTransferFrom(msg.sender, currentBid.bidder, _tokenId);
// Payout all parties.
address payable owner = _makePayable(owner());
if(!iMarketplaceSettings.hasERC721TokenSold(_originContract, _tokenId)){
Payments.payoutPrimary(
currentBid.amount,
!iMarketplaceSettings.hasERC721TokenSold(_originContract, _tokenId),
iMarketplaceSettings.getMarketplaceFeePercentage(),
iERC721CreatorRoyalty.getERC721TokenRoyaltyPercentage(
_originContract,
_tokenId
),
iMarketplaceSettings.getERC721ContractPrimarySaleFeePercentage(
_originContract
),
msg.sender,
owner,
iERC721CreatorRoyalty.tokenCreator(_originContract, _tokenId),
owner
);
iMarketplaceSettings.markERC721Token(_originContract, _tokenId, true);
emit AcceptBid(
_originContract,
currentBid.bidder,
msg.sender,
currentBid.amount,
_tokenId
);
}
else{
Payments.payoutSecondary(
currentBid.amount,
!iMarketplaceSettings.hasERC721TokenSold(_originContract, _tokenId),
iMarketplaceSettings.getMarketplaceFeePercentage(),
iERC721CreatorRoyalty.getERC721TokenRoyaltyPercentage(
_originContract,
_tokenId
),
iMarketplaceSettings.getERC721ContractSecondarySaleFeePercentage(
_originContract
),
msg.sender,
owner,
iERC721CreatorRoyalty.tokenCreator(_originContract, _tokenId),
owner
);
iMarketplaceSettings.markERC721Token(_originContract, _tokenId, true);
emit AcceptBid(
_originContract,
currentBid.bidder,
msg.sender,
currentBid.amount,
_tokenId
);
}
}
/////////////////////////////////////////////////////////////////////////
// cancelBid
/////////////////////////////////////////////////////////////////////////
/**
* @dev Cancel the bid on the token.
* @param _originContract address of the contract storing the token.
* @param _tokenId uint256 ID of the token.
*/
function cancelBid(address _originContract, uint256 _tokenId) external {
// Check that sender has a current bid.
require(
_addressHasBidOnToken(msg.sender, _originContract, _tokenId),
"cancelBid::Cannot cancel a bid if sender hasn't made one."
);
// Refund the bidder.
_refundBid(_originContract, _tokenId);
emit CancelBid(
_originContract,
msg.sender,
tokenCurrentBids[_originContract][_tokenId].amount,
_tokenId
);
}
/////////////////////////////////////////////////////////////////////////
// currentBidDetailsOfToken
/////////////////////////////////////////////////////////////////////////
/**
* @dev Function to get current bid and bidder of a token.
* @param _originContract address of ERC721 contract.
* @param _tokenId uin256 id of the token.
*/
function currentBidDetailsOfToken(address _originContract, uint256 _tokenId)
public
view
returns (uint256, address)
{
return (
tokenCurrentBids[_originContract][_tokenId].amount,
tokenCurrentBids[_originContract][_tokenId].bidder
);
}
/////////////////////////////////////////////////////////////////////////
// _priceSetterStillOwnsTheToken
/////////////////////////////////////////////////////////////////////////
/**
* @dev Checks that the token is owned by the same person who set the sale price.
* @param _originContract address of the contract storing the token.
* @param _tokenId uint256 id of the.
*/
function _priceSetterStillOwnsTheToken(
address _originContract,
uint256 _tokenId
) internal view returns (bool) {
IERC721Upgradeable erc721 = IERC721Upgradeable(_originContract);
return
erc721.ownerOf(_tokenId) ==
tokenPrices[_originContract][_tokenId].seller;
}
/////////////////////////////////////////////////////////////////////////
// _resetTokenPrice
/////////////////////////////////////////////////////////////////////////
/**
* @dev Internal function to set token price to 0 for a given contract.
* @param _originContract address of ERC721 contract.
* @param _tokenId uin256 id of the token.
*/
function _resetTokenPrice(address _originContract, uint256 _tokenId)
internal
{
tokenPrices[_originContract][_tokenId] = SalePrice(address(0), 0);
}
/////////////////////////////////////////////////////////////////////////
// _addressHasBidOnToken
/////////////////////////////////////////////////////////////////////////
/**
* @dev Internal function see if the given address has an existing bid on a token.
* @param _bidder address that may have a current bid.
* @param _originContract address of ERC721 contract.
* @param _tokenId uin256 id of the token.
*/
function _addressHasBidOnToken(
address _bidder,
address _originContract,
uint256 _tokenId
) internal view returns (bool) {
return tokenCurrentBids[_originContract][_tokenId].bidder == _bidder;
}
/////////////////////////////////////////////////////////////////////////
// _tokenHasBid
/////////////////////////////////////////////////////////////////////////
/**
* @dev Internal function see if the token has an existing bid.
* @param _originContract address of ERC721 contract.
* @param _tokenId uin256 id of the token.
*/
function _tokenHasBid(address _originContract, uint256 _tokenId)
internal
view
returns (bool)
{
return tokenCurrentBids[_originContract][_tokenId].bidder != address(0);
}
/////////////////////////////////////////////////////////////////////////
// _refundBid
/////////////////////////////////////////////////////////////////////////
/**
* @dev Internal function to return an existing bid on a token to the
* bidder and reset bid.
* @param _originContract address of ERC721 contract.
* @param _tokenId uin256 id of the token.
*/
function _refundBid(address _originContract, uint256 _tokenId) internal {
ActiveBid memory currentBid =
tokenCurrentBids[_originContract][_tokenId];
if (currentBid.bidder == address(0)) {
return;
}
_resetBid(_originContract, _tokenId);
Payments.refund(
currentBid.marketplaceFee,
currentBid.bidder,
currentBid.amount
);
}
/////////////////////////////////////////////////////////////////////////
// _resetBid
/////////////////////////////////////////////////////////////////////////
/**
* @dev Internal function to reset bid by setting bidder and bid to 0.
* @param _originContract address of ERC721 contract.
* @param _tokenId uin256 id of the token.
*/
function _resetBid(address _originContract, uint256 _tokenId) internal {
tokenCurrentBids[_originContract][_tokenId] = ActiveBid(
address(0),
0,
0
);
}
/////////////////////////////////////////////////////////////////////////
// _setBid
/////////////////////////////////////////////////////////////////////////
/**
* @dev Internal function to set a bid.
* @param _amount uint256 value in wei to bid. Does not include marketplace fee.
* @param _bidder address of the bidder.
* @param _originContract address of ERC721 contract.
* @param _tokenId uin256 id of the token.
*/
function _setBid(
uint256 _amount,
address payable _bidder,
address _originContract,
uint256 _tokenId
) internal {
// Check bidder not 0 address.
require(_bidder != address(0), "Bidder cannot be 0 address.");
// Set bid.
tokenCurrentBids[_originContract][_tokenId] = ActiveBid(
_bidder,
iMarketplaceSettings.getMarketplaceFeePercentage(),
_amount
);
}
/////////////////////////////////////////////////////////////////////////
// _makePayable
/////////////////////////////////////////////////////////////////////////
/**
* @dev Internal function to set a bid.
* @param _address non-payable address
* @return payable address
*/
function _makePayable(address _address)
internal
pure
returns (address payable)
{
return address(uint160(_address));
}
}
Raw
SuperRareRoyaltyRegistry.sol
pragma solidity 0.6.12;
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/math/SafeMathUpgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/access/OwnableUpgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/access/AccessControlUpgradeable.sol';
import "./IERC721CreatorRoyalty.sol";
/**
* @title IERC721 Non-Fungible Token Creator basic interface
*/
contract SuperRareRoyaltyRegistry is OwnableUpgradeable, IERC721CreatorRoyalty {
using SafeMathUpgradeable for uint256;
/////////////////////////////////////////////////////////////////////////
// State Variables
/////////////////////////////////////////////////////////////////////////
// Mapping of ERC721 contract to royalty percentage for all NFTs, 3 == 3%
mapping(address => uint8) private contractRoyaltyPercentage;
// Mapping of ERC721 creator to royalty percentage for all NFTs.
mapping(address => uint8) private creatorRoyaltyPercentage;
// Mapping of ERC721 token to royalty percentage for all NFTs.
mapping(address => mapping(uint256 => uint8))
private tokenRoyaltyPercentage;
IERC721TokenCreator public iERC721TokenCreator;
/////////////////////////////////////////////////////////////////////////
// Constructor
/////////////////////////////////////////////////////////////////////////
// constructor(address _iERC721TokenCreator) public {
// require(
// _iERC721TokenCreator != address(0),
// "constructor::Cannot set the null address as an _iERC721TokenCreator"
// );
// iERC721TokenCreator = IERC721TokenCreator(_iERC721TokenCreator);
// }
/////////////////////////////////////////////////////////////////////////
// Constructor
/////////////////////////////////////////////////////////////////////////
function initialize(address _iERC721TokenCreator) public initializer
{
require(
_iERC721TokenCreator != address(0),
"constructor::Cannot set the null address as an _iERC721TokenCreator"
);
__Ownable_init();
iERC721TokenCreator = IERC721TokenCreator(_iERC721TokenCreator);
}
/////////////////////////////////////////////////////////////////////////
// setIERC721TokenCreator
/////////////////////////////////////////////////////////////////////////
/**
* @dev Set an address as an IERC721TokenCreator
* @param _contractAddress address of the IERC721TokenCreator contract
*/
function setIERC721TokenCreator(address _contractAddress)
external
onlyOwner
{
require(
_contractAddress != address(0),
"setIERC721TokenCreator::_contractAddress cannot be null"
);
iERC721TokenCreator = IERC721TokenCreator(_contractAddress);
}
/////////////////////////////////////////////////////////////////////////
// getERC721TokenRoyaltyPercentage
/////////////////////////////////////////////////////////////////////////
/**
* @dev Get the royalty fee percentage for a specific ERC721 contract.
* @param _contractAddress address ERC721Contract address.
* @param _tokenId uint256 token ID.
* @return uint8 wei royalty fee.
*/
function getERC721TokenRoyaltyPercentage(
address _contractAddress,
uint256 _tokenId
) public override view returns (uint8) {
if (tokenRoyaltyPercentage[_contractAddress][_tokenId] > 0) {
return tokenRoyaltyPercentage[_contractAddress][_tokenId];
}
address creator = iERC721TokenCreator.tokenCreator(
_contractAddress,
_tokenId
);
if (creatorRoyaltyPercentage[creator] > 0) {
return creatorRoyaltyPercentage[creator];
}
return contractRoyaltyPercentage[_contractAddress];
}
/////////////////////////////////////////////////////////////////////////
// getPercentageForSetERC721TokenRoyalty
/////////////////////////////////////////////////////////////////////////
/**
* @dev Gets the royalty percentage set for an ERC721 token
* @param _contractAddress address ERC721Contract address.
* @param _tokenId uint256 token ID.
* @return uint8 wei royalty fee.
*/
function getPercentageForSetERC721TokenRoyalty(
address _contractAddress,
uint256 _tokenId
) external view returns (uint8) {
return tokenRoyaltyPercentage[_contractAddress][_tokenId];
}
/////////////////////////////////////////////////////////////////////////
// setPercentageForSetERC721TokenRoyalty
/////////////////////////////////////////////////////////////////////////
/**
* @dev Sets the royalty percentage set for an ERC721 token
* Requirements:
* - `_percentage` must be <= 100.
* - only the owner of this contract or the creator can call this method.
* @param _contractAddress address ERC721Contract address.
* @param _tokenId uint256 token ID.
* @param _percentage uint8 wei royalty fee.
*/
function setPercentageForSetERC721TokenRoyalty(
address _contractAddress,
uint256 _tokenId,
uint8 _percentage
) external returns (uint8) {
require(
msg.sender ==
iERC721TokenCreator.tokenCreator(_contractAddress, _tokenId) ||
msg.sender == owner(),
"setPercentageForSetERC721TokenRoyalty::Must be contract owner or creator "
);
require(
_percentage <= 100,
"setPercentageForSetERC721TokenRoyalty::_percentage must be <= 100"
);
tokenRoyaltyPercentage[_contractAddress][_tokenId] = _percentage;
}
/////////////////////////////////////////////////////////////////////////
// getPercentageForSetERC721CreatorRoyalty
/////////////////////////////////////////////////////////////////////////
/**
* @dev Gets the royalty percentage set for an ERC721 creator
* @param _contractAddress address ERC721Contract address.
* @param _tokenId uint256 token ID.
* @return uint8 wei royalty fee.
*/
function getPercentageForSetERC721CreatorRoyalty(
address _contractAddress,
uint256 _tokenId
) external view returns (uint8) {
address creator = iERC721TokenCreator.tokenCreator(
_contractAddress,
_tokenId
);
return creatorRoyaltyPercentage[creator];
}
/////////////////////////////////////////////////////////////////////////
// setPercentageForSetERC721CreatorRoyalty
/////////////////////////////////////////////////////////////////////////
/**
* @dev Sets the royalty percentage set for an ERC721 creator
* Requirements:
* - `_percentage` must be <= 100.
* - only the owner of this contract or the creator can call this method.
* @param _creatorAddress address token ID.
* @param _percentage uint8 wei royalty fee.
*/
function setPercentageForSetERC721CreatorRoyalty(
address _creatorAddress,
uint8 _percentage
) external returns (uint8) {
require(
msg.sender == _creatorAddress || msg.sender == owner(),
"setPercentageForSetERC721CreatorRoyalty::Must be owner or creator"
);
require(
_percentage <= 100,
"setPercentageForSetERC721CreatorRoyalty::_percentage must be <= 100"
);
creatorRoyaltyPercentage[_creatorAddress] = _percentage;
}
/////////////////////////////////////////////////////////////////////////
// getPercentageForSetERC721ContractRoyalty
/////////////////////////////////////////////////////////////////////////
/**
* @dev Gets the royalty percentage set for an ERC721 contract
* @param _contractAddress address ERC721Contract address.
* @return uint8 wei royalty fee.
*/
function getPercentageForSetERC721ContractRoyalty(address _contractAddress)
external
view
returns (uint8)
{
return contractRoyaltyPercentage[_contractAddress];
}
/////////////////////////////////////////////////////////////////////////
// setPercentageForSetERC721ContractRoyalty
/////////////////////////////////////////////////////////////////////////
/**
* @dev Sets the royalty percentage set for an ERC721 token
* Requirements:
* - `_percentage` must be <= 100.
* - only the owner of this contract.
* @param _contractAddress address ERC721Contract address.
* @param _percentage uint8 wei royalty fee.
*/
function setPercentageForSetERC721ContractRoyalty(
address _contractAddress,
uint8 _percentage
) external onlyOwner returns (uint8) {
require(
_percentage <= 100,
"setPercentageForSetERC721ContractRoyalty::_percentage must be <= 100"
);
contractRoyaltyPercentage[_contractAddress] = _percentage;
}
/////////////////////////////////////////////////////////////////////////
// calculateRoyaltyFee
/////////////////////////////////////////////////////////////////////////
/**
* @dev Utililty function to calculate the royalty fee for a token.
* @param _contractAddress address ERC721Contract address.
* @param _tokenId uint256 token ID.
* @param _amount uint256 wei amount.
* @return uint256 wei fee.
*/
function calculateRoyaltyFee(
address _contractAddress,
uint256 _tokenId,
uint256 _amount
) external override view returns (uint256) {
return
_amount
.mul(
getERC721TokenRoyaltyPercentage(_contractAddress, _tokenId)
)
.div(100);
}
/////////////////////////////////////////////////////////////////////////
// tokenCreator
/////////////////////////////////////////////////////////////////////////
/**
* @dev Gets the creator of the token
* @param _contractAddress address of the ERC721 contract
* @param _tokenId uint256 ID of the token
* @return address of the creator
*/
function tokenCreator(address _contractAddress, uint256 _tokenId)
external
override
view
returns (address payable)
{
return iERC721TokenCreator.tokenCreator(_contractAddress, _tokenId);
}
}
Raw
SuperRareTokenCreatorRegistry.sol
pragma solidity 0.6.12;
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/math/SafeMathUpgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/access/OwnableUpgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/proxy/Initializable.sol';
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/solc-0.6/contracts/math/SafeMath.sol";
// import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/solc-0.6/contracts/access/Ownable.sol";
import "./IERC721CreatorRoyalty.sol";
import "./IERC721Creator.sol";
/**
* @title IERC721 Non-Fungible Token Creator basic interface
*/
contract SuperRareTokenCreatorRegistry is Initializable, OwnableUpgradeable, IERC721TokenCreator {
using SafeMathUpgradeable for uint256;
/////////////////////////////////////////////////////////////////////////
// State Variables
/////////////////////////////////////////////////////////////////////////
// Mapping of ERC721 token to it's creator.
mapping(address => mapping(uint256 => address payable))
private tokenCreators;
// Mapping of addresses that implement IERC721Creator.
mapping(address => bool) private iERC721Creators;
/////////////////////////////////////////////////////////////////////////
// Constructor
/////////////////////////////////////////////////////////////////////////
/**
* @dev Initializes the contract setting the iERC721Creators with the provided addresses.
* @param _iERC721Creators address[] to set as iERC721Creators.
*/
// constructor(address[] memory _iERC721Creators) public {
// require(
// _iERC721Creators.length < 1000,
// "constructor::Cannot mark more than 1000 addresses as IERC721Creator"
// );
// for (uint8 i = 0; i < _iERC721Creators.length; i++) {
// require(
// _iERC721Creators[i] != address(0),
// "constructor::Cannot set the null address as an IERC721Creator"
// );
// iERC721Creators[_iERC721Creators[i]] = true;
// }
// }
/////////////////////////////////////////////////////////////////////////
// initializer
/////////////////////////////////////////////////////////////////////////
/**
* @dev Initializes the contract setting the iERC721Creators with the provided addresses.
* @param _iERC721Creators address[] to set as iERC721Creators.
*/
function initialize(address[] memory _iERC721Creators) public initializer {
require(
_iERC721Creators.length < 1000,
"constructor::Cannot mark more than 1000 addresses as IERC721Creator"
);
__Ownable_init();
for (uint8 i = 0; i < _iERC721Creators.length; i++) {
require(
_iERC721Creators[i] != address(0),
"constructor::Cannot set the null address as an IERC721Creator"
);
iERC721Creators[_iERC721Creators[i]] = true;
}
}
/////////////////////////////////////////////////////////////////////////
// tokenCreator
/////////////////////////////////////////////////////////////////////////
/**
* @dev Gets the creator of the token
* @param _contractAddress address of the ERC721 contract
* @param _tokenId uint256 ID of the token
* @return address of the creator
*/
function tokenCreator(address _contractAddress, uint256 _tokenId)
external
override
view
returns (address payable)
{
if (tokenCreators[_contractAddress][_tokenId] != address(0)) {
return tokenCreators[_contractAddress][_tokenId];
}
if (iERC721Creators[_contractAddress]) {
return IERC721Creator(_contractAddress).tokenCreator(_tokenId);
}
return address(0);
}
/////////////////////////////////////////////////////////////////////////
// setTokenCreator
/////////////////////////////////////////////////////////////////////////
/**
* @dev Sets the creator of the token
* @param _contractAddress address of the ERC721 contract
* @param _tokenId uint256 ID of the token
* @param _creator address of the creator for the token
*/
function setTokenCreator(
address _contractAddress,
uint256 _tokenId,
address payable _creator
) external onlyOwner {
require(
_creator != address(0),
"setTokenCreator::Cannot set null address as creator"
);
require(
_contractAddress != address(0),
"setTokenCreator::_contractAddress cannot be null"
);
tokenCreators[_contractAddress][_tokenId] = _creator;
}
/////////////////////////////////////////////////////////////////////////
// setIERC721Creator
/////////////////////////////////////////////////////////////////////////
/**
* @dev Set an address as an IERC721Creator
* @param _contractAddress address of the IERC721Creator contract
*/
function setIERC721Creator(address _contractAddress) external onlyOwner {
require(
_contractAddress != address(0),
"setIERC721Creator::_contractAddress cannot be null"
);
iERC721Creators[_contractAddress] = true;
}
}
Raw
TestAssertFailOnPay.sol
pragma solidity 0.6.12;
import "./SuperRareMarketAuctionV2.sol";
contract TestAssertFailOnPay {
/**
* @dev A payment method that will fail by an assertion
*/
receive() external payable {
assert(false);
}
/**
* @dev Place a bid for the owner
* @param _newBidAmount uint256 value in wei to bid, plus marketplace fee.
* @param _originContract address of the contract storing the token.
* @param _tokenId uint256 ID of the token
* @param _market address of the marketplace to make the bid
*/
function bid(
uint256 _newBidAmount,
address _originContract,
uint256 _tokenId,
address _market
) public payable {
SuperRareMarketAuctionV2(_market).bid{value: msg.value}(
_newBidAmount,
_originContract,
_tokenId
);
}
}
Raw
TestExpensiveWallet.sol
pragma solidity 0.6.12;
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/access/OwnableUpgradeable.sol';
import 'https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/release-v3.3/contracts/proxy/Initializable.sol';
import "./SuperRareMarketAuctionV2.sol";
contract TestExpensiveWallet is OwnableUpgradeable {
function initialize() public initializer {
__Ownable_init();
}
/**
* @dev A costly payment method. Should fail on `<address>.transfer`
*/
receive() external payable {
uint256 a = 0;
while (a < 1500000) {
a = a + 1;
}
_makePayable(owner()).transfer(msg.value);
}
/**
* @dev Claim the money as the owner.
* @param _escrowAddress address of the contract escrowing the money to be claimed
*/
function claimMoney(address _escrowAddress) external onlyOwner {
SuperRareMarketAuctionV2(_escrowAddress).withdrawPayments(
_makePayable(address(this))
);
}
/**
* @dev Place a bid for the owner
* @param _newBidAmount uint256 value in wei to bid, plus marketplace fee.
* @param _originContract address of the contract storing the token.
* @param _tokenId uint256 ID of the token
* @param _market address of the marketplace to make the bid
*/
function bid(
uint256 _newBidAmount,
address _originContract,
uint256 _tokenId,
address _market
) public payable {
SuperRareMarketAuctionV2(_market).bid{value: msg.value}(
_newBidAmount,
_originContract,
_tokenId
);
}
/////////////////////////////////////////////////////////////////////////
// _makePayable
/////////////////////////////////////////////////////////////////////////
/**
* @dev Internal function to set a bid.
* @param _address non-payable address
* @return payable address
*/
function _makePayable(address _address)
internal
pure
returns (address payable)
{
return address(uint160(_address));
}
}
Raw
TestRequireFailOnPay.sol
pragma solidity 0.6.12;
import "./SuperRareMarketAuctionV2.sol";
contract TestRequireFailOnPay {
/**
* @dev A payment method that will fail by a failed require
*/
receive() external payable {
require(false, "ready to fail!!!");
}
/**
* @dev Place a bid for the owner
* @param _newBidAmount uint256 value in wei to bid, plus marketplace fee.
* @param _originContract address of the contract storing the token.
* @param _tokenId uint256 ID of the token
* @param _market address of the marketplace to make the bid
*/
function bid(
uint256 _newBidAmount,
address _originContract,
uint256 _tokenId,
address _market
) public payable {
SuperRareMarketAuctionV2(_market).bid{value: msg.value}(
_newBidAmount,
_originContract,
_tokenId
);
}
}
Raw
TestRevertOnPay.sol
pragma solidity 0.6.12;
import "./SuperRareMarketAuctionV2.sol";
contract TestRevertOnPay {
/**
* @dev A payment method that will fail by a failed revert
*/
receive() external payable {
revert("Will always");
}
/**
* @dev Place a bid for the owner
* @param _newBidAmount uint256 value in wei to bid, plus marketplace fee.
* @param _originContract address of the contract storing the token.
* @param _tokenId uint256 ID of the token
* @param _market address of the marketplace to make the bid
*/
function bid(
uint256 _newBidAmount,
address _originContract,
uint256 _tokenId,
address _market
) public payable {
SuperRareMarketAuctionV2(_market).bid{value: msg.value}(
_newBidAmount,
_originContract,
_tokenId
);
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment