d-bis/dodo-contractV2
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init nftPool

Browse Source
This commit is contained in:
owen05
2021-09-06 19:15:17 +08:00
parent a1f377b6a7
commit 3ef45bc799
7 changed files with 555 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

146
contracts/NFTPool/impl/FilterAdmin.sol Normal file
View File

@@ -0,0 +1,146 @@
/*
Copyright 2021 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
import {InitializableInternalMintableERC20} from "../../external/ERC20/InitializableInternalMintableERC20.sol";
import {SafeMath} from "../../lib/SafeMath.sol";
import {IFilterERC721Model} from "../intf/IFilterERC721Model.sol";
import {IFilterERC1155Model} from "../intf/IFilterERC1155Model.sol";
import {IERC721} from "../../intf/IERC721.sol";
import {IERC721Receiver} from "../../intf/IERC721Receiver.sol";
import {IERC1155} from "../../intf/IERC1155.sol";
import {IERC1155Receiver} from "../../intf/IERC1155Receiver.sol";
contract FilterAdmin is InitializableInternalMintableERC20, IERC721Receiver, IERC1155Receiver {
using SafeMath for uint256;
// ============ Storage ============
address public _ERC721_FILTER_MODEL_;
address public _ERC1155_FILTER_MODEL_;
function init(
address _owner,
uint256 _initSupply,
string memory _name,
string memory _symbol,
uint8 _decimals,
address _erc721FilterModel,
address _erc1155FilterModel
) external {
super.init(_owner, _initSupply, _name, _symbol, _decimals);
_ERC721_FILTER_MODEL_ = _erc721FilterModel;
_ERC1155_FILTER_MODEL_ = _erc1155FilterModel;
}
// ============ Event ============
event RemoveNftToken(address nftContract, uint256 tokenId, uint256 amount);
event AddNftToken(address nftContract, uint256 tokenId, uint256 amount);
function depositERC721(address nftContract, uint256[] memory tokenIds) public {
require(nftContract != address(0), "ZERO_ADDRESS");
for(uint256 i = 0; i < tokenIds.length; i++) {
uint256 price = IFilterERC721Model(_ERC721_FILTER_MODEL_).saveNFTPrice(nftContract, tokenIds[i]);
_mint(msg.sender, price);
IERC721(nftContract).safeTransferFrom(msg.sender, address(this), tokenIds[i]);
emit AddNftToken(nftContract, tokenIds[i], 1);
}
}
function depoistERC1155(address nftContract, uint256[] memory tokenIds, uint256[] memory amounts) public {
require(nftContract != address(0), "ZERO_ADDRESS");
require(tokenIds.length == amounts.length, "PARAMS_NOT_MATCH");
for(uint256 i = 0; i < tokenIds.length; i++) {
uint256 price = IFilterERC1155Model(_ERC1155_FILTER_MODEL_).saveNFTPrice(nftContract, tokenIds[i], amounts[i]);
_mint(msg.sender, price);
emit AddNftToken(nftContract, tokenIds[i], amounts[i]);
}
IERC1155(nftContract).safeBatchTransferFrom(msg.sender, address(this), tokenIds, amounts, "");
}
function doLotteryERC721() external {
uint256 lotteryPrice = IFilterERC721Model(_ERC721_FILTER_MODEL_).buyLotteryNFTPrice();
_burn(msg.sender, lotteryPrice);
(address nftContract, uint256 tokenId) = IFilterERC721Model(_ERC721_FILTER_MODEL_).lottery();
IERC721(nftContract).safeTransferFrom(address(this), msg.sender, tokenId);
emit RemoveNftToken(nftContract, tokenId, 1);
}
function doLotteryERC1155() external {
uint256 lotteryPrice = IFilterERC1155Model(_ERC1155_FILTER_MODEL_).buyLotteryNFTPrice();
_burn(msg.sender, lotteryPrice);
(address nftContract, uint256 tokenId) = IFilterERC1155Model(_ERC721_FILTER_MODEL_).lottery();
//TODO: amount
IERC1155(nftContract).safeTransferFrom(address(this), msg.sender, tokenId, 1, "");
emit RemoveNftToken(nftContract, tokenId, 1);
}
function buySpecERC721(address nftContract, uint256 tokenId) external {
uint256 price = IFilterERC721Model(_ERC721_FILTER_MODEL_).buySpecNFTPrice(nftContract, tokenId);
_burn(msg.sender, price);
IERC721(nftContract).safeTransferFrom(address(this), msg.sender, tokenId);
emit RemoveNftToken(nftContract, tokenId, 1);
}
function buySpecERC1155(address nftContract, uint256 tokenId, uint256 amount) external {
uint256 price = IFilterERC1155Model(_ERC1155_FILTER_MODEL_).buySpecNFTPrice(nftContract, tokenId, amount);
_burn(msg.sender, price);
IERC1155(nftContract).safeTransferFrom(address(this), msg.sender, tokenId, amount, "");
emit RemoveNftToken(nftContract, tokenId, amount);
}
function supportsInterface(bytes4 interfaceId) public override view returns (bool) {
return interfaceId == type(IERC1155Receiver).interfaceId
|| interfaceId == type(IERC721Receiver).interfaceId;
}
// ============ Callback ============
function onERC721Received(
address,
address,
uint256 tokenId,
bytes calldata
) external override returns (bytes4) {
emit AddNftToken(msg.sender, tokenId, 1);
return IERC721Receiver.onERC721Received.selector;
}
function onERC1155Received(
address,
address,
uint256 id,
uint256 value,
bytes calldata
) external override returns (bytes4){
emit AddNftToken(msg.sender, id, value);
return IERC1155Receiver.onERC1155Received.selector;
}
function onERC1155BatchReceived(
address,
address,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata
) external override returns (bytes4){
require(ids.length == values.length, "PARAMS_NOT_MATCH");
for(uint256 i = 0; i < ids.length; i++) {
emit AddNftToken(msg.sender, ids[i], values[i]);
}
return IERC1155Receiver.onERC1155BatchReceived.selector;
}
}

130
contracts/NFTPool/impl/FilterERC1155Model.sol Normal file
View File

@@ -0,0 +1,130 @@
/*
Copyright 2021 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
import {InitializableOwnable} from "../../lib/InitializableOwnable.sol";
import {SafeMath} from "../../lib/SafeMath.sol";
import {IFilterERC1155Model} from "../intf/IFilterERC1155Model.sol";
contract FilterERC1155Model is InitializableOwnable, IFilterERC1155Model {
using SafeMath for uint256;
//=================== Storage =====================
// nftCollection -> nftId -> price(frag)
mapping(address => mapping(uint256 => uint256)) public _PRICES_;
// nftCollection -> nftId -> amount
mapping(address => mapping(uint256 => uint256)) public _ERC1155_AMOUNT_;
// nftCollection -> nftId -> specPrice(frag)
mapping(address => mapping(uint256 => uint256)) public _SPEC_PRICES_;
uint256 public _SPEC_FACTOR_ = 200;
// nftColletcion -> nftIds
mapping(address => uint256[]) public _NFT_COLLECTION_IDS_;
address[] public _NFT_COLLECTIONS_;
uint256 public _LOTTERY_THRESHOLD_;
uint256 public _TOTAL_NFT_AMOUNT_;
uint256 public _CURRENT_NFT_AMOUNT_;
function init(
address owner
) external {
//TODO:
initOwner(owner);
}
//================== View ======================
function isFilterERC1155Pass(address nftCollectionAddress, uint256 nftId, uint256 amount) override external view returns (bool) {
if(_PRICES_[nftCollectionAddress][nftId] == 0)
return false;
else {
if(_ERC1155_AMOUNT_[nftCollectionAddress][nftId] >= amount)
return true;
else
return false;
}
}
//TODO: nftInCap
//TODO: nftOutCap
function saveNFTPrice(address nftCollectionAddress, uint256 nftId, uint256 amount) override external view returns(uint256) {
return _PRICES_[nftCollectionAddress][nftId].mul(amount);
}
function buySpecNFTPrice(address nftCollectionAddress, uint256 nftId, uint256 amount) override external view returns(uint256) {
require(_ERC1155_AMOUNT_[nftCollectionAddress][nftId] >= amount, "BUY_OVERFLOW");
return _SPEC_PRICES_[nftCollectionAddress][nftId].mul(amount);
}
//TODO: amount = 1
function buyLotteryNFTPrice() override external view returns(uint256) {
return _LOTTERY_THRESHOLD_;
}
function lottery() override external view returns(address nftCollection, uint256 nftId) {
//random
}
//================== Owner =====================
function setNFTFilter(
address[] memory nftCollections,
uint256[] memory nftIds,
uint256[] memory amounts,
uint256[] memory prices,
uint256[] memory specPrices
) external onlyOwner {
require(nftCollections.length == nftIds.length, "PARAMS_INVALID");
require(nftCollections.length == amounts.length, "PARAMS_INVALID");
require(nftCollections.length == prices.length, "PARAMS_INVALID");
require(nftCollections.length == specPrices.length, "PARAMS_INVALID");
for(uint256 i = 0; i < nftCollections.length; i++){
_PRICES_[nftCollections[i]][nftIds[i]] = prices[i];
_PRICES_[nftCollections[i]][nftIds[i]] = amounts[i];
if(specPrices[i] == 0){
_SPEC_PRICES_[nftCollections[i]][nftIds[i]] = prices[i].mul(_SPEC_FACTOR_).div(100);
}else {
_SPEC_PRICES_[nftCollections[i]][nftIds[i]] = specPrices[i];
}
if(_NFT_COLLECTION_IDS_[nftCollections[i]].length == 0) {
_NFT_COLLECTIONS_.push(nftCollections[i]);
_NFT_COLLECTION_IDS_[nftCollections[i]] = [nftIds[i]];
require(++_CURRENT_NFT_AMOUNT_ <= _TOTAL_NFT_AMOUNT_, "OVERFLOW_NFT_AMOUNT");
} else {
uint256 j = 0;
for(; j < _NFT_COLLECTION_IDS_[nftCollections[i]].length; i++) {
if(_NFT_COLLECTION_IDS_[nftCollections[i]][j] == nftIds[i]) {
break;
}
}
if(j == _NFT_COLLECTION_IDS_[nftCollections[i]].length) {
_NFT_COLLECTION_IDS_[nftCollections[i]].push(nftIds[i]);
require(++_CURRENT_NFT_AMOUNT_ <= _TOTAL_NFT_AMOUNT_, "OVERFLOW_NFT_AMOUNT");
}
}
}
}
function setLotteryThreshold(uint256 newLotteryThreshold) external onlyOwner {
_LOTTERY_THRESHOLD_ = newLotteryThreshold;
}
function setSpecFactor(uint256 newSpecFactor) external onlyOwner {
_SPEC_FACTOR_ = newSpecFactor;
}
}

129
contracts/NFTPool/impl/FilterERC721Model.sol Normal file
View File

@@ -0,0 +1,129 @@
/*
Copyright 2021 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
import {InitializableOwnable} from "../../lib/InitializableOwnable.sol";
import {SafeMath} from "../../lib/SafeMath.sol";
import {IFilterERC721Model} from "../intf/IFilterERC721Model.sol";
contract FilterERC721Model is InitializableOwnable, IFilterERC721Model {
using SafeMath for uint256;
//=================== Storage ===================
// nftCollection -> nftId -> price(frag)
mapping(address => mapping(uint256 => uint256)) public _PRICES_;
// nftCollection -> nftId -> specPrice(frag)
mapping(address => mapping(uint256 => uint256)) public _SPEC_PRICES_;
uint256 public _SPEC_FACTOR_ = 200;
// nftColletcion -> nftIds
mapping(address => uint256[]) public _NFT_COLLECTION_IDS_;
address[] public _NFT_COLLECTIONS_;
uint256 public _LOTTERY_THRESHOLD_;
uint256 public _TOTAL_NFT_AMOUNT_;
uint256 public _CURRENT_NFT_AMOUNT_;
function init(
address owner
) external {
//TODO:
initOwner(owner);
}
//==================== View ==================
function isFilterERC721Pass(address nftCollectionAddress, uint256 nftId) override external view returns (bool) {
if(_PRICES_[nftCollectionAddress][nftId] == 0)
return false;
else
return true;
}
function saveNFTPrice(address nftCollectionAddress, uint256 nftId) override external view returns(uint256) {
return _PRICES_[nftCollectionAddress][nftId];
}
function buySpecNFTPrice(address nftCollectionAddress, uint256 nftId) override external view returns(uint256) {
return _SPEC_PRICES_[nftCollectionAddress][nftId];
}
function buyLotteryNFTPrice() override external view returns(uint256) {
return _LOTTERY_THRESHOLD_;
}
function lottery() override external view returns(address nftCollection, uint256 nftId) {
//random
}
//TODO: nftInCap
//TODO: nftOutCap
//============= Owner ===============
function setNFTFilter(
address[] memory nftCollections,
uint256[] memory nftIds,
uint256[] memory prices,
uint256[] memory specPrices
) external onlyOwner {
require(nftCollections.length == nftIds.length, "PARAMS_INVALID");
require(nftCollections.length == prices.length, "PARAMS_INVALID");
require(nftCollections.length == specPrices.length, "PARAMS_INVALID");
for(uint256 i = 0; i < nftCollections.length; i++){
_PRICES_[nftCollections[i]][nftIds[i]] = prices[i];
if(specPrices[i] == 0){
_SPEC_PRICES_[nftCollections[i]][nftIds[i]] = prices[i].mul(_SPEC_FACTOR_).div(100);
}else {
_SPEC_PRICES_[nftCollections[i]][nftIds[i]] = specPrices[i];
}
if(_NFT_COLLECTION_IDS_[nftCollections[i]].length == 0) {
_NFT_COLLECTIONS_.push(nftCollections[i]);
_NFT_COLLECTION_IDS_[nftCollections[i]] = [nftIds[i]];
require(++_CURRENT_NFT_AMOUNT_ <= _TOTAL_NFT_AMOUNT_, "OVERFLOW_NFT_AMOUNT");
} else {
uint256 j = 0;
for(; j < _NFT_COLLECTION_IDS_[nftCollections[i]].length; i++) {
if(_NFT_COLLECTION_IDS_[nftCollections[i]][j] == nftIds[i]) {
break;
}
}
if(j == _NFT_COLLECTION_IDS_[nftCollections[i]].length) {
_NFT_COLLECTION_IDS_[nftCollections[i]].push(nftIds[i]);
require(++_CURRENT_NFT_AMOUNT_ <= _TOTAL_NFT_AMOUNT_, "OVERFLOW_NFT_AMOUNT");
}
}
}
}
function setLotteryThreshold(uint256 newLotteryThreshold) external onlyOwner {
_LOTTERY_THRESHOLD_ = newLotteryThreshold;
}
function setSpecFactor(uint256 newSpecFactor) external onlyOwner {
_SPEC_FACTOR_ = newSpecFactor;
}
function setTotalNFTAmount(uint256 newTotalNFTAmount) external onlyOwner {
_TOTAL_NFT_AMOUNT_ = newTotalNFTAmount;
}
}