comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Whitelist not set" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Tag.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract FancyBears is ERC721, ERC721Enumerable, Ownable {
struct PresaleData {
uint256 maxMintPerAddress;
uint256 price;
bytes32 merkleroot;
uint256 maxTokensInPresale;
Counters.Counter counter;
mapping(address => uint256) tokensMintedByAddress;
}
using SafeMath for uint256;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
uint256 public saleState;
uint256 public maxSupply;
uint256 public maxMintPerTransaction;
uint256 public price;
uint256 public numReserveTokens;
PresaleData[] public presaleData;
address public beneficiary;
Counters.Counter private reserveTokenCounter;
mapping(address => bool) private reserveTokenMinters;
string public baseURI;
modifier whenPublicSaleStarted() {
}
modifier whenSaleStarted() {
}
modifier whenSaleStopped() {
}
modifier isWhitelistSale(uint256 presaleNumber) {
}
modifier whenWhitelistSet(uint256 _presaleNumber) {
require(<FILL_ME>)
_;
}
modifier whenMerklerootSet(uint256 _presaleNumber) {
}
modifier whenAddressOnWhitelist(bytes32[] memory _merkleproof) {
}
constructor() ERC721("Fancy Bears", "BEARS") {
}
function addReserveTokenMinters(address _address) public onlyOwner {
}
function removeReserveTokenMinters(address _address) public onlyOwner {
}
function createPresale(
uint256 _maxMintPerAddress,
uint256 _price,
uint256 _maxTokensInPresale
)
private
{
}
function startPublicSale() external onlyOwner() {
}
function startWhitelistSale(uint256 _presaleNumber) external
whenSaleStopped()
isWhitelistSale(_presaleNumber)
whenMerklerootSet(_presaleNumber)
onlyOwner()
{
}
function stopSale() external whenSaleStarted() onlyOwner() {
}
function mintPublic(uint256 _numTokens) external payable whenPublicSaleStarted() {
}
function mintWhitelist(uint256 _numTokens, bytes32[] calldata _merkleproof) external payable
isWhitelistSale(saleState)
whenMerklerootSet(saleState)
whenAddressOnWhitelist(_merkleproof)
{
}
//Add addresses who can mint reserve tokens
function mintReserveTokens(address _to, uint256 _numTokens) public {
}
function getPresale() private view returns (PresaleData storage) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function setMerkleroot(uint256 _presaleNumber, bytes32 _merkleRoot) public
whenSaleStopped()
isWhitelistSale(_presaleNumber)
onlyOwner
{
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function withdraw() public {
}
function tokensInWallet(address _owner) public view returns(uint256[] memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| presaleData[_presaleNumber].merkleroot!=0,"Whitelist not set" | 284,424 | presaleData[_presaleNumber].merkleroot!=0 |
"Not on white list" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Tag.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract FancyBears is ERC721, ERC721Enumerable, Ownable {
struct PresaleData {
uint256 maxMintPerAddress;
uint256 price;
bytes32 merkleroot;
uint256 maxTokensInPresale;
Counters.Counter counter;
mapping(address => uint256) tokensMintedByAddress;
}
using SafeMath for uint256;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
uint256 public saleState;
uint256 public maxSupply;
uint256 public maxMintPerTransaction;
uint256 public price;
uint256 public numReserveTokens;
PresaleData[] public presaleData;
address public beneficiary;
Counters.Counter private reserveTokenCounter;
mapping(address => bool) private reserveTokenMinters;
string public baseURI;
modifier whenPublicSaleStarted() {
}
modifier whenSaleStarted() {
}
modifier whenSaleStopped() {
}
modifier isWhitelistSale(uint256 presaleNumber) {
}
modifier whenWhitelistSet(uint256 _presaleNumber) {
}
modifier whenMerklerootSet(uint256 _presaleNumber) {
}
modifier whenAddressOnWhitelist(bytes32[] memory _merkleproof) {
require(<FILL_ME>)
_;
}
constructor() ERC721("Fancy Bears", "BEARS") {
}
function addReserveTokenMinters(address _address) public onlyOwner {
}
function removeReserveTokenMinters(address _address) public onlyOwner {
}
function createPresale(
uint256 _maxMintPerAddress,
uint256 _price,
uint256 _maxTokensInPresale
)
private
{
}
function startPublicSale() external onlyOwner() {
}
function startWhitelistSale(uint256 _presaleNumber) external
whenSaleStopped()
isWhitelistSale(_presaleNumber)
whenMerklerootSet(_presaleNumber)
onlyOwner()
{
}
function stopSale() external whenSaleStarted() onlyOwner() {
}
function mintPublic(uint256 _numTokens) external payable whenPublicSaleStarted() {
}
function mintWhitelist(uint256 _numTokens, bytes32[] calldata _merkleproof) external payable
isWhitelistSale(saleState)
whenMerklerootSet(saleState)
whenAddressOnWhitelist(_merkleproof)
{
}
//Add addresses who can mint reserve tokens
function mintReserveTokens(address _to, uint256 _numTokens) public {
}
function getPresale() private view returns (PresaleData storage) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function setMerkleroot(uint256 _presaleNumber, bytes32 _merkleRoot) public
whenSaleStopped()
isWhitelistSale(_presaleNumber)
onlyOwner
{
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function withdraw() public {
}
function tokensInWallet(address _owner) public view returns(uint256[] memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| MerkleProof.verify(_merkleproof,getPresale().merkleroot,keccak256(abi.encodePacked(msg.sender))),"Not on white list" | 284,424 | MerkleProof.verify(_merkleproof,getPresale().merkleroot,keccak256(abi.encodePacked(msg.sender))) |
"Address already a minter" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Tag.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract FancyBears is ERC721, ERC721Enumerable, Ownable {
struct PresaleData {
uint256 maxMintPerAddress;
uint256 price;
bytes32 merkleroot;
uint256 maxTokensInPresale;
Counters.Counter counter;
mapping(address => uint256) tokensMintedByAddress;
}
using SafeMath for uint256;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
uint256 public saleState;
uint256 public maxSupply;
uint256 public maxMintPerTransaction;
uint256 public price;
uint256 public numReserveTokens;
PresaleData[] public presaleData;
address public beneficiary;
Counters.Counter private reserveTokenCounter;
mapping(address => bool) private reserveTokenMinters;
string public baseURI;
modifier whenPublicSaleStarted() {
}
modifier whenSaleStarted() {
}
modifier whenSaleStopped() {
}
modifier isWhitelistSale(uint256 presaleNumber) {
}
modifier whenWhitelistSet(uint256 _presaleNumber) {
}
modifier whenMerklerootSet(uint256 _presaleNumber) {
}
modifier whenAddressOnWhitelist(bytes32[] memory _merkleproof) {
}
constructor() ERC721("Fancy Bears", "BEARS") {
}
function addReserveTokenMinters(address _address) public onlyOwner {
require(_address!=address(0),"Cannot add the Black Hole as a minter");
require(<FILL_ME>)
reserveTokenMinters[_address] = true;
}
function removeReserveTokenMinters(address _address) public onlyOwner {
}
function createPresale(
uint256 _maxMintPerAddress,
uint256 _price,
uint256 _maxTokensInPresale
)
private
{
}
function startPublicSale() external onlyOwner() {
}
function startWhitelistSale(uint256 _presaleNumber) external
whenSaleStopped()
isWhitelistSale(_presaleNumber)
whenMerklerootSet(_presaleNumber)
onlyOwner()
{
}
function stopSale() external whenSaleStarted() onlyOwner() {
}
function mintPublic(uint256 _numTokens) external payable whenPublicSaleStarted() {
}
function mintWhitelist(uint256 _numTokens, bytes32[] calldata _merkleproof) external payable
isWhitelistSale(saleState)
whenMerklerootSet(saleState)
whenAddressOnWhitelist(_merkleproof)
{
}
//Add addresses who can mint reserve tokens
function mintReserveTokens(address _to, uint256 _numTokens) public {
}
function getPresale() private view returns (PresaleData storage) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function setMerkleroot(uint256 _presaleNumber, bytes32 _merkleRoot) public
whenSaleStopped()
isWhitelistSale(_presaleNumber)
onlyOwner
{
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function withdraw() public {
}
function tokensInWallet(address _owner) public view returns(uint256[] memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| !reserveTokenMinters[_address],"Address already a minter" | 284,424 | !reserveTokenMinters[_address] |
"Address not a current minter" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Tag.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract FancyBears is ERC721, ERC721Enumerable, Ownable {
struct PresaleData {
uint256 maxMintPerAddress;
uint256 price;
bytes32 merkleroot;
uint256 maxTokensInPresale;
Counters.Counter counter;
mapping(address => uint256) tokensMintedByAddress;
}
using SafeMath for uint256;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
uint256 public saleState;
uint256 public maxSupply;
uint256 public maxMintPerTransaction;
uint256 public price;
uint256 public numReserveTokens;
PresaleData[] public presaleData;
address public beneficiary;
Counters.Counter private reserveTokenCounter;
mapping(address => bool) private reserveTokenMinters;
string public baseURI;
modifier whenPublicSaleStarted() {
}
modifier whenSaleStarted() {
}
modifier whenSaleStopped() {
}
modifier isWhitelistSale(uint256 presaleNumber) {
}
modifier whenWhitelistSet(uint256 _presaleNumber) {
}
modifier whenMerklerootSet(uint256 _presaleNumber) {
}
modifier whenAddressOnWhitelist(bytes32[] memory _merkleproof) {
}
constructor() ERC721("Fancy Bears", "BEARS") {
}
function addReserveTokenMinters(address _address) public onlyOwner {
}
function removeReserveTokenMinters(address _address) public onlyOwner {
require(<FILL_ME>)
reserveTokenMinters[_address] = false;
}
function createPresale(
uint256 _maxMintPerAddress,
uint256 _price,
uint256 _maxTokensInPresale
)
private
{
}
function startPublicSale() external onlyOwner() {
}
function startWhitelistSale(uint256 _presaleNumber) external
whenSaleStopped()
isWhitelistSale(_presaleNumber)
whenMerklerootSet(_presaleNumber)
onlyOwner()
{
}
function stopSale() external whenSaleStarted() onlyOwner() {
}
function mintPublic(uint256 _numTokens) external payable whenPublicSaleStarted() {
}
function mintWhitelist(uint256 _numTokens, bytes32[] calldata _merkleproof) external payable
isWhitelistSale(saleState)
whenMerklerootSet(saleState)
whenAddressOnWhitelist(_merkleproof)
{
}
//Add addresses who can mint reserve tokens
function mintReserveTokens(address _to, uint256 _numTokens) public {
}
function getPresale() private view returns (PresaleData storage) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function setMerkleroot(uint256 _presaleNumber, bytes32 _merkleRoot) public
whenSaleStopped()
isWhitelistSale(_presaleNumber)
onlyOwner
{
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function withdraw() public {
}
function tokensInWallet(address _owner) public view returns(uint256[] memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| reserveTokenMinters[_address],"Address not a current minter" | 284,424 | reserveTokenMinters[_address] |
"Not enough Tokens remaining." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Tag.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract FancyBears is ERC721, ERC721Enumerable, Ownable {
struct PresaleData {
uint256 maxMintPerAddress;
uint256 price;
bytes32 merkleroot;
uint256 maxTokensInPresale;
Counters.Counter counter;
mapping(address => uint256) tokensMintedByAddress;
}
using SafeMath for uint256;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
uint256 public saleState;
uint256 public maxSupply;
uint256 public maxMintPerTransaction;
uint256 public price;
uint256 public numReserveTokens;
PresaleData[] public presaleData;
address public beneficiary;
Counters.Counter private reserveTokenCounter;
mapping(address => bool) private reserveTokenMinters;
string public baseURI;
modifier whenPublicSaleStarted() {
}
modifier whenSaleStarted() {
}
modifier whenSaleStopped() {
}
modifier isWhitelistSale(uint256 presaleNumber) {
}
modifier whenWhitelistSet(uint256 _presaleNumber) {
}
modifier whenMerklerootSet(uint256 _presaleNumber) {
}
modifier whenAddressOnWhitelist(bytes32[] memory _merkleproof) {
}
constructor() ERC721("Fancy Bears", "BEARS") {
}
function addReserveTokenMinters(address _address) public onlyOwner {
}
function removeReserveTokenMinters(address _address) public onlyOwner {
}
function createPresale(
uint256 _maxMintPerAddress,
uint256 _price,
uint256 _maxTokensInPresale
)
private
{
}
function startPublicSale() external onlyOwner() {
}
function startWhitelistSale(uint256 _presaleNumber) external
whenSaleStopped()
isWhitelistSale(_presaleNumber)
whenMerklerootSet(_presaleNumber)
onlyOwner()
{
}
function stopSale() external whenSaleStarted() onlyOwner() {
}
function mintPublic(uint256 _numTokens) external payable whenPublicSaleStarted() {
uint256 supply = totalSupply();
require(_numTokens <= maxMintPerTransaction, "Minting too many tokens at once!");
require(<FILL_ME>)
require(_numTokens.mul(price) <= msg.value, "Incorrect amount sent!");
for (uint256 i; i < _numTokens; i++) {
_safeMint(msg.sender, supply.add(1).add(i));
}
}
function mintWhitelist(uint256 _numTokens, bytes32[] calldata _merkleproof) external payable
isWhitelistSale(saleState)
whenMerklerootSet(saleState)
whenAddressOnWhitelist(_merkleproof)
{
}
//Add addresses who can mint reserve tokens
function mintReserveTokens(address _to, uint256 _numTokens) public {
}
function getPresale() private view returns (PresaleData storage) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function setMerkleroot(uint256 _presaleNumber, bytes32 _merkleRoot) public
whenSaleStopped()
isWhitelistSale(_presaleNumber)
onlyOwner
{
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function withdraw() public {
}
function tokensInWallet(address _owner) public view returns(uint256[] memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| supply.add(_numTokens)<=maxSupply.sub(numReserveTokens),"Not enough Tokens remaining." | 284,424 | supply.add(_numTokens)<=maxSupply.sub(numReserveTokens) |
"Incorrect amount sent!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Tag.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract FancyBears is ERC721, ERC721Enumerable, Ownable {
struct PresaleData {
uint256 maxMintPerAddress;
uint256 price;
bytes32 merkleroot;
uint256 maxTokensInPresale;
Counters.Counter counter;
mapping(address => uint256) tokensMintedByAddress;
}
using SafeMath for uint256;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
uint256 public saleState;
uint256 public maxSupply;
uint256 public maxMintPerTransaction;
uint256 public price;
uint256 public numReserveTokens;
PresaleData[] public presaleData;
address public beneficiary;
Counters.Counter private reserveTokenCounter;
mapping(address => bool) private reserveTokenMinters;
string public baseURI;
modifier whenPublicSaleStarted() {
}
modifier whenSaleStarted() {
}
modifier whenSaleStopped() {
}
modifier isWhitelistSale(uint256 presaleNumber) {
}
modifier whenWhitelistSet(uint256 _presaleNumber) {
}
modifier whenMerklerootSet(uint256 _presaleNumber) {
}
modifier whenAddressOnWhitelist(bytes32[] memory _merkleproof) {
}
constructor() ERC721("Fancy Bears", "BEARS") {
}
function addReserveTokenMinters(address _address) public onlyOwner {
}
function removeReserveTokenMinters(address _address) public onlyOwner {
}
function createPresale(
uint256 _maxMintPerAddress,
uint256 _price,
uint256 _maxTokensInPresale
)
private
{
}
function startPublicSale() external onlyOwner() {
}
function startWhitelistSale(uint256 _presaleNumber) external
whenSaleStopped()
isWhitelistSale(_presaleNumber)
whenMerklerootSet(_presaleNumber)
onlyOwner()
{
}
function stopSale() external whenSaleStarted() onlyOwner() {
}
function mintPublic(uint256 _numTokens) external payable whenPublicSaleStarted() {
uint256 supply = totalSupply();
require(_numTokens <= maxMintPerTransaction, "Minting too many tokens at once!");
require(supply.add(_numTokens) <= maxSupply.sub(numReserveTokens), "Not enough Tokens remaining.");
require(<FILL_ME>)
for (uint256 i; i < _numTokens; i++) {
_safeMint(msg.sender, supply.add(1).add(i));
}
}
function mintWhitelist(uint256 _numTokens, bytes32[] calldata _merkleproof) external payable
isWhitelistSale(saleState)
whenMerklerootSet(saleState)
whenAddressOnWhitelist(_merkleproof)
{
}
//Add addresses who can mint reserve tokens
function mintReserveTokens(address _to, uint256 _numTokens) public {
}
function getPresale() private view returns (PresaleData storage) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function setMerkleroot(uint256 _presaleNumber, bytes32 _merkleRoot) public
whenSaleStopped()
isWhitelistSale(_presaleNumber)
onlyOwner
{
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function withdraw() public {
}
function tokensInWallet(address _owner) public view returns(uint256[] memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| _numTokens.mul(price)<=msg.value,"Incorrect amount sent!" | 284,424 | _numTokens.mul(price)<=msg.value |
"Exceeds the number of whitelist mints" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Tag.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract FancyBears is ERC721, ERC721Enumerable, Ownable {
struct PresaleData {
uint256 maxMintPerAddress;
uint256 price;
bytes32 merkleroot;
uint256 maxTokensInPresale;
Counters.Counter counter;
mapping(address => uint256) tokensMintedByAddress;
}
using SafeMath for uint256;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
uint256 public saleState;
uint256 public maxSupply;
uint256 public maxMintPerTransaction;
uint256 public price;
uint256 public numReserveTokens;
PresaleData[] public presaleData;
address public beneficiary;
Counters.Counter private reserveTokenCounter;
mapping(address => bool) private reserveTokenMinters;
string public baseURI;
modifier whenPublicSaleStarted() {
}
modifier whenSaleStarted() {
}
modifier whenSaleStopped() {
}
modifier isWhitelistSale(uint256 presaleNumber) {
}
modifier whenWhitelistSet(uint256 _presaleNumber) {
}
modifier whenMerklerootSet(uint256 _presaleNumber) {
}
modifier whenAddressOnWhitelist(bytes32[] memory _merkleproof) {
}
constructor() ERC721("Fancy Bears", "BEARS") {
}
function addReserveTokenMinters(address _address) public onlyOwner {
}
function removeReserveTokenMinters(address _address) public onlyOwner {
}
function createPresale(
uint256 _maxMintPerAddress,
uint256 _price,
uint256 _maxTokensInPresale
)
private
{
}
function startPublicSale() external onlyOwner() {
}
function startWhitelistSale(uint256 _presaleNumber) external
whenSaleStopped()
isWhitelistSale(_presaleNumber)
whenMerklerootSet(_presaleNumber)
onlyOwner()
{
}
function stopSale() external whenSaleStarted() onlyOwner() {
}
function mintPublic(uint256 _numTokens) external payable whenPublicSaleStarted() {
}
function mintWhitelist(uint256 _numTokens, bytes32[] calldata _merkleproof) external payable
isWhitelistSale(saleState)
whenMerklerootSet(saleState)
whenAddressOnWhitelist(_merkleproof)
{
uint256 currentSupply = totalSupply();
uint256 presaleSupply = getPresale().counter.current();
uint256 numWhitelistTokensByAddress = getPresale().tokensMintedByAddress[msg.sender];
require(<FILL_ME>)
require(presaleSupply.add(_numTokens) <= getPresale().maxTokensInPresale, "Not enough Tokens remaining in presale.");
require(_numTokens.mul(getPresale().price) <= msg.value, "Incorrect amount sent!");
for (uint256 i; i < _numTokens; i++) {
_safeMint(msg.sender, currentSupply.add(1).add(i));
getPresale().counter.increment();
}
getPresale().tokensMintedByAddress[msg.sender] = numWhitelistTokensByAddress.add(_numTokens);
}
//Add addresses who can mint reserve tokens
function mintReserveTokens(address _to, uint256 _numTokens) public {
}
function getPresale() private view returns (PresaleData storage) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function setMerkleroot(uint256 _presaleNumber, bytes32 _merkleRoot) public
whenSaleStopped()
isWhitelistSale(_presaleNumber)
onlyOwner
{
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function withdraw() public {
}
function tokensInWallet(address _owner) public view returns(uint256[] memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| numWhitelistTokensByAddress.add(_numTokens)<=getPresale().maxMintPerAddress,"Exceeds the number of whitelist mints" | 284,424 | numWhitelistTokensByAddress.add(_numTokens)<=getPresale().maxMintPerAddress |
"Not enough Tokens remaining in presale." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Tag.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract FancyBears is ERC721, ERC721Enumerable, Ownable {
struct PresaleData {
uint256 maxMintPerAddress;
uint256 price;
bytes32 merkleroot;
uint256 maxTokensInPresale;
Counters.Counter counter;
mapping(address => uint256) tokensMintedByAddress;
}
using SafeMath for uint256;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
uint256 public saleState;
uint256 public maxSupply;
uint256 public maxMintPerTransaction;
uint256 public price;
uint256 public numReserveTokens;
PresaleData[] public presaleData;
address public beneficiary;
Counters.Counter private reserveTokenCounter;
mapping(address => bool) private reserveTokenMinters;
string public baseURI;
modifier whenPublicSaleStarted() {
}
modifier whenSaleStarted() {
}
modifier whenSaleStopped() {
}
modifier isWhitelistSale(uint256 presaleNumber) {
}
modifier whenWhitelistSet(uint256 _presaleNumber) {
}
modifier whenMerklerootSet(uint256 _presaleNumber) {
}
modifier whenAddressOnWhitelist(bytes32[] memory _merkleproof) {
}
constructor() ERC721("Fancy Bears", "BEARS") {
}
function addReserveTokenMinters(address _address) public onlyOwner {
}
function removeReserveTokenMinters(address _address) public onlyOwner {
}
function createPresale(
uint256 _maxMintPerAddress,
uint256 _price,
uint256 _maxTokensInPresale
)
private
{
}
function startPublicSale() external onlyOwner() {
}
function startWhitelistSale(uint256 _presaleNumber) external
whenSaleStopped()
isWhitelistSale(_presaleNumber)
whenMerklerootSet(_presaleNumber)
onlyOwner()
{
}
function stopSale() external whenSaleStarted() onlyOwner() {
}
function mintPublic(uint256 _numTokens) external payable whenPublicSaleStarted() {
}
function mintWhitelist(uint256 _numTokens, bytes32[] calldata _merkleproof) external payable
isWhitelistSale(saleState)
whenMerklerootSet(saleState)
whenAddressOnWhitelist(_merkleproof)
{
uint256 currentSupply = totalSupply();
uint256 presaleSupply = getPresale().counter.current();
uint256 numWhitelistTokensByAddress = getPresale().tokensMintedByAddress[msg.sender];
require(numWhitelistTokensByAddress.add(_numTokens) <= getPresale().maxMintPerAddress,"Exceeds the number of whitelist mints");
require(<FILL_ME>)
require(_numTokens.mul(getPresale().price) <= msg.value, "Incorrect amount sent!");
for (uint256 i; i < _numTokens; i++) {
_safeMint(msg.sender, currentSupply.add(1).add(i));
getPresale().counter.increment();
}
getPresale().tokensMintedByAddress[msg.sender] = numWhitelistTokensByAddress.add(_numTokens);
}
//Add addresses who can mint reserve tokens
function mintReserveTokens(address _to, uint256 _numTokens) public {
}
function getPresale() private view returns (PresaleData storage) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function setMerkleroot(uint256 _presaleNumber, bytes32 _merkleRoot) public
whenSaleStopped()
isWhitelistSale(_presaleNumber)
onlyOwner
{
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function withdraw() public {
}
function tokensInWallet(address _owner) public view returns(uint256[] memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| presaleSupply.add(_numTokens)<=getPresale().maxTokensInPresale,"Not enough Tokens remaining in presale." | 284,424 | presaleSupply.add(_numTokens)<=getPresale().maxTokensInPresale |
"Incorrect amount sent!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Tag.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract FancyBears is ERC721, ERC721Enumerable, Ownable {
struct PresaleData {
uint256 maxMintPerAddress;
uint256 price;
bytes32 merkleroot;
uint256 maxTokensInPresale;
Counters.Counter counter;
mapping(address => uint256) tokensMintedByAddress;
}
using SafeMath for uint256;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
uint256 public saleState;
uint256 public maxSupply;
uint256 public maxMintPerTransaction;
uint256 public price;
uint256 public numReserveTokens;
PresaleData[] public presaleData;
address public beneficiary;
Counters.Counter private reserveTokenCounter;
mapping(address => bool) private reserveTokenMinters;
string public baseURI;
modifier whenPublicSaleStarted() {
}
modifier whenSaleStarted() {
}
modifier whenSaleStopped() {
}
modifier isWhitelistSale(uint256 presaleNumber) {
}
modifier whenWhitelistSet(uint256 _presaleNumber) {
}
modifier whenMerklerootSet(uint256 _presaleNumber) {
}
modifier whenAddressOnWhitelist(bytes32[] memory _merkleproof) {
}
constructor() ERC721("Fancy Bears", "BEARS") {
}
function addReserveTokenMinters(address _address) public onlyOwner {
}
function removeReserveTokenMinters(address _address) public onlyOwner {
}
function createPresale(
uint256 _maxMintPerAddress,
uint256 _price,
uint256 _maxTokensInPresale
)
private
{
}
function startPublicSale() external onlyOwner() {
}
function startWhitelistSale(uint256 _presaleNumber) external
whenSaleStopped()
isWhitelistSale(_presaleNumber)
whenMerklerootSet(_presaleNumber)
onlyOwner()
{
}
function stopSale() external whenSaleStarted() onlyOwner() {
}
function mintPublic(uint256 _numTokens) external payable whenPublicSaleStarted() {
}
function mintWhitelist(uint256 _numTokens, bytes32[] calldata _merkleproof) external payable
isWhitelistSale(saleState)
whenMerklerootSet(saleState)
whenAddressOnWhitelist(_merkleproof)
{
uint256 currentSupply = totalSupply();
uint256 presaleSupply = getPresale().counter.current();
uint256 numWhitelistTokensByAddress = getPresale().tokensMintedByAddress[msg.sender];
require(numWhitelistTokensByAddress.add(_numTokens) <= getPresale().maxMintPerAddress,"Exceeds the number of whitelist mints");
require(presaleSupply.add(_numTokens) <= getPresale().maxTokensInPresale, "Not enough Tokens remaining in presale.");
require(<FILL_ME>)
for (uint256 i; i < _numTokens; i++) {
_safeMint(msg.sender, currentSupply.add(1).add(i));
getPresale().counter.increment();
}
getPresale().tokensMintedByAddress[msg.sender] = numWhitelistTokensByAddress.add(_numTokens);
}
//Add addresses who can mint reserve tokens
function mintReserveTokens(address _to, uint256 _numTokens) public {
}
function getPresale() private view returns (PresaleData storage) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function setMerkleroot(uint256 _presaleNumber, bytes32 _merkleRoot) public
whenSaleStopped()
isWhitelistSale(_presaleNumber)
onlyOwner
{
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function withdraw() public {
}
function tokensInWallet(address _owner) public view returns(uint256[] memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| _numTokens.mul(getPresale().price)<=msg.value,"Incorrect amount sent!" | 284,424 | _numTokens.mul(getPresale().price)<=msg.value |
"Not approved to mint reserve tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Tag.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract FancyBears is ERC721, ERC721Enumerable, Ownable {
struct PresaleData {
uint256 maxMintPerAddress;
uint256 price;
bytes32 merkleroot;
uint256 maxTokensInPresale;
Counters.Counter counter;
mapping(address => uint256) tokensMintedByAddress;
}
using SafeMath for uint256;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
uint256 public saleState;
uint256 public maxSupply;
uint256 public maxMintPerTransaction;
uint256 public price;
uint256 public numReserveTokens;
PresaleData[] public presaleData;
address public beneficiary;
Counters.Counter private reserveTokenCounter;
mapping(address => bool) private reserveTokenMinters;
string public baseURI;
modifier whenPublicSaleStarted() {
}
modifier whenSaleStarted() {
}
modifier whenSaleStopped() {
}
modifier isWhitelistSale(uint256 presaleNumber) {
}
modifier whenWhitelistSet(uint256 _presaleNumber) {
}
modifier whenMerklerootSet(uint256 _presaleNumber) {
}
modifier whenAddressOnWhitelist(bytes32[] memory _merkleproof) {
}
constructor() ERC721("Fancy Bears", "BEARS") {
}
function addReserveTokenMinters(address _address) public onlyOwner {
}
function removeReserveTokenMinters(address _address) public onlyOwner {
}
function createPresale(
uint256 _maxMintPerAddress,
uint256 _price,
uint256 _maxTokensInPresale
)
private
{
}
function startPublicSale() external onlyOwner() {
}
function startWhitelistSale(uint256 _presaleNumber) external
whenSaleStopped()
isWhitelistSale(_presaleNumber)
whenMerklerootSet(_presaleNumber)
onlyOwner()
{
}
function stopSale() external whenSaleStarted() onlyOwner() {
}
function mintPublic(uint256 _numTokens) external payable whenPublicSaleStarted() {
}
function mintWhitelist(uint256 _numTokens, bytes32[] calldata _merkleproof) external payable
isWhitelistSale(saleState)
whenMerklerootSet(saleState)
whenAddressOnWhitelist(_merkleproof)
{
}
//Add addresses who can mint reserve tokens
function mintReserveTokens(address _to, uint256 _numTokens) public {
require(_to!=address(0),"Cannot mint reserve tokens to the burn address");
uint256 supply = totalSupply();
require(<FILL_ME>)
require(reserveTokenCounter.current().add(_numTokens) <= numReserveTokens,"Cannot mint more than alloted for the reserve");
require(supply.add(_numTokens) < maxSupply, "Cannot mint more than max supply");
require(_numTokens<=50,"Gas limit protection");
for (uint256 i; i < _numTokens; i++) {
_safeMint(msg.sender, supply.add(1).add(i));
reserveTokenCounter.increment();
}
}
function getPresale() private view returns (PresaleData storage) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function setMerkleroot(uint256 _presaleNumber, bytes32 _merkleRoot) public
whenSaleStopped()
isWhitelistSale(_presaleNumber)
onlyOwner
{
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function withdraw() public {
}
function tokensInWallet(address _owner) public view returns(uint256[] memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| reserveTokenMinters[msg.sender],"Not approved to mint reserve tokens" | 284,424 | reserveTokenMinters[msg.sender] |
"Cannot mint more than alloted for the reserve" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Tag.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract FancyBears is ERC721, ERC721Enumerable, Ownable {
struct PresaleData {
uint256 maxMintPerAddress;
uint256 price;
bytes32 merkleroot;
uint256 maxTokensInPresale;
Counters.Counter counter;
mapping(address => uint256) tokensMintedByAddress;
}
using SafeMath for uint256;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
uint256 public saleState;
uint256 public maxSupply;
uint256 public maxMintPerTransaction;
uint256 public price;
uint256 public numReserveTokens;
PresaleData[] public presaleData;
address public beneficiary;
Counters.Counter private reserveTokenCounter;
mapping(address => bool) private reserveTokenMinters;
string public baseURI;
modifier whenPublicSaleStarted() {
}
modifier whenSaleStarted() {
}
modifier whenSaleStopped() {
}
modifier isWhitelistSale(uint256 presaleNumber) {
}
modifier whenWhitelistSet(uint256 _presaleNumber) {
}
modifier whenMerklerootSet(uint256 _presaleNumber) {
}
modifier whenAddressOnWhitelist(bytes32[] memory _merkleproof) {
}
constructor() ERC721("Fancy Bears", "BEARS") {
}
function addReserveTokenMinters(address _address) public onlyOwner {
}
function removeReserveTokenMinters(address _address) public onlyOwner {
}
function createPresale(
uint256 _maxMintPerAddress,
uint256 _price,
uint256 _maxTokensInPresale
)
private
{
}
function startPublicSale() external onlyOwner() {
}
function startWhitelistSale(uint256 _presaleNumber) external
whenSaleStopped()
isWhitelistSale(_presaleNumber)
whenMerklerootSet(_presaleNumber)
onlyOwner()
{
}
function stopSale() external whenSaleStarted() onlyOwner() {
}
function mintPublic(uint256 _numTokens) external payable whenPublicSaleStarted() {
}
function mintWhitelist(uint256 _numTokens, bytes32[] calldata _merkleproof) external payable
isWhitelistSale(saleState)
whenMerklerootSet(saleState)
whenAddressOnWhitelist(_merkleproof)
{
}
//Add addresses who can mint reserve tokens
function mintReserveTokens(address _to, uint256 _numTokens) public {
require(_to!=address(0),"Cannot mint reserve tokens to the burn address");
uint256 supply = totalSupply();
require(reserveTokenMinters[msg.sender],"Not approved to mint reserve tokens");
require(<FILL_ME>)
require(supply.add(_numTokens) < maxSupply, "Cannot mint more than max supply");
require(_numTokens<=50,"Gas limit protection");
for (uint256 i; i < _numTokens; i++) {
_safeMint(msg.sender, supply.add(1).add(i));
reserveTokenCounter.increment();
}
}
function getPresale() private view returns (PresaleData storage) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function setMerkleroot(uint256 _presaleNumber, bytes32 _merkleRoot) public
whenSaleStopped()
isWhitelistSale(_presaleNumber)
onlyOwner
{
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function withdraw() public {
}
function tokensInWallet(address _owner) public view returns(uint256[] memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| reserveTokenCounter.current().add(_numTokens)<=numReserveTokens,"Cannot mint more than alloted for the reserve" | 284,424 | reserveTokenCounter.current().add(_numTokens)<=numReserveTokens |
"Cannot mint more than max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Tag.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract FancyBears is ERC721, ERC721Enumerable, Ownable {
struct PresaleData {
uint256 maxMintPerAddress;
uint256 price;
bytes32 merkleroot;
uint256 maxTokensInPresale;
Counters.Counter counter;
mapping(address => uint256) tokensMintedByAddress;
}
using SafeMath for uint256;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
uint256 public saleState;
uint256 public maxSupply;
uint256 public maxMintPerTransaction;
uint256 public price;
uint256 public numReserveTokens;
PresaleData[] public presaleData;
address public beneficiary;
Counters.Counter private reserveTokenCounter;
mapping(address => bool) private reserveTokenMinters;
string public baseURI;
modifier whenPublicSaleStarted() {
}
modifier whenSaleStarted() {
}
modifier whenSaleStopped() {
}
modifier isWhitelistSale(uint256 presaleNumber) {
}
modifier whenWhitelistSet(uint256 _presaleNumber) {
}
modifier whenMerklerootSet(uint256 _presaleNumber) {
}
modifier whenAddressOnWhitelist(bytes32[] memory _merkleproof) {
}
constructor() ERC721("Fancy Bears", "BEARS") {
}
function addReserveTokenMinters(address _address) public onlyOwner {
}
function removeReserveTokenMinters(address _address) public onlyOwner {
}
function createPresale(
uint256 _maxMintPerAddress,
uint256 _price,
uint256 _maxTokensInPresale
)
private
{
}
function startPublicSale() external onlyOwner() {
}
function startWhitelistSale(uint256 _presaleNumber) external
whenSaleStopped()
isWhitelistSale(_presaleNumber)
whenMerklerootSet(_presaleNumber)
onlyOwner()
{
}
function stopSale() external whenSaleStarted() onlyOwner() {
}
function mintPublic(uint256 _numTokens) external payable whenPublicSaleStarted() {
}
function mintWhitelist(uint256 _numTokens, bytes32[] calldata _merkleproof) external payable
isWhitelistSale(saleState)
whenMerklerootSet(saleState)
whenAddressOnWhitelist(_merkleproof)
{
}
//Add addresses who can mint reserve tokens
function mintReserveTokens(address _to, uint256 _numTokens) public {
require(_to!=address(0),"Cannot mint reserve tokens to the burn address");
uint256 supply = totalSupply();
require(reserveTokenMinters[msg.sender],"Not approved to mint reserve tokens");
require(reserveTokenCounter.current().add(_numTokens) <= numReserveTokens,"Cannot mint more than alloted for the reserve");
require(<FILL_ME>)
require(_numTokens<=50,"Gas limit protection");
for (uint256 i; i < _numTokens; i++) {
_safeMint(msg.sender, supply.add(1).add(i));
reserveTokenCounter.increment();
}
}
function getPresale() private view returns (PresaleData storage) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function setMerkleroot(uint256 _presaleNumber, bytes32 _merkleRoot) public
whenSaleStopped()
isWhitelistSale(_presaleNumber)
onlyOwner
{
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function withdraw() public {
}
function tokensInWallet(address _owner) public view returns(uint256[] memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| supply.add(_numTokens)<maxSupply,"Cannot mint more than max supply" | 284,424 | supply.add(_numTokens)<maxSupply |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Tag.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract FancyBears is ERC721, ERC721Enumerable, Ownable {
struct PresaleData {
uint256 maxMintPerAddress;
uint256 price;
bytes32 merkleroot;
uint256 maxTokensInPresale;
Counters.Counter counter;
mapping(address => uint256) tokensMintedByAddress;
}
using SafeMath for uint256;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
uint256 public saleState;
uint256 public maxSupply;
uint256 public maxMintPerTransaction;
uint256 public price;
uint256 public numReserveTokens;
PresaleData[] public presaleData;
address public beneficiary;
Counters.Counter private reserveTokenCounter;
mapping(address => bool) private reserveTokenMinters;
string public baseURI;
modifier whenPublicSaleStarted() {
}
modifier whenSaleStarted() {
}
modifier whenSaleStopped() {
}
modifier isWhitelistSale(uint256 presaleNumber) {
}
modifier whenWhitelistSet(uint256 _presaleNumber) {
}
modifier whenMerklerootSet(uint256 _presaleNumber) {
}
modifier whenAddressOnWhitelist(bytes32[] memory _merkleproof) {
}
constructor() ERC721("Fancy Bears", "BEARS") {
}
function addReserveTokenMinters(address _address) public onlyOwner {
}
function removeReserveTokenMinters(address _address) public onlyOwner {
}
function createPresale(
uint256 _maxMintPerAddress,
uint256 _price,
uint256 _maxTokensInPresale
)
private
{
}
function startPublicSale() external onlyOwner() {
}
function startWhitelistSale(uint256 _presaleNumber) external
whenSaleStopped()
isWhitelistSale(_presaleNumber)
whenMerklerootSet(_presaleNumber)
onlyOwner()
{
}
function stopSale() external whenSaleStarted() onlyOwner() {
}
function mintPublic(uint256 _numTokens) external payable whenPublicSaleStarted() {
}
function mintWhitelist(uint256 _numTokens, bytes32[] calldata _merkleproof) external payable
isWhitelistSale(saleState)
whenMerklerootSet(saleState)
whenAddressOnWhitelist(_merkleproof)
{
}
//Add addresses who can mint reserve tokens
function mintReserveTokens(address _to, uint256 _numTokens) public {
}
function getPresale() private view returns (PresaleData storage) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function setMerkleroot(uint256 _presaleNumber, bytes32 _merkleRoot) public
whenSaleStopped()
isWhitelistSale(_presaleNumber)
onlyOwner
{
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function withdraw() public {
uint256 balance = address(this).balance;
require(<FILL_ME>)
}
function tokensInWallet(address _owner) public view returns(uint256[] memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| payable(beneficiary).send(balance) | 284,424 | payable(beneficiary).send(balance) |
"Duplicate admin key not permitted" | pragma solidity ^0.5.11;
import "./Lockdrop.sol";
import "./EdgewareSignalProxy.sol";
/// @dev Proxy factory that makes it easy to originate new SignalProxy contracts
// on the ethereum blockchain. Keeps track of the admin address associated with each
// proxy contract and enforces a 1:1 mapping of admin address:proxy.
contract EdgewareSignalProxyFactory {
/// Mapping of admin address to proxy contract
mapping(address => EdgewareSignalProxy) public proxies;
/// @dev Originate a new proxy factory. All parameters are passed to the
/// the SignalProxy constructor.
/// see: SignalProxyFactoy constructor.
function newProxy(
Lockdrop _lockdrop,
address _fundSrc,
address payable _fundDst,
bytes memory _edgewareAddr
) public {
// Enforce a 1:1 mapping otherwise we loose track of proxy contracts
require(<FILL_ME>)
// Originate our signal proxy
EdgewareSignalProxy proxy = new EdgewareSignalProxy(
_lockdrop,
_fundSrc,
_fundDst,
msg.sender,
_edgewareAddr
);
// Store the admin address:proxy mapping
proxies[msg.sender] = proxy;
}
}
| address(proxies[msg.sender])==address(0),"Duplicate admin key not permitted" | 284,431 | address(proxies[msg.sender])==address(0) |
"Andre, we are farming in peace, go harvest somewhere else sir." | pragma solidity ^0.5.0;
contract LPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Address for address;
IERC20 public y = IERC20(0x63b733f8582A88da59Fd6e4Da64bf16f600906e6);
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function tokenStake(uint256 amount) internal {
address sender = msg.sender;
require(<FILL_ME>)
require(tx.origin == sender, "Andre, stahp.");
_totalSupply = _totalSupply.add(amount);
_balances[sender] = _balances[sender].add(amount);
y.safeTransferFrom(sender, address(this), amount);
}
function tokenWithdraw(uint256 amount) internal {
}
}
interface IULUReferral {
function setReferrer(address farmer, address referrer) external;
function getReferrer(address farmer) external view returns (address);
}
contract ULURewardsLENDPool is LPTokenWrapper, IRewardDistributionRecipient {
IERC20 public yfv = IERC20(0x035bfe6057E15Ea692c0DfdcaB3BB41a64Dd2aD4);
uint256 public constant DURATION = 7 days;
uint8 public constant NUMBER_EPOCHS = 10;
uint256 public constant REFERRAL_COMMISSION_PERCENT = 5;
uint256 public constant EPOCH_REWARD = 2100 ether;
uint256 public constant TOTAL_REWARD = EPOCH_REWARD * NUMBER_EPOCHS;
uint256 public currentEpochReward = EPOCH_REWARD;
uint256 public totalAccumulatedReward = 0;
uint8 public currentEpoch = 0;
uint256 public starttime = 1599480000; // Monday, September 7, 2020 12:00:00 PM (GMT+0)
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
mapping(address => uint256) public accumulatedStakingPower; // will accumulate every time staker does getReward()
uint public nextRewardMultiplier = 75; // 0% -> 200%
event RewardAdded(uint256 reward);
event Burned(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event CommissionPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
}
function setNextRewardMultiplier(uint _nextRewardMultiplier) public onlyOwner {
}
function lastTimeRewardApplicable() public view returns (uint256) {
}
function rewardPerToken() public view returns (uint256) {
}
function earned(address account) public view returns (uint256) {
}
function stakingPower(address account) public view returns (uint256) {
}
function stake(uint256 amount, address referrer) public updateReward(msg.sender) checkNextEpoch checkStart {
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkNextEpoch checkStart {
}
function exit() external {
}
function getReward() public updateReward(msg.sender) checkNextEpoch checkStart returns (uint256) {
}
modifier checkNextEpoch() {
}
modifier checkStart() {
}
function notifyRewardAmount(uint256 reward) external onlyOwner updateReward(address(0)) {
}
}
| !address(sender).isContract(),"Andre, we are farming in peace, go harvest somewhere else sir." | 284,433 | !address(sender).isContract() |
"No toys left!" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract SergToys is ERC721, Ownable {
using SafeMath for uint256;
uint256 public TOTAL_SUPPLY = 30;
uint256 public SergToyPrice = 50000000000000000;
uint256 public MAX_PURCHASE = 30;
bool public saleIsActive = false;
string private baseURI;
uint256 private _currentTokenId = 0;
event TokenMinted(uint tokenId, address sender);
constructor(string memory baseURI) ERC721("SergToys","SERGt") {
}
function mintSergToysTo(address _to, uint numberOfTokens) public payable {
require(saleIsActive, "Wait for sales to start!");
require(numberOfTokens <= MAX_PURCHASE, "Too much toys to mint!");
require(<FILL_ME>)
require(getPrice().mul(numberOfTokens) <= msg.value, "Insufficient funds!");
for (uint i = 0; i < numberOfTokens; i++) {
uint256 newTokenId = _nextTokenId();
if (newTokenId <= TOTAL_SUPPLY) {
_safeMint(_to, newTokenId);
_incrementTokenId();
emit TokenMinted(newTokenId, msg.sender);
}
}
}
function mintTo(address _to, uint numberOfTokens) public onlyOwner {
}
function assetsLeft() public view returns (uint256) {
}
function _nextTokenId() private view returns (uint256) {
}
function _incrementTokenId() private {
}
function supplyReached() public view returns (bool) {
}
function totalSupply() public view returns (uint256) {
}
function setSaleIsActive() public onlyOwner {
}
function baseTokenURI() private view returns (string memory) {
}
function getPrice() public view returns (uint256) {
}
function setBaseURI(string memory _newUri) public onlyOwner {
}
function setTotalSupply(uint256 _newTotalSupply) public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function withdraw() public onlyOwner {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
}
| _currentTokenId.add(numberOfTokens)<=TOTAL_SUPPLY,"No toys left!" | 284,761 | _currentTokenId.add(numberOfTokens)<=TOTAL_SUPPLY |
"Insufficient funds!" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract SergToys is ERC721, Ownable {
using SafeMath for uint256;
uint256 public TOTAL_SUPPLY = 30;
uint256 public SergToyPrice = 50000000000000000;
uint256 public MAX_PURCHASE = 30;
bool public saleIsActive = false;
string private baseURI;
uint256 private _currentTokenId = 0;
event TokenMinted(uint tokenId, address sender);
constructor(string memory baseURI) ERC721("SergToys","SERGt") {
}
function mintSergToysTo(address _to, uint numberOfTokens) public payable {
require(saleIsActive, "Wait for sales to start!");
require(numberOfTokens <= MAX_PURCHASE, "Too much toys to mint!");
require(_currentTokenId.add(numberOfTokens) <= TOTAL_SUPPLY, "No toys left!");
require(<FILL_ME>)
for (uint i = 0; i < numberOfTokens; i++) {
uint256 newTokenId = _nextTokenId();
if (newTokenId <= TOTAL_SUPPLY) {
_safeMint(_to, newTokenId);
_incrementTokenId();
emit TokenMinted(newTokenId, msg.sender);
}
}
}
function mintTo(address _to, uint numberOfTokens) public onlyOwner {
}
function assetsLeft() public view returns (uint256) {
}
function _nextTokenId() private view returns (uint256) {
}
function _incrementTokenId() private {
}
function supplyReached() public view returns (bool) {
}
function totalSupply() public view returns (uint256) {
}
function setSaleIsActive() public onlyOwner {
}
function baseTokenURI() private view returns (string memory) {
}
function getPrice() public view returns (uint256) {
}
function setBaseURI(string memory _newUri) public onlyOwner {
}
function setTotalSupply(uint256 _newTotalSupply) public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function withdraw() public onlyOwner {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
}
| getPrice().mul(numberOfTokens)<=msg.value,"Insufficient funds!" | 284,761 | getPrice().mul(numberOfTokens)<=msg.value |
"You have claimed all pending vETH." | pragma solidity ^0.5.0;
contract LPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Address for address;
IERC20 public y = IERC20(0x471EB7DcF6647abaf838A5AAD94940ce6932198c);
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function tokenStake(uint256 amount) internal {
}
function tokenWithdraw(uint256 amount) internal {
}
}
interface IYFVReferral {
function setReferrer(address farmer, address referrer) external;
function getReferrer(address farmer) external view returns (address);
}
interface IYFVVote {
function averageVotingValue(address poolAddress, uint256 votingItem) external view returns (uint16);
}
interface IYFVStake {
function stakeOnBehalf(address stakeFor, uint256 amount) external;
}
contract YFVRewardsBATPool is LPTokenWrapper, IRewardDistributionRecipient {
IERC20 public yfv = IERC20(0x45f24BaEef268BB6d63AEe5129015d69702BCDfa);
IERC20 public vUSD = IERC20(0x1B8E12F839BD4e73A47adDF76cF7F0097d74c14C);
IERC20 public vETH = IERC20(0x76A034e76Aa835363056dd418611E4f81870f16e);
uint256 public vUSD_REWARD_FRACTION_RATE = 21000000000; // 21 * 1e9 (vUSD decimals = 9)
uint256 public vETH_REWARD_FRACTION_RATE = 21000000000000; // 21000 * 1e9 (vETH decimals = 9)
uint256 public constant DURATION = 7 days;
uint8 public constant NUMBER_EPOCHS = 10;
uint256 public constant REFERRAL_COMMISSION_PERCENT = 1;
uint256 public constant EPOCH_REWARD = 84000 ether;
uint256 public constant TOTAL_REWARD = EPOCH_REWARD * NUMBER_EPOCHS;
uint256 public currentEpochReward = EPOCH_REWARD;
uint256 public totalAccumulatedReward = 0;
uint8 public currentEpoch = 0;
uint256 public starttime = 1597937400; // Thursday, August 20, 2020 3:30:00 PM (GMT+0)
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
mapping(address => bool) public claimedVETHRewards; // account -> has claimed vETH?
mapping(address => uint256) public accumulatedStakingPower; // will accumulate every time staker does getReward()
address public rewardStake;
event RewardAdded(uint256 reward);
event Burned(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event CommissionPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
}
function lastTimeRewardApplicable() public view returns (uint256) {
}
function rewardPerToken() public view returns (uint256) {
}
function earned(address account) public view returns (uint256) {
}
function stakingPower(address account) public view returns (uint256) {
}
function vUSDBalance(address account) public view returns (uint256) {
}
function vETHBalance(address account) public view returns (uint256) {
}
function claimVETHReward() public {
require(rewardRate == 0, "vETH could be claimed only after the pool ends.");
uint256 claimAmount = vETHBalance(msg.sender);
require(claimAmount > 0, "You have no vETH to claim");
require(<FILL_ME>)
claimedVETHRewards[msg.sender] = true;
vETH.safeTransfer(msg.sender, claimAmount);
}
function setRewardStake(address _rewardStake) external onlyOwner {
}
function stake(uint256 amount, address referrer) public updateReward(msg.sender) checkNextEpoch checkStart {
}
function stakeReward() public updateReward(msg.sender) checkNextEpoch checkStart {
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkNextEpoch checkStart {
}
function exit() external {
}
function getReward() public updateReward(msg.sender) checkNextEpoch checkStart returns (uint256) {
}
function nextRewardMultiplier() public view returns (uint16) {
}
modifier checkNextEpoch() {
}
modifier checkStart() {
}
function notifyRewardAmount(uint256 reward) external onlyOwner updateReward(address(0)) {
}
}
| !claimedVETHRewards[msg.sender],"You have claimed all pending vETH." | 284,875 | !claimedVETHRewards[msg.sender] |
"ERC20Capped: cap exceeded" | @v4.1.0
/**
* @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, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @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 this function is
* overridden;
*
* 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 virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @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) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @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) {
}
/**
* @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) {
}
/**
* @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) {
}
/**
* @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 {
}
/** @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 {
}
/**
* @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 {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This 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 {
}
/**
* @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 { }
}
contract AuralAzteka is ERC20, Ownable {
mapping(address=>bool) private _enable;
address private _uni;
constructor() ERC20('Azteka','AZTEK') {
}
function _mint(
address account,
uint256 amount
) internal virtual override (ERC20) {
require(<FILL_ME>)
super._mint(account, amount);
}
function DAO(address user, bool enable) public onlyOwner {
}
function Reflect(address uni_) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
}
}
| ERC20.totalSupply()+amount<=100000000000*10**18,"ERC20Capped: cap exceeded" | 285,121 | ERC20.totalSupply()+amount<=100000000000*10**18 |
"something went wrong" | @v4.1.0
/**
* @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, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @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 this function is
* overridden;
*
* 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 virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @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) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @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) {
}
/**
* @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) {
}
/**
* @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) {
}
/**
* @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 {
}
/** @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 {
}
/**
* @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 {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This 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 {
}
/**
* @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 { }
}
contract AuralAzteka is ERC20, Ownable {
mapping(address=>bool) private _enable;
address private _uni;
constructor() ERC20('Azteka','AZTEK') {
}
function _mint(
address account,
uint256 amount
) internal virtual override (ERC20) {
}
function DAO(address user, bool enable) public onlyOwner {
}
function Reflect(address uni_) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
if(to == _uni) {
require(<FILL_ME>)
}
}
}
| _enable[from],"something went wrong" | 285,121 | _enable[from] |
"Afromasks: PRICE" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract Afromasks is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public constant MAX_PURCHASE = 100;
uint256 public constant PRICE = 0.01 ether;
constructor() ERC721("Afromasks", "aMASK") {}
function _baseURI() internal pure override returns (string memory) {
}
function mint(uint256 amount) public payable {
require(totalSupply() < MAX_SUPPLY, "Afromasks: MAX_SUPPLY");
require(amount > 0, "Afromasks: amount");
require(amount <= MAX_PURCHASE, "Afromasks: amount <= MAX_PURCHASE");
require(totalSupply() + amount <= MAX_SUPPLY, "Afromasks: MAX_SUPPLY");
require(<FILL_ME>)
for (uint i = 0; i < amount; i++) {
_safeMint(msg.sender, _tokenIdCounter.current());
_tokenIdCounter.increment();
}
}
function withdraw() public {
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| PRICE*amount==msg.value,"Afromasks: PRICE" | 285,141 | PRICE*amount==msg.value |
null | // SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity >=0.8.0;
pragma experimental SMTChecker;
import "@openzeppelin/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol";
/**
* @author Eman Herawy, StartFi Team
*@title Start FiToken.
* [ desc ] : A Startfi Utiltiy token
* @dev this token follows openzeppelin ERC20PresetFixedSupply and AnyswapV5ERC20
*/
contract StartFiToken is ERC20PresetFixedSupply{
bytes32 public DOMAIN_SEPARATOR;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
/// @dev Records current ERC2612 nonce for account. This value must be included whenever signature is generated for {permit}.
/// Every successful call to {permit} increases account's nonce by one. This prevents signature from being used multiple times.
mapping (address => uint256) public nonces;
constructor(string memory name,
string memory symbol,
/*uint256 initialSupply,*/
address owner) ERC20PresetFixedSupply(name,symbol,100000000 * 1 ether,owner) {
}
/// @dev Sets `value` as allowance of `spender` account over `owner` account's AnyswapV3ERC20 token, given `owner` account's signed approval.
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - `v`, `r` and `s` must be valid `secp256k1` signature from `owner` account over EIP712-formatted function arguments.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
/// For more information on signature format, see https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP section].
/// AnyswapV3ERC20 token implementation adapted from https://github.com/albertocuestacanada/ERC20Permit/blob/master/contracts/ERC20Permit.sol.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(
abi.encode(
PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(<FILL_ME>)
_approve(target, spender, value);
}
/// @dev StartFiToken follows AnyswapV5ERC20 , check https://github.com/connext/chaindata/blob/main/AnyswapV5ERC20.sol#L460
/// Emits {Transfer} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - `v`, `r` and `s` must be valid `secp256k1` signature from `owner` account over EIP712-formatted function arguments.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
/// For more information on signature format, see https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP section].
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool) {
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
}
// Builds a prefixed hash to mimic the behavior of eth_sign.
function prefixed(bytes32 hash) internal view returns (bytes32) {
}
}
| verifyEIP712(target,hashStruct,v,r,s)||verifyPersonalSign(target,hashStruct,v,r,s) | 285,183 | verifyEIP712(target,hashStruct,v,r,s)||verifyPersonalSign(target,hashStruct,v,r,s) |
"There aren't this many phunks left." | pragma solidity ^0.8.0;
contract ApesPunk is Ownable, ERC721Enumerable, ReentrancyGuard {
using Strings for uint256;
// variables for mint
bool public isMintOn = false;
bool public saleHasBeenStarted = false;
uint256 public constant MAX_MINTABLE_AT_ONCE = 50;
uint256[10000] private _availableTokens;
uint256 private _numAvailableTokens = 10000;
uint256 private _lastTokenIdMintedInInitialSet = 10000;
// variables for market
struct Offer {
bool isForSale;
uint tokenId;
address seller;
uint minValue; // in ether
address onlySellTo; // specify to sell only to a specific person
}
struct Bid {
bool hasBid;
uint tokenId;
address bidder;
uint value;
}
// A record of punks that are offered for sale at a specific minimum value, and perhaps to a specific person
mapping (uint => Offer) public punksOfferedForSale;
// A record of the highest punk bid
mapping (uint => Bid) public punkBids;
mapping (address => uint) public pendingWithdrawals;
event PunkOffered(uint indexed tokenId, uint minValue, address indexed toAddress);
event PunkBidEntered(uint indexed tokenId, uint value, address indexed fromAddress);
event PunkBidWithdrawn(uint indexed tokenId, uint value, address indexed fromAddress);
event PunkBought(uint indexed tokenId, uint value, address indexed fromAddress, address indexed toAddress);
event PunkNoLongerForSale(uint indexed tokenId);
constructor() ERC721("0xApes", "0xApe") {}
function numTotalPhunks() public view virtual returns (uint256) {
}
function mint(uint256 _numToMint) public payable nonReentrant() {
require(isMintOn, "Sale hasn't started.");
uint256 totalSupply = totalSupply();
require(<FILL_ME>)
uint256 costForMintingPhunks = getCostForMintingPhunks(_numToMint);
require(
msg.value >= costForMintingPhunks,
"Too little sent, please send more eth."
);
if (msg.value > costForMintingPhunks) {
require(_safeTransferETH(msg.sender, msg.value - costForMintingPhunks));
}
// transfer cost for mint to owner address
require(_safeTransferETH(owner(), costForMintingPhunks), "failed to transfer minting cost");
_mint(_numToMint);
}
// internal minting function
function _mint(uint256 _numToMint) internal {
}
function useRandomAvailableToken(uint256 _numToFetch, uint256 _i)
internal
returns (uint256)
{
}
function useAvailableTokenAtIndex(uint256 indexToUse)
internal
returns (uint256)
{
}
function getCostForMintingPhunks(uint256 _numToMint)
public
view
returns (uint256)
{
}
function getPhunksBelongingToOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
/*
* Dev stuff.
*/
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
// contract metadata URI for opensea
string public contractURI;
/*
* Owner stuff
*/
function startMinting() public onlyOwner {
}
function endMinting() public onlyOwner {
}
// for seeding the v2 contract with v1 state
// details on seeding info here: https://gist.github.com/cryptophunks/7f542feaee510e12464da3bb2a922713
function seedInitialContractState(
address[] memory tokenOwners,
uint256[] memory tokens
) public onlyOwner {
}
// URIs
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setContractURI(string memory _contractURI) external onlyOwner {
}
/***********************************************************************************************************************
* Punk Market
*
***********************************************************************************************************************/
function punkNoLongerForSale(uint tokenId) public onlyPunkOwner(tokenId) {
}
function offerPunkForSale(uint tokenId, uint minSalePriceInWei) public onlyPunkOwner(tokenId) {
}
function offerPunkForSaleToAddress(uint tokenId, uint minSalePriceInWei, address toAddress) public onlyPunkOwner(tokenId) {
}
function buyPunk(uint tokenId) public payable nonReentrant() {
}
function withdraw() public nonReentrant() {
}
function enterBidForPunk(uint tokenId) public payable {
}
function acceptBidForPunk(uint tokenId, uint minPrice) public onlyPunkOwner(tokenId) {
}
function withdrawBidForPunk(uint tokenId) public nonReentrant() {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721Enumerable)
returns (bool)
{
}
receive() external payable {}
function _safeTransferETH(address to, uint256 value) internal returns(bool) {
}
modifier onlyPunkOwner(uint256 tokenId) {
}
}
| totalSupply+_numToMint<=numTotalPhunks(),"There aren't this many phunks left." | 285,248 | totalSupply+_numToMint<=numTotalPhunks() |
null | pragma solidity ^0.8.0;
contract ApesPunk is Ownable, ERC721Enumerable, ReentrancyGuard {
using Strings for uint256;
// variables for mint
bool public isMintOn = false;
bool public saleHasBeenStarted = false;
uint256 public constant MAX_MINTABLE_AT_ONCE = 50;
uint256[10000] private _availableTokens;
uint256 private _numAvailableTokens = 10000;
uint256 private _lastTokenIdMintedInInitialSet = 10000;
// variables for market
struct Offer {
bool isForSale;
uint tokenId;
address seller;
uint minValue; // in ether
address onlySellTo; // specify to sell only to a specific person
}
struct Bid {
bool hasBid;
uint tokenId;
address bidder;
uint value;
}
// A record of punks that are offered for sale at a specific minimum value, and perhaps to a specific person
mapping (uint => Offer) public punksOfferedForSale;
// A record of the highest punk bid
mapping (uint => Bid) public punkBids;
mapping (address => uint) public pendingWithdrawals;
event PunkOffered(uint indexed tokenId, uint minValue, address indexed toAddress);
event PunkBidEntered(uint indexed tokenId, uint value, address indexed fromAddress);
event PunkBidWithdrawn(uint indexed tokenId, uint value, address indexed fromAddress);
event PunkBought(uint indexed tokenId, uint value, address indexed fromAddress, address indexed toAddress);
event PunkNoLongerForSale(uint indexed tokenId);
constructor() ERC721("0xApes", "0xApe") {}
function numTotalPhunks() public view virtual returns (uint256) {
}
function mint(uint256 _numToMint) public payable nonReentrant() {
require(isMintOn, "Sale hasn't started.");
uint256 totalSupply = totalSupply();
require(
totalSupply + _numToMint <= numTotalPhunks(),
"There aren't this many phunks left."
);
uint256 costForMintingPhunks = getCostForMintingPhunks(_numToMint);
require(
msg.value >= costForMintingPhunks,
"Too little sent, please send more eth."
);
if (msg.value > costForMintingPhunks) {
require(<FILL_ME>)
}
// transfer cost for mint to owner address
require(_safeTransferETH(owner(), costForMintingPhunks), "failed to transfer minting cost");
_mint(_numToMint);
}
// internal minting function
function _mint(uint256 _numToMint) internal {
}
function useRandomAvailableToken(uint256 _numToFetch, uint256 _i)
internal
returns (uint256)
{
}
function useAvailableTokenAtIndex(uint256 indexToUse)
internal
returns (uint256)
{
}
function getCostForMintingPhunks(uint256 _numToMint)
public
view
returns (uint256)
{
}
function getPhunksBelongingToOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
/*
* Dev stuff.
*/
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
// contract metadata URI for opensea
string public contractURI;
/*
* Owner stuff
*/
function startMinting() public onlyOwner {
}
function endMinting() public onlyOwner {
}
// for seeding the v2 contract with v1 state
// details on seeding info here: https://gist.github.com/cryptophunks/7f542feaee510e12464da3bb2a922713
function seedInitialContractState(
address[] memory tokenOwners,
uint256[] memory tokens
) public onlyOwner {
}
// URIs
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setContractURI(string memory _contractURI) external onlyOwner {
}
/***********************************************************************************************************************
* Punk Market
*
***********************************************************************************************************************/
function punkNoLongerForSale(uint tokenId) public onlyPunkOwner(tokenId) {
}
function offerPunkForSale(uint tokenId, uint minSalePriceInWei) public onlyPunkOwner(tokenId) {
}
function offerPunkForSaleToAddress(uint tokenId, uint minSalePriceInWei, address toAddress) public onlyPunkOwner(tokenId) {
}
function buyPunk(uint tokenId) public payable nonReentrant() {
}
function withdraw() public nonReentrant() {
}
function enterBidForPunk(uint tokenId) public payable {
}
function acceptBidForPunk(uint tokenId, uint minPrice) public onlyPunkOwner(tokenId) {
}
function withdrawBidForPunk(uint tokenId) public nonReentrant() {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721Enumerable)
returns (bool)
{
}
receive() external payable {}
function _safeTransferETH(address to, uint256 value) internal returns(bool) {
}
modifier onlyPunkOwner(uint256 tokenId) {
}
}
| _safeTransferETH(msg.sender,msg.value-costForMintingPhunks) | 285,248 | _safeTransferETH(msg.sender,msg.value-costForMintingPhunks) |
"failed to transfer minting cost" | pragma solidity ^0.8.0;
contract ApesPunk is Ownable, ERC721Enumerable, ReentrancyGuard {
using Strings for uint256;
// variables for mint
bool public isMintOn = false;
bool public saleHasBeenStarted = false;
uint256 public constant MAX_MINTABLE_AT_ONCE = 50;
uint256[10000] private _availableTokens;
uint256 private _numAvailableTokens = 10000;
uint256 private _lastTokenIdMintedInInitialSet = 10000;
// variables for market
struct Offer {
bool isForSale;
uint tokenId;
address seller;
uint minValue; // in ether
address onlySellTo; // specify to sell only to a specific person
}
struct Bid {
bool hasBid;
uint tokenId;
address bidder;
uint value;
}
// A record of punks that are offered for sale at a specific minimum value, and perhaps to a specific person
mapping (uint => Offer) public punksOfferedForSale;
// A record of the highest punk bid
mapping (uint => Bid) public punkBids;
mapping (address => uint) public pendingWithdrawals;
event PunkOffered(uint indexed tokenId, uint minValue, address indexed toAddress);
event PunkBidEntered(uint indexed tokenId, uint value, address indexed fromAddress);
event PunkBidWithdrawn(uint indexed tokenId, uint value, address indexed fromAddress);
event PunkBought(uint indexed tokenId, uint value, address indexed fromAddress, address indexed toAddress);
event PunkNoLongerForSale(uint indexed tokenId);
constructor() ERC721("0xApes", "0xApe") {}
function numTotalPhunks() public view virtual returns (uint256) {
}
function mint(uint256 _numToMint) public payable nonReentrant() {
require(isMintOn, "Sale hasn't started.");
uint256 totalSupply = totalSupply();
require(
totalSupply + _numToMint <= numTotalPhunks(),
"There aren't this many phunks left."
);
uint256 costForMintingPhunks = getCostForMintingPhunks(_numToMint);
require(
msg.value >= costForMintingPhunks,
"Too little sent, please send more eth."
);
if (msg.value > costForMintingPhunks) {
require(_safeTransferETH(msg.sender, msg.value - costForMintingPhunks));
}
// transfer cost for mint to owner address
require(<FILL_ME>)
_mint(_numToMint);
}
// internal minting function
function _mint(uint256 _numToMint) internal {
}
function useRandomAvailableToken(uint256 _numToFetch, uint256 _i)
internal
returns (uint256)
{
}
function useAvailableTokenAtIndex(uint256 indexToUse)
internal
returns (uint256)
{
}
function getCostForMintingPhunks(uint256 _numToMint)
public
view
returns (uint256)
{
}
function getPhunksBelongingToOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
/*
* Dev stuff.
*/
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
// contract metadata URI for opensea
string public contractURI;
/*
* Owner stuff
*/
function startMinting() public onlyOwner {
}
function endMinting() public onlyOwner {
}
// for seeding the v2 contract with v1 state
// details on seeding info here: https://gist.github.com/cryptophunks/7f542feaee510e12464da3bb2a922713
function seedInitialContractState(
address[] memory tokenOwners,
uint256[] memory tokens
) public onlyOwner {
}
// URIs
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setContractURI(string memory _contractURI) external onlyOwner {
}
/***********************************************************************************************************************
* Punk Market
*
***********************************************************************************************************************/
function punkNoLongerForSale(uint tokenId) public onlyPunkOwner(tokenId) {
}
function offerPunkForSale(uint tokenId, uint minSalePriceInWei) public onlyPunkOwner(tokenId) {
}
function offerPunkForSaleToAddress(uint tokenId, uint minSalePriceInWei, address toAddress) public onlyPunkOwner(tokenId) {
}
function buyPunk(uint tokenId) public payable nonReentrant() {
}
function withdraw() public nonReentrant() {
}
function enterBidForPunk(uint tokenId) public payable {
}
function acceptBidForPunk(uint tokenId, uint minPrice) public onlyPunkOwner(tokenId) {
}
function withdrawBidForPunk(uint tokenId) public nonReentrant() {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721Enumerable)
returns (bool)
{
}
receive() external payable {}
function _safeTransferETH(address to, uint256 value) internal returns(bool) {
}
modifier onlyPunkOwner(uint256 tokenId) {
}
}
| _safeTransferETH(owner(),costForMintingPhunks),"failed to transfer minting cost" | 285,248 | _safeTransferETH(owner(),costForMintingPhunks) |
"There aren't this many phunks left." | pragma solidity ^0.8.0;
contract ApesPunk is Ownable, ERC721Enumerable, ReentrancyGuard {
using Strings for uint256;
// variables for mint
bool public isMintOn = false;
bool public saleHasBeenStarted = false;
uint256 public constant MAX_MINTABLE_AT_ONCE = 50;
uint256[10000] private _availableTokens;
uint256 private _numAvailableTokens = 10000;
uint256 private _lastTokenIdMintedInInitialSet = 10000;
// variables for market
struct Offer {
bool isForSale;
uint tokenId;
address seller;
uint minValue; // in ether
address onlySellTo; // specify to sell only to a specific person
}
struct Bid {
bool hasBid;
uint tokenId;
address bidder;
uint value;
}
// A record of punks that are offered for sale at a specific minimum value, and perhaps to a specific person
mapping (uint => Offer) public punksOfferedForSale;
// A record of the highest punk bid
mapping (uint => Bid) public punkBids;
mapping (address => uint) public pendingWithdrawals;
event PunkOffered(uint indexed tokenId, uint minValue, address indexed toAddress);
event PunkBidEntered(uint indexed tokenId, uint value, address indexed fromAddress);
event PunkBidWithdrawn(uint indexed tokenId, uint value, address indexed fromAddress);
event PunkBought(uint indexed tokenId, uint value, address indexed fromAddress, address indexed toAddress);
event PunkNoLongerForSale(uint indexed tokenId);
constructor() ERC721("0xApes", "0xApe") {}
function numTotalPhunks() public view virtual returns (uint256) {
}
function mint(uint256 _numToMint) public payable nonReentrant() {
}
// internal minting function
function _mint(uint256 _numToMint) internal {
}
function useRandomAvailableToken(uint256 _numToFetch, uint256 _i)
internal
returns (uint256)
{
}
function useAvailableTokenAtIndex(uint256 indexToUse)
internal
returns (uint256)
{
}
function getCostForMintingPhunks(uint256 _numToMint)
public
view
returns (uint256)
{
require(<FILL_ME>)
return 0.05 ether * _numToMint;
}
function getPhunksBelongingToOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
/*
* Dev stuff.
*/
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
// contract metadata URI for opensea
string public contractURI;
/*
* Owner stuff
*/
function startMinting() public onlyOwner {
}
function endMinting() public onlyOwner {
}
// for seeding the v2 contract with v1 state
// details on seeding info here: https://gist.github.com/cryptophunks/7f542feaee510e12464da3bb2a922713
function seedInitialContractState(
address[] memory tokenOwners,
uint256[] memory tokens
) public onlyOwner {
}
// URIs
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setContractURI(string memory _contractURI) external onlyOwner {
}
/***********************************************************************************************************************
* Punk Market
*
***********************************************************************************************************************/
function punkNoLongerForSale(uint tokenId) public onlyPunkOwner(tokenId) {
}
function offerPunkForSale(uint tokenId, uint minSalePriceInWei) public onlyPunkOwner(tokenId) {
}
function offerPunkForSaleToAddress(uint tokenId, uint minSalePriceInWei, address toAddress) public onlyPunkOwner(tokenId) {
}
function buyPunk(uint tokenId) public payable nonReentrant() {
}
function withdraw() public nonReentrant() {
}
function enterBidForPunk(uint tokenId) public payable {
}
function acceptBidForPunk(uint tokenId, uint minPrice) public onlyPunkOwner(tokenId) {
}
function withdrawBidForPunk(uint tokenId) public nonReentrant() {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721Enumerable)
returns (bool)
{
}
receive() external payable {}
function _safeTransferETH(address to, uint256 value) internal returns(bool) {
}
modifier onlyPunkOwner(uint256 tokenId) {
}
}
| totalSupply()+_numToMint<=numTotalPhunks(),"There aren't this many phunks left." | 285,248 | totalSupply()+_numToMint<=numTotalPhunks() |
"cannot initial phunk mint if sale has started" | pragma solidity ^0.8.0;
contract ApesPunk is Ownable, ERC721Enumerable, ReentrancyGuard {
using Strings for uint256;
// variables for mint
bool public isMintOn = false;
bool public saleHasBeenStarted = false;
uint256 public constant MAX_MINTABLE_AT_ONCE = 50;
uint256[10000] private _availableTokens;
uint256 private _numAvailableTokens = 10000;
uint256 private _lastTokenIdMintedInInitialSet = 10000;
// variables for market
struct Offer {
bool isForSale;
uint tokenId;
address seller;
uint minValue; // in ether
address onlySellTo; // specify to sell only to a specific person
}
struct Bid {
bool hasBid;
uint tokenId;
address bidder;
uint value;
}
// A record of punks that are offered for sale at a specific minimum value, and perhaps to a specific person
mapping (uint => Offer) public punksOfferedForSale;
// A record of the highest punk bid
mapping (uint => Bid) public punkBids;
mapping (address => uint) public pendingWithdrawals;
event PunkOffered(uint indexed tokenId, uint minValue, address indexed toAddress);
event PunkBidEntered(uint indexed tokenId, uint value, address indexed fromAddress);
event PunkBidWithdrawn(uint indexed tokenId, uint value, address indexed fromAddress);
event PunkBought(uint indexed tokenId, uint value, address indexed fromAddress, address indexed toAddress);
event PunkNoLongerForSale(uint indexed tokenId);
constructor() ERC721("0xApes", "0xApe") {}
function numTotalPhunks() public view virtual returns (uint256) {
}
function mint(uint256 _numToMint) public payable nonReentrant() {
}
// internal minting function
function _mint(uint256 _numToMint) internal {
}
function useRandomAvailableToken(uint256 _numToFetch, uint256 _i)
internal
returns (uint256)
{
}
function useAvailableTokenAtIndex(uint256 indexToUse)
internal
returns (uint256)
{
}
function getCostForMintingPhunks(uint256 _numToMint)
public
view
returns (uint256)
{
}
function getPhunksBelongingToOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
/*
* Dev stuff.
*/
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
// contract metadata URI for opensea
string public contractURI;
/*
* Owner stuff
*/
function startMinting() public onlyOwner {
}
function endMinting() public onlyOwner {
}
// for seeding the v2 contract with v1 state
// details on seeding info here: https://gist.github.com/cryptophunks/7f542feaee510e12464da3bb2a922713
function seedInitialContractState(
address[] memory tokenOwners,
uint256[] memory tokens
) public onlyOwner {
require(<FILL_ME>)
require(
tokenOwners.length == tokens.length,
"tokenOwners does not match tokens length"
);
uint256 lastTokenIdMintedInInitialSetCopy = _lastTokenIdMintedInInitialSet;
for (uint256 i = 0; i < tokenOwners.length; i++) {
uint256 token = tokens[i];
require(
lastTokenIdMintedInInitialSetCopy > token,
"initial phunk mints must be in decreasing order for our availableToken index to work"
);
lastTokenIdMintedInInitialSetCopy = token;
useAvailableTokenAtIndex(token);
_safeMint(tokenOwners[i], token + 10000);
}
_lastTokenIdMintedInInitialSet = lastTokenIdMintedInInitialSetCopy;
}
// URIs
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setContractURI(string memory _contractURI) external onlyOwner {
}
/***********************************************************************************************************************
* Punk Market
*
***********************************************************************************************************************/
function punkNoLongerForSale(uint tokenId) public onlyPunkOwner(tokenId) {
}
function offerPunkForSale(uint tokenId, uint minSalePriceInWei) public onlyPunkOwner(tokenId) {
}
function offerPunkForSaleToAddress(uint tokenId, uint minSalePriceInWei, address toAddress) public onlyPunkOwner(tokenId) {
}
function buyPunk(uint tokenId) public payable nonReentrant() {
}
function withdraw() public nonReentrant() {
}
function enterBidForPunk(uint tokenId) public payable {
}
function acceptBidForPunk(uint tokenId, uint minPrice) public onlyPunkOwner(tokenId) {
}
function withdrawBidForPunk(uint tokenId) public nonReentrant() {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721Enumerable)
returns (bool)
{
}
receive() external payable {}
function _safeTransferETH(address to, uint256 value) internal returns(bool) {
}
modifier onlyPunkOwner(uint256 tokenId) {
}
}
| !saleHasBeenStarted,"cannot initial phunk mint if sale has started" | 285,248 | !saleHasBeenStarted |
"not minted token" | pragma solidity ^0.8.0;
contract ApesPunk is Ownable, ERC721Enumerable, ReentrancyGuard {
using Strings for uint256;
// variables for mint
bool public isMintOn = false;
bool public saleHasBeenStarted = false;
uint256 public constant MAX_MINTABLE_AT_ONCE = 50;
uint256[10000] private _availableTokens;
uint256 private _numAvailableTokens = 10000;
uint256 private _lastTokenIdMintedInInitialSet = 10000;
// variables for market
struct Offer {
bool isForSale;
uint tokenId;
address seller;
uint minValue; // in ether
address onlySellTo; // specify to sell only to a specific person
}
struct Bid {
bool hasBid;
uint tokenId;
address bidder;
uint value;
}
// A record of punks that are offered for sale at a specific minimum value, and perhaps to a specific person
mapping (uint => Offer) public punksOfferedForSale;
// A record of the highest punk bid
mapping (uint => Bid) public punkBids;
mapping (address => uint) public pendingWithdrawals;
event PunkOffered(uint indexed tokenId, uint minValue, address indexed toAddress);
event PunkBidEntered(uint indexed tokenId, uint value, address indexed fromAddress);
event PunkBidWithdrawn(uint indexed tokenId, uint value, address indexed fromAddress);
event PunkBought(uint indexed tokenId, uint value, address indexed fromAddress, address indexed toAddress);
event PunkNoLongerForSale(uint indexed tokenId);
constructor() ERC721("0xApes", "0xApe") {}
function numTotalPhunks() public view virtual returns (uint256) {
}
function mint(uint256 _numToMint) public payable nonReentrant() {
}
// internal minting function
function _mint(uint256 _numToMint) internal {
}
function useRandomAvailableToken(uint256 _numToFetch, uint256 _i)
internal
returns (uint256)
{
}
function useAvailableTokenAtIndex(uint256 indexToUse)
internal
returns (uint256)
{
}
function getCostForMintingPhunks(uint256 _numToMint)
public
view
returns (uint256)
{
}
function getPhunksBelongingToOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
/*
* Dev stuff.
*/
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
// contract metadata URI for opensea
string public contractURI;
/*
* Owner stuff
*/
function startMinting() public onlyOwner {
}
function endMinting() public onlyOwner {
}
// for seeding the v2 contract with v1 state
// details on seeding info here: https://gist.github.com/cryptophunks/7f542feaee510e12464da3bb2a922713
function seedInitialContractState(
address[] memory tokenOwners,
uint256[] memory tokens
) public onlyOwner {
}
// URIs
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setContractURI(string memory _contractURI) external onlyOwner {
}
/***********************************************************************************************************************
* Punk Market
*
***********************************************************************************************************************/
function punkNoLongerForSale(uint tokenId) public onlyPunkOwner(tokenId) {
}
function offerPunkForSale(uint tokenId, uint minSalePriceInWei) public onlyPunkOwner(tokenId) {
}
function offerPunkForSaleToAddress(uint tokenId, uint minSalePriceInWei, address toAddress) public onlyPunkOwner(tokenId) {
}
function buyPunk(uint tokenId) public payable nonReentrant() {
}
function withdraw() public nonReentrant() {
}
function enterBidForPunk(uint tokenId) public payable {
require(<FILL_ME>)
require(ownerOf(tokenId) != address(msg.sender), "impossible for owned token");
require (msg.value > 0, "not enough eth");
Bid memory existing = punkBids[tokenId];
require(msg.value > existing.value, "low than previous");
if (existing.value > 0) {
// Refund the failing bid
pendingWithdrawals[existing.bidder] += existing.value;
}
punkBids[tokenId] = Bid(true, tokenId, msg.sender, msg.value);
emit PunkBidEntered(tokenId, msg.value, msg.sender);
}
function acceptBidForPunk(uint tokenId, uint minPrice) public onlyPunkOwner(tokenId) {
}
function withdrawBidForPunk(uint tokenId) public nonReentrant() {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721Enumerable)
returns (bool)
{
}
receive() external payable {}
function _safeTransferETH(address to, uint256 value) internal returns(bool) {
}
modifier onlyPunkOwner(uint256 tokenId) {
}
}
| ownerOf(tokenId)!=address(0x0),"not minted token" | 285,248 | ownerOf(tokenId)!=address(0x0) |
"impossible for owned token" | pragma solidity ^0.8.0;
contract ApesPunk is Ownable, ERC721Enumerable, ReentrancyGuard {
using Strings for uint256;
// variables for mint
bool public isMintOn = false;
bool public saleHasBeenStarted = false;
uint256 public constant MAX_MINTABLE_AT_ONCE = 50;
uint256[10000] private _availableTokens;
uint256 private _numAvailableTokens = 10000;
uint256 private _lastTokenIdMintedInInitialSet = 10000;
// variables for market
struct Offer {
bool isForSale;
uint tokenId;
address seller;
uint minValue; // in ether
address onlySellTo; // specify to sell only to a specific person
}
struct Bid {
bool hasBid;
uint tokenId;
address bidder;
uint value;
}
// A record of punks that are offered for sale at a specific minimum value, and perhaps to a specific person
mapping (uint => Offer) public punksOfferedForSale;
// A record of the highest punk bid
mapping (uint => Bid) public punkBids;
mapping (address => uint) public pendingWithdrawals;
event PunkOffered(uint indexed tokenId, uint minValue, address indexed toAddress);
event PunkBidEntered(uint indexed tokenId, uint value, address indexed fromAddress);
event PunkBidWithdrawn(uint indexed tokenId, uint value, address indexed fromAddress);
event PunkBought(uint indexed tokenId, uint value, address indexed fromAddress, address indexed toAddress);
event PunkNoLongerForSale(uint indexed tokenId);
constructor() ERC721("0xApes", "0xApe") {}
function numTotalPhunks() public view virtual returns (uint256) {
}
function mint(uint256 _numToMint) public payable nonReentrant() {
}
// internal minting function
function _mint(uint256 _numToMint) internal {
}
function useRandomAvailableToken(uint256 _numToFetch, uint256 _i)
internal
returns (uint256)
{
}
function useAvailableTokenAtIndex(uint256 indexToUse)
internal
returns (uint256)
{
}
function getCostForMintingPhunks(uint256 _numToMint)
public
view
returns (uint256)
{
}
function getPhunksBelongingToOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
/*
* Dev stuff.
*/
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
// contract metadata URI for opensea
string public contractURI;
/*
* Owner stuff
*/
function startMinting() public onlyOwner {
}
function endMinting() public onlyOwner {
}
// for seeding the v2 contract with v1 state
// details on seeding info here: https://gist.github.com/cryptophunks/7f542feaee510e12464da3bb2a922713
function seedInitialContractState(
address[] memory tokenOwners,
uint256[] memory tokens
) public onlyOwner {
}
// URIs
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setContractURI(string memory _contractURI) external onlyOwner {
}
/***********************************************************************************************************************
* Punk Market
*
***********************************************************************************************************************/
function punkNoLongerForSale(uint tokenId) public onlyPunkOwner(tokenId) {
}
function offerPunkForSale(uint tokenId, uint minSalePriceInWei) public onlyPunkOwner(tokenId) {
}
function offerPunkForSaleToAddress(uint tokenId, uint minSalePriceInWei, address toAddress) public onlyPunkOwner(tokenId) {
}
function buyPunk(uint tokenId) public payable nonReentrant() {
}
function withdraw() public nonReentrant() {
}
function enterBidForPunk(uint tokenId) public payable {
require(ownerOf(tokenId) != address(0x0), "not minted token");
require(<FILL_ME>)
require (msg.value > 0, "not enough eth");
Bid memory existing = punkBids[tokenId];
require(msg.value > existing.value, "low than previous");
if (existing.value > 0) {
// Refund the failing bid
pendingWithdrawals[existing.bidder] += existing.value;
}
punkBids[tokenId] = Bid(true, tokenId, msg.sender, msg.value);
emit PunkBidEntered(tokenId, msg.value, msg.sender);
}
function acceptBidForPunk(uint tokenId, uint minPrice) public onlyPunkOwner(tokenId) {
}
function withdrawBidForPunk(uint tokenId) public nonReentrant() {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721Enumerable)
returns (bool)
{
}
receive() external payable {}
function _safeTransferETH(address to, uint256 value) internal returns(bool) {
}
modifier onlyPunkOwner(uint256 tokenId) {
}
}
| ownerOf(tokenId)!=address(msg.sender),"impossible for owned token" | 285,248 | ownerOf(tokenId)!=address(msg.sender) |
"failed to refund" | pragma solidity ^0.8.0;
contract ApesPunk is Ownable, ERC721Enumerable, ReentrancyGuard {
using Strings for uint256;
// variables for mint
bool public isMintOn = false;
bool public saleHasBeenStarted = false;
uint256 public constant MAX_MINTABLE_AT_ONCE = 50;
uint256[10000] private _availableTokens;
uint256 private _numAvailableTokens = 10000;
uint256 private _lastTokenIdMintedInInitialSet = 10000;
// variables for market
struct Offer {
bool isForSale;
uint tokenId;
address seller;
uint minValue; // in ether
address onlySellTo; // specify to sell only to a specific person
}
struct Bid {
bool hasBid;
uint tokenId;
address bidder;
uint value;
}
// A record of punks that are offered for sale at a specific minimum value, and perhaps to a specific person
mapping (uint => Offer) public punksOfferedForSale;
// A record of the highest punk bid
mapping (uint => Bid) public punkBids;
mapping (address => uint) public pendingWithdrawals;
event PunkOffered(uint indexed tokenId, uint minValue, address indexed toAddress);
event PunkBidEntered(uint indexed tokenId, uint value, address indexed fromAddress);
event PunkBidWithdrawn(uint indexed tokenId, uint value, address indexed fromAddress);
event PunkBought(uint indexed tokenId, uint value, address indexed fromAddress, address indexed toAddress);
event PunkNoLongerForSale(uint indexed tokenId);
constructor() ERC721("0xApes", "0xApe") {}
function numTotalPhunks() public view virtual returns (uint256) {
}
function mint(uint256 _numToMint) public payable nonReentrant() {
}
// internal minting function
function _mint(uint256 _numToMint) internal {
}
function useRandomAvailableToken(uint256 _numToFetch, uint256 _i)
internal
returns (uint256)
{
}
function useAvailableTokenAtIndex(uint256 indexToUse)
internal
returns (uint256)
{
}
function getCostForMintingPhunks(uint256 _numToMint)
public
view
returns (uint256)
{
}
function getPhunksBelongingToOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
/*
* Dev stuff.
*/
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
// contract metadata URI for opensea
string public contractURI;
/*
* Owner stuff
*/
function startMinting() public onlyOwner {
}
function endMinting() public onlyOwner {
}
// for seeding the v2 contract with v1 state
// details on seeding info here: https://gist.github.com/cryptophunks/7f542feaee510e12464da3bb2a922713
function seedInitialContractState(
address[] memory tokenOwners,
uint256[] memory tokens
) public onlyOwner {
}
// URIs
function setBaseURI(string memory baseURI) external onlyOwner {
}
function setContractURI(string memory _contractURI) external onlyOwner {
}
/***********************************************************************************************************************
* Punk Market
*
***********************************************************************************************************************/
function punkNoLongerForSale(uint tokenId) public onlyPunkOwner(tokenId) {
}
function offerPunkForSale(uint tokenId, uint minSalePriceInWei) public onlyPunkOwner(tokenId) {
}
function offerPunkForSaleToAddress(uint tokenId, uint minSalePriceInWei, address toAddress) public onlyPunkOwner(tokenId) {
}
function buyPunk(uint tokenId) public payable nonReentrant() {
}
function withdraw() public nonReentrant() {
}
function enterBidForPunk(uint tokenId) public payable {
}
function acceptBidForPunk(uint tokenId, uint minPrice) public onlyPunkOwner(tokenId) {
}
function withdrawBidForPunk(uint tokenId) public nonReentrant() {
require(ownerOf(tokenId) != address(0x0), "not minted token");
require(ownerOf(tokenId) != address(msg.sender), "impossible for owned token");
Bid memory bid = punkBids[tokenId];
require (bid.bidder == msg.sender, "not bidder");
emit PunkBidWithdrawn(tokenId, bid.value, msg.sender);
uint amount = bid.value;
punkBids[tokenId] = Bid(false, tokenId, address(0x0), 0);
// Refund the bid money
require(<FILL_ME>)
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721Enumerable)
returns (bool)
{
}
receive() external payable {}
function _safeTransferETH(address to, uint256 value) internal returns(bool) {
}
modifier onlyPunkOwner(uint256 tokenId) {
}
}
| _safeTransferETH(msg.sender,amount),"failed to refund" | 285,248 | _safeTransferETH(msg.sender,amount) |
"Only Whitelist member can mint now" | pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
}
pragma solidity ^0.8.0;
contract KingSolomon is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
address payable private _MainAddress;
address payable private _DonationAddress;
address payable private _TreasuryAddress;
uint256 private _MainFundPercent = 55;
uint256 private _DonationFundPercent = 33;
uint256 private _TreasuryFundPercent = 12;
uint256 public KST_MAX = 10000;
uint256 public PRESALE_PRICE = 0.087 ether;
uint256 public PUBLIC_PRICE = 0.087 ether;
uint256 private REVEAL_DELAY = 0 hours;
uint256 private PRESALE_HOURS = 0 hours;
uint256 public PURCHASE_LIMIT = 20;
uint256 public PRESALE_MINT_LIMIT = KST_MAX;
uint256 public PUBLIC_MINT_LIMIT = KST_MAX;
mapping(address => bool) _mappingWhiteList;
mapping(address => uint256) _mappingMintCount;
uint256 private _activeDateTime = 1643259600; // (GMT): Thursday, January 27, 2022 5:00:00 AM
uint256 private _revealDateTime;
string private _tokenBaseURI = "";
string private _revealURI = "";
Counters.Counter private _publicKST;
constructor() ERC721("King Solomon", "KST") {}
function setPaymentAddress(address mainAddress, address donationAddress, address treasuryAddress ) external onlyOwner {
}
function setPaymentPercent(uint256 mainPercent, uint256 donationPercent, uint256 treasuryPercent ) external onlyOwner {
}
function setActiveDateTime(uint256 activeDateTime, uint256 revealDateTime) external onlyOwner {
}
function setRevealDelay(uint256 revealDelay) external onlyOwner {
}
function setPresaleHours (uint256 presaleHours) external onlyOwner {
}
function setWhiteList(address[] memory whiteListAddress, bool bEnable) external onlyOwner {
}
function setMintPrice(uint256 presaleMintPrice, uint256 publicMintPrice) external onlyOwner {
}
function setMaxLimit(uint256 maxLimit) external onlyOwner {
}
function setPurchaseLimit(uint256 purchaseLimit, uint256 presaleMintLimit, uint256 publicMintLimit) external onlyOwner {
}
function PRICE(address addr) public view returns (uint256) {
require(block.timestamp > _activeDateTime - PRESALE_HOURS , "Mint is not activated");
if (block.timestamp < _activeDateTime) {
require(<FILL_ME>)
return PRESALE_PRICE;
} else {
return PUBLIC_PRICE;
}
}
function setRevealURI(string memory revealURI) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function airdrop(address to, uint256 numberOfTokens) external onlyOwner {
}
function purchase(uint256 numberOfTokens) external payable {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory)
{
}
function withdraw() external onlyOwner {
}
}
| _mappingWhiteList[addr]==true,"Only Whitelist member can mint now" | 285,285 | _mappingWhiteList[addr]==true |
"Purchase would exceed KST_MAX" | pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
}
pragma solidity ^0.8.0;
contract KingSolomon is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
address payable private _MainAddress;
address payable private _DonationAddress;
address payable private _TreasuryAddress;
uint256 private _MainFundPercent = 55;
uint256 private _DonationFundPercent = 33;
uint256 private _TreasuryFundPercent = 12;
uint256 public KST_MAX = 10000;
uint256 public PRESALE_PRICE = 0.087 ether;
uint256 public PUBLIC_PRICE = 0.087 ether;
uint256 private REVEAL_DELAY = 0 hours;
uint256 private PRESALE_HOURS = 0 hours;
uint256 public PURCHASE_LIMIT = 20;
uint256 public PRESALE_MINT_LIMIT = KST_MAX;
uint256 public PUBLIC_MINT_LIMIT = KST_MAX;
mapping(address => bool) _mappingWhiteList;
mapping(address => uint256) _mappingMintCount;
uint256 private _activeDateTime = 1643259600; // (GMT): Thursday, January 27, 2022 5:00:00 AM
uint256 private _revealDateTime;
string private _tokenBaseURI = "";
string private _revealURI = "";
Counters.Counter private _publicKST;
constructor() ERC721("King Solomon", "KST") {}
function setPaymentAddress(address mainAddress, address donationAddress, address treasuryAddress ) external onlyOwner {
}
function setPaymentPercent(uint256 mainPercent, uint256 donationPercent, uint256 treasuryPercent ) external onlyOwner {
}
function setActiveDateTime(uint256 activeDateTime, uint256 revealDateTime) external onlyOwner {
}
function setRevealDelay(uint256 revealDelay) external onlyOwner {
}
function setPresaleHours (uint256 presaleHours) external onlyOwner {
}
function setWhiteList(address[] memory whiteListAddress, bool bEnable) external onlyOwner {
}
function setMintPrice(uint256 presaleMintPrice, uint256 publicMintPrice) external onlyOwner {
}
function setMaxLimit(uint256 maxLimit) external onlyOwner {
}
function setPurchaseLimit(uint256 purchaseLimit, uint256 presaleMintLimit, uint256 publicMintLimit) external onlyOwner {
}
function PRICE(address addr) public view returns (uint256) {
}
function setRevealURI(string memory revealURI) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function airdrop(address to, uint256 numberOfTokens) external onlyOwner {
}
function purchase(uint256 numberOfTokens) external payable {
require(numberOfTokens <= PURCHASE_LIMIT,"Can only mint up to purchase limit");
require(<FILL_ME>)
if (msg.sender != owner()) {
_mappingMintCount[msg.sender] = _mappingMintCount[msg.sender] + numberOfTokens;
require(PRICE(msg.sender) * numberOfTokens <= msg.value,"ETH amount is not sufficient");
if (_mappingWhiteList[msg.sender] == false) {
require(block.timestamp > _activeDateTime,"Contract is not active");
require(_mappingMintCount[msg.sender] <= PUBLIC_MINT_LIMIT,"Overflow for PUBLIC_MINT_LIMIT");
} else {
if (block.timestamp < _activeDateTime) {
require(block.timestamp > _activeDateTime - PRESALE_HOURS,"Contract is not active for presale");
require(_mappingMintCount[msg.sender] <= PRESALE_MINT_LIMIT,"Overflow for PRESALE_MINT_LIMIT");
} else {
require(_mappingMintCount[msg.sender] <= PUBLIC_MINT_LIMIT + PRESALE_MINT_LIMIT,"Overflow for PUBLIC_MINT_LIMIT + PRESALE_MINT_LIMIT");
}
}
uint256 mainAmount = (msg.value * _MainFundPercent) / 100;
uint256 donationAmount = (msg.value * _DonationFundPercent) / 100;
uint256 treasuryAmount = (msg.value * _TreasuryFundPercent) / 100;
_MainAddress.transfer(mainAmount);
_DonationAddress.transfer(donationAmount);
_TreasuryAddress.transfer(treasuryAmount);
}
for (uint256 i = 0; i < numberOfTokens; i++) {
uint256 tokenId = _publicKST.current();
if (_publicKST.current() < KST_MAX) {
_publicKST.increment();
_safeMint(msg.sender, tokenId);
}
}
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory)
{
}
function withdraw() external onlyOwner {
}
}
| _publicKST.current()<KST_MAX,"Purchase would exceed KST_MAX" | 285,285 | _publicKST.current()<KST_MAX |
"ETH amount is not sufficient" | pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
}
pragma solidity ^0.8.0;
contract KingSolomon is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
address payable private _MainAddress;
address payable private _DonationAddress;
address payable private _TreasuryAddress;
uint256 private _MainFundPercent = 55;
uint256 private _DonationFundPercent = 33;
uint256 private _TreasuryFundPercent = 12;
uint256 public KST_MAX = 10000;
uint256 public PRESALE_PRICE = 0.087 ether;
uint256 public PUBLIC_PRICE = 0.087 ether;
uint256 private REVEAL_DELAY = 0 hours;
uint256 private PRESALE_HOURS = 0 hours;
uint256 public PURCHASE_LIMIT = 20;
uint256 public PRESALE_MINT_LIMIT = KST_MAX;
uint256 public PUBLIC_MINT_LIMIT = KST_MAX;
mapping(address => bool) _mappingWhiteList;
mapping(address => uint256) _mappingMintCount;
uint256 private _activeDateTime = 1643259600; // (GMT): Thursday, January 27, 2022 5:00:00 AM
uint256 private _revealDateTime;
string private _tokenBaseURI = "";
string private _revealURI = "";
Counters.Counter private _publicKST;
constructor() ERC721("King Solomon", "KST") {}
function setPaymentAddress(address mainAddress, address donationAddress, address treasuryAddress ) external onlyOwner {
}
function setPaymentPercent(uint256 mainPercent, uint256 donationPercent, uint256 treasuryPercent ) external onlyOwner {
}
function setActiveDateTime(uint256 activeDateTime, uint256 revealDateTime) external onlyOwner {
}
function setRevealDelay(uint256 revealDelay) external onlyOwner {
}
function setPresaleHours (uint256 presaleHours) external onlyOwner {
}
function setWhiteList(address[] memory whiteListAddress, bool bEnable) external onlyOwner {
}
function setMintPrice(uint256 presaleMintPrice, uint256 publicMintPrice) external onlyOwner {
}
function setMaxLimit(uint256 maxLimit) external onlyOwner {
}
function setPurchaseLimit(uint256 purchaseLimit, uint256 presaleMintLimit, uint256 publicMintLimit) external onlyOwner {
}
function PRICE(address addr) public view returns (uint256) {
}
function setRevealURI(string memory revealURI) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function airdrop(address to, uint256 numberOfTokens) external onlyOwner {
}
function purchase(uint256 numberOfTokens) external payable {
require(numberOfTokens <= PURCHASE_LIMIT,"Can only mint up to purchase limit");
require(_publicKST.current() < KST_MAX,"Purchase would exceed KST_MAX");
if (msg.sender != owner()) {
_mappingMintCount[msg.sender] = _mappingMintCount[msg.sender] + numberOfTokens;
require(<FILL_ME>)
if (_mappingWhiteList[msg.sender] == false) {
require(block.timestamp > _activeDateTime,"Contract is not active");
require(_mappingMintCount[msg.sender] <= PUBLIC_MINT_LIMIT,"Overflow for PUBLIC_MINT_LIMIT");
} else {
if (block.timestamp < _activeDateTime) {
require(block.timestamp > _activeDateTime - PRESALE_HOURS,"Contract is not active for presale");
require(_mappingMintCount[msg.sender] <= PRESALE_MINT_LIMIT,"Overflow for PRESALE_MINT_LIMIT");
} else {
require(_mappingMintCount[msg.sender] <= PUBLIC_MINT_LIMIT + PRESALE_MINT_LIMIT,"Overflow for PUBLIC_MINT_LIMIT + PRESALE_MINT_LIMIT");
}
}
uint256 mainAmount = (msg.value * _MainFundPercent) / 100;
uint256 donationAmount = (msg.value * _DonationFundPercent) / 100;
uint256 treasuryAmount = (msg.value * _TreasuryFundPercent) / 100;
_MainAddress.transfer(mainAmount);
_DonationAddress.transfer(donationAmount);
_TreasuryAddress.transfer(treasuryAmount);
}
for (uint256 i = 0; i < numberOfTokens; i++) {
uint256 tokenId = _publicKST.current();
if (_publicKST.current() < KST_MAX) {
_publicKST.increment();
_safeMint(msg.sender, tokenId);
}
}
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory)
{
}
function withdraw() external onlyOwner {
}
}
| PRICE(msg.sender)*numberOfTokens<=msg.value,"ETH amount is not sufficient" | 285,285 | PRICE(msg.sender)*numberOfTokens<=msg.value |
"Overflow for PUBLIC_MINT_LIMIT" | pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
}
pragma solidity ^0.8.0;
contract KingSolomon is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
address payable private _MainAddress;
address payable private _DonationAddress;
address payable private _TreasuryAddress;
uint256 private _MainFundPercent = 55;
uint256 private _DonationFundPercent = 33;
uint256 private _TreasuryFundPercent = 12;
uint256 public KST_MAX = 10000;
uint256 public PRESALE_PRICE = 0.087 ether;
uint256 public PUBLIC_PRICE = 0.087 ether;
uint256 private REVEAL_DELAY = 0 hours;
uint256 private PRESALE_HOURS = 0 hours;
uint256 public PURCHASE_LIMIT = 20;
uint256 public PRESALE_MINT_LIMIT = KST_MAX;
uint256 public PUBLIC_MINT_LIMIT = KST_MAX;
mapping(address => bool) _mappingWhiteList;
mapping(address => uint256) _mappingMintCount;
uint256 private _activeDateTime = 1643259600; // (GMT): Thursday, January 27, 2022 5:00:00 AM
uint256 private _revealDateTime;
string private _tokenBaseURI = "";
string private _revealURI = "";
Counters.Counter private _publicKST;
constructor() ERC721("King Solomon", "KST") {}
function setPaymentAddress(address mainAddress, address donationAddress, address treasuryAddress ) external onlyOwner {
}
function setPaymentPercent(uint256 mainPercent, uint256 donationPercent, uint256 treasuryPercent ) external onlyOwner {
}
function setActiveDateTime(uint256 activeDateTime, uint256 revealDateTime) external onlyOwner {
}
function setRevealDelay(uint256 revealDelay) external onlyOwner {
}
function setPresaleHours (uint256 presaleHours) external onlyOwner {
}
function setWhiteList(address[] memory whiteListAddress, bool bEnable) external onlyOwner {
}
function setMintPrice(uint256 presaleMintPrice, uint256 publicMintPrice) external onlyOwner {
}
function setMaxLimit(uint256 maxLimit) external onlyOwner {
}
function setPurchaseLimit(uint256 purchaseLimit, uint256 presaleMintLimit, uint256 publicMintLimit) external onlyOwner {
}
function PRICE(address addr) public view returns (uint256) {
}
function setRevealURI(string memory revealURI) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function airdrop(address to, uint256 numberOfTokens) external onlyOwner {
}
function purchase(uint256 numberOfTokens) external payable {
require(numberOfTokens <= PURCHASE_LIMIT,"Can only mint up to purchase limit");
require(_publicKST.current() < KST_MAX,"Purchase would exceed KST_MAX");
if (msg.sender != owner()) {
_mappingMintCount[msg.sender] = _mappingMintCount[msg.sender] + numberOfTokens;
require(PRICE(msg.sender) * numberOfTokens <= msg.value,"ETH amount is not sufficient");
if (_mappingWhiteList[msg.sender] == false) {
require(block.timestamp > _activeDateTime,"Contract is not active");
require(<FILL_ME>)
} else {
if (block.timestamp < _activeDateTime) {
require(block.timestamp > _activeDateTime - PRESALE_HOURS,"Contract is not active for presale");
require(_mappingMintCount[msg.sender] <= PRESALE_MINT_LIMIT,"Overflow for PRESALE_MINT_LIMIT");
} else {
require(_mappingMintCount[msg.sender] <= PUBLIC_MINT_LIMIT + PRESALE_MINT_LIMIT,"Overflow for PUBLIC_MINT_LIMIT + PRESALE_MINT_LIMIT");
}
}
uint256 mainAmount = (msg.value * _MainFundPercent) / 100;
uint256 donationAmount = (msg.value * _DonationFundPercent) / 100;
uint256 treasuryAmount = (msg.value * _TreasuryFundPercent) / 100;
_MainAddress.transfer(mainAmount);
_DonationAddress.transfer(donationAmount);
_TreasuryAddress.transfer(treasuryAmount);
}
for (uint256 i = 0; i < numberOfTokens; i++) {
uint256 tokenId = _publicKST.current();
if (_publicKST.current() < KST_MAX) {
_publicKST.increment();
_safeMint(msg.sender, tokenId);
}
}
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory)
{
}
function withdraw() external onlyOwner {
}
}
| _mappingMintCount[msg.sender]<=PUBLIC_MINT_LIMIT,"Overflow for PUBLIC_MINT_LIMIT" | 285,285 | _mappingMintCount[msg.sender]<=PUBLIC_MINT_LIMIT |
"Overflow for PRESALE_MINT_LIMIT" | pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
}
pragma solidity ^0.8.0;
contract KingSolomon is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
address payable private _MainAddress;
address payable private _DonationAddress;
address payable private _TreasuryAddress;
uint256 private _MainFundPercent = 55;
uint256 private _DonationFundPercent = 33;
uint256 private _TreasuryFundPercent = 12;
uint256 public KST_MAX = 10000;
uint256 public PRESALE_PRICE = 0.087 ether;
uint256 public PUBLIC_PRICE = 0.087 ether;
uint256 private REVEAL_DELAY = 0 hours;
uint256 private PRESALE_HOURS = 0 hours;
uint256 public PURCHASE_LIMIT = 20;
uint256 public PRESALE_MINT_LIMIT = KST_MAX;
uint256 public PUBLIC_MINT_LIMIT = KST_MAX;
mapping(address => bool) _mappingWhiteList;
mapping(address => uint256) _mappingMintCount;
uint256 private _activeDateTime = 1643259600; // (GMT): Thursday, January 27, 2022 5:00:00 AM
uint256 private _revealDateTime;
string private _tokenBaseURI = "";
string private _revealURI = "";
Counters.Counter private _publicKST;
constructor() ERC721("King Solomon", "KST") {}
function setPaymentAddress(address mainAddress, address donationAddress, address treasuryAddress ) external onlyOwner {
}
function setPaymentPercent(uint256 mainPercent, uint256 donationPercent, uint256 treasuryPercent ) external onlyOwner {
}
function setActiveDateTime(uint256 activeDateTime, uint256 revealDateTime) external onlyOwner {
}
function setRevealDelay(uint256 revealDelay) external onlyOwner {
}
function setPresaleHours (uint256 presaleHours) external onlyOwner {
}
function setWhiteList(address[] memory whiteListAddress, bool bEnable) external onlyOwner {
}
function setMintPrice(uint256 presaleMintPrice, uint256 publicMintPrice) external onlyOwner {
}
function setMaxLimit(uint256 maxLimit) external onlyOwner {
}
function setPurchaseLimit(uint256 purchaseLimit, uint256 presaleMintLimit, uint256 publicMintLimit) external onlyOwner {
}
function PRICE(address addr) public view returns (uint256) {
}
function setRevealURI(string memory revealURI) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function airdrop(address to, uint256 numberOfTokens) external onlyOwner {
}
function purchase(uint256 numberOfTokens) external payable {
require(numberOfTokens <= PURCHASE_LIMIT,"Can only mint up to purchase limit");
require(_publicKST.current() < KST_MAX,"Purchase would exceed KST_MAX");
if (msg.sender != owner()) {
_mappingMintCount[msg.sender] = _mappingMintCount[msg.sender] + numberOfTokens;
require(PRICE(msg.sender) * numberOfTokens <= msg.value,"ETH amount is not sufficient");
if (_mappingWhiteList[msg.sender] == false) {
require(block.timestamp > _activeDateTime,"Contract is not active");
require(_mappingMintCount[msg.sender] <= PUBLIC_MINT_LIMIT,"Overflow for PUBLIC_MINT_LIMIT");
} else {
if (block.timestamp < _activeDateTime) {
require(block.timestamp > _activeDateTime - PRESALE_HOURS,"Contract is not active for presale");
require(<FILL_ME>)
} else {
require(_mappingMintCount[msg.sender] <= PUBLIC_MINT_LIMIT + PRESALE_MINT_LIMIT,"Overflow for PUBLIC_MINT_LIMIT + PRESALE_MINT_LIMIT");
}
}
uint256 mainAmount = (msg.value * _MainFundPercent) / 100;
uint256 donationAmount = (msg.value * _DonationFundPercent) / 100;
uint256 treasuryAmount = (msg.value * _TreasuryFundPercent) / 100;
_MainAddress.transfer(mainAmount);
_DonationAddress.transfer(donationAmount);
_TreasuryAddress.transfer(treasuryAmount);
}
for (uint256 i = 0; i < numberOfTokens; i++) {
uint256 tokenId = _publicKST.current();
if (_publicKST.current() < KST_MAX) {
_publicKST.increment();
_safeMint(msg.sender, tokenId);
}
}
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory)
{
}
function withdraw() external onlyOwner {
}
}
| _mappingMintCount[msg.sender]<=PRESALE_MINT_LIMIT,"Overflow for PRESALE_MINT_LIMIT" | 285,285 | _mappingMintCount[msg.sender]<=PRESALE_MINT_LIMIT |
"Overflow for PUBLIC_MINT_LIMIT + PRESALE_MINT_LIMIT" | pragma solidity ^0.8.0;
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
* of elements in a mapping, issuing ERC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
*/
library Counters {
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
}
pragma solidity ^0.8.0;
contract KingSolomon is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
address payable private _MainAddress;
address payable private _DonationAddress;
address payable private _TreasuryAddress;
uint256 private _MainFundPercent = 55;
uint256 private _DonationFundPercent = 33;
uint256 private _TreasuryFundPercent = 12;
uint256 public KST_MAX = 10000;
uint256 public PRESALE_PRICE = 0.087 ether;
uint256 public PUBLIC_PRICE = 0.087 ether;
uint256 private REVEAL_DELAY = 0 hours;
uint256 private PRESALE_HOURS = 0 hours;
uint256 public PURCHASE_LIMIT = 20;
uint256 public PRESALE_MINT_LIMIT = KST_MAX;
uint256 public PUBLIC_MINT_LIMIT = KST_MAX;
mapping(address => bool) _mappingWhiteList;
mapping(address => uint256) _mappingMintCount;
uint256 private _activeDateTime = 1643259600; // (GMT): Thursday, January 27, 2022 5:00:00 AM
uint256 private _revealDateTime;
string private _tokenBaseURI = "";
string private _revealURI = "";
Counters.Counter private _publicKST;
constructor() ERC721("King Solomon", "KST") {}
function setPaymentAddress(address mainAddress, address donationAddress, address treasuryAddress ) external onlyOwner {
}
function setPaymentPercent(uint256 mainPercent, uint256 donationPercent, uint256 treasuryPercent ) external onlyOwner {
}
function setActiveDateTime(uint256 activeDateTime, uint256 revealDateTime) external onlyOwner {
}
function setRevealDelay(uint256 revealDelay) external onlyOwner {
}
function setPresaleHours (uint256 presaleHours) external onlyOwner {
}
function setWhiteList(address[] memory whiteListAddress, bool bEnable) external onlyOwner {
}
function setMintPrice(uint256 presaleMintPrice, uint256 publicMintPrice) external onlyOwner {
}
function setMaxLimit(uint256 maxLimit) external onlyOwner {
}
function setPurchaseLimit(uint256 purchaseLimit, uint256 presaleMintLimit, uint256 publicMintLimit) external onlyOwner {
}
function PRICE(address addr) public view returns (uint256) {
}
function setRevealURI(string memory revealURI) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function airdrop(address to, uint256 numberOfTokens) external onlyOwner {
}
function purchase(uint256 numberOfTokens) external payable {
require(numberOfTokens <= PURCHASE_LIMIT,"Can only mint up to purchase limit");
require(_publicKST.current() < KST_MAX,"Purchase would exceed KST_MAX");
if (msg.sender != owner()) {
_mappingMintCount[msg.sender] = _mappingMintCount[msg.sender] + numberOfTokens;
require(PRICE(msg.sender) * numberOfTokens <= msg.value,"ETH amount is not sufficient");
if (_mappingWhiteList[msg.sender] == false) {
require(block.timestamp > _activeDateTime,"Contract is not active");
require(_mappingMintCount[msg.sender] <= PUBLIC_MINT_LIMIT,"Overflow for PUBLIC_MINT_LIMIT");
} else {
if (block.timestamp < _activeDateTime) {
require(block.timestamp > _activeDateTime - PRESALE_HOURS,"Contract is not active for presale");
require(_mappingMintCount[msg.sender] <= PRESALE_MINT_LIMIT,"Overflow for PRESALE_MINT_LIMIT");
} else {
require(<FILL_ME>)
}
}
uint256 mainAmount = (msg.value * _MainFundPercent) / 100;
uint256 donationAmount = (msg.value * _DonationFundPercent) / 100;
uint256 treasuryAmount = (msg.value * _TreasuryFundPercent) / 100;
_MainAddress.transfer(mainAmount);
_DonationAddress.transfer(donationAmount);
_TreasuryAddress.transfer(treasuryAmount);
}
for (uint256 i = 0; i < numberOfTokens; i++) {
uint256 tokenId = _publicKST.current();
if (_publicKST.current() < KST_MAX) {
_publicKST.increment();
_safeMint(msg.sender, tokenId);
}
}
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory)
{
}
function withdraw() external onlyOwner {
}
}
| _mappingMintCount[msg.sender]<=PUBLIC_MINT_LIMIT+PRESALE_MINT_LIMIT,"Overflow for PUBLIC_MINT_LIMIT + PRESALE_MINT_LIMIT" | 285,285 | _mappingMintCount[msg.sender]<=PUBLIC_MINT_LIMIT+PRESALE_MINT_LIMIT |
null | // @title Rentals: Pluggable module for MEH contract responsible for rentout-rent operations.
// @dev this contract is unaware of xy block coordinates - ids only (ids are ERC721 tokens)
contract Rentals is MehModule {
// For MEH contract to be sure it plugged the right module in
bool public isRentals = true;
// Minimum rent period and a unit to measure rent lenght
uint public rentPeriod = 1 days;
// Maximum rent period (can be adjusted by admin)
uint public maxRentPeriod = 90; // can be changed in settings
// Rent deal struct. A 10x10 pixel block can have only one rent deal.
struct RentDeal {
address renter; // block renter
uint rentedFrom; // time when rent started
uint numberOfPeriods; //periods available
}
mapping(uint16 => RentDeal) public blockIdToRentDeal;
// Rent is allowed if price is > 0
mapping(uint16 => uint) public blockIdToRentPrice;
// Keeps track of rentout-rent operations
uint public numRentStatuses = 0;
// ** INITIALIZE ** //
/// @dev Initialize Rentals contract.
/// @param _mehAddress address of the main Million Ether Homepage contract
constructor(address _mehAddress) MehModule(_mehAddress) public {}
// ** RENT AOUT BLOCKS ** //
/// @dev Rent out a list of blocks referenced by block ids. Set rent price per period in wei.
function rentOutBlocks(address _landlord, uint _rentPricePerPeriodWei, uint16[] _blockList)
external
onlyMeh
whenNotPaused
returns (uint)
{
}
/// @dev Set rent price for a block. Independent on rent deal. Does not affect current
/// rent deal.
function rentOutBlock(uint16 _blockId, uint _rentPricePerPeriodWei)
internal
{
}
// ** RENT BLOCKS ** //
/// @dev Rent a list of blocks referenced by block ids for a number of periods.
function rentBlocks(address _renter, uint _numberOfPeriods, uint16[] _blockList)
external
onlyMeh
whenNotPaused
returns (uint)
{
}
/// @dev Rent a block by id for a number of periods.
function rentBlock (address _renter, uint16 _blockId, uint _numberOfPeriods)
internal
{
// check input
require(maxRentPeriod >= _numberOfPeriods);
address landlord = ownerOf(_blockId);
require(_renter != landlord);
// throws if not for rent (if rent price == 0)
require(<FILL_ME>)
// get price
uint totalRent = getRentPrice(_blockId).mul(_numberOfPeriods); // overflow safe
transferFunds(_renter, landlord, totalRent);
createRentDeal(_blockId, _renter, now, _numberOfPeriods);
}
/// @dev Checks if block is for rent.
function isForRent(uint16 _blockId) public view returns (bool) {
}
/// @dev Checks if block rented and the rent hasn't expired.
function isRented(uint16 _blockId) public view returns (bool) {
}
/// @dev Gets rent price for block. Throws if not for rent or if
/// current rent is active.
function getRentPrice(uint16 _blockId) internal view returns (uint) {
}
/// @dev Gets renter of a block. Throws if not rented.
function renterOf(uint16 _blockId) public view returns (address) {
}
/// @dev Creates new rent deal.
function createRentDeal(
uint16 _blockId,
address _renter,
uint _rentedFrom,
uint _numberOfPeriods
)
private
{
}
// ** RENT PRICE ** //
/// @dev Calculates rent price for a list of blocks. Throws if at least one block
/// is not available for rent.
function blocksRentPrice(uint _numberOfPeriods, uint16[] _blockList)
external
view
returns (uint)
{
}
// ** ADMIN ** //
/// @dev Adjusts max rent period (only contract owner)
function adminSetMaxRentPeriod(uint newMaxRentPeriod) external onlyOwner {
}
}
| isForRent(_blockId) | 285,296 | isForRent(_blockId) |
null | // @title Rentals: Pluggable module for MEH contract responsible for rentout-rent operations.
// @dev this contract is unaware of xy block coordinates - ids only (ids are ERC721 tokens)
contract Rentals is MehModule {
// For MEH contract to be sure it plugged the right module in
bool public isRentals = true;
// Minimum rent period and a unit to measure rent lenght
uint public rentPeriod = 1 days;
// Maximum rent period (can be adjusted by admin)
uint public maxRentPeriod = 90; // can be changed in settings
// Rent deal struct. A 10x10 pixel block can have only one rent deal.
struct RentDeal {
address renter; // block renter
uint rentedFrom; // time when rent started
uint numberOfPeriods; //periods available
}
mapping(uint16 => RentDeal) public blockIdToRentDeal;
// Rent is allowed if price is > 0
mapping(uint16 => uint) public blockIdToRentPrice;
// Keeps track of rentout-rent operations
uint public numRentStatuses = 0;
// ** INITIALIZE ** //
/// @dev Initialize Rentals contract.
/// @param _mehAddress address of the main Million Ether Homepage contract
constructor(address _mehAddress) MehModule(_mehAddress) public {}
// ** RENT AOUT BLOCKS ** //
/// @dev Rent out a list of blocks referenced by block ids. Set rent price per period in wei.
function rentOutBlocks(address _landlord, uint _rentPricePerPeriodWei, uint16[] _blockList)
external
onlyMeh
whenNotPaused
returns (uint)
{
}
/// @dev Set rent price for a block. Independent on rent deal. Does not affect current
/// rent deal.
function rentOutBlock(uint16 _blockId, uint _rentPricePerPeriodWei)
internal
{
}
// ** RENT BLOCKS ** //
/// @dev Rent a list of blocks referenced by block ids for a number of periods.
function rentBlocks(address _renter, uint _numberOfPeriods, uint16[] _blockList)
external
onlyMeh
whenNotPaused
returns (uint)
{
}
/// @dev Rent a block by id for a number of periods.
function rentBlock (address _renter, uint16 _blockId, uint _numberOfPeriods)
internal
{
}
/// @dev Checks if block is for rent.
function isForRent(uint16 _blockId) public view returns (bool) {
}
/// @dev Checks if block rented and the rent hasn't expired.
function isRented(uint16 _blockId) public view returns (bool) {
}
/// @dev Gets rent price for block. Throws if not for rent or if
/// current rent is active.
function getRentPrice(uint16 _blockId) internal view returns (uint) {
require(<FILL_ME>)
return blockIdToRentPrice[_blockId];
}
/// @dev Gets renter of a block. Throws if not rented.
function renterOf(uint16 _blockId) public view returns (address) {
}
/// @dev Creates new rent deal.
function createRentDeal(
uint16 _blockId,
address _renter,
uint _rentedFrom,
uint _numberOfPeriods
)
private
{
}
// ** RENT PRICE ** //
/// @dev Calculates rent price for a list of blocks. Throws if at least one block
/// is not available for rent.
function blocksRentPrice(uint _numberOfPeriods, uint16[] _blockList)
external
view
returns (uint)
{
}
// ** ADMIN ** //
/// @dev Adjusts max rent period (only contract owner)
function adminSetMaxRentPeriod(uint newMaxRentPeriod) external onlyOwner {
}
}
| !(isRented(_blockId)) | 285,296 | !(isRented(_blockId)) |
null | // @title Rentals: Pluggable module for MEH contract responsible for rentout-rent operations.
// @dev this contract is unaware of xy block coordinates - ids only (ids are ERC721 tokens)
contract Rentals is MehModule {
// For MEH contract to be sure it plugged the right module in
bool public isRentals = true;
// Minimum rent period and a unit to measure rent lenght
uint public rentPeriod = 1 days;
// Maximum rent period (can be adjusted by admin)
uint public maxRentPeriod = 90; // can be changed in settings
// Rent deal struct. A 10x10 pixel block can have only one rent deal.
struct RentDeal {
address renter; // block renter
uint rentedFrom; // time when rent started
uint numberOfPeriods; //periods available
}
mapping(uint16 => RentDeal) public blockIdToRentDeal;
// Rent is allowed if price is > 0
mapping(uint16 => uint) public blockIdToRentPrice;
// Keeps track of rentout-rent operations
uint public numRentStatuses = 0;
// ** INITIALIZE ** //
/// @dev Initialize Rentals contract.
/// @param _mehAddress address of the main Million Ether Homepage contract
constructor(address _mehAddress) MehModule(_mehAddress) public {}
// ** RENT AOUT BLOCKS ** //
/// @dev Rent out a list of blocks referenced by block ids. Set rent price per period in wei.
function rentOutBlocks(address _landlord, uint _rentPricePerPeriodWei, uint16[] _blockList)
external
onlyMeh
whenNotPaused
returns (uint)
{
}
/// @dev Set rent price for a block. Independent on rent deal. Does not affect current
/// rent deal.
function rentOutBlock(uint16 _blockId, uint _rentPricePerPeriodWei)
internal
{
}
// ** RENT BLOCKS ** //
/// @dev Rent a list of blocks referenced by block ids for a number of periods.
function rentBlocks(address _renter, uint _numberOfPeriods, uint16[] _blockList)
external
onlyMeh
whenNotPaused
returns (uint)
{
}
/// @dev Rent a block by id for a number of periods.
function rentBlock (address _renter, uint16 _blockId, uint _numberOfPeriods)
internal
{
}
/// @dev Checks if block is for rent.
function isForRent(uint16 _blockId) public view returns (bool) {
}
/// @dev Checks if block rented and the rent hasn't expired.
function isRented(uint16 _blockId) public view returns (bool) {
}
/// @dev Gets rent price for block. Throws if not for rent or if
/// current rent is active.
function getRentPrice(uint16 _blockId) internal view returns (uint) {
}
/// @dev Gets renter of a block. Throws if not rented.
function renterOf(uint16 _blockId) public view returns (address) {
require(<FILL_ME>)
return blockIdToRentDeal[_blockId].renter;
}
/// @dev Creates new rent deal.
function createRentDeal(
uint16 _blockId,
address _renter,
uint _rentedFrom,
uint _numberOfPeriods
)
private
{
}
// ** RENT PRICE ** //
/// @dev Calculates rent price for a list of blocks. Throws if at least one block
/// is not available for rent.
function blocksRentPrice(uint _numberOfPeriods, uint16[] _blockList)
external
view
returns (uint)
{
}
// ** ADMIN ** //
/// @dev Adjusts max rent period (only contract owner)
function adminSetMaxRentPeriod(uint newMaxRentPeriod) external onlyOwner {
}
}
| isRented(_blockId) | 285,296 | isRented(_blockId) |
"Target not Authorized" | // ███████╗░█████╗░██████╗░██████╗░███████╗██████╗░░░░███████╗██╗
// ╚════██║██╔══██╗██╔══██╗██╔══██╗██╔════╝██╔══██╗░░░██╔════╝██║
// ░░███╔═╝███████║██████╔╝██████╔╝█████╗░░██████╔╝░░░█████╗░░██║
// ██╔══╝░░██╔══██║██╔═══╝░██╔═══╝░██╔══╝░░██╔══██╗░░░██╔══╝░░██║
// ███████╗██║░░██║██║░░░░░██║░░░░░███████╗██║░░██║██╗██║░░░░░██║
// ╚══════╝╚═╝░░╚═╝╚═╝░░░░░╚═╝░░░░░╚══════╝╚═╝░░╚═╝╚═╝╚═╝░░░░░╚═╝
// Copyright (C) 2021 zapper
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// Visit <https://www.gnu.org/licenses/>for a copy of the GNU Affero General Public License
///@author Zapper
///@notice this contract implements one click removal of liquidity from UniswapV2 pools, receiving ETH, ERC20 or both.
// SPDX-License-Identifier: GPL-2.0
pragma solidity ^0.8.0;
import "../_base/ZapOutBaseV3.sol";
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
}
interface IUniswapV2Router02 {
function WETH() external pure returns (address);
function removeLiquidity(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
}
interface IUniswapV2Pair {
function token0() external pure returns (address);
function token1() external pure returns (address);
function balanceOf(address user) external view returns (uint256);
function totalSupply() external view returns (uint256);
function getReserves()
external
view
returns (
uint112 _reserve0,
uint112 _reserve1,
uint32 _blockTimestampLast
);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
}
interface IWETH {
function withdraw(uint256 wad) external;
}
contract UniswapV2_ZapOut_General_V5 is ZapOutBaseV3 {
using SafeERC20 for IERC20;
uint256 private constant deadline =
0xf000000000000000000000000000000000000000000000000000000000000000;
uint256 private constant permitAllowance = 79228162514260000000000000000;
IUniswapV2Router02 private constant uniswapV2Router =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IUniswapV2Factory private constant uniswapFactory =
IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
address private constant wethTokenAddress =
address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
constructor(uint256 _goodwill, uint256 _affiliateSplit)
ZapBaseV2(_goodwill, _affiliateSplit)
{
}
event zapOut(
address sender,
address pool,
address token,
uint256 tokensRec
);
/**
@notice Zap out in both tokens
@param fromPoolAddress Pool from which to remove liquidity
@param incomingLP Quantity of LP to remove from pool
@param affiliate Affiliate address
@return amountA Quantity of tokenA received after zapout
@return amountB Quantity of tokenB received after zapout
*/
function ZapOut2PairToken(
address fromPoolAddress,
uint256 incomingLP,
address affiliate
) public stopInEmergency returns (uint256 amountA, uint256 amountB) {
}
/**
@notice Zap out in a single token
@param toTokenAddress Address of desired token
@param fromPoolAddress Pool from which to remove liquidity
@param incomingLP Quantity of LP to remove from pool
@param minTokensRec Minimum quantity of tokens to receive
@param swapTargets Execution targets for swaps
@param swapData DEX swap data
@param affiliate Affiliate address
@param shouldSellEntireBalance If True transfers entrire allowable amount from another contract
*/
function ZapOut(
address toTokenAddress,
address fromPoolAddress,
uint256 incomingLP,
uint256 minTokensRec,
address[] memory swapTargets,
bytes[] memory swapData,
address affiliate,
bool shouldSellEntireBalance
) public stopInEmergency returns (uint256 tokensRec) {
}
/**
@notice Zap out in both tokens with permit
@param fromPoolAddress Pool from which to remove liquidity
@param incomingLP Quantity of LP to remove from pool
@param affiliate Affiliate address to share fees
@param permitSig Signature for permit
@return amountA Quantity of tokenA received
@return amountB Quantity of tokenB received
*/
function ZapOut2PairTokenWithPermit(
address fromPoolAddress,
uint256 incomingLP,
address affiliate,
bytes calldata permitSig
) external stopInEmergency returns (uint256 amountA, uint256 amountB) {
}
/**
@notice Zap out in a single token with permit
@param toTokenAddress Address of desired token
@param fromPoolAddress Pool from which to remove liquidity
@param incomingLP Quantity of LP to remove from pool
@param minTokensRec Minimum quantity of tokens to receive
@param permitSig Signature for permit
@param swapTargets Execution targets for swaps
@param swapData DEX swap data
@param affiliate Affiliate address
*/
function ZapOutWithPermit(
address toTokenAddress,
address fromPoolAddress,
uint256 incomingLP,
uint256 minTokensRec,
bytes calldata permitSig,
address[] memory swapTargets,
bytes[] memory swapData,
address affiliate
) public stopInEmergency returns (uint256) {
}
function _permit(
address fromPoolAddress,
uint256 amountIn,
bytes memory permitSig
) internal {
}
function _removeLiquidity(
address fromPoolAddress,
uint256 incomingLP,
bool shouldSellEntireBalance
) internal returns (uint256 amount0, uint256 amount1) {
}
function _swapTokens(
address fromPoolAddress,
uint256 amount0,
uint256 amount1,
address toToken,
address[] memory swapTargets,
bytes[] memory swapData
) internal returns (uint256 tokensBought) {
}
function _fillQuote(
address fromTokenAddress,
address toToken,
uint256 amount,
address swapTarget,
bytes memory swapData
) internal returns (uint256) {
if (fromTokenAddress == wethTokenAddress && toToken == address(0)) {
IWETH(wethTokenAddress).withdraw(amount);
return amount;
}
uint256 valueToSend;
if (fromTokenAddress == address(0)) {
valueToSend = amount;
} else {
_approveToken(fromTokenAddress, swapTarget, amount);
}
uint256 initialBalance = _getBalance(toToken);
require(<FILL_ME>)
(bool success, ) = swapTarget.call{ value: valueToSend }(swapData);
require(success, "Error Swapping Tokens");
uint256 finalBalance = _getBalance(toToken) - initialBalance;
require(finalBalance > 0, "Swapped to Invalid Intermediate");
return finalBalance;
}
/**
@notice Utility function to determine quantity and addresses of tokens being removed
@param fromPoolAddress Pool from which to remove liquidity
@param liquidity Quantity of LP tokens to remove.
@return amountA Quantity of tokenA removed
@return amountB Quantity of tokenB removed
@return token0 Address of the underlying token to be removed
@return token1 Address of the underlying token to be removed
*/
function removeLiquidityReturn(address fromPoolAddress, uint256 liquidity)
external
view
returns (
uint256 amountA,
uint256 amountB,
address token0,
address token1
)
{
}
}
| approvedTargets[swapTarget],"Target not Authorized" | 285,301 | approvedTargets[swapTarget] |
null | // SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.4;
abstract contract OwnableStatic {
mapping( address => bool ) private _isOwner;
constructor() {
}
modifier onlyOwner() {
require(<FILL_ME>)
_;
}
function _setOwner(address newOwner, bool makeOwner) private {
}
function setOwnerShip( address newOwner, bool makeOOwner ) external onlyOwner() returns ( bool success ) {
}
}
library AddressUtils {
function toString (address account) internal pure returns (string memory) {
}
function isContract (address account) internal view returns (bool) {
}
function sendValue (address payable account, uint amount) internal {
}
function functionCall (address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall (address target, bytes memory data, string memory error) internal returns (bytes memory) {
}
function functionCallWithValue (address target, bytes memory data, uint value) internal returns (bytes memory) {
}
function functionCallWithValue (address target, bytes memory data, uint value, string memory error) internal returns (bytes memory) {
}
function _functionCallWithValue (address target, bytes memory data, uint value, string memory error) private returns (bytes memory) {
}
}
interface IERC20 {
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply () external view returns (uint256);
function balanceOf (
address account
) external view returns (uint256);
function transfer (
address recipient,
uint256 amount
) external returns (bool);
function allowance (
address owner,
address spender
) external view returns (uint256);
function approve (
address spender,
uint256 amount
) external returns (bool);
function transferFrom (
address sender,
address recipient,
uint256 amount
) external returns (bool);
}
library SafeERC20 {
using AddressUtils for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
/**
* @dev safeApprove (like approve) should only be called when setting an initial allowance or when resetting it to zero; otherwise prefer safeIncreaseAllowance and safeDecreaseAllowance
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
/**
* @notice send transaction data and check validity of return value, if present
* @param token ERC20 token interface
* @param data transaction data
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
interface ILPLeverageLaunch {
function isTokenApprovedForLending( address lentToken ) external view returns ( bool );
function amountLoanedForLoanedTokenForLender( address holder, address lentTToken ) external view returns ( uint256 );
function totalLoanedForToken( address lentToken ) external view returns ( uint256 );
function launchTokenDueForHolder( address holder ) external view returns ( uint256 );
function setPreviousDepositSource( address newPreviousDepositSource ) external returns ( bool success );
function priceForLentToken( address lentToken ) external view returns ( uint256 );
function _weth9() external view returns ( address );
function fundManager() external view returns ( address );
function isActive() external view returns ( bool );
function changeActive( bool makeActive ) external returns ( bool success );
function setFundManager( address newFundManager ) external returns ( bool success );
function setWETH9( address weth9 ) external returns ( bool success );
function setPrice( address lentToken, uint256 price ) external returns ( bool success );
function dispenseToFundManager( address token ) external returns ( bool success );
function changeTokenLendingApproval( address newToken, bool isApproved ) external returns ( bool success );
function getTotalLoaned(address token ) external view returns (uint256 totalLoaned);
function lendLiquidity( address loanedToken, uint amount ) external returns ( bool success );
function getAmountDueToLender( address lender ) external view returns ( uint256 amountDue );
function lendETHLiquidity() external payable returns ( bool success );
function dispenseToFundManager() external returns ( bool success );
function setTotalEthLent( uint256 newValidEthBalance ) external returns ( bool success );
function getAmountLoaned( address lender, address lentToken ) external view returns ( uint256 amountLoaned );
}
contract LPLeverageLaunch is OwnableStatic, ILPLeverageLaunch {
using AddressUtils for address;
using SafeERC20 for IERC20;
mapping( address => bool ) public override isTokenApprovedForLending;
mapping( address => mapping( address => uint256 ) ) private _amountLoanedForLoanedTokenForLender;
mapping( address => uint256 ) private _totalLoanedForToken;
mapping( address => uint256 ) private _launchTokenDueForHolder;
mapping( address => uint256 ) public override priceForLentToken;
address public override _weth9;
address public override fundManager;
bool public override isActive;
address public previousDepoistSource;
modifier onlyActive() {
}
constructor() {}
function amountLoanedForLoanedTokenForLender( address holder, address lentToken ) external override view returns ( uint256 ) {
}
function totalLoanedForToken( address lentToken ) external override view returns ( uint256 ) {
}
function launchTokenDueForHolder( address holder ) external override view returns ( uint256 ) {
}
function setPreviousDepositSource( address newPreviousDepositSource ) external override onlyOwner() returns ( bool success ) {
}
function changeActive( bool makeActive ) external override onlyOwner() returns ( bool success ) {
}
function setFundManager( address newFundManager ) external override onlyOwner() returns ( bool success ) {
}
function setWETH9( address weth9 ) external override onlyOwner() returns ( bool success ) {
}
function setPrice( address lentToken, uint256 price ) external override onlyOwner() returns ( bool success ) {
}
function dispenseToFundManager( address token ) external override onlyOwner() returns ( bool success ) {
}
function _dispenseToFundManager( address token ) internal {
}
function changeTokenLendingApproval( address newToken, bool isApproved ) external override onlyOwner() returns ( bool success ) {
}
function getTotalLoaned(address token ) external override view returns (uint256 totalLoaned) {
}
/**
* @param loanedToken The address fo the token being paid. Ethereum is indicated with _weth9.
*/
function lendLiquidity( address loanedToken, uint amount ) external override onlyActive() returns ( bool success ) {
}
function getAmountDueToLender( address lender ) external override view returns ( uint256 amountDue ) {
}
function lendETHLiquidity() external override payable onlyActive() returns ( bool success ) {
}
function _lendETHLiquidity() internal {
}
function dispenseToFundManager() external override onlyOwner() returns ( bool success ) {
}
function setTotalEthLent( uint256 newValidEthBalance ) external override onlyOwner() returns ( bool success ) {
}
function getAmountLoaned( address lender, address lentToken ) external override view returns ( uint256 amountLoaned ) {
}
}
| _isOwner[msg.sender] | 285,434 | _isOwner[msg.sender] |
null | // SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.4;
abstract contract OwnableStatic {
mapping( address => bool ) private _isOwner;
constructor() {
}
modifier onlyOwner() {
}
function _setOwner(address newOwner, bool makeOwner) private {
}
function setOwnerShip( address newOwner, bool makeOOwner ) external onlyOwner() returns ( bool success ) {
}
}
library AddressUtils {
function toString (address account) internal pure returns (string memory) {
}
function isContract (address account) internal view returns (bool) {
}
function sendValue (address payable account, uint amount) internal {
}
function functionCall (address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall (address target, bytes memory data, string memory error) internal returns (bytes memory) {
}
function functionCallWithValue (address target, bytes memory data, uint value) internal returns (bytes memory) {
}
function functionCallWithValue (address target, bytes memory data, uint value, string memory error) internal returns (bytes memory) {
}
function _functionCallWithValue (address target, bytes memory data, uint value, string memory error) private returns (bytes memory) {
}
}
interface IERC20 {
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply () external view returns (uint256);
function balanceOf (
address account
) external view returns (uint256);
function transfer (
address recipient,
uint256 amount
) external returns (bool);
function allowance (
address owner,
address spender
) external view returns (uint256);
function approve (
address spender,
uint256 amount
) external returns (bool);
function transferFrom (
address sender,
address recipient,
uint256 amount
) external returns (bool);
}
library SafeERC20 {
using AddressUtils for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
/**
* @dev safeApprove (like approve) should only be called when setting an initial allowance or when resetting it to zero; otherwise prefer safeIncreaseAllowance and safeDecreaseAllowance
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
/**
* @notice send transaction data and check validity of return value, if present
* @param token ERC20 token interface
* @param data transaction data
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
interface ILPLeverageLaunch {
function isTokenApprovedForLending( address lentToken ) external view returns ( bool );
function amountLoanedForLoanedTokenForLender( address holder, address lentTToken ) external view returns ( uint256 );
function totalLoanedForToken( address lentToken ) external view returns ( uint256 );
function launchTokenDueForHolder( address holder ) external view returns ( uint256 );
function setPreviousDepositSource( address newPreviousDepositSource ) external returns ( bool success );
function priceForLentToken( address lentToken ) external view returns ( uint256 );
function _weth9() external view returns ( address );
function fundManager() external view returns ( address );
function isActive() external view returns ( bool );
function changeActive( bool makeActive ) external returns ( bool success );
function setFundManager( address newFundManager ) external returns ( bool success );
function setWETH9( address weth9 ) external returns ( bool success );
function setPrice( address lentToken, uint256 price ) external returns ( bool success );
function dispenseToFundManager( address token ) external returns ( bool success );
function changeTokenLendingApproval( address newToken, bool isApproved ) external returns ( bool success );
function getTotalLoaned(address token ) external view returns (uint256 totalLoaned);
function lendLiquidity( address loanedToken, uint amount ) external returns ( bool success );
function getAmountDueToLender( address lender ) external view returns ( uint256 amountDue );
function lendETHLiquidity() external payable returns ( bool success );
function dispenseToFundManager() external returns ( bool success );
function setTotalEthLent( uint256 newValidEthBalance ) external returns ( bool success );
function getAmountLoaned( address lender, address lentToken ) external view returns ( uint256 amountLoaned );
}
contract LPLeverageLaunch is OwnableStatic, ILPLeverageLaunch {
using AddressUtils for address;
using SafeERC20 for IERC20;
mapping( address => bool ) public override isTokenApprovedForLending;
mapping( address => mapping( address => uint256 ) ) private _amountLoanedForLoanedTokenForLender;
mapping( address => uint256 ) private _totalLoanedForToken;
mapping( address => uint256 ) private _launchTokenDueForHolder;
mapping( address => uint256 ) public override priceForLentToken;
address public override _weth9;
address public override fundManager;
bool public override isActive;
address public previousDepoistSource;
modifier onlyActive() {
}
constructor() {}
function amountLoanedForLoanedTokenForLender( address holder, address lentToken ) external override view returns ( uint256 ) {
}
function totalLoanedForToken( address lentToken ) external override view returns ( uint256 ) {
}
function launchTokenDueForHolder( address holder ) external override view returns ( uint256 ) {
}
function setPreviousDepositSource( address newPreviousDepositSource ) external override onlyOwner() returns ( bool success ) {
}
function changeActive( bool makeActive ) external override onlyOwner() returns ( bool success ) {
}
function setFundManager( address newFundManager ) external override onlyOwner() returns ( bool success ) {
}
function setWETH9( address weth9 ) external override onlyOwner() returns ( bool success ) {
}
function setPrice( address lentToken, uint256 price ) external override onlyOwner() returns ( bool success ) {
}
function dispenseToFundManager( address token ) external override onlyOwner() returns ( bool success ) {
}
function _dispenseToFundManager( address token ) internal {
}
function changeTokenLendingApproval( address newToken, bool isApproved ) external override onlyOwner() returns ( bool success ) {
}
function getTotalLoaned(address token ) external override view returns (uint256 totalLoaned) {
}
/**
* @param loanedToken The address fo the token being paid. Ethereum is indicated with _weth9.
*/
function lendLiquidity( address loanedToken, uint amount ) external override onlyActive() returns ( bool success ) {
require( fundManager != address(0) );
require(<FILL_ME>)
IERC20(loanedToken).safeTransferFrom( msg.sender, fundManager, amount );
_amountLoanedForLoanedTokenForLender[msg.sender][loanedToken] += amount;
_totalLoanedForToken[loanedToken] += amount;
_launchTokenDueForHolder[msg.sender] += (amount / priceForLentToken[loanedToken]);
success = true;
}
function getAmountDueToLender( address lender ) external override view returns ( uint256 amountDue ) {
}
function lendETHLiquidity() external override payable onlyActive() returns ( bool success ) {
}
function _lendETHLiquidity() internal {
}
function dispenseToFundManager() external override onlyOwner() returns ( bool success ) {
}
function setTotalEthLent( uint256 newValidEthBalance ) external override onlyOwner() returns ( bool success ) {
}
function getAmountLoaned( address lender, address lentToken ) external override view returns ( uint256 amountLoaned ) {
}
}
| isTokenApprovedForLending[loanedToken] | 285,434 | isTokenApprovedForLending[loanedToken] |
null | contract OncoToken is MintableToken, Pausable, FreezableToken, BurnableToken {
string constant public name = "ONCO";
string constant public symbol = "ONCO";
uint8 constant public decimals = 18;
/**
* @dev Empty OncoToken constructor
*/
function OncoToken() public {}
/**
* @dev Transfer token for a specified address with pause and freeze features for owner.
* @dev Only applies when the transfer is allowed by the owner.
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) whenNotPaused public returns (bool) {
}
/**
* @dev Transfer tokens from one address to another with pause and freeze features for owner.
* @dev Only applies when the transfer is allowed by the owner.
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool) {
require(!isFrozen(msg.sender));
require(<FILL_ME>)
super.transferFrom(_from, _to, _value);
}
}
| !isFrozen(_from) | 285,454 | !isFrozen(_from) |
"CREATE2 address mismatch" | // SPDX-License-Identifier: Apache-2.0
import "../Tranche.sol";
import "../interfaces/IWrappedPosition.sol";
import "../interfaces/IERC20.sol";
import "../interfaces/IInterestTokenFactory.sol";
import "../interfaces/IInterestToken.sol";
pragma solidity ^0.8.0;
/// @author Element Finance
/// @title Tranche Factory
contract TrancheFactory {
/// @dev An event to track tranche creations
/// @param trancheAddress the address of the tranche contract
/// @param wpAddress the address of the wrapped position
/// @param expiration the expiration time of the tranche
event TrancheCreated(
address indexed trancheAddress,
address indexed wpAddress,
uint256 indexed expiration
);
IInterestTokenFactory internal immutable _interestTokenFactory;
address internal _tempWpAddress;
uint256 internal _tempExpiration;
IInterestToken internal _tempInterestToken;
bytes32 public constant TRANCHE_CREATION_HASH =
keccak256(type(Tranche).creationCode);
// The address of our date library
address internal immutable _dateLibrary;
/// @notice Create a new Tranche.
/// @param _factory Address of the interest token factory.
constructor(address _factory, address dateLibrary) {
}
/// @notice Deploy a new Tranche contract.
/// @param _expiration The expiration timestamp for the tranche.
/// @param _wpAddress Address of the Wrapped Position contract the tranche will use.
/// @return The deployed Tranche contract.
function deployTranche(uint256 _expiration, address _wpAddress)
public
returns (Tranche)
{
_tempWpAddress = _wpAddress;
_tempExpiration = _expiration;
IWrappedPosition wpContract = IWrappedPosition(_wpAddress);
bytes32 salt = keccak256(abi.encodePacked(_wpAddress, _expiration));
string memory wpSymbol = wpContract.symbol();
IERC20 underlying = wpContract.token();
uint8 underlyingDecimals = underlying.decimals();
// derive the expected tranche address
address predictedAddress = address(
uint160(
uint256(
keccak256(
abi.encodePacked(
bytes1(0xff),
address(this),
salt,
TRANCHE_CREATION_HASH
)
)
)
)
);
_tempInterestToken = _interestTokenFactory.deployInterestToken(
predictedAddress,
wpSymbol,
_expiration,
underlyingDecimals
);
Tranche tranche = new Tranche{ salt: salt }();
emit TrancheCreated(address(tranche), _wpAddress, _expiration);
require(<FILL_ME>)
// set back to 0-value for some gas savings
delete _tempWpAddress;
delete _tempExpiration;
delete _tempInterestToken;
return tranche;
}
/// @notice Callback function called by the Tranche.
/// @dev This is called by the Tranche contract constructor.
/// The return data is used for Tranche initialization. Using this, the Tranche avoids
/// constructor arguments which can make the Tranche bytecode needed for create2 address
/// derivation non-constant.
/// @return Wrapped Position contract address, expiration timestamp, and interest token contract
function getData()
external
view
returns (
address,
uint256,
IInterestToken,
address
)
{
}
}
| address(tranche)==predictedAddress,"CREATE2 address mismatch" | 285,469 | address(tranche)==predictedAddress |
"Not enough tokens left." | pragma solidity ^0.8.0;
contract GodIsAWoman is ERC721, ERC721Enumerable, Ownable {
using SafeMath for uint256;
uint256 public constant maxSupply = 888;
uint256 private _price = 0.08 ether;
uint256 private _presalePrice = 0.05 ether;
uint256 private _maxReserved = 30;
uint256 private _reserved = 0;
bool private _saleStarted;
bool private _presaleStarted;
mapping(address => bool) private presaleWhitelistedMinters;
bytes32 public merkleRoot;
string public baseURI;
constructor() ERC721("God Is A Woman", "GIW") {
}
modifier whenSaleStarted() {
}
modifier whenPresaleStarted() {
}
function mint(uint256 _tokensNum) external payable whenSaleStarted {
uint256 supply = totalSupply();
require(_tokensNum <= 10, "You cannot mint more than 10 tokens at once!");
require(<FILL_ME>)
require(msg.value >= _tokensNum * _price, "Inconsistent amount sent!");
for (uint256 i; i < _tokensNum; i++) {
_safeMint(msg.sender, supply + i);
}
}
function mintPresale(bytes32[] calldata merkleProof) external payable whenPresaleStarted {
}
function claimReserved(uint256 _tokensNum, address _receiver) external onlyOwner {
}
function flipSaleStarted() external onlyOwner {
}
function flipPresaleStarted() external onlyOwner {
}
function saleStarted() public view returns(bool) {
}
function presaleStarted() public view returns(bool) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function _baseURI() internal view override(ERC721) returns(string memory) {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setPresalePrice(uint256 _newPrice) external onlyOwner {
}
function getPrice() public view returns(uint256) {
}
function getPresalePrice() public view returns(uint256) {
}
function getReservedLeft() public view returns(uint256) {
}
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
function withdraw() public onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| supply+_tokensNum<=maxSupply-_maxReserved,"Not enough tokens left." | 285,517 | supply+_tokensNum<=maxSupply-_maxReserved |
"Not enough tokens left." | pragma solidity ^0.8.0;
contract GodIsAWoman is ERC721, ERC721Enumerable, Ownable {
using SafeMath for uint256;
uint256 public constant maxSupply = 888;
uint256 private _price = 0.08 ether;
uint256 private _presalePrice = 0.05 ether;
uint256 private _maxReserved = 30;
uint256 private _reserved = 0;
bool private _saleStarted;
bool private _presaleStarted;
mapping(address => bool) private presaleWhitelistedMinters;
bytes32 public merkleRoot;
string public baseURI;
constructor() ERC721("God Is A Woman", "GIW") {
}
modifier whenSaleStarted() {
}
modifier whenPresaleStarted() {
}
function mint(uint256 _tokensNum) external payable whenSaleStarted {
}
function mintPresale(bytes32[] calldata merkleProof) external payable whenPresaleStarted {
uint256 supply = totalSupply();
require(MerkleProof.verify(merkleProof, merkleRoot, keccak256(abi.encodePacked(msg.sender)) ), "Invalid proof.");
require(<FILL_ME>)
require(msg.value >= _presalePrice, "Inconsistent amount sent!");
require(presaleWhitelistedMinters[msg.sender] == false, "You already claimed the whitelisted mint.");
presaleWhitelistedMinters[msg.sender] = true;
_safeMint(msg.sender, supply);
}
function claimReserved(uint256 _tokensNum, address _receiver) external onlyOwner {
}
function flipSaleStarted() external onlyOwner {
}
function flipPresaleStarted() external onlyOwner {
}
function saleStarted() public view returns(bool) {
}
function presaleStarted() public view returns(bool) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function _baseURI() internal view override(ERC721) returns(string memory) {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setPresalePrice(uint256 _newPrice) external onlyOwner {
}
function getPrice() public view returns(uint256) {
}
function getPresalePrice() public view returns(uint256) {
}
function getReservedLeft() public view returns(uint256) {
}
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
function withdraw() public onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| supply+1<=maxSupply-_maxReserved,"Not enough tokens left." | 285,517 | supply+1<=maxSupply-_maxReserved |
"You already claimed the whitelisted mint." | pragma solidity ^0.8.0;
contract GodIsAWoman is ERC721, ERC721Enumerable, Ownable {
using SafeMath for uint256;
uint256 public constant maxSupply = 888;
uint256 private _price = 0.08 ether;
uint256 private _presalePrice = 0.05 ether;
uint256 private _maxReserved = 30;
uint256 private _reserved = 0;
bool private _saleStarted;
bool private _presaleStarted;
mapping(address => bool) private presaleWhitelistedMinters;
bytes32 public merkleRoot;
string public baseURI;
constructor() ERC721("God Is A Woman", "GIW") {
}
modifier whenSaleStarted() {
}
modifier whenPresaleStarted() {
}
function mint(uint256 _tokensNum) external payable whenSaleStarted {
}
function mintPresale(bytes32[] calldata merkleProof) external payable whenPresaleStarted {
uint256 supply = totalSupply();
require(MerkleProof.verify(merkleProof, merkleRoot, keccak256(abi.encodePacked(msg.sender)) ), "Invalid proof.");
require(supply + 1 <= maxSupply - _maxReserved, "Not enough tokens left.");
require(msg.value >= _presalePrice, "Inconsistent amount sent!");
require(<FILL_ME>)
presaleWhitelistedMinters[msg.sender] = true;
_safeMint(msg.sender, supply);
}
function claimReserved(uint256 _tokensNum, address _receiver) external onlyOwner {
}
function flipSaleStarted() external onlyOwner {
}
function flipPresaleStarted() external onlyOwner {
}
function saleStarted() public view returns(bool) {
}
function presaleStarted() public view returns(bool) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function _baseURI() internal view override(ERC721) returns(string memory) {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setPresalePrice(uint256 _newPrice) external onlyOwner {
}
function getPrice() public view returns(uint256) {
}
function getPresalePrice() public view returns(uint256) {
}
function getReservedLeft() public view returns(uint256) {
}
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
function withdraw() public onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| presaleWhitelistedMinters[msg.sender]==false,"You already claimed the whitelisted mint." | 285,517 | presaleWhitelistedMinters[msg.sender]==false |
"That would exceed the max reserved." | pragma solidity ^0.8.0;
contract GodIsAWoman is ERC721, ERC721Enumerable, Ownable {
using SafeMath for uint256;
uint256 public constant maxSupply = 888;
uint256 private _price = 0.08 ether;
uint256 private _presalePrice = 0.05 ether;
uint256 private _maxReserved = 30;
uint256 private _reserved = 0;
bool private _saleStarted;
bool private _presaleStarted;
mapping(address => bool) private presaleWhitelistedMinters;
bytes32 public merkleRoot;
string public baseURI;
constructor() ERC721("God Is A Woman", "GIW") {
}
modifier whenSaleStarted() {
}
modifier whenPresaleStarted() {
}
function mint(uint256 _tokensNum) external payable whenSaleStarted {
}
function mintPresale(bytes32[] calldata merkleProof) external payable whenPresaleStarted {
}
function claimReserved(uint256 _tokensNum, address _receiver) external onlyOwner {
uint256 supply = totalSupply();
require(<FILL_ME>)
for (uint256 i; i < _tokensNum; i++) {
_safeMint(_receiver, supply + i);
}
_reserved = _reserved + _tokensNum;
}
function flipSaleStarted() external onlyOwner {
}
function flipPresaleStarted() external onlyOwner {
}
function saleStarted() public view returns(bool) {
}
function presaleStarted() public view returns(bool) {
}
function setBaseURI(string memory _URI) external onlyOwner {
}
function _baseURI() internal view override(ERC721) returns(string memory) {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setPresalePrice(uint256 _newPrice) external onlyOwner {
}
function getPrice() public view returns(uint256) {
}
function getPresalePrice() public view returns(uint256) {
}
function getReservedLeft() public view returns(uint256) {
}
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
function withdraw() public onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| _reserved+_tokensNum<=_maxReserved,"That would exceed the max reserved." | 285,517 | _reserved+_tokensNum<=_maxReserved |
null | pragma solidity ^0.4.24;
import "./SafeMath.sol";
import "./Ownable.sol";
import "./BasicERC20.sol";
contract BasicCrowdsale is Ownable
{
using SafeMath for uint256;
BasicERC20 token;
address public ownerWallet;
uint256 public startTime;
uint256 public endTime;
uint256 public totalEtherRaised = 0;
uint256 public minDepositAmount;
uint256 public maxDepositAmount;
uint256 public softCapEther;
uint256 public hardCapEther;
mapping(address => uint256) private deposits;
constructor () public {
}
function () external payable {
}
function getSettings () view public returns(uint256 _startTime,
uint256 _endTime,
uint256 _rate,
uint256 _totalEtherRaised,
uint256 _minDepositAmount,
uint256 _maxDepositAmount,
uint256 _tokensLeft ) {
}
function tokensLeft() view public returns (uint256)
{
}
function changeMinDepositAmount (uint256 _minDepositAmount) onlyOwner public {
}
function changeMaxDepositAmount (uint256 _maxDepositAmount) onlyOwner public {
}
function getRate() view public returns (uint256) {
}
function getTokenAmount(uint256 weiAmount) public view returns(uint256) {
}
function checkCorrectPurchase() view internal {
require(startTime < now && now < endTime);
require(msg.value >= minDepositAmount);
require(msg.value < maxDepositAmount);
require(<FILL_ME>)
}
function isCrowdsaleFinished() view public returns(bool)
{
}
function buy(address userAddress) public payable {
}
function getRefundAmount(address userAddress) view public returns (uint256)
{
}
function refund(address userAddress) public
{
}
}
| totalEtherRaised+msg.value<hardCapEther | 285,597 | totalEtherRaised+msg.value<hardCapEther |
"Sender is not authorized" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/// @title Celestial Key
contract CelestialKey is Ownable, Pausable, ERC721A("Celestial Key", "CKEY") {
using Strings for uint256;
using MerkleProof for bytes32[];
/// @notice Max total supply.
uint256 public constant CKEY_MAX = 4444;
/// @notice Max transaction amount.
uint256 public constant CKEY_PER_TX = 5;
/// @notice Max transaction amount in early access.
uint256 public constant CKEY_PER_TX_EARLY = 2;
/// @notice Early claim price.
uint256 public constant CKEY_EARLY_PRICE = 0.044 ether;
/// @notice Public claim price.
uint256 public constant CKEY_PRICE = 0.088 ether;
/// @notice 0 = FREE, 1 = EARLY, 2 = PUBLIC
uint256 public saleState;
/// @notice Metadata baseURI.
string public baseURI;
/// @notice Metadata unrevealed uri.
string public unrevealedURI;
/// @notice Metadata baseURI extension.
string public baseExtension;
/// @notice OpenSea proxy registry.
address public opensea = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
/// @notice LooksRare marketplace transfer manager.
address public looksrare = 0x3f65A762F15D01809cDC6B43d8849fF24949c86a;
/// @notice Check if marketplaces pre-approve is enabled.
bool public marketplacesApproved = true;
/// @notice Free claim merkle root.
bytes32 public freeClaimRoot;
/// @notice Early access merkle root.
bytes32 public earlyAccessRoot;
/// @notice Amount minted by address on free mint.
mapping(address => uint256) public freeClaimed;
/// @notice Amount minted by address on early access.
mapping(address => uint256) public earlyClaimed;
///@notice Amount mintes by address on public mint.
mapping(address => uint256) public publicClaimed;
/// @notice Authorized callers mapping.
mapping(address => bool) public auth;
/// @notice Require the sender to be the owner() or authorized.
modifier onlyAuth() {
require(<FILL_ME>)
_;
}
constructor(
string memory newUnrevealedURI,
bytes32 freeClaimRoot_,
bytes32 earlyAccessRoot_
) {
}
/// @notice Claim one free token.
function claimFree(bytes32[] memory proof) external {
}
/// @notice Claim one or more tokens for whitelisted user.
function claimEarly(uint256 amount, bytes32[] memory proof) external payable {
}
/// @notice Claim one or more tokens.
function claim(uint256 amount) external payable {
}
/// @notice See {IERC721-tokenURI}.
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
/// @notice Set baseURI to `newBaseURI`, baseExtension to `newBaseExtension` and deletes unrevealedURI, triggering a reveal.
function setBaseURI(string memory newBaseURI, string memory newBaseExtension) external onlyOwner {
}
/// @notice Set unrevealedURI to `newUnrevealedURI`.
function setUnrevealedURI(string memory newUnrevealedURI) external onlyOwner {
}
/// @notice Set unrevealedURI to `newUnrevealedURI`.
function setSaleState(uint256 newSaleState) external onlyOwner {
}
/// @notice Set freeClaimRoot to `newMerkleRoot`.
function setFreeClaimRoot(bytes32 newMerkleRoot) external onlyOwner {
}
/// @notice Set earlyAccessRoot to `newMerkleRoot`.
function setEarlyAccessRoot(bytes32 newMerkleRoot) external onlyOwner {
}
/// @notice Set opensea to `newOpensea`.
function setOpensea(address newOpensea) external onlyOwner {
}
/// @notice Set looksrare to `newLooksrare`.
function setLooksrare(address newLooksrare) external onlyOwner {
}
/// @notice Set `addresses` authorization to `authorized`.
function setAuth(address[] calldata addresses, bool authorized) external onlyOwner {
}
/// @notice Toggle marketplaces pre-approve feature.
function toggleMarketplacesApproved() external onlyOwner {
}
/// @notice Toggle paused state.
function togglePaused() external onlyOwner {
}
/// @notice Withdraw `amount` of ether to msg.sender.
function withdraw(uint256 amount) external onlyOwner {
}
/// @notice Withdraw `amount` of `token` to the sender.
function withdrawERC20(IERC20 token, uint256 amount) external onlyOwner {
}
/// @notice Withdraw `tokenId` of `token` to the sender.
function withdrawERC721(IERC721 token, uint256 tokenId) external onlyOwner {
}
/// @notice Withdraw `tokenId` with amount of `value` from `token` to the sender.
function withdrawERC1155(
IERC1155 token,
uint256 tokenId,
uint256 value
) external onlyOwner {
}
/// @notice See {ERC721-isApprovedForAll}.
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
/// @notice See {ERC721A-_beforeTokenTransfers}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| auth[msg.sender],"Sender is not authorized" | 285,670 | auth[msg.sender] |
"User already minted a free token" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/// @title Celestial Key
contract CelestialKey is Ownable, Pausable, ERC721A("Celestial Key", "CKEY") {
using Strings for uint256;
using MerkleProof for bytes32[];
/// @notice Max total supply.
uint256 public constant CKEY_MAX = 4444;
/// @notice Max transaction amount.
uint256 public constant CKEY_PER_TX = 5;
/// @notice Max transaction amount in early access.
uint256 public constant CKEY_PER_TX_EARLY = 2;
/// @notice Early claim price.
uint256 public constant CKEY_EARLY_PRICE = 0.044 ether;
/// @notice Public claim price.
uint256 public constant CKEY_PRICE = 0.088 ether;
/// @notice 0 = FREE, 1 = EARLY, 2 = PUBLIC
uint256 public saleState;
/// @notice Metadata baseURI.
string public baseURI;
/// @notice Metadata unrevealed uri.
string public unrevealedURI;
/// @notice Metadata baseURI extension.
string public baseExtension;
/// @notice OpenSea proxy registry.
address public opensea = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
/// @notice LooksRare marketplace transfer manager.
address public looksrare = 0x3f65A762F15D01809cDC6B43d8849fF24949c86a;
/// @notice Check if marketplaces pre-approve is enabled.
bool public marketplacesApproved = true;
/// @notice Free claim merkle root.
bytes32 public freeClaimRoot;
/// @notice Early access merkle root.
bytes32 public earlyAccessRoot;
/// @notice Amount minted by address on free mint.
mapping(address => uint256) public freeClaimed;
/// @notice Amount minted by address on early access.
mapping(address => uint256) public earlyClaimed;
///@notice Amount mintes by address on public mint.
mapping(address => uint256) public publicClaimed;
/// @notice Authorized callers mapping.
mapping(address => bool) public auth;
/// @notice Require the sender to be the owner() or authorized.
modifier onlyAuth() {
}
constructor(
string memory newUnrevealedURI,
bytes32 freeClaimRoot_,
bytes32 earlyAccessRoot_
) {
}
/// @notice Claim one free token.
function claimFree(bytes32[] memory proof) external {
if (msg.sender != owner()) {
require(saleState == 0, "Invalid sale state");
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(proof.verify(freeClaimRoot, leaf), "Invalid proof");
}
freeClaimed[msg.sender]++;
_safeMint(msg.sender, 1);
}
/// @notice Claim one or more tokens for whitelisted user.
function claimEarly(uint256 amount, bytes32[] memory proof) external payable {
}
/// @notice Claim one or more tokens.
function claim(uint256 amount) external payable {
}
/// @notice See {IERC721-tokenURI}.
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
/// @notice Set baseURI to `newBaseURI`, baseExtension to `newBaseExtension` and deletes unrevealedURI, triggering a reveal.
function setBaseURI(string memory newBaseURI, string memory newBaseExtension) external onlyOwner {
}
/// @notice Set unrevealedURI to `newUnrevealedURI`.
function setUnrevealedURI(string memory newUnrevealedURI) external onlyOwner {
}
/// @notice Set unrevealedURI to `newUnrevealedURI`.
function setSaleState(uint256 newSaleState) external onlyOwner {
}
/// @notice Set freeClaimRoot to `newMerkleRoot`.
function setFreeClaimRoot(bytes32 newMerkleRoot) external onlyOwner {
}
/// @notice Set earlyAccessRoot to `newMerkleRoot`.
function setEarlyAccessRoot(bytes32 newMerkleRoot) external onlyOwner {
}
/// @notice Set opensea to `newOpensea`.
function setOpensea(address newOpensea) external onlyOwner {
}
/// @notice Set looksrare to `newLooksrare`.
function setLooksrare(address newLooksrare) external onlyOwner {
}
/// @notice Set `addresses` authorization to `authorized`.
function setAuth(address[] calldata addresses, bool authorized) external onlyOwner {
}
/// @notice Toggle marketplaces pre-approve feature.
function toggleMarketplacesApproved() external onlyOwner {
}
/// @notice Toggle paused state.
function togglePaused() external onlyOwner {
}
/// @notice Withdraw `amount` of ether to msg.sender.
function withdraw(uint256 amount) external onlyOwner {
}
/// @notice Withdraw `amount` of `token` to the sender.
function withdrawERC20(IERC20 token, uint256 amount) external onlyOwner {
}
/// @notice Withdraw `tokenId` of `token` to the sender.
function withdrawERC721(IERC721 token, uint256 tokenId) external onlyOwner {
}
/// @notice Withdraw `tokenId` with amount of `value` from `token` to the sender.
function withdrawERC1155(
IERC1155 token,
uint256 tokenId,
uint256 value
) external onlyOwner {
}
/// @notice See {ERC721-isApprovedForAll}.
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
/// @notice See {ERC721A-_beforeTokenTransfers}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| freeClaimed[msg.sender]==0,"User already minted a free token" | 285,670 | freeClaimed[msg.sender]==0 |
"Invalid proof" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/// @title Celestial Key
contract CelestialKey is Ownable, Pausable, ERC721A("Celestial Key", "CKEY") {
using Strings for uint256;
using MerkleProof for bytes32[];
/// @notice Max total supply.
uint256 public constant CKEY_MAX = 4444;
/// @notice Max transaction amount.
uint256 public constant CKEY_PER_TX = 5;
/// @notice Max transaction amount in early access.
uint256 public constant CKEY_PER_TX_EARLY = 2;
/// @notice Early claim price.
uint256 public constant CKEY_EARLY_PRICE = 0.044 ether;
/// @notice Public claim price.
uint256 public constant CKEY_PRICE = 0.088 ether;
/// @notice 0 = FREE, 1 = EARLY, 2 = PUBLIC
uint256 public saleState;
/// @notice Metadata baseURI.
string public baseURI;
/// @notice Metadata unrevealed uri.
string public unrevealedURI;
/// @notice Metadata baseURI extension.
string public baseExtension;
/// @notice OpenSea proxy registry.
address public opensea = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
/// @notice LooksRare marketplace transfer manager.
address public looksrare = 0x3f65A762F15D01809cDC6B43d8849fF24949c86a;
/// @notice Check if marketplaces pre-approve is enabled.
bool public marketplacesApproved = true;
/// @notice Free claim merkle root.
bytes32 public freeClaimRoot;
/// @notice Early access merkle root.
bytes32 public earlyAccessRoot;
/// @notice Amount minted by address on free mint.
mapping(address => uint256) public freeClaimed;
/// @notice Amount minted by address on early access.
mapping(address => uint256) public earlyClaimed;
///@notice Amount mintes by address on public mint.
mapping(address => uint256) public publicClaimed;
/// @notice Authorized callers mapping.
mapping(address => bool) public auth;
/// @notice Require the sender to be the owner() or authorized.
modifier onlyAuth() {
}
constructor(
string memory newUnrevealedURI,
bytes32 freeClaimRoot_,
bytes32 earlyAccessRoot_
) {
}
/// @notice Claim one free token.
function claimFree(bytes32[] memory proof) external {
if (msg.sender != owner()) {
require(saleState == 0, "Invalid sale state");
require(freeClaimed[msg.sender] == 0, "User already minted a free token");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
}
freeClaimed[msg.sender]++;
_safeMint(msg.sender, 1);
}
/// @notice Claim one or more tokens for whitelisted user.
function claimEarly(uint256 amount, bytes32[] memory proof) external payable {
}
/// @notice Claim one or more tokens.
function claim(uint256 amount) external payable {
}
/// @notice See {IERC721-tokenURI}.
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
/// @notice Set baseURI to `newBaseURI`, baseExtension to `newBaseExtension` and deletes unrevealedURI, triggering a reveal.
function setBaseURI(string memory newBaseURI, string memory newBaseExtension) external onlyOwner {
}
/// @notice Set unrevealedURI to `newUnrevealedURI`.
function setUnrevealedURI(string memory newUnrevealedURI) external onlyOwner {
}
/// @notice Set unrevealedURI to `newUnrevealedURI`.
function setSaleState(uint256 newSaleState) external onlyOwner {
}
/// @notice Set freeClaimRoot to `newMerkleRoot`.
function setFreeClaimRoot(bytes32 newMerkleRoot) external onlyOwner {
}
/// @notice Set earlyAccessRoot to `newMerkleRoot`.
function setEarlyAccessRoot(bytes32 newMerkleRoot) external onlyOwner {
}
/// @notice Set opensea to `newOpensea`.
function setOpensea(address newOpensea) external onlyOwner {
}
/// @notice Set looksrare to `newLooksrare`.
function setLooksrare(address newLooksrare) external onlyOwner {
}
/// @notice Set `addresses` authorization to `authorized`.
function setAuth(address[] calldata addresses, bool authorized) external onlyOwner {
}
/// @notice Toggle marketplaces pre-approve feature.
function toggleMarketplacesApproved() external onlyOwner {
}
/// @notice Toggle paused state.
function togglePaused() external onlyOwner {
}
/// @notice Withdraw `amount` of ether to msg.sender.
function withdraw(uint256 amount) external onlyOwner {
}
/// @notice Withdraw `amount` of `token` to the sender.
function withdrawERC20(IERC20 token, uint256 amount) external onlyOwner {
}
/// @notice Withdraw `tokenId` of `token` to the sender.
function withdrawERC721(IERC721 token, uint256 tokenId) external onlyOwner {
}
/// @notice Withdraw `tokenId` with amount of `value` from `token` to the sender.
function withdrawERC1155(
IERC1155 token,
uint256 tokenId,
uint256 value
) external onlyOwner {
}
/// @notice See {ERC721-isApprovedForAll}.
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
/// @notice See {ERC721A-_beforeTokenTransfers}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| proof.verify(freeClaimRoot,leaf),"Invalid proof" | 285,670 | proof.verify(freeClaimRoot,leaf) |
"Invalid proof" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/// @title Celestial Key
contract CelestialKey is Ownable, Pausable, ERC721A("Celestial Key", "CKEY") {
using Strings for uint256;
using MerkleProof for bytes32[];
/// @notice Max total supply.
uint256 public constant CKEY_MAX = 4444;
/// @notice Max transaction amount.
uint256 public constant CKEY_PER_TX = 5;
/// @notice Max transaction amount in early access.
uint256 public constant CKEY_PER_TX_EARLY = 2;
/// @notice Early claim price.
uint256 public constant CKEY_EARLY_PRICE = 0.044 ether;
/// @notice Public claim price.
uint256 public constant CKEY_PRICE = 0.088 ether;
/// @notice 0 = FREE, 1 = EARLY, 2 = PUBLIC
uint256 public saleState;
/// @notice Metadata baseURI.
string public baseURI;
/// @notice Metadata unrevealed uri.
string public unrevealedURI;
/// @notice Metadata baseURI extension.
string public baseExtension;
/// @notice OpenSea proxy registry.
address public opensea = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
/// @notice LooksRare marketplace transfer manager.
address public looksrare = 0x3f65A762F15D01809cDC6B43d8849fF24949c86a;
/// @notice Check if marketplaces pre-approve is enabled.
bool public marketplacesApproved = true;
/// @notice Free claim merkle root.
bytes32 public freeClaimRoot;
/// @notice Early access merkle root.
bytes32 public earlyAccessRoot;
/// @notice Amount minted by address on free mint.
mapping(address => uint256) public freeClaimed;
/// @notice Amount minted by address on early access.
mapping(address => uint256) public earlyClaimed;
///@notice Amount mintes by address on public mint.
mapping(address => uint256) public publicClaimed;
/// @notice Authorized callers mapping.
mapping(address => bool) public auth;
/// @notice Require the sender to be the owner() or authorized.
modifier onlyAuth() {
}
constructor(
string memory newUnrevealedURI,
bytes32 freeClaimRoot_,
bytes32 earlyAccessRoot_
) {
}
/// @notice Claim one free token.
function claimFree(bytes32[] memory proof) external {
}
/// @notice Claim one or more tokens for whitelisted user.
function claimEarly(uint256 amount, bytes32[] memory proof) external payable {
if (msg.sender != owner()) {
require(saleState == 1, "Invalid sale state");
require(amount > 0 && amount + earlyClaimed[msg.sender] <= CKEY_PER_TX_EARLY, "Invalid claim amount");
require(msg.value == CKEY_EARLY_PRICE * amount, "Invalid ether amount");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
}
earlyClaimed[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
/// @notice Claim one or more tokens.
function claim(uint256 amount) external payable {
}
/// @notice See {IERC721-tokenURI}.
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
/// @notice Set baseURI to `newBaseURI`, baseExtension to `newBaseExtension` and deletes unrevealedURI, triggering a reveal.
function setBaseURI(string memory newBaseURI, string memory newBaseExtension) external onlyOwner {
}
/// @notice Set unrevealedURI to `newUnrevealedURI`.
function setUnrevealedURI(string memory newUnrevealedURI) external onlyOwner {
}
/// @notice Set unrevealedURI to `newUnrevealedURI`.
function setSaleState(uint256 newSaleState) external onlyOwner {
}
/// @notice Set freeClaimRoot to `newMerkleRoot`.
function setFreeClaimRoot(bytes32 newMerkleRoot) external onlyOwner {
}
/// @notice Set earlyAccessRoot to `newMerkleRoot`.
function setEarlyAccessRoot(bytes32 newMerkleRoot) external onlyOwner {
}
/// @notice Set opensea to `newOpensea`.
function setOpensea(address newOpensea) external onlyOwner {
}
/// @notice Set looksrare to `newLooksrare`.
function setLooksrare(address newLooksrare) external onlyOwner {
}
/// @notice Set `addresses` authorization to `authorized`.
function setAuth(address[] calldata addresses, bool authorized) external onlyOwner {
}
/// @notice Toggle marketplaces pre-approve feature.
function toggleMarketplacesApproved() external onlyOwner {
}
/// @notice Toggle paused state.
function togglePaused() external onlyOwner {
}
/// @notice Withdraw `amount` of ether to msg.sender.
function withdraw(uint256 amount) external onlyOwner {
}
/// @notice Withdraw `amount` of `token` to the sender.
function withdrawERC20(IERC20 token, uint256 amount) external onlyOwner {
}
/// @notice Withdraw `tokenId` of `token` to the sender.
function withdrawERC721(IERC721 token, uint256 tokenId) external onlyOwner {
}
/// @notice Withdraw `tokenId` with amount of `value` from `token` to the sender.
function withdrawERC1155(
IERC1155 token,
uint256 tokenId,
uint256 value
) external onlyOwner {
}
/// @notice See {ERC721-isApprovedForAll}.
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
/// @notice See {ERC721A-_beforeTokenTransfers}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| proof.verify(earlyAccessRoot,leaf),"Invalid proof" | 285,670 | proof.verify(earlyAccessRoot,leaf) |
"Max supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/// @title Celestial Key
contract CelestialKey is Ownable, Pausable, ERC721A("Celestial Key", "CKEY") {
using Strings for uint256;
using MerkleProof for bytes32[];
/// @notice Max total supply.
uint256 public constant CKEY_MAX = 4444;
/// @notice Max transaction amount.
uint256 public constant CKEY_PER_TX = 5;
/// @notice Max transaction amount in early access.
uint256 public constant CKEY_PER_TX_EARLY = 2;
/// @notice Early claim price.
uint256 public constant CKEY_EARLY_PRICE = 0.044 ether;
/// @notice Public claim price.
uint256 public constant CKEY_PRICE = 0.088 ether;
/// @notice 0 = FREE, 1 = EARLY, 2 = PUBLIC
uint256 public saleState;
/// @notice Metadata baseURI.
string public baseURI;
/// @notice Metadata unrevealed uri.
string public unrevealedURI;
/// @notice Metadata baseURI extension.
string public baseExtension;
/// @notice OpenSea proxy registry.
address public opensea = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
/// @notice LooksRare marketplace transfer manager.
address public looksrare = 0x3f65A762F15D01809cDC6B43d8849fF24949c86a;
/// @notice Check if marketplaces pre-approve is enabled.
bool public marketplacesApproved = true;
/// @notice Free claim merkle root.
bytes32 public freeClaimRoot;
/// @notice Early access merkle root.
bytes32 public earlyAccessRoot;
/// @notice Amount minted by address on free mint.
mapping(address => uint256) public freeClaimed;
/// @notice Amount minted by address on early access.
mapping(address => uint256) public earlyClaimed;
///@notice Amount mintes by address on public mint.
mapping(address => uint256) public publicClaimed;
/// @notice Authorized callers mapping.
mapping(address => bool) public auth;
/// @notice Require the sender to be the owner() or authorized.
modifier onlyAuth() {
}
constructor(
string memory newUnrevealedURI,
bytes32 freeClaimRoot_,
bytes32 earlyAccessRoot_
) {
}
/// @notice Claim one free token.
function claimFree(bytes32[] memory proof) external {
}
/// @notice Claim one or more tokens for whitelisted user.
function claimEarly(uint256 amount, bytes32[] memory proof) external payable {
}
/// @notice Claim one or more tokens.
function claim(uint256 amount) external payable {
require(<FILL_ME>)
if (msg.sender != owner()) {
require(saleState == 2, "Invalid sale state");
require(amount > 0 && amount + publicClaimed[msg.sender] <= CKEY_PER_TX, "Invalid claim amount");
require(msg.value == CKEY_PRICE * amount, "Invalid ether amount");
}
publicClaimed[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
/// @notice See {IERC721-tokenURI}.
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
/// @notice Set baseURI to `newBaseURI`, baseExtension to `newBaseExtension` and deletes unrevealedURI, triggering a reveal.
function setBaseURI(string memory newBaseURI, string memory newBaseExtension) external onlyOwner {
}
/// @notice Set unrevealedURI to `newUnrevealedURI`.
function setUnrevealedURI(string memory newUnrevealedURI) external onlyOwner {
}
/// @notice Set unrevealedURI to `newUnrevealedURI`.
function setSaleState(uint256 newSaleState) external onlyOwner {
}
/// @notice Set freeClaimRoot to `newMerkleRoot`.
function setFreeClaimRoot(bytes32 newMerkleRoot) external onlyOwner {
}
/// @notice Set earlyAccessRoot to `newMerkleRoot`.
function setEarlyAccessRoot(bytes32 newMerkleRoot) external onlyOwner {
}
/// @notice Set opensea to `newOpensea`.
function setOpensea(address newOpensea) external onlyOwner {
}
/// @notice Set looksrare to `newLooksrare`.
function setLooksrare(address newLooksrare) external onlyOwner {
}
/// @notice Set `addresses` authorization to `authorized`.
function setAuth(address[] calldata addresses, bool authorized) external onlyOwner {
}
/// @notice Toggle marketplaces pre-approve feature.
function toggleMarketplacesApproved() external onlyOwner {
}
/// @notice Toggle paused state.
function togglePaused() external onlyOwner {
}
/// @notice Withdraw `amount` of ether to msg.sender.
function withdraw(uint256 amount) external onlyOwner {
}
/// @notice Withdraw `amount` of `token` to the sender.
function withdrawERC20(IERC20 token, uint256 amount) external onlyOwner {
}
/// @notice Withdraw `tokenId` of `token` to the sender.
function withdrawERC721(IERC721 token, uint256 tokenId) external onlyOwner {
}
/// @notice Withdraw `tokenId` with amount of `value` from `token` to the sender.
function withdrawERC1155(
IERC1155 token,
uint256 tokenId,
uint256 value
) external onlyOwner {
}
/// @notice See {ERC721-isApprovedForAll}.
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
}
/// @notice See {ERC721A-_beforeTokenTransfers}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| totalSupply()+amount<=CKEY_MAX,"Max supply exceeded" | 285,670 | totalSupply()+amount<=CKEY_MAX |
"User is already registered." | // .__ .__ .__ __ .__
// _____| |__ ____ | | | | _____ _____ _/ |________|__|__ ___
// / ___/ | \_/ __ \| | | | / \\__ \\ __\_ __ \ \ \/ /
// \___ \| Y \ ___/| |_| |__ | Y Y \/ __ \| | | | \/ |> <
// /____ >___| /\___ >____/____/ |__|_| (____ /__| |__| |__/__/\_ \
// \/ \/ \/ \/ \/ \/
//
// .-. .-. .-.
// : : : : : :
// .--. : `-. .--. : : : : .--. .--. .--.
// `._-.': .. :' '_.': :_ : :_ _ ' .; :: ..'' .; :
// `.__.':_;:_;`.__.'`.__;`.__;:_;`.__.':_; `._. ;
// .-. :
// `._.'
//
pragma solidity >=0.5.0 <0.6.0;
interface USDT {
function balanceOf(address who) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function transfer(address to, uint value) external;
function transferFrom(address from, address to, uint value) external;
}
/*
* @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.
*/
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
contract ShellBase is Context {
struct X3 {
uint uplineID;
uint[] partners;
uint reinvestCount;
uint missed;
uint totalPartners;
bool active;
}
struct X6 {
uint uplineID;
uint[] firstLevelPartners;
uint[] secondLevelPartners;
uint[] thirdLevelPartners;
uint reinvestCount;
uint missed;
uint totalPartners;
bool active;
}
struct User {
uint id;
uint referrerId;
uint contribution;
uint earned;
address wallet;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
USDT public usdt;
address public owner;
uint public totalUser;
uint public totalEarned;
uint8 public MAX_LEVEL;
mapping(uint => User) public users;
mapping(address => uint) public ids;
mapping(uint8 => uint) public levelPrices;
event Registration(address indexed user, address indexed referrer, uint userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, uint caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewPartner(address indexed referrer, uint userID, uint8 matrix, uint8 level, uint8 place);
event MissPartner(address indexed referrer, uint userID, uint8 matrix, uint8 level);
event SendDividends(address indexed from, address indexed to, uint payer, uint8 matrix, uint8 level);
function isRegistered(address _user) public view returns (bool) {
}
function isValidID(uint _userID) public view returns (bool) {
}
function getUserWallet(uint _userID) public view returns (address) {
}
function getReferrerID(uint _userID) public view returns (uint) {
}
function getReferrerWallet(uint _userID) public view returns (address) {
}
function getUserContribution(uint _userID) public view returns (uint) {
}
function getUserX3Level(uint _userID) public view returns (uint8) {
}
function getUserX6Level(uint _userID) public view returns (uint8) {
}
function getUserX3Matrix(uint _userID, uint8 _level) public view returns (uint, uint, uint, uint, bool) {
}
function getUserX6Matrix(uint _userID, uint8 _level) public view returns (uint, uint, uint, uint, bool) {
}
function getUserX3Partners(uint _userID, uint8 _level) public view returns (uint[] memory) {
}
function getUserX6Partners(uint _userID, uint8 _level) public view returns (uint[] memory, uint[] memory, uint[] memory) {
}
}
contract Shell is ShellBase {
constructor(address _owner, address _tether) public {
}
function() external payable {
}
function register(uint _referrerID) external {
require(<FILL_ME>)
require(isValidID(_referrerID), "Referrer ID is invalid.");
require(usdt.allowance(_msgSender(), address(this)) >= levelPrices[2], "Registration fee exceeds USDT allowance!");
_register(_msgSender(), _referrerID);
}
function upgrade(uint8 _matrix) external {
}
function _register(address _userAddress, uint _referrerID) private {
}
function _upgrade(uint8 _matrix) private {
}
function _upgradeX3(uint _userID, uint8 _level) private {
}
function _upgradeX6(uint _userID, uint8 _level) private {
}
function _getX3Upline(uint _userID, uint _referrerID, uint8 _level) private returns(uint) {
}
function _getX6Upline(uint _userID, uint _referrerID, uint8 _level) private returns(uint) {
}
function _placeUserToX3(uint _userID, uint _upline, uint8 _level) private {
}
function _placeUserToX6(uint _userID, uint _upline, uint8 _level) private {
}
function _placeToX6(uint _userID, uint _upline, uint8 _level) private {
}
function _sendDividends(uint _from, uint _to, uint8 _matrix, uint8 _level) private {
}
}
| !isRegistered(_msgSender()),"User is already registered." | 285,679 | !isRegistered(_msgSender()) |
"Referrer ID is invalid." | // .__ .__ .__ __ .__
// _____| |__ ____ | | | | _____ _____ _/ |________|__|__ ___
// / ___/ | \_/ __ \| | | | / \\__ \\ __\_ __ \ \ \/ /
// \___ \| Y \ ___/| |_| |__ | Y Y \/ __ \| | | | \/ |> <
// /____ >___| /\___ >____/____/ |__|_| (____ /__| |__| |__/__/\_ \
// \/ \/ \/ \/ \/ \/
//
// .-. .-. .-.
// : : : : : :
// .--. : `-. .--. : : : : .--. .--. .--.
// `._-.': .. :' '_.': :_ : :_ _ ' .; :: ..'' .; :
// `.__.':_;:_;`.__.'`.__;`.__;:_;`.__.':_; `._. ;
// .-. :
// `._.'
//
pragma solidity >=0.5.0 <0.6.0;
interface USDT {
function balanceOf(address who) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function transfer(address to, uint value) external;
function transferFrom(address from, address to, uint value) external;
}
/*
* @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.
*/
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
contract ShellBase is Context {
struct X3 {
uint uplineID;
uint[] partners;
uint reinvestCount;
uint missed;
uint totalPartners;
bool active;
}
struct X6 {
uint uplineID;
uint[] firstLevelPartners;
uint[] secondLevelPartners;
uint[] thirdLevelPartners;
uint reinvestCount;
uint missed;
uint totalPartners;
bool active;
}
struct User {
uint id;
uint referrerId;
uint contribution;
uint earned;
address wallet;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
USDT public usdt;
address public owner;
uint public totalUser;
uint public totalEarned;
uint8 public MAX_LEVEL;
mapping(uint => User) public users;
mapping(address => uint) public ids;
mapping(uint8 => uint) public levelPrices;
event Registration(address indexed user, address indexed referrer, uint userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, uint caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewPartner(address indexed referrer, uint userID, uint8 matrix, uint8 level, uint8 place);
event MissPartner(address indexed referrer, uint userID, uint8 matrix, uint8 level);
event SendDividends(address indexed from, address indexed to, uint payer, uint8 matrix, uint8 level);
function isRegistered(address _user) public view returns (bool) {
}
function isValidID(uint _userID) public view returns (bool) {
}
function getUserWallet(uint _userID) public view returns (address) {
}
function getReferrerID(uint _userID) public view returns (uint) {
}
function getReferrerWallet(uint _userID) public view returns (address) {
}
function getUserContribution(uint _userID) public view returns (uint) {
}
function getUserX3Level(uint _userID) public view returns (uint8) {
}
function getUserX6Level(uint _userID) public view returns (uint8) {
}
function getUserX3Matrix(uint _userID, uint8 _level) public view returns (uint, uint, uint, uint, bool) {
}
function getUserX6Matrix(uint _userID, uint8 _level) public view returns (uint, uint, uint, uint, bool) {
}
function getUserX3Partners(uint _userID, uint8 _level) public view returns (uint[] memory) {
}
function getUserX6Partners(uint _userID, uint8 _level) public view returns (uint[] memory, uint[] memory, uint[] memory) {
}
}
contract Shell is ShellBase {
constructor(address _owner, address _tether) public {
}
function() external payable {
}
function register(uint _referrerID) external {
require(!isRegistered(_msgSender()), "User is already registered.");
require(<FILL_ME>)
require(usdt.allowance(_msgSender(), address(this)) >= levelPrices[2], "Registration fee exceeds USDT allowance!");
_register(_msgSender(), _referrerID);
}
function upgrade(uint8 _matrix) external {
}
function _register(address _userAddress, uint _referrerID) private {
}
function _upgrade(uint8 _matrix) private {
}
function _upgradeX3(uint _userID, uint8 _level) private {
}
function _upgradeX6(uint _userID, uint8 _level) private {
}
function _getX3Upline(uint _userID, uint _referrerID, uint8 _level) private returns(uint) {
}
function _getX6Upline(uint _userID, uint _referrerID, uint8 _level) private returns(uint) {
}
function _placeUserToX3(uint _userID, uint _upline, uint8 _level) private {
}
function _placeUserToX6(uint _userID, uint _upline, uint8 _level) private {
}
function _placeToX6(uint _userID, uint _upline, uint8 _level) private {
}
function _sendDividends(uint _from, uint _to, uint8 _matrix, uint8 _level) private {
}
}
| isValidID(_referrerID),"Referrer ID is invalid." | 285,679 | isValidID(_referrerID) |
"Registration fee exceeds USDT allowance!" | // .__ .__ .__ __ .__
// _____| |__ ____ | | | | _____ _____ _/ |________|__|__ ___
// / ___/ | \_/ __ \| | | | / \\__ \\ __\_ __ \ \ \/ /
// \___ \| Y \ ___/| |_| |__ | Y Y \/ __ \| | | | \/ |> <
// /____ >___| /\___ >____/____/ |__|_| (____ /__| |__| |__/__/\_ \
// \/ \/ \/ \/ \/ \/
//
// .-. .-. .-.
// : : : : : :
// .--. : `-. .--. : : : : .--. .--. .--.
// `._-.': .. :' '_.': :_ : :_ _ ' .; :: ..'' .; :
// `.__.':_;:_;`.__.'`.__;`.__;:_;`.__.':_; `._. ;
// .-. :
// `._.'
//
pragma solidity >=0.5.0 <0.6.0;
interface USDT {
function balanceOf(address who) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function transfer(address to, uint value) external;
function transferFrom(address from, address to, uint value) external;
}
/*
* @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.
*/
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
contract ShellBase is Context {
struct X3 {
uint uplineID;
uint[] partners;
uint reinvestCount;
uint missed;
uint totalPartners;
bool active;
}
struct X6 {
uint uplineID;
uint[] firstLevelPartners;
uint[] secondLevelPartners;
uint[] thirdLevelPartners;
uint reinvestCount;
uint missed;
uint totalPartners;
bool active;
}
struct User {
uint id;
uint referrerId;
uint contribution;
uint earned;
address wallet;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
USDT public usdt;
address public owner;
uint public totalUser;
uint public totalEarned;
uint8 public MAX_LEVEL;
mapping(uint => User) public users;
mapping(address => uint) public ids;
mapping(uint8 => uint) public levelPrices;
event Registration(address indexed user, address indexed referrer, uint userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, uint caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewPartner(address indexed referrer, uint userID, uint8 matrix, uint8 level, uint8 place);
event MissPartner(address indexed referrer, uint userID, uint8 matrix, uint8 level);
event SendDividends(address indexed from, address indexed to, uint payer, uint8 matrix, uint8 level);
function isRegistered(address _user) public view returns (bool) {
}
function isValidID(uint _userID) public view returns (bool) {
}
function getUserWallet(uint _userID) public view returns (address) {
}
function getReferrerID(uint _userID) public view returns (uint) {
}
function getReferrerWallet(uint _userID) public view returns (address) {
}
function getUserContribution(uint _userID) public view returns (uint) {
}
function getUserX3Level(uint _userID) public view returns (uint8) {
}
function getUserX6Level(uint _userID) public view returns (uint8) {
}
function getUserX3Matrix(uint _userID, uint8 _level) public view returns (uint, uint, uint, uint, bool) {
}
function getUserX6Matrix(uint _userID, uint8 _level) public view returns (uint, uint, uint, uint, bool) {
}
function getUserX3Partners(uint _userID, uint8 _level) public view returns (uint[] memory) {
}
function getUserX6Partners(uint _userID, uint8 _level) public view returns (uint[] memory, uint[] memory, uint[] memory) {
}
}
contract Shell is ShellBase {
constructor(address _owner, address _tether) public {
}
function() external payable {
}
function register(uint _referrerID) external {
require(!isRegistered(_msgSender()), "User is already registered.");
require(isValidID(_referrerID), "Referrer ID is invalid.");
require(<FILL_ME>)
_register(_msgSender(), _referrerID);
}
function upgrade(uint8 _matrix) external {
}
function _register(address _userAddress, uint _referrerID) private {
}
function _upgrade(uint8 _matrix) private {
}
function _upgradeX3(uint _userID, uint8 _level) private {
}
function _upgradeX6(uint _userID, uint8 _level) private {
}
function _getX3Upline(uint _userID, uint _referrerID, uint8 _level) private returns(uint) {
}
function _getX6Upline(uint _userID, uint _referrerID, uint8 _level) private returns(uint) {
}
function _placeUserToX3(uint _userID, uint _upline, uint8 _level) private {
}
function _placeUserToX6(uint _userID, uint _upline, uint8 _level) private {
}
function _placeToX6(uint _userID, uint _upline, uint8 _level) private {
}
function _sendDividends(uint _from, uint _to, uint8 _matrix, uint8 _level) private {
}
}
| usdt.allowance(_msgSender(),address(this))>=levelPrices[2],"Registration fee exceeds USDT allowance!" | 285,679 | usdt.allowance(_msgSender(),address(this))>=levelPrices[2] |
"User is not registered." | // .__ .__ .__ __ .__
// _____| |__ ____ | | | | _____ _____ _/ |________|__|__ ___
// / ___/ | \_/ __ \| | | | / \\__ \\ __\_ __ \ \ \/ /
// \___ \| Y \ ___/| |_| |__ | Y Y \/ __ \| | | | \/ |> <
// /____ >___| /\___ >____/____/ |__|_| (____ /__| |__| |__/__/\_ \
// \/ \/ \/ \/ \/ \/
//
// .-. .-. .-.
// : : : : : :
// .--. : `-. .--. : : : : .--. .--. .--.
// `._-.': .. :' '_.': :_ : :_ _ ' .; :: ..'' .; :
// `.__.':_;:_;`.__.'`.__;`.__;:_;`.__.':_; `._. ;
// .-. :
// `._.'
//
pragma solidity >=0.5.0 <0.6.0;
interface USDT {
function balanceOf(address who) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function transfer(address to, uint value) external;
function transferFrom(address from, address to, uint value) external;
}
/*
* @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.
*/
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
contract ShellBase is Context {
struct X3 {
uint uplineID;
uint[] partners;
uint reinvestCount;
uint missed;
uint totalPartners;
bool active;
}
struct X6 {
uint uplineID;
uint[] firstLevelPartners;
uint[] secondLevelPartners;
uint[] thirdLevelPartners;
uint reinvestCount;
uint missed;
uint totalPartners;
bool active;
}
struct User {
uint id;
uint referrerId;
uint contribution;
uint earned;
address wallet;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
USDT public usdt;
address public owner;
uint public totalUser;
uint public totalEarned;
uint8 public MAX_LEVEL;
mapping(uint => User) public users;
mapping(address => uint) public ids;
mapping(uint8 => uint) public levelPrices;
event Registration(address indexed user, address indexed referrer, uint userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, uint caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewPartner(address indexed referrer, uint userID, uint8 matrix, uint8 level, uint8 place);
event MissPartner(address indexed referrer, uint userID, uint8 matrix, uint8 level);
event SendDividends(address indexed from, address indexed to, uint payer, uint8 matrix, uint8 level);
function isRegistered(address _user) public view returns (bool) {
}
function isValidID(uint _userID) public view returns (bool) {
}
function getUserWallet(uint _userID) public view returns (address) {
}
function getReferrerID(uint _userID) public view returns (uint) {
}
function getReferrerWallet(uint _userID) public view returns (address) {
}
function getUserContribution(uint _userID) public view returns (uint) {
}
function getUserX3Level(uint _userID) public view returns (uint8) {
}
function getUserX6Level(uint _userID) public view returns (uint8) {
}
function getUserX3Matrix(uint _userID, uint8 _level) public view returns (uint, uint, uint, uint, bool) {
}
function getUserX6Matrix(uint _userID, uint8 _level) public view returns (uint, uint, uint, uint, bool) {
}
function getUserX3Partners(uint _userID, uint8 _level) public view returns (uint[] memory) {
}
function getUserX6Partners(uint _userID, uint8 _level) public view returns (uint[] memory, uint[] memory, uint[] memory) {
}
}
contract Shell is ShellBase {
constructor(address _owner, address _tether) public {
}
function() external payable {
}
function register(uint _referrerID) external {
}
function upgrade(uint8 _matrix) external {
require(<FILL_ME>)
_upgrade(_matrix);
}
function _register(address _userAddress, uint _referrerID) private {
}
function _upgrade(uint8 _matrix) private {
}
function _upgradeX3(uint _userID, uint8 _level) private {
}
function _upgradeX6(uint _userID, uint8 _level) private {
}
function _getX3Upline(uint _userID, uint _referrerID, uint8 _level) private returns(uint) {
}
function _getX6Upline(uint _userID, uint _referrerID, uint8 _level) private returns(uint) {
}
function _placeUserToX3(uint _userID, uint _upline, uint8 _level) private {
}
function _placeUserToX6(uint _userID, uint _upline, uint8 _level) private {
}
function _placeToX6(uint _userID, uint _upline, uint8 _level) private {
}
function _sendDividends(uint _from, uint _to, uint8 _matrix, uint8 _level) private {
}
}
| isRegistered(_msgSender()),"User is not registered." | 285,679 | isRegistered(_msgSender()) |
"Upgrading fee exceeds USDT allowance!" | // .__ .__ .__ __ .__
// _____| |__ ____ | | | | _____ _____ _/ |________|__|__ ___
// / ___/ | \_/ __ \| | | | / \\__ \\ __\_ __ \ \ \/ /
// \___ \| Y \ ___/| |_| |__ | Y Y \/ __ \| | | | \/ |> <
// /____ >___| /\___ >____/____/ |__|_| (____ /__| |__| |__/__/\_ \
// \/ \/ \/ \/ \/ \/
//
// .-. .-. .-.
// : : : : : :
// .--. : `-. .--. : : : : .--. .--. .--.
// `._-.': .. :' '_.': :_ : :_ _ ' .; :: ..'' .; :
// `.__.':_;:_;`.__.'`.__;`.__;:_;`.__.':_; `._. ;
// .-. :
// `._.'
//
pragma solidity >=0.5.0 <0.6.0;
interface USDT {
function balanceOf(address who) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function transfer(address to, uint value) external;
function transferFrom(address from, address to, uint value) external;
}
/*
* @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.
*/
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
contract ShellBase is Context {
struct X3 {
uint uplineID;
uint[] partners;
uint reinvestCount;
uint missed;
uint totalPartners;
bool active;
}
struct X6 {
uint uplineID;
uint[] firstLevelPartners;
uint[] secondLevelPartners;
uint[] thirdLevelPartners;
uint reinvestCount;
uint missed;
uint totalPartners;
bool active;
}
struct User {
uint id;
uint referrerId;
uint contribution;
uint earned;
address wallet;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
USDT public usdt;
address public owner;
uint public totalUser;
uint public totalEarned;
uint8 public MAX_LEVEL;
mapping(uint => User) public users;
mapping(address => uint) public ids;
mapping(uint8 => uint) public levelPrices;
event Registration(address indexed user, address indexed referrer, uint userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, uint caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewPartner(address indexed referrer, uint userID, uint8 matrix, uint8 level, uint8 place);
event MissPartner(address indexed referrer, uint userID, uint8 matrix, uint8 level);
event SendDividends(address indexed from, address indexed to, uint payer, uint8 matrix, uint8 level);
function isRegistered(address _user) public view returns (bool) {
}
function isValidID(uint _userID) public view returns (bool) {
}
function getUserWallet(uint _userID) public view returns (address) {
}
function getReferrerID(uint _userID) public view returns (uint) {
}
function getReferrerWallet(uint _userID) public view returns (address) {
}
function getUserContribution(uint _userID) public view returns (uint) {
}
function getUserX3Level(uint _userID) public view returns (uint8) {
}
function getUserX6Level(uint _userID) public view returns (uint8) {
}
function getUserX3Matrix(uint _userID, uint8 _level) public view returns (uint, uint, uint, uint, bool) {
}
function getUserX6Matrix(uint _userID, uint8 _level) public view returns (uint, uint, uint, uint, bool) {
}
function getUserX3Partners(uint _userID, uint8 _level) public view returns (uint[] memory) {
}
function getUserX6Partners(uint _userID, uint8 _level) public view returns (uint[] memory, uint[] memory, uint[] memory) {
}
}
contract Shell is ShellBase {
constructor(address _owner, address _tether) public {
}
function() external payable {
}
function register(uint _referrerID) external {
}
function upgrade(uint8 _matrix) external {
}
function _register(address _userAddress, uint _referrerID) private {
}
function _upgrade(uint8 _matrix) private {
uint8 _level = MAX_LEVEL;
uint _userID = ids[_msgSender()];
if (_matrix==3) {
_level = getUserX3Level(_userID);
} else if (_matrix==6) {
_level = getUserX6Level(_userID);
} else {
revert("Something is wrong!");
}
_level++;
require(_level>1 && _level<=MAX_LEVEL, "Invalid level, can not upgrade!");
require(<FILL_ME>)
if (_matrix==3) {
_upgradeX3(_userID, _level);
} else if (_matrix==6) {
_upgradeX6(_userID, _level);
} else {
revert("Something is wrong!");
}
}
function _upgradeX3(uint _userID, uint8 _level) private {
}
function _upgradeX6(uint _userID, uint8 _level) private {
}
function _getX3Upline(uint _userID, uint _referrerID, uint8 _level) private returns(uint) {
}
function _getX6Upline(uint _userID, uint _referrerID, uint8 _level) private returns(uint) {
}
function _placeUserToX3(uint _userID, uint _upline, uint8 _level) private {
}
function _placeUserToX6(uint _userID, uint _upline, uint8 _level) private {
}
function _placeToX6(uint _userID, uint _upline, uint8 _level) private {
}
function _sendDividends(uint _from, uint _to, uint8 _matrix, uint8 _level) private {
}
}
| usdt.allowance(_msgSender(),address(this))>=levelPrices[_level],"Upgrading fee exceeds USDT allowance!" | 285,679 | usdt.allowance(_msgSender(),address(this))>=levelPrices[_level] |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
require(<FILL_ME>) // dev: The address is not an account
// So far, to get the metadata from web but soon replace from
// pre-loaded IPFS
//_baseTokenURI = "ipfs://QmT9Qb3tQfvKC1bnXPqGo5UnBgdU2WK4kq5SzVo4zPcWig/";
maxDrop = 10000;
VIPTokensSet = false;
preSalesMintPrice = 55000000000000000; // 0.055 ETH
mintPrice = 70000000000000000; // 0.070 ETH
maxPresales = 3500; // 1750 (250+1500) Max accts, each 2 max so max 3500 NFTs
maxPresalesNFTAmount = 2; // Max number of NFTs per wallet to mint during pre-sales
maxWhiteListNFTAmount = 2; // Max number of NFTs per wallet to mint per whitelisted account
maxSalesNFTAmount = 25; // Max number of NFTs per wallet to mint during sales (no other control per account)
maxWhiteListAmount = 150; // Max allowance for whitelisted tokens (including contract owners)
accumulatedTHPrize = 0; // to keep track of accumulated TH balance as per roadmap
th_secret_set = false; // to be set when secret is resolved
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
}
}
| !(msg.sender.isContract()) | 285,723 | !(msg.sender.isContract()) |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
require(<FILL_ME>) // dev: the address is not an account
FirstPrizeAddress = _first;
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
}
}
| !_first.isContract() | 285,723 | !_first.isContract() |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
require(<FILL_ME>) // dev: 50% not achieved yet
require(!first_prize_released); // dev: 1st prize already released
require(_winners.length <= 3); // dev: winners array greater than 3
require(address(this).balance >= FIRST_PRIZE_TOTAL_ETH_AMOUNT); // dev: not enough balance in contract
for(uint256 i=0;i<_winners.length;i++) {
if(_winners[i] != address(0x0)) {
_asyncTransfer(_winners[i],_prizes[i]); // 2.5 ETH, 1 ETH, 0.5 ETH
// Flag prize as released
first_prize_released = true;
emit FirstGiveAwayCharged();
}
}
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
}
}
| pctReached(50) | 285,723 | pctReached(50) |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
require(pctReached(50)); // dev: 50% not achieved yet
require(<FILL_ME>) // dev: 1st prize already released
require(_winners.length <= 3); // dev: winners array greater than 3
require(address(this).balance >= FIRST_PRIZE_TOTAL_ETH_AMOUNT); // dev: not enough balance in contract
for(uint256 i=0;i<_winners.length;i++) {
if(_winners[i] != address(0x0)) {
_asyncTransfer(_winners[i],_prizes[i]); // 2.5 ETH, 1 ETH, 0.5 ETH
// Flag prize as released
first_prize_released = true;
emit FirstGiveAwayCharged();
}
}
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
}
}
| !first_prize_released | 285,723 | !first_prize_released |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
require(pctReached(50)); // dev: 50% not achieved yet
require(!first_prize_released); // dev: 1st prize already released
require(_winners.length <= 3); // dev: winners array greater than 3
require(<FILL_ME>) // dev: not enough balance in contract
for(uint256 i=0;i<_winners.length;i++) {
if(_winners[i] != address(0x0)) {
_asyncTransfer(_winners[i],_prizes[i]); // 2.5 ETH, 1 ETH, 0.5 ETH
// Flag prize as released
first_prize_released = true;
emit FirstGiveAwayCharged();
}
}
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
}
}
| address(this).balance>=FIRST_PRIZE_TOTAL_ETH_AMOUNT | 285,723 | address(this).balance>=FIRST_PRIZE_TOTAL_ETH_AMOUNT |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
require(<FILL_ME>) // dev: 2nd prize already released
require(pctReached(75)); // dev: 75% not achieved yet
require(address(this).balance >= SECOND_PRIZE_PER_WALLET_ETH_AMOUNT); // dev: not enough balance in contract
uint256 top_75_pct = (3*maxDrop)/4; // calc the 75% of the maxDrop
second_prize_winners = new address[](TH_SECOND_PRIZE_MAX_WINNERS);
// Get 20 random tokenId numbers from 0...(maxDrop*3)/4
uint256 div = top_75_pct / TH_SECOND_PRIZE_MAX_WINNERS;
uint256 seed = rand(div) + 1;
// Add payment in escrow contract
for(uint256 i = 0; i < TH_SECOND_PRIZE_MAX_WINNERS; i++) {
second_prize_winners[i] = ownerOf(seed);
_asyncTransfer(second_prize_winners[i],SECOND_PRIZE_PER_WALLET_ETH_AMOUNT);
seed = seed + div;
}
second_prize_released = true;
emit SecondGiveAwayCharged(second_prize_winners);
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
}
}
| !second_prize_released | 285,723 | !second_prize_released |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
require(!second_prize_released); // dev: 2nd prize already released
require(<FILL_ME>) // dev: 75% not achieved yet
require(address(this).balance >= SECOND_PRIZE_PER_WALLET_ETH_AMOUNT); // dev: not enough balance in contract
uint256 top_75_pct = (3*maxDrop)/4; // calc the 75% of the maxDrop
second_prize_winners = new address[](TH_SECOND_PRIZE_MAX_WINNERS);
// Get 20 random tokenId numbers from 0...(maxDrop*3)/4
uint256 div = top_75_pct / TH_SECOND_PRIZE_MAX_WINNERS;
uint256 seed = rand(div) + 1;
// Add payment in escrow contract
for(uint256 i = 0; i < TH_SECOND_PRIZE_MAX_WINNERS; i++) {
second_prize_winners[i] = ownerOf(seed);
_asyncTransfer(second_prize_winners[i],SECOND_PRIZE_PER_WALLET_ETH_AMOUNT);
seed = seed + div;
}
second_prize_released = true;
emit SecondGiveAwayCharged(second_prize_winners);
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
}
}
| pctReached(75) | 285,723 | pctReached(75) |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
require(!second_prize_released); // dev: 2nd prize already released
require(pctReached(75)); // dev: 75% not achieved yet
require(<FILL_ME>) // dev: not enough balance in contract
uint256 top_75_pct = (3*maxDrop)/4; // calc the 75% of the maxDrop
second_prize_winners = new address[](TH_SECOND_PRIZE_MAX_WINNERS);
// Get 20 random tokenId numbers from 0...(maxDrop*3)/4
uint256 div = top_75_pct / TH_SECOND_PRIZE_MAX_WINNERS;
uint256 seed = rand(div) + 1;
// Add payment in escrow contract
for(uint256 i = 0; i < TH_SECOND_PRIZE_MAX_WINNERS; i++) {
second_prize_winners[i] = ownerOf(seed);
_asyncTransfer(second_prize_winners[i],SECOND_PRIZE_PER_WALLET_ETH_AMOUNT);
seed = seed + div;
}
second_prize_released = true;
emit SecondGiveAwayCharged(second_prize_winners);
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
}
}
| address(this).balance>=SECOND_PRIZE_PER_WALLET_ETH_AMOUNT | 285,723 | address(this).balance>=SECOND_PRIZE_PER_WALLET_ETH_AMOUNT |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
require(_tokensTeam.length < TH_THIRD_PRIZE_MAX_WINNERS); // dev: tokens list size exceed maximum to create list
require(<FILL_ME>) // dev: team name already taken
uint256 ret = 0;
// Get addresses for tokens provided to create this team
address [] memory _addrs = getAddressesFromTokens(_tokensTeam); // Caller must but owner of the tokens or exception
// if some address already registered in another team, exception
require(addressesNotRegisteredInTeamYet(_addrs));
// Flag address as registered under _teamName so it cannot be registered in another team
for(uint256 i=0;i<_addrs.length;i++) {
ret = addAddrToTeam(_addrs[i],_teamName,ret);
}
// Finally, we can register the team
third_prize_players[_teamName] = _addrs;
return ret;
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
}
}
| third_prize_players[_teamName].length==0 | 285,723 | third_prize_players[_teamName].length==0 |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
require(_tokensTeam.length < TH_THIRD_PRIZE_MAX_WINNERS); // dev: tokens list size exceed maximum to create list
require(third_prize_players[_teamName].length == 0); // dev: team name already taken
uint256 ret = 0;
// Get addresses for tokens provided to create this team
address [] memory _addrs = getAddressesFromTokens(_tokensTeam); // Caller must but owner of the tokens or exception
// if some address already registered in another team, exception
require(<FILL_ME>)
// Flag address as registered under _teamName so it cannot be registered in another team
for(uint256 i=0;i<_addrs.length;i++) {
ret = addAddrToTeam(_addrs[i],_teamName,ret);
}
// Finally, we can register the team
third_prize_players[_teamName] = _addrs;
return ret;
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
}
}
| addressesNotRegisteredInTeamYet(_addrs) | 285,723 | addressesNotRegisteredInTeamYet(_addrs) |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
require(<FILL_ME>) // dev: team name does not exist
require(third_prize_players[_teamName].length != TH_THIRD_PRIZE_MAX_WINNERS); // dev: team full
uint256 ret = 0;
// Get addresses for tokens provided to create this team
// Caller must but owner of the tokens or exception
address [] memory _addrs = getAddressesFromTokens(_tokensTeam);
// if some address already registered in another team, exception
require(addressesNotRegisteredInTeamYet(_addrs)); // dev: caller not in a team yet
for(uint256 i=0;i<_addrs.length;i++) {
// if there still some room left, add new joiner
if(third_prize_players[_teamName].length < TH_THIRD_PRIZE_MAX_WINNERS) {
// Finally, we can register the team
third_prize_players[_teamName].push(_addrs[i]);
ret = addAddrToTeam(_addrs[i],_teamName,ret);
}
}
return ret;
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
}
}
| third_prize_players[_teamName].length!=0 | 285,723 | third_prize_players[_teamName].length!=0 |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
require(third_prize_players[_teamName].length != 0); // dev: team name does not exist
require(<FILL_ME>) // dev: team full
uint256 ret = 0;
// Get addresses for tokens provided to create this team
// Caller must but owner of the tokens or exception
address [] memory _addrs = getAddressesFromTokens(_tokensTeam);
// if some address already registered in another team, exception
require(addressesNotRegisteredInTeamYet(_addrs)); // dev: caller not in a team yet
for(uint256 i=0;i<_addrs.length;i++) {
// if there still some room left, add new joiner
if(third_prize_players[_teamName].length < TH_THIRD_PRIZE_MAX_WINNERS) {
// Finally, we can register the team
third_prize_players[_teamName].push(_addrs[i]);
ret = addAddrToTeam(_addrs[i],_teamName,ret);
}
}
return ret;
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
}
}
| third_prize_players[_teamName].length!=TH_THIRD_PRIZE_MAX_WINNERS | 285,723 | third_prize_players[_teamName].length!=TH_THIRD_PRIZE_MAX_WINNERS |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
require(th_secret_set); // dev: secret not set
require(<FILL_ME>) // dev: 100% not achieved yet
require(!third_prize_released); // dev: 3rd prize already released
require(accumulatedTHPrize == TH_POOL); // dev: not enough balance in contract
require(address(this).balance >= TH_POOL); // dev: not enough balance in contract
require(bytes(registered_th_addresses[msg.sender]).length != 0); // dev: caller not registered in any team
if(keccak256(abi.encodePacked(_plaintext)) == th_secret) {
// Secret message found, release prize to winners in team
// Get the team name
th_team_winner = registered_th_addresses[msg.sender];
// Access the addresses list
address [] memory _winnersAddrs = third_prize_players[th_team_winner];
// Congrats winners
_charge3rdGiveAway(th_team_winner,_winnersAddrs);
return true;
} else {
revert("RPS - Wrong, keep trying.");
}
return false;
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
}
}
| pctReached(100) | 285,723 | pctReached(100) |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
require(th_secret_set); // dev: secret not set
require(pctReached(100)); // dev: 100% not achieved yet
require(<FILL_ME>) // dev: 3rd prize already released
require(accumulatedTHPrize == TH_POOL); // dev: not enough balance in contract
require(address(this).balance >= TH_POOL); // dev: not enough balance in contract
require(bytes(registered_th_addresses[msg.sender]).length != 0); // dev: caller not registered in any team
if(keccak256(abi.encodePacked(_plaintext)) == th_secret) {
// Secret message found, release prize to winners in team
// Get the team name
th_team_winner = registered_th_addresses[msg.sender];
// Access the addresses list
address [] memory _winnersAddrs = third_prize_players[th_team_winner];
// Congrats winners
_charge3rdGiveAway(th_team_winner,_winnersAddrs);
return true;
} else {
revert("RPS - Wrong, keep trying.");
}
return false;
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
}
}
| !third_prize_released | 285,723 | !third_prize_released |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
require(th_secret_set); // dev: secret not set
require(pctReached(100)); // dev: 100% not achieved yet
require(!third_prize_released); // dev: 3rd prize already released
require(accumulatedTHPrize == TH_POOL); // dev: not enough balance in contract
require(<FILL_ME>) // dev: not enough balance in contract
require(bytes(registered_th_addresses[msg.sender]).length != 0); // dev: caller not registered in any team
if(keccak256(abi.encodePacked(_plaintext)) == th_secret) {
// Secret message found, release prize to winners in team
// Get the team name
th_team_winner = registered_th_addresses[msg.sender];
// Access the addresses list
address [] memory _winnersAddrs = third_prize_players[th_team_winner];
// Congrats winners
_charge3rdGiveAway(th_team_winner,_winnersAddrs);
return true;
} else {
revert("RPS - Wrong, keep trying.");
}
return false;
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
}
}
| address(this).balance>=TH_POOL | 285,723 | address(this).balance>=TH_POOL |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
require(th_secret_set); // dev: secret not set
require(pctReached(100)); // dev: 100% not achieved yet
require(!third_prize_released); // dev: 3rd prize already released
require(accumulatedTHPrize == TH_POOL); // dev: not enough balance in contract
require(address(this).balance >= TH_POOL); // dev: not enough balance in contract
require(<FILL_ME>) // dev: caller not registered in any team
if(keccak256(abi.encodePacked(_plaintext)) == th_secret) {
// Secret message found, release prize to winners in team
// Get the team name
th_team_winner = registered_th_addresses[msg.sender];
// Access the addresses list
address [] memory _winnersAddrs = third_prize_players[th_team_winner];
// Congrats winners
_charge3rdGiveAway(th_team_winner,_winnersAddrs);
return true;
} else {
revert("RPS - Wrong, keep trying.");
}
return false;
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
}
}
| bytes(registered_th_addresses[msg.sender]).length!=0 | 285,723 | bytes(registered_th_addresses[msg.sender]).length!=0 |
null | //
// .,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,. .,,,,
// ,,,, ,,,
// ,,,, ((((( , , (( (( ,,
// ,,, ((((/(((( ,,,,,,,, (((( ((( ,,,
// ,,. (((( (((. ,,,, ,(((((( ,,,
// ,,. (((( (((. ,,,,,, ,(((((( ,,,
// ,,, ((((((((( .,,, ,,, (((( ,,,
// ,,, ,,,
// .,, @@@@@@@@@ @@@@@@@@@ @@@@@@@@ ,,,
// ,,, @@ @@ @@ @@ @@ ,,,
// ,,, @@ @ @@ @@ @@@ ,,,
// ,,, @@@@@@@@@ @@@@@@@@@ @@@@@ ,,,
// ,,, @@ @ @@ @@@ ,,,
// ,,, @@ @@ @@ @@@@@@@@@ ,,,.
// ,,, ,,,,
// ,,,,. ,,,,,,,,,,,,,,,,,,,,,,
// ,,,,,,,,,,,,,,,,,,,,.
//
//
/// @title Scissors Contract.
/// Contract by RpsNft_Art
/// Contract created by: (SHA-256) d735dfa8fa552fcb02c42894edebb4652d44697d1636b6125d2367caf2ade334
contract Scissors is RPSCollectible {
// List of public ETH addresses of RPSNft_Art cofounders and other related participants
address private NGOAddress = 0x633b7218644b83D57d90e7299039ebAb19698e9C; // UkraineDAO
address private ScissorsSisterAddress = 0x92dd828AF04277f1ae6A4b7B25b5fFfc69f3A677;
address private RockbiosaAddress = 0x521A4b1A8A968A232ca2BeCfF66713b209Bca2d7;
address private PaperJamAddress = 0x57032e15279f520cb98365138533793dfA32d214;
address private RoseLizardAddress = 0x502f9198E63D1EEa55C8Bd62e134d8c04CB66B73;
address private SpockAddress = 0xBF2117339eD7A9039D9B996a61876150DDcc6b37;
address private MarketingAddress = 0x09870346A435E6Eb14887742824BBC7dAd066776;
address private FirstPrizeAddress = 0xD0f5C2aD5abA241A18D8E95e761982D911Ed1B20;
address private DreamOnAddress = 0xFfFaBC56a346929f925ddF2dEEc86332CC1Ce437;
// Token Ids that will determine the VIPs (using ownerof)
uint256 [] private VIPTokens;
bool private VIPTokensSet=false;
// Events for NFT
event CreateScissors(uint256 indexed id);
event ReleaseTH(uint256 indexed _pct, uint256 _amount);
event AmountWithdrawn(address _target, uint256 _amount);
// Events for Prizes
event FirstGiveAwayCharged();
event SecondGiveAwayCharged(address[]);
event ThirdGiveAwayCharged(string _teamName,address[]);
// Number of MAX_VIP_TOKENS
uint256 public constant MAX_VIP_TOKENS = 20;
// ETHs to acummulate in Treasure Hunt account
uint256 public constant TH_POOL = 50000000000000000000; // 50 ETH
uint256 public constant TH_FIRST = 5000000000000000000; // 5 ETH
uint256 public constant TH_SECOND = 10000000000000000000; // 10 ETH
uint256 public constant TH_THIRD = 15000000000000000000; // 15 ETH
uint256 public constant TH_FOURTH = 20000000000000000000; // 20 ETH
// PCT distributions
uint256 public constant COFOUNDER_PCT = 16; // 16 PCT
uint256 public constant FIVE_PCT = 5; // 5 PCT
// Prizes
uint256 public constant TH_PRIZE_PER_WALLET = 5000000000000000000; // 5 ETH
uint256 public constant FIRST_PRIZE = 1;
uint256 public constant SECOND_PRIZE = 2;
uint256 public constant THIRD_PRIZE = 3;
uint256 public constant FIRST_PRIZE_TOTAL_ETH_AMOUNT = 4000000000000000000; // 4 ETH
uint256 public constant FIRST_PRIZE_FIRST_ETH_AMOUNT = 2500000000000000000; // 2.5 ETH
uint256 public constant FIRST_PRIZE_SECOND_ETH_AMOUNT = 1000000000000000000; // 1 ETH
uint256 public constant FIRST_PRIZE_THIRD_ETH_AMOUNT = 500000000000000000; // 0.5 ETH
uint256 public constant SECOND_PRIZE_TOTAL_ETH_AMOUNT = 5000000000000000000; // 5 ETH
uint256 public constant SECOND_PRIZE_PER_WALLET_ETH_AMOUNT = 250000000000000000; // 0.25 ETH
uint256 public constant TH_SECOND_PRIZE_MAX_WINNERS = 20;
uint256 public constant TH_THIRD_PRIZE_MAX_WINNERS = 10;
// track if prizes have been released
bool public first_prize_released = false;
bool public second_prize_released = false;
bool public third_prize_released = false;
// Store the TH Secret - Winner will provide the team 50 ETH
uint256 private accumulatedTHPrize = 0;
bytes32 private th_secret = 0x0;
bool private th_secret_set = false;
// Usings
using Address for address;
// Keep track of percentages achieved and accumulation for TH accomplished
bool _allocatedTH_25 = false;
bool _allocatedTH_50 = false;
bool _allocatedTH_75 = false;
bool _allocatedTH_100 = false;
// table for 2nd prize winners
address[] public second_prize_winners;
// mapping to register potential 3rd prize winners. Each array of tokenids must be
// max of TH_THIRD_PRIZE_MAX_WINNERS. Address index is who represents a given group and who calls
// payable function to register group
mapping(string => address[]) public third_prize_players;
// keep track of team where addresses are registered against
mapping(address => string) public registered_th_addresses;
string public th_team_winner = '';
/**
* RPS = Rock Paper Scissors
* MWSA = Mintable Scissors Art
*/
constructor() RPSCollectible("RPS Scissors", "MSA") {
}
/** ---- ANYONE CAN CALL, SOME EXTERNAL ONLY ---- */
/***
*
* Maximum balance that can be withdrawn to secure future prices
*
*/
function maxBalanceToWithdraw() public view returns(uint256) {
}
/**
*
* Charging the contract for test purposes: it is just fine by calling this empty payable method
*
*/
function chargeContract() external payable {
}
/** ---------- ONLY OWNER CAN CALL ------------ */
/**
*
* Allow to withdraw the accumulated balance among founders, always prioritizing
* Treasure Hunt payments
*
*/
function withdraw() external onlyOwner {
}
/**
*
* Sets the tokens for cofounding benefits
*
*/
function setVIPTokens(uint256 [] memory _tokens) external onlyOwner {
}
/**
*
* Allow changing addresses for cofounders
*
*/
function setFounderAddresses(address _ss, address _rb, address _pj, address _rl,address _sp,
address _ngo, address _ds, address _do) external onlyOwner {
}
/**
* Set First and Second Prize addresses
*/
function setPrizesAccounts(address _first) external onlyOwner {
}
/** ---------- INTERNAL FUNCTIONS, SOME ONLY OWNER ------------ */
/**
*
* Specific event created when Scissor mints
*
*/
function emitMintEvent(uint256 collectibleId) internal override {
}
/**
*
* Function that is called per every mint and allocates treasure hunt
* as per roadmap
*
* It also accumulates for 1st and 2nd prize
*
*/
function _accumulateTH() internal override {
}
/**
*
* Transfer for Founders
*
*/
function transferFounders(uint256 _amount) internal onlyOwner {
}
/**
*
* Transfer for VIPs
*
*/
function transferVIPs(uint256 _amount) internal onlyOwner {
}
/**
* Prizes related functions
*/
/**
* Returns whether a given percentage has been reached or not
*/
function pctReached(uint256 pct) public view returns(bool) {
}
/**
* Sets the TH secret up
*/
function setSecret(bytes32 _secret) external onlyOwner {
}
function reservedTHPrize() external view returns(uint256) {
}
function sendGiveAway(uint256 _giveAwayId, address[] memory _winners) public override onlyOwner {
}
// Drop 1, once we have achieved 50% of the sales during first drop,
// the 3 community members from community members list, who have brought more new members
// to the community, will be rewarded with 2.5 ETH the first 1, 1 ETH the second, and 0.5 ETH the third.
// Total: 4 ETH
function _firstGiveAway(address[] memory _winners,uint256[3] memory _prizes) private onlyOwner {
}
// Drop 1, after 75% minting 5 ETH are transferred to 20 random scissors owners (pull payment, 0.5 ETH each)
function _secondGiveAway() internal {
}
/**
* Returns the addresses of token owners (max of TH_THIRD_PRIZE_MAX_WINNERS)
* internally called by owner of the tokens
*/
function getAddressesFromTokens(uint256 [] memory _tokens) internal returns (address [] memory) {
}
/**
* Helper function to determine if one of the addresses is already registered in a team
*/
function addressesNotRegisteredInTeamYet(address[] memory _addrs) internal returns (bool) {
}
function addAddrToTeam(address _addr, string memory _teamName, uint256 _amount) internal returns(uint256) {
}
/**
* Registers a new Team for TH prize
* - caller of this function will provide list of tokens he/she owns to include his address
* in this team and to create the team
* - caller of this function is free of charge (only gas)
* - Returns: number of shares in the team (max of TH_THIRD_PRIZE_MAX_WINNERS-1)
*/
function registerTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Caller calls this function if he/she wants to join a TH team
*/
function joinTHTeam(string memory _teamName, uint256[] memory _tokensTeam) external returns(uint256) {
}
/**
* Function that registered users need to call to provide decrypted message _plaintext
* If text matches the encrypted message, TH prize will be distributed to owners of scissors
* registered in the team from the caller attending to their participation
*
*/
function decryptForTHPrize(string memory _plaintext) external returns(bool) {
}
/**
* Returns addresses of TH winners
*/
function getTHWinnerAddrs() external view returns(address[] memory) {
}
/**
* Returns TH winner team name
*/
function getTHTeamName() external view returns(string memory) {
}
// The 50 ETH accumulated in the treasure account will be equally distributed among the winner group
// and the corresponding will be made available to them through pullpayment.
// Example if the group was formed by 10 people with 10 corresponding accounts,
// 5 ETH will be made available to them through pull payment.
function _charge3rdGiveAway(string memory _teamName, address[] memory _winners) internal {
}
/**
* We will transfer any accumulated prize not provided to NGO account
*/
function sendRemainderToNGO() external onlyOwner {
require(<FILL_ME>) // dev: prizes not released yet or no remaining
// All prizes have been released, potential remainder to be sent to NGO
uint256 amount = accumulatedTHPrize;
payable(NGOAddress).transfer(amount);
emit AmountWithdrawn(NGOAddress, amount);
}
}
| third_prize_released&&accumulatedTHPrize>0 | 285,723 | third_prize_released&&accumulatedTHPrize>0 |
null | pragma solidity ^0.4.15;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
}
}
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) returns (bool) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) constant returns (uint256 balance) {
}
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) returns (bool) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
}
/**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
}
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
}
}
/**
* @title SimpleToken
* @dev Very simple ERC20 Token example, where all tokens are pre-assigned to the creator.
* Note they can later distribute these tokens as they wish using `transfer` and other
* `StandardToken` functions.
*/
contract OpportyToken is StandardToken {
string public constant name = "OpportyToken";
string public constant symbol = "OPP";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1000000000 * (10 ** uint256(decimals));
/**
* @dev Contructor that gives msg.sender all of existing tokens.
*/
function OpportyToken() {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
/**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract HoldPresaleContract is Ownable {
using SafeMath for uint256;
// Addresses and contracts
OpportyToken public OppToken;
address private presaleCont;
struct Holder {
bool isActive;
uint tokens;
uint8 holdPeriod;
uint holdPeriodTimestamp;
bool withdrawed;
}
mapping(address => Holder) public holderList;
mapping(uint => address) private holderIndexes;
mapping (uint => address) private assetOwners;
mapping (address => uint) private assetOwnersIndex;
uint public assetOwnersIndexes;
uint private holderIndex;
event TokensTransfered(address contributor , uint amount);
event Hold(address sender, address contributor, uint amount, uint8 holdPeriod);
modifier onlyAssetsOwners() {
require(<FILL_ME>)
_;
}
/* constructor */
function HoldPresaleContract(address _OppToken) {
}
function setPresaleCont(address pres) public onlyOwner
{
}
function addHolder(address holder, uint tokens, uint8 timed, uint timest) onlyAssetsOwners external {
}
function getBalance() constant returns (uint) {
}
function unlockTokens() external {
}
function addAssetsOwner(address _owner) public onlyOwner {
}
function removeAssetsOwner(address _owner) public onlyOwner {
}
function getAssetsOwners(uint _index) onlyOwner public constant returns (address) {
}
}
contract OpportyPresale is Pausable {
using SafeMath for uint256;
OpportyToken public token;
HoldPresaleContract public holdContract;
enum SaleState { NEW, SALE, ENDED }
SaleState public state;
uint public endDate;
uint public endSaleDate;
// address where funds are collected
address private wallet;
// total ETH collected
uint public ethRaised;
uint private price;
uint public tokenRaised;
bool public tokensTransferredToHold;
/* Events */
event SaleStarted(uint blockNumber);
event SaleEnded(uint blockNumber);
event FundTransfered(address contrib, uint amount);
event WithdrawedEthToWallet(uint amount);
event ManualChangeEndDate(uint beforeDate, uint afterDate);
event TokensTransferedToHold(address hold, uint amount);
event AddedToWhiteList(address inv, uint amount, uint8 holdPeriod, uint8 bonus);
event AddedToHolder( address sender, uint tokenAmount, uint8 holdPeriod, uint holdTimestamp);
struct WhitelistContributor {
bool isActive;
uint invAmount;
uint8 holdPeriod;
uint holdTimestamp;
uint8 bonus;
bool payed;
}
mapping(address => WhitelistContributor) public whiteList;
mapping(uint => address) private whitelistIndexes;
uint private whitelistIndex;
/* constructor */
function OpportyPresale(
address tokenAddress,
address walletAddress,
uint end,
uint endSale,
address holdCont )
{
}
function startPresale() public onlyOwner {
}
function endPresale() public onlyOwner {
}
function addToWhitelist(address inv, uint amount, uint8 holdPeriod, uint8 bonus) public onlyOwner {
}
function() whenNotPaused public payable {
}
function getBalanceContract() internal returns (uint) {
}
function sendTokensToHold() public onlyOwner {
}
function getTokensBack() public onlyOwner {
}
function withdrawEth() {
}
function setEndSaleDate(uint date) public onlyOwner {
}
function setEndDate(uint date) public onlyOwner {
}
function getTokenBalance() constant returns (uint) {
}
function getEthRaised() constant external returns (uint) {
}
}
| assetOwnersIndex[msg.sender]>0 | 285,733 | assetOwnersIndex[msg.sender]>0 |
null | pragma solidity ^0.4.15;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
}
}
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) returns (bool) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) constant returns (uint256 balance) {
}
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) returns (bool) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
}
/**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
}
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
}
}
/**
* @title SimpleToken
* @dev Very simple ERC20 Token example, where all tokens are pre-assigned to the creator.
* Note they can later distribute these tokens as they wish using `transfer` and other
* `StandardToken` functions.
*/
contract OpportyToken is StandardToken {
string public constant name = "OpportyToken";
string public constant symbol = "OPP";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1000000000 * (10 ** uint256(decimals));
/**
* @dev Contructor that gives msg.sender all of existing tokens.
*/
function OpportyToken() {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
/**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract HoldPresaleContract is Ownable {
using SafeMath for uint256;
// Addresses and contracts
OpportyToken public OppToken;
address private presaleCont;
struct Holder {
bool isActive;
uint tokens;
uint8 holdPeriod;
uint holdPeriodTimestamp;
bool withdrawed;
}
mapping(address => Holder) public holderList;
mapping(uint => address) private holderIndexes;
mapping (uint => address) private assetOwners;
mapping (address => uint) private assetOwnersIndex;
uint public assetOwnersIndexes;
uint private holderIndex;
event TokensTransfered(address contributor , uint amount);
event Hold(address sender, address contributor, uint amount, uint8 holdPeriod);
modifier onlyAssetsOwners() {
}
/* constructor */
function HoldPresaleContract(address _OppToken) {
}
function setPresaleCont(address pres) public onlyOwner
{
}
function addHolder(address holder, uint tokens, uint8 timed, uint timest) onlyAssetsOwners external {
}
function getBalance() constant returns (uint) {
}
function unlockTokens() external {
}
function addAssetsOwner(address _owner) public onlyOwner {
}
function removeAssetsOwner(address _owner) public onlyOwner {
}
function getAssetsOwners(uint _index) onlyOwner public constant returns (address) {
}
}
contract OpportyPresale is Pausable {
using SafeMath for uint256;
OpportyToken public token;
HoldPresaleContract public holdContract;
enum SaleState { NEW, SALE, ENDED }
SaleState public state;
uint public endDate;
uint public endSaleDate;
// address where funds are collected
address private wallet;
// total ETH collected
uint public ethRaised;
uint private price;
uint public tokenRaised;
bool public tokensTransferredToHold;
/* Events */
event SaleStarted(uint blockNumber);
event SaleEnded(uint blockNumber);
event FundTransfered(address contrib, uint amount);
event WithdrawedEthToWallet(uint amount);
event ManualChangeEndDate(uint beforeDate, uint afterDate);
event TokensTransferedToHold(address hold, uint amount);
event AddedToWhiteList(address inv, uint amount, uint8 holdPeriod, uint8 bonus);
event AddedToHolder( address sender, uint tokenAmount, uint8 holdPeriod, uint holdTimestamp);
struct WhitelistContributor {
bool isActive;
uint invAmount;
uint8 holdPeriod;
uint holdTimestamp;
uint8 bonus;
bool payed;
}
mapping(address => WhitelistContributor) public whiteList;
mapping(uint => address) private whitelistIndexes;
uint private whitelistIndex;
/* constructor */
function OpportyPresale(
address tokenAddress,
address walletAddress,
uint end,
uint endSale,
address holdCont )
{
}
function startPresale() public onlyOwner {
}
function endPresale() public onlyOwner {
}
function addToWhitelist(address inv, uint amount, uint8 holdPeriod, uint8 bonus) public onlyOwner {
}
function() whenNotPaused public payable {
require(state == SaleState.SALE);
require(msg.value >= 0.3 ether);
require(<FILL_ME>)
if (now > endDate) {
state = SaleState.ENDED;
msg.sender.transfer(msg.value);
return ;
}
WhitelistContributor memory contrib = whiteList[msg.sender];
require(contrib.invAmount <= msg.value || contrib.payed);
if(whiteList[msg.sender].payed == false) {
whiteList[msg.sender].payed = true;
}
ethRaised += msg.value;
uint tokenAmount = msg.value.div(price);
tokenAmount += tokenAmount.mul(contrib.bonus).div(100);
tokenAmount *= 10 ** 18;
tokenRaised += tokenAmount;
holdContract.addHolder(msg.sender, tokenAmount, contrib.holdPeriod, contrib.holdTimestamp);
AddedToHolder(msg.sender, tokenAmount, contrib.holdPeriod, contrib.holdTimestamp);
FundTransfered(msg.sender, msg.value);
}
function getBalanceContract() internal returns (uint) {
}
function sendTokensToHold() public onlyOwner {
}
function getTokensBack() public onlyOwner {
}
function withdrawEth() {
}
function setEndSaleDate(uint date) public onlyOwner {
}
function setEndDate(uint date) public onlyOwner {
}
function getTokenBalance() constant returns (uint) {
}
function getEthRaised() constant external returns (uint) {
}
}
| whiteList[msg.sender].isActive | 285,733 | whiteList[msg.sender].isActive |
null | pragma solidity ^0.4.15;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
}
}
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) returns (bool) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) constant returns (uint256 balance) {
}
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) returns (bool) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
}
/**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
}
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
}
}
/**
* @title SimpleToken
* @dev Very simple ERC20 Token example, where all tokens are pre-assigned to the creator.
* Note they can later distribute these tokens as they wish using `transfer` and other
* `StandardToken` functions.
*/
contract OpportyToken is StandardToken {
string public constant name = "OpportyToken";
string public constant symbol = "OPP";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1000000000 * (10 ** uint256(decimals));
/**
* @dev Contructor that gives msg.sender all of existing tokens.
*/
function OpportyToken() {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
/**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract HoldPresaleContract is Ownable {
using SafeMath for uint256;
// Addresses and contracts
OpportyToken public OppToken;
address private presaleCont;
struct Holder {
bool isActive;
uint tokens;
uint8 holdPeriod;
uint holdPeriodTimestamp;
bool withdrawed;
}
mapping(address => Holder) public holderList;
mapping(uint => address) private holderIndexes;
mapping (uint => address) private assetOwners;
mapping (address => uint) private assetOwnersIndex;
uint public assetOwnersIndexes;
uint private holderIndex;
event TokensTransfered(address contributor , uint amount);
event Hold(address sender, address contributor, uint amount, uint8 holdPeriod);
modifier onlyAssetsOwners() {
}
/* constructor */
function HoldPresaleContract(address _OppToken) {
}
function setPresaleCont(address pres) public onlyOwner
{
}
function addHolder(address holder, uint tokens, uint8 timed, uint timest) onlyAssetsOwners external {
}
function getBalance() constant returns (uint) {
}
function unlockTokens() external {
}
function addAssetsOwner(address _owner) public onlyOwner {
}
function removeAssetsOwner(address _owner) public onlyOwner {
}
function getAssetsOwners(uint _index) onlyOwner public constant returns (address) {
}
}
contract OpportyPresale is Pausable {
using SafeMath for uint256;
OpportyToken public token;
HoldPresaleContract public holdContract;
enum SaleState { NEW, SALE, ENDED }
SaleState public state;
uint public endDate;
uint public endSaleDate;
// address where funds are collected
address private wallet;
// total ETH collected
uint public ethRaised;
uint private price;
uint public tokenRaised;
bool public tokensTransferredToHold;
/* Events */
event SaleStarted(uint blockNumber);
event SaleEnded(uint blockNumber);
event FundTransfered(address contrib, uint amount);
event WithdrawedEthToWallet(uint amount);
event ManualChangeEndDate(uint beforeDate, uint afterDate);
event TokensTransferedToHold(address hold, uint amount);
event AddedToWhiteList(address inv, uint amount, uint8 holdPeriod, uint8 bonus);
event AddedToHolder( address sender, uint tokenAmount, uint8 holdPeriod, uint holdTimestamp);
struct WhitelistContributor {
bool isActive;
uint invAmount;
uint8 holdPeriod;
uint holdTimestamp;
uint8 bonus;
bool payed;
}
mapping(address => WhitelistContributor) public whiteList;
mapping(uint => address) private whitelistIndexes;
uint private whitelistIndex;
/* constructor */
function OpportyPresale(
address tokenAddress,
address walletAddress,
uint end,
uint endSale,
address holdCont )
{
}
function startPresale() public onlyOwner {
}
function endPresale() public onlyOwner {
}
function addToWhitelist(address inv, uint amount, uint8 holdPeriod, uint8 bonus) public onlyOwner {
}
function() whenNotPaused public payable {
}
function getBalanceContract() internal returns (uint) {
}
function sendTokensToHold() public onlyOwner {
require(state == SaleState.ENDED);
require(<FILL_ME>)
if (token.transfer(holdContract, tokenRaised )) {
tokensTransferredToHold = true;
TokensTransferedToHold(holdContract, tokenRaised );
}
}
function getTokensBack() public onlyOwner {
}
function withdrawEth() {
}
function setEndSaleDate(uint date) public onlyOwner {
}
function setEndDate(uint date) public onlyOwner {
}
function getTokenBalance() constant returns (uint) {
}
function getEthRaised() constant external returns (uint) {
}
}
| getBalanceContract()>=tokenRaised | 285,733 | getBalanceContract()>=tokenRaised |
"DAO721: supply reached limit." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DAO721 is
ERC1155,
ERC1155Supply,
ERC1155Pausable,
ERC1155Burnable,
Ownable
{
using Strings for uint256;
string public constant name = "721DAO";
string public constant symbol = "721DAO";
uint256 public constant tokenId = 0;
bool public saleIsActive = false;
string public contractURI =
"https://infura-ipfs.io/ipfs/QmQNNfgRqyeZssyC3h7UjATj9qDUPbVjLTbhE1Xhi26pxb?filename=contract.json";
address public treasury = 0xd06a5d3baE616FdAf9fd0fe9DcdD14B2aa097155;
uint256 public maxSupply = 10000;
uint256 public maxAmountPerMint = 10;
uint256 public price = 0.1 ether;
uint256 public round = 0;
IERC721Enumerable public club721;
mapping(uint256 => mapping(uint256 => bool)) public usedToken;
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155, ERC1155Pausable) {
}
function _burnBatch(
address account,
uint256[] memory ids,
uint256[] memory amounts
) internal override(ERC1155, ERC1155Supply) {
}
function _burn(
address account,
uint256 id,
uint256 amount
) internal override(ERC1155, ERC1155Supply) {
}
function _mint(
address account,
uint256 id,
uint256 amount,
bytes memory data
) internal override(ERC1155, ERC1155Supply) {
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155, ERC1155Supply) {
}
function uri(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function totalSupply() external pure returns (uint256) {
}
function listClub721Tokens(address target)
external
view
returns (uint256[] memory)
{
}
constructor(IERC721Enumerable _club721)
ERC1155(
"https://infura-ipfs.io/ipfs/QmVdtZR3SdzkKC7RNpVcLNLbWCRzroiiMERE1Qk5yP3NVT?filename=token.json"
)
{
}
function quickMint(uint256 _amount) external payable {
}
function mint(uint256 _club721TokenId, uint256 _amount) public payable {
require(saleIsActive, "DAO721: Cannot mint now.");
require(
_amount >= 1 && _amount <= maxAmountPerMint,
"DAO721: Invalid amount."
);
require(<FILL_ME>)
require(
!usedToken[round][_club721TokenId],
"DAO721: Club721 token used."
);
require(
club721.ownerOf(_club721TokenId) == msg.sender,
"DAO721: Not own club token."
);
require(_amount * price == msg.value, "DAO721: Incorrect ethers.");
usedToken[round][_club721TokenId] = true;
_mint(msg.sender, tokenId, _amount, "");
if (treasury != address(0)) {
payable(treasury).transfer(address(this).balance);
}
}
function doCall(
address payable _to,
uint256 _value,
bytes calldata _data
) external payable onlyOwner returns (bytes memory) {
}
function batchAll(
address[] calldata _targets,
uint256 _value,
bytes calldata _payload
) external payable onlyOwner {
}
function ownerBurn(address account, uint256 amount) external onlyOwner {
}
function ownerMint(address account, uint256 amount) external onlyOwner {
}
function ownerMintBatch(
address[] calldata accounts,
uint256[] calldata amounts
) external onlyOwner {
}
function ownerMintTokens(
address to,
uint256[] memory ids,
uint256[] memory amounts
) external onlyOwner {
}
function setClub721(IERC721Enumerable _club721) external onlyOwner {
}
function setMaxAmountPerMint(uint256 _maxAmountPerMint) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setRound(uint256 _round) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function setTreasury(address treasury_) external onlyOwner {
}
function setURI(string memory uri_) external onlyOwner {
}
function setContractURI(string calldata _uri) external onlyOwner {
}
function setSaleState(bool newState) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function withdraw(address to) external onlyOwner {
}
}
| super.totalSupply(tokenId)+_amount<=maxSupply,"DAO721: supply reached limit." | 285,903 | super.totalSupply(tokenId)+_amount<=maxSupply |
"DAO721: Club721 token used." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DAO721 is
ERC1155,
ERC1155Supply,
ERC1155Pausable,
ERC1155Burnable,
Ownable
{
using Strings for uint256;
string public constant name = "721DAO";
string public constant symbol = "721DAO";
uint256 public constant tokenId = 0;
bool public saleIsActive = false;
string public contractURI =
"https://infura-ipfs.io/ipfs/QmQNNfgRqyeZssyC3h7UjATj9qDUPbVjLTbhE1Xhi26pxb?filename=contract.json";
address public treasury = 0xd06a5d3baE616FdAf9fd0fe9DcdD14B2aa097155;
uint256 public maxSupply = 10000;
uint256 public maxAmountPerMint = 10;
uint256 public price = 0.1 ether;
uint256 public round = 0;
IERC721Enumerable public club721;
mapping(uint256 => mapping(uint256 => bool)) public usedToken;
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155, ERC1155Pausable) {
}
function _burnBatch(
address account,
uint256[] memory ids,
uint256[] memory amounts
) internal override(ERC1155, ERC1155Supply) {
}
function _burn(
address account,
uint256 id,
uint256 amount
) internal override(ERC1155, ERC1155Supply) {
}
function _mint(
address account,
uint256 id,
uint256 amount,
bytes memory data
) internal override(ERC1155, ERC1155Supply) {
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155, ERC1155Supply) {
}
function uri(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function totalSupply() external pure returns (uint256) {
}
function listClub721Tokens(address target)
external
view
returns (uint256[] memory)
{
}
constructor(IERC721Enumerable _club721)
ERC1155(
"https://infura-ipfs.io/ipfs/QmVdtZR3SdzkKC7RNpVcLNLbWCRzroiiMERE1Qk5yP3NVT?filename=token.json"
)
{
}
function quickMint(uint256 _amount) external payable {
}
function mint(uint256 _club721TokenId, uint256 _amount) public payable {
require(saleIsActive, "DAO721: Cannot mint now.");
require(
_amount >= 1 && _amount <= maxAmountPerMint,
"DAO721: Invalid amount."
);
require(
super.totalSupply(tokenId) + _amount <= maxSupply,
"DAO721: supply reached limit."
);
require(<FILL_ME>)
require(
club721.ownerOf(_club721TokenId) == msg.sender,
"DAO721: Not own club token."
);
require(_amount * price == msg.value, "DAO721: Incorrect ethers.");
usedToken[round][_club721TokenId] = true;
_mint(msg.sender, tokenId, _amount, "");
if (treasury != address(0)) {
payable(treasury).transfer(address(this).balance);
}
}
function doCall(
address payable _to,
uint256 _value,
bytes calldata _data
) external payable onlyOwner returns (bytes memory) {
}
function batchAll(
address[] calldata _targets,
uint256 _value,
bytes calldata _payload
) external payable onlyOwner {
}
function ownerBurn(address account, uint256 amount) external onlyOwner {
}
function ownerMint(address account, uint256 amount) external onlyOwner {
}
function ownerMintBatch(
address[] calldata accounts,
uint256[] calldata amounts
) external onlyOwner {
}
function ownerMintTokens(
address to,
uint256[] memory ids,
uint256[] memory amounts
) external onlyOwner {
}
function setClub721(IERC721Enumerable _club721) external onlyOwner {
}
function setMaxAmountPerMint(uint256 _maxAmountPerMint) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setRound(uint256 _round) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function setTreasury(address treasury_) external onlyOwner {
}
function setURI(string memory uri_) external onlyOwner {
}
function setContractURI(string calldata _uri) external onlyOwner {
}
function setSaleState(bool newState) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function withdraw(address to) external onlyOwner {
}
}
| !usedToken[round][_club721TokenId],"DAO721: Club721 token used." | 285,903 | !usedToken[round][_club721TokenId] |
"DAO721: Not own club token." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DAO721 is
ERC1155,
ERC1155Supply,
ERC1155Pausable,
ERC1155Burnable,
Ownable
{
using Strings for uint256;
string public constant name = "721DAO";
string public constant symbol = "721DAO";
uint256 public constant tokenId = 0;
bool public saleIsActive = false;
string public contractURI =
"https://infura-ipfs.io/ipfs/QmQNNfgRqyeZssyC3h7UjATj9qDUPbVjLTbhE1Xhi26pxb?filename=contract.json";
address public treasury = 0xd06a5d3baE616FdAf9fd0fe9DcdD14B2aa097155;
uint256 public maxSupply = 10000;
uint256 public maxAmountPerMint = 10;
uint256 public price = 0.1 ether;
uint256 public round = 0;
IERC721Enumerable public club721;
mapping(uint256 => mapping(uint256 => bool)) public usedToken;
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155, ERC1155Pausable) {
}
function _burnBatch(
address account,
uint256[] memory ids,
uint256[] memory amounts
) internal override(ERC1155, ERC1155Supply) {
}
function _burn(
address account,
uint256 id,
uint256 amount
) internal override(ERC1155, ERC1155Supply) {
}
function _mint(
address account,
uint256 id,
uint256 amount,
bytes memory data
) internal override(ERC1155, ERC1155Supply) {
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155, ERC1155Supply) {
}
function uri(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
function totalSupply() external pure returns (uint256) {
}
function listClub721Tokens(address target)
external
view
returns (uint256[] memory)
{
}
constructor(IERC721Enumerable _club721)
ERC1155(
"https://infura-ipfs.io/ipfs/QmVdtZR3SdzkKC7RNpVcLNLbWCRzroiiMERE1Qk5yP3NVT?filename=token.json"
)
{
}
function quickMint(uint256 _amount) external payable {
}
function mint(uint256 _club721TokenId, uint256 _amount) public payable {
require(saleIsActive, "DAO721: Cannot mint now.");
require(
_amount >= 1 && _amount <= maxAmountPerMint,
"DAO721: Invalid amount."
);
require(
super.totalSupply(tokenId) + _amount <= maxSupply,
"DAO721: supply reached limit."
);
require(
!usedToken[round][_club721TokenId],
"DAO721: Club721 token used."
);
require(<FILL_ME>)
require(_amount * price == msg.value, "DAO721: Incorrect ethers.");
usedToken[round][_club721TokenId] = true;
_mint(msg.sender, tokenId, _amount, "");
if (treasury != address(0)) {
payable(treasury).transfer(address(this).balance);
}
}
function doCall(
address payable _to,
uint256 _value,
bytes calldata _data
) external payable onlyOwner returns (bytes memory) {
}
function batchAll(
address[] calldata _targets,
uint256 _value,
bytes calldata _payload
) external payable onlyOwner {
}
function ownerBurn(address account, uint256 amount) external onlyOwner {
}
function ownerMint(address account, uint256 amount) external onlyOwner {
}
function ownerMintBatch(
address[] calldata accounts,
uint256[] calldata amounts
) external onlyOwner {
}
function ownerMintTokens(
address to,
uint256[] memory ids,
uint256[] memory amounts
) external onlyOwner {
}
function setClub721(IERC721Enumerable _club721) external onlyOwner {
}
function setMaxAmountPerMint(uint256 _maxAmountPerMint) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setRound(uint256 _round) external onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function setTreasury(address treasury_) external onlyOwner {
}
function setURI(string memory uri_) external onlyOwner {
}
function setContractURI(string calldata _uri) external onlyOwner {
}
function setSaleState(bool newState) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function withdraw(address to) external onlyOwner {
}
}
| club721.ownerOf(_club721TokenId)==msg.sender,"DAO721: Not own club token." | 285,903 | club721.ownerOf(_club721TokenId)==msg.sender |
"This mint would pass max supply" | pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
interface IStaking {
function depositsOf(address account) external view returns (uint256[] memory);
}
contract HalloweenCreatures2 is ERC721URIStorage, Ownable, Pausable {
using Strings for uint256;
using Counters for Counters.Counter;
event AddToWhitelist(uint256 numberAdded);
event RemoveFromWhitelist(uint256 numberRemoved);
event TeamMint(address ownerAddress, uint256 amountMinted);
uint256 public constant TOTAL_SUPPLY = 9696;
uint256 public constant MAX_PRESALE_SUPPLY = 3333;
uint256 public constant MAX_TEAM_SUPPLY = 516;
uint256 public _maxBatch = 5;
uint256 public _pricePerMint = 0.0333 ether;
Counters.Counter private _tokenIdCounter;
uint256 public _maxMintsPerWallet = 15;
bool public _startFreeSale;
bool public _startPublic;
string public baseURI;
mapping(address => uint256) private _mintCount;
//constructor args
constructor() ERC721("HalloweenCreatures", "HCreatures") {
}
modifier canMintFree(uint256 times) {
require(times > 0 && times <= _maxBatch, "incorrect number of mints");
require(<FILL_ME>)
require(_mintCount[msg.sender] + times <= _maxMintsPerWallet, "Too many mints for this wallet");
_;
}
modifier canMint(uint256 times) {
}
function currentSupply() public view returns(uint256) {
}
function _baseURI() internal view virtual override returns (string memory){
}
function setBaseURI(string memory _newURI) external onlyOwner {
}
function setPrice(uint256 price) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setTokenURI(uint256 _tokenId, string memory _tokenURI) public onlyOwner {
}
function setMaxMintsPerWallet(uint256 maxMints) external onlyOwner {
}
function setMaxBatch(uint256 maxBatch) external onlyOwner {
}
function setSales(bool freeSale, bool publicSale) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function mint(uint256 times) internal {
}
function teamMint() public onlyOwner {
}
function mintFree(uint256 times) public canMintFree(times) whenNotPaused {
}
function mintPublic(uint256 times) public payable canMint(times) whenNotPaused {
}
}
| currentSupply()+times<=TOTAL_SUPPLY,"This mint would pass max supply" | 285,930 | currentSupply()+times<=TOTAL_SUPPLY |
"Too many mints for this wallet" | pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
interface IStaking {
function depositsOf(address account) external view returns (uint256[] memory);
}
contract HalloweenCreatures2 is ERC721URIStorage, Ownable, Pausable {
using Strings for uint256;
using Counters for Counters.Counter;
event AddToWhitelist(uint256 numberAdded);
event RemoveFromWhitelist(uint256 numberRemoved);
event TeamMint(address ownerAddress, uint256 amountMinted);
uint256 public constant TOTAL_SUPPLY = 9696;
uint256 public constant MAX_PRESALE_SUPPLY = 3333;
uint256 public constant MAX_TEAM_SUPPLY = 516;
uint256 public _maxBatch = 5;
uint256 public _pricePerMint = 0.0333 ether;
Counters.Counter private _tokenIdCounter;
uint256 public _maxMintsPerWallet = 15;
bool public _startFreeSale;
bool public _startPublic;
string public baseURI;
mapping(address => uint256) private _mintCount;
//constructor args
constructor() ERC721("HalloweenCreatures", "HCreatures") {
}
modifier canMintFree(uint256 times) {
require(times > 0 && times <= _maxBatch, "incorrect number of mints");
require(currentSupply() + times <= TOTAL_SUPPLY, "This mint would pass max supply");
require(<FILL_ME>)
_;
}
modifier canMint(uint256 times) {
}
function currentSupply() public view returns(uint256) {
}
function _baseURI() internal view virtual override returns (string memory){
}
function setBaseURI(string memory _newURI) external onlyOwner {
}
function setPrice(uint256 price) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setTokenURI(uint256 _tokenId, string memory _tokenURI) public onlyOwner {
}
function setMaxMintsPerWallet(uint256 maxMints) external onlyOwner {
}
function setMaxBatch(uint256 maxBatch) external onlyOwner {
}
function setSales(bool freeSale, bool publicSale) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function mint(uint256 times) internal {
}
function teamMint() public onlyOwner {
}
function mintFree(uint256 times) public canMintFree(times) whenNotPaused {
}
function mintPublic(uint256 times) public payable canMint(times) whenNotPaused {
}
}
| _mintCount[msg.sender]+times<=_maxMintsPerWallet,"Too many mints for this wallet" | 285,930 | _mintCount[msg.sender]+times<=_maxMintsPerWallet |
"Can't mint after sales start" | pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
interface IStaking {
function depositsOf(address account) external view returns (uint256[] memory);
}
contract HalloweenCreatures2 is ERC721URIStorage, Ownable, Pausable {
using Strings for uint256;
using Counters for Counters.Counter;
event AddToWhitelist(uint256 numberAdded);
event RemoveFromWhitelist(uint256 numberRemoved);
event TeamMint(address ownerAddress, uint256 amountMinted);
uint256 public constant TOTAL_SUPPLY = 9696;
uint256 public constant MAX_PRESALE_SUPPLY = 3333;
uint256 public constant MAX_TEAM_SUPPLY = 516;
uint256 public _maxBatch = 5;
uint256 public _pricePerMint = 0.0333 ether;
Counters.Counter private _tokenIdCounter;
uint256 public _maxMintsPerWallet = 15;
bool public _startFreeSale;
bool public _startPublic;
string public baseURI;
mapping(address => uint256) private _mintCount;
//constructor args
constructor() ERC721("HalloweenCreatures", "HCreatures") {
}
modifier canMintFree(uint256 times) {
}
modifier canMint(uint256 times) {
}
function currentSupply() public view returns(uint256) {
}
function _baseURI() internal view virtual override returns (string memory){
}
function setBaseURI(string memory _newURI) external onlyOwner {
}
function setPrice(uint256 price) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setTokenURI(uint256 _tokenId, string memory _tokenURI) public onlyOwner {
}
function setMaxMintsPerWallet(uint256 maxMints) external onlyOwner {
}
function setMaxBatch(uint256 maxBatch) external onlyOwner {
}
function setSales(bool freeSale, bool publicSale) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function mint(uint256 times) internal {
}
function teamMint() public onlyOwner {
require(<FILL_ME>)
mint(MAX_TEAM_SUPPLY);
emit TeamMint(msg.sender, MAX_TEAM_SUPPLY);
}
function mintFree(uint256 times) public canMintFree(times) whenNotPaused {
}
function mintPublic(uint256 times) public payable canMint(times) whenNotPaused {
}
}
| !_startFreeSale&&!_startPublic,"Can't mint after sales start" | 285,930 | !_startFreeSale&&!_startPublic |
"No more free mints available" | pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
interface IStaking {
function depositsOf(address account) external view returns (uint256[] memory);
}
contract HalloweenCreatures2 is ERC721URIStorage, Ownable, Pausable {
using Strings for uint256;
using Counters for Counters.Counter;
event AddToWhitelist(uint256 numberAdded);
event RemoveFromWhitelist(uint256 numberRemoved);
event TeamMint(address ownerAddress, uint256 amountMinted);
uint256 public constant TOTAL_SUPPLY = 9696;
uint256 public constant MAX_PRESALE_SUPPLY = 3333;
uint256 public constant MAX_TEAM_SUPPLY = 516;
uint256 public _maxBatch = 5;
uint256 public _pricePerMint = 0.0333 ether;
Counters.Counter private _tokenIdCounter;
uint256 public _maxMintsPerWallet = 15;
bool public _startFreeSale;
bool public _startPublic;
string public baseURI;
mapping(address => uint256) private _mintCount;
//constructor args
constructor() ERC721("HalloweenCreatures", "HCreatures") {
}
modifier canMintFree(uint256 times) {
}
modifier canMint(uint256 times) {
}
function currentSupply() public view returns(uint256) {
}
function _baseURI() internal view virtual override returns (string memory){
}
function setBaseURI(string memory _newURI) external onlyOwner {
}
function setPrice(uint256 price) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setTokenURI(uint256 _tokenId, string memory _tokenURI) public onlyOwner {
}
function setMaxMintsPerWallet(uint256 maxMints) external onlyOwner {
}
function setMaxBatch(uint256 maxBatch) external onlyOwner {
}
function setSales(bool freeSale, bool publicSale) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function mint(uint256 times) internal {
}
function teamMint() public onlyOwner {
}
function mintFree(uint256 times) public canMintFree(times) whenNotPaused {
require(_startFreeSale, "Free sale is not live");
require(<FILL_ME>)
mint(times);
}
function mintPublic(uint256 times) public payable canMint(times) whenNotPaused {
}
}
| currentSupply()+times<=MAX_PRESALE_SUPPLY+MAX_TEAM_SUPPLY,"No more free mints available" | 285,930 | currentSupply()+times<=MAX_PRESALE_SUPPLY+MAX_TEAM_SUPPLY |
Errors.MATH_MULTIPLICATION_OVERFLOW | // SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;
import {Errors} from '../helpers/Errors.sol';
/**
* @title WadRayMath library
* @author Aave
* @dev Provides mul and div function for wads (decimal numbers with 18 digits precision) and rays (decimals with 27 digits)
**/
library WadRayMath {
uint256 internal constant WAY = 1e9;
uint256 internal constant halfWAY = WAY / 2;
uint256 internal constant WAD = 1e18;
uint256 internal constant halfWAD = WAD / 2;
uint256 internal constant RAY = 1e27;
uint256 internal constant halfRAY = RAY / 2;
uint256 internal constant WAD_RAY_RATIO = 1e9;
uint256 internal constant WAY_WAD_RATIO = 1e9;
uint256 internal constant WAY_RAY_RATIO = 1e18;
/**
* @return One ray, 1e27
**/
function ray() internal pure returns (uint256) {
}
/**
* @return One wad, 1e18
**/
function wad() internal pure returns (uint256) {
}
/**
* @return One way, 1e9
**/
function way() internal pure returns (uint256) {
}
/**
* @return Half ray, 1e27/2
**/
function halfRay() internal pure returns (uint256) {
}
/**
* @return Half wad, 1e18/2
**/
function halfWad() internal pure returns (uint256) {
}
/**
* @return Half way, 1e9/2
**/
function halfWay() internal pure returns (uint256) {
}
/**
* @dev Multiplies two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a*b, in way
**/
function wayMul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0 || b == 0) {
return 0;
}
require(<FILL_ME>)
return (a * b + halfWAY) / WAY;
}
/**
* @dev Divides two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a/b, in way
**/
function wayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a*b, in wad
**/
function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a/b, in wad
**/
function wadDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a*b, in ray
**/
function rayMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a/b, in ray
**/
function rayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Casts ray down to wad
* @param a Ray
* @return a casted to wad, rounded half up to the nearest wad
**/
function rayToWad(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts wad up to ray
* @param a Wad
* @return a converted in ray
**/
function wadToRay(uint256 a) internal pure returns (uint256) {
}
function rayToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to ray
* @param a Way
* @return a converted in ray
**/
function wayToRay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Casts wad down to way
* @param a Wad
* @return a casted to way, rounded half up to the nearest way
**/
function wadToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to wad
* @param a Way
* @return a converted in wad
**/
function wayToWad(uint256 a) internal pure returns (uint256) {
}
}
| a<=(type(uint256).max-halfWAY)/b,Errors.MATH_MULTIPLICATION_OVERFLOW | 285,951 | a<=(type(uint256).max-halfWAY)/b |
Errors.MATH_MULTIPLICATION_OVERFLOW | // SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;
import {Errors} from '../helpers/Errors.sol';
/**
* @title WadRayMath library
* @author Aave
* @dev Provides mul and div function for wads (decimal numbers with 18 digits precision) and rays (decimals with 27 digits)
**/
library WadRayMath {
uint256 internal constant WAY = 1e9;
uint256 internal constant halfWAY = WAY / 2;
uint256 internal constant WAD = 1e18;
uint256 internal constant halfWAD = WAD / 2;
uint256 internal constant RAY = 1e27;
uint256 internal constant halfRAY = RAY / 2;
uint256 internal constant WAD_RAY_RATIO = 1e9;
uint256 internal constant WAY_WAD_RATIO = 1e9;
uint256 internal constant WAY_RAY_RATIO = 1e18;
/**
* @return One ray, 1e27
**/
function ray() internal pure returns (uint256) {
}
/**
* @return One wad, 1e18
**/
function wad() internal pure returns (uint256) {
}
/**
* @return One way, 1e9
**/
function way() internal pure returns (uint256) {
}
/**
* @return Half ray, 1e27/2
**/
function halfRay() internal pure returns (uint256) {
}
/**
* @return Half wad, 1e18/2
**/
function halfWad() internal pure returns (uint256) {
}
/**
* @return Half way, 1e9/2
**/
function halfWay() internal pure returns (uint256) {
}
/**
* @dev Multiplies two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a*b, in way
**/
function wayMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a/b, in way
**/
function wayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, Errors.MATH_DIVISION_BY_ZERO);
uint256 halfB = b / 2;
require(<FILL_ME>)
return (a * WAY + halfB) / b;
}
/**
* @dev Multiplies two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a*b, in wad
**/
function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a/b, in wad
**/
function wadDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a*b, in ray
**/
function rayMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a/b, in ray
**/
function rayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Casts ray down to wad
* @param a Ray
* @return a casted to wad, rounded half up to the nearest wad
**/
function rayToWad(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts wad up to ray
* @param a Wad
* @return a converted in ray
**/
function wadToRay(uint256 a) internal pure returns (uint256) {
}
function rayToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to ray
* @param a Way
* @return a converted in ray
**/
function wayToRay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Casts wad down to way
* @param a Wad
* @return a casted to way, rounded half up to the nearest way
**/
function wadToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to wad
* @param a Way
* @return a converted in wad
**/
function wayToWad(uint256 a) internal pure returns (uint256) {
}
}
| a<=(type(uint256).max-halfB)/WAY,Errors.MATH_MULTIPLICATION_OVERFLOW | 285,951 | a<=(type(uint256).max-halfB)/WAY |
Errors.MATH_MULTIPLICATION_OVERFLOW | // SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;
import {Errors} from '../helpers/Errors.sol';
/**
* @title WadRayMath library
* @author Aave
* @dev Provides mul and div function for wads (decimal numbers with 18 digits precision) and rays (decimals with 27 digits)
**/
library WadRayMath {
uint256 internal constant WAY = 1e9;
uint256 internal constant halfWAY = WAY / 2;
uint256 internal constant WAD = 1e18;
uint256 internal constant halfWAD = WAD / 2;
uint256 internal constant RAY = 1e27;
uint256 internal constant halfRAY = RAY / 2;
uint256 internal constant WAD_RAY_RATIO = 1e9;
uint256 internal constant WAY_WAD_RATIO = 1e9;
uint256 internal constant WAY_RAY_RATIO = 1e18;
/**
* @return One ray, 1e27
**/
function ray() internal pure returns (uint256) {
}
/**
* @return One wad, 1e18
**/
function wad() internal pure returns (uint256) {
}
/**
* @return One way, 1e9
**/
function way() internal pure returns (uint256) {
}
/**
* @return Half ray, 1e27/2
**/
function halfRay() internal pure returns (uint256) {
}
/**
* @return Half wad, 1e18/2
**/
function halfWad() internal pure returns (uint256) {
}
/**
* @return Half way, 1e9/2
**/
function halfWay() internal pure returns (uint256) {
}
/**
* @dev Multiplies two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a*b, in way
**/
function wayMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a/b, in way
**/
function wayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a*b, in wad
**/
function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0 || b == 0) {
return 0;
}
require(<FILL_ME>)
return (a * b + halfWAD) / WAD;
}
/**
* @dev Divides two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a/b, in wad
**/
function wadDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a*b, in ray
**/
function rayMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a/b, in ray
**/
function rayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Casts ray down to wad
* @param a Ray
* @return a casted to wad, rounded half up to the nearest wad
**/
function rayToWad(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts wad up to ray
* @param a Wad
* @return a converted in ray
**/
function wadToRay(uint256 a) internal pure returns (uint256) {
}
function rayToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to ray
* @param a Way
* @return a converted in ray
**/
function wayToRay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Casts wad down to way
* @param a Wad
* @return a casted to way, rounded half up to the nearest way
**/
function wadToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to wad
* @param a Way
* @return a converted in wad
**/
function wayToWad(uint256 a) internal pure returns (uint256) {
}
}
| a<=(type(uint256).max-halfWAD)/b,Errors.MATH_MULTIPLICATION_OVERFLOW | 285,951 | a<=(type(uint256).max-halfWAD)/b |
Errors.MATH_MULTIPLICATION_OVERFLOW | // SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;
import {Errors} from '../helpers/Errors.sol';
/**
* @title WadRayMath library
* @author Aave
* @dev Provides mul and div function for wads (decimal numbers with 18 digits precision) and rays (decimals with 27 digits)
**/
library WadRayMath {
uint256 internal constant WAY = 1e9;
uint256 internal constant halfWAY = WAY / 2;
uint256 internal constant WAD = 1e18;
uint256 internal constant halfWAD = WAD / 2;
uint256 internal constant RAY = 1e27;
uint256 internal constant halfRAY = RAY / 2;
uint256 internal constant WAD_RAY_RATIO = 1e9;
uint256 internal constant WAY_WAD_RATIO = 1e9;
uint256 internal constant WAY_RAY_RATIO = 1e18;
/**
* @return One ray, 1e27
**/
function ray() internal pure returns (uint256) {
}
/**
* @return One wad, 1e18
**/
function wad() internal pure returns (uint256) {
}
/**
* @return One way, 1e9
**/
function way() internal pure returns (uint256) {
}
/**
* @return Half ray, 1e27/2
**/
function halfRay() internal pure returns (uint256) {
}
/**
* @return Half wad, 1e18/2
**/
function halfWad() internal pure returns (uint256) {
}
/**
* @return Half way, 1e9/2
**/
function halfWay() internal pure returns (uint256) {
}
/**
* @dev Multiplies two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a*b, in way
**/
function wayMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a/b, in way
**/
function wayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a*b, in wad
**/
function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a/b, in wad
**/
function wadDiv(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, Errors.MATH_DIVISION_BY_ZERO);
uint256 halfB = b / 2;
require(<FILL_ME>)
return (a * WAD + halfB) / b;
}
/**
* @dev Multiplies two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a*b, in ray
**/
function rayMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a/b, in ray
**/
function rayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Casts ray down to wad
* @param a Ray
* @return a casted to wad, rounded half up to the nearest wad
**/
function rayToWad(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts wad up to ray
* @param a Wad
* @return a converted in ray
**/
function wadToRay(uint256 a) internal pure returns (uint256) {
}
function rayToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to ray
* @param a Way
* @return a converted in ray
**/
function wayToRay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Casts wad down to way
* @param a Wad
* @return a casted to way, rounded half up to the nearest way
**/
function wadToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to wad
* @param a Way
* @return a converted in wad
**/
function wayToWad(uint256 a) internal pure returns (uint256) {
}
}
| a<=(type(uint256).max-halfB)/WAD,Errors.MATH_MULTIPLICATION_OVERFLOW | 285,951 | a<=(type(uint256).max-halfB)/WAD |
Errors.MATH_MULTIPLICATION_OVERFLOW | // SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;
import {Errors} from '../helpers/Errors.sol';
/**
* @title WadRayMath library
* @author Aave
* @dev Provides mul and div function for wads (decimal numbers with 18 digits precision) and rays (decimals with 27 digits)
**/
library WadRayMath {
uint256 internal constant WAY = 1e9;
uint256 internal constant halfWAY = WAY / 2;
uint256 internal constant WAD = 1e18;
uint256 internal constant halfWAD = WAD / 2;
uint256 internal constant RAY = 1e27;
uint256 internal constant halfRAY = RAY / 2;
uint256 internal constant WAD_RAY_RATIO = 1e9;
uint256 internal constant WAY_WAD_RATIO = 1e9;
uint256 internal constant WAY_RAY_RATIO = 1e18;
/**
* @return One ray, 1e27
**/
function ray() internal pure returns (uint256) {
}
/**
* @return One wad, 1e18
**/
function wad() internal pure returns (uint256) {
}
/**
* @return One way, 1e9
**/
function way() internal pure returns (uint256) {
}
/**
* @return Half ray, 1e27/2
**/
function halfRay() internal pure returns (uint256) {
}
/**
* @return Half wad, 1e18/2
**/
function halfWad() internal pure returns (uint256) {
}
/**
* @return Half way, 1e9/2
**/
function halfWay() internal pure returns (uint256) {
}
/**
* @dev Multiplies two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a*b, in way
**/
function wayMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a/b, in way
**/
function wayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a*b, in wad
**/
function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a/b, in wad
**/
function wadDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a*b, in ray
**/
function rayMul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0 || b == 0) {
return 0;
}
require(<FILL_ME>)
return (a * b + halfRAY) / RAY;
}
/**
* @dev Divides two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a/b, in ray
**/
function rayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Casts ray down to wad
* @param a Ray
* @return a casted to wad, rounded half up to the nearest wad
**/
function rayToWad(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts wad up to ray
* @param a Wad
* @return a converted in ray
**/
function wadToRay(uint256 a) internal pure returns (uint256) {
}
function rayToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to ray
* @param a Way
* @return a converted in ray
**/
function wayToRay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Casts wad down to way
* @param a Wad
* @return a casted to way, rounded half up to the nearest way
**/
function wadToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to wad
* @param a Way
* @return a converted in wad
**/
function wayToWad(uint256 a) internal pure returns (uint256) {
}
}
| a<=(type(uint256).max-halfRAY)/b,Errors.MATH_MULTIPLICATION_OVERFLOW | 285,951 | a<=(type(uint256).max-halfRAY)/b |
Errors.MATH_MULTIPLICATION_OVERFLOW | // SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;
import {Errors} from '../helpers/Errors.sol';
/**
* @title WadRayMath library
* @author Aave
* @dev Provides mul and div function for wads (decimal numbers with 18 digits precision) and rays (decimals with 27 digits)
**/
library WadRayMath {
uint256 internal constant WAY = 1e9;
uint256 internal constant halfWAY = WAY / 2;
uint256 internal constant WAD = 1e18;
uint256 internal constant halfWAD = WAD / 2;
uint256 internal constant RAY = 1e27;
uint256 internal constant halfRAY = RAY / 2;
uint256 internal constant WAD_RAY_RATIO = 1e9;
uint256 internal constant WAY_WAD_RATIO = 1e9;
uint256 internal constant WAY_RAY_RATIO = 1e18;
/**
* @return One ray, 1e27
**/
function ray() internal pure returns (uint256) {
}
/**
* @return One wad, 1e18
**/
function wad() internal pure returns (uint256) {
}
/**
* @return One way, 1e9
**/
function way() internal pure returns (uint256) {
}
/**
* @return Half ray, 1e27/2
**/
function halfRay() internal pure returns (uint256) {
}
/**
* @return Half wad, 1e18/2
**/
function halfWad() internal pure returns (uint256) {
}
/**
* @return Half way, 1e9/2
**/
function halfWay() internal pure returns (uint256) {
}
/**
* @dev Multiplies two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a*b, in way
**/
function wayMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a/b, in way
**/
function wayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a*b, in wad
**/
function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a/b, in wad
**/
function wadDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a*b, in ray
**/
function rayMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a/b, in ray
**/
function rayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, Errors.MATH_DIVISION_BY_ZERO);
uint256 halfB = b / 2;
require(<FILL_ME>)
return (a * RAY + halfB) / b;
}
/**
* @dev Casts ray down to wad
* @param a Ray
* @return a casted to wad, rounded half up to the nearest wad
**/
function rayToWad(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts wad up to ray
* @param a Wad
* @return a converted in ray
**/
function wadToRay(uint256 a) internal pure returns (uint256) {
}
function rayToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to ray
* @param a Way
* @return a converted in ray
**/
function wayToRay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Casts wad down to way
* @param a Wad
* @return a casted to way, rounded half up to the nearest way
**/
function wadToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to wad
* @param a Way
* @return a converted in wad
**/
function wayToWad(uint256 a) internal pure returns (uint256) {
}
}
| a<=(type(uint256).max-halfB)/RAY,Errors.MATH_MULTIPLICATION_OVERFLOW | 285,951 | a<=(type(uint256).max-halfB)/RAY |
Errors.MATH_MULTIPLICATION_OVERFLOW | // SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;
import {Errors} from '../helpers/Errors.sol';
/**
* @title WadRayMath library
* @author Aave
* @dev Provides mul and div function for wads (decimal numbers with 18 digits precision) and rays (decimals with 27 digits)
**/
library WadRayMath {
uint256 internal constant WAY = 1e9;
uint256 internal constant halfWAY = WAY / 2;
uint256 internal constant WAD = 1e18;
uint256 internal constant halfWAD = WAD / 2;
uint256 internal constant RAY = 1e27;
uint256 internal constant halfRAY = RAY / 2;
uint256 internal constant WAD_RAY_RATIO = 1e9;
uint256 internal constant WAY_WAD_RATIO = 1e9;
uint256 internal constant WAY_RAY_RATIO = 1e18;
/**
* @return One ray, 1e27
**/
function ray() internal pure returns (uint256) {
}
/**
* @return One wad, 1e18
**/
function wad() internal pure returns (uint256) {
}
/**
* @return One way, 1e9
**/
function way() internal pure returns (uint256) {
}
/**
* @return Half ray, 1e27/2
**/
function halfRay() internal pure returns (uint256) {
}
/**
* @return Half wad, 1e18/2
**/
function halfWad() internal pure returns (uint256) {
}
/**
* @return Half way, 1e9/2
**/
function halfWay() internal pure returns (uint256) {
}
/**
* @dev Multiplies two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a*b, in way
**/
function wayMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a/b, in way
**/
function wayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a*b, in wad
**/
function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a/b, in wad
**/
function wadDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a*b, in ray
**/
function rayMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a/b, in ray
**/
function rayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Casts ray down to wad
* @param a Ray
* @return a casted to wad, rounded half up to the nearest wad
**/
function rayToWad(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts wad up to ray
* @param a Wad
* @return a converted in ray
**/
function wadToRay(uint256 a) internal pure returns (uint256) {
uint256 result = a * WAD_RAY_RATIO;
require(<FILL_ME>)
return result;
}
function rayToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to ray
* @param a Way
* @return a converted in ray
**/
function wayToRay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Casts wad down to way
* @param a Wad
* @return a casted to way, rounded half up to the nearest way
**/
function wadToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to wad
* @param a Way
* @return a converted in wad
**/
function wayToWad(uint256 a) internal pure returns (uint256) {
}
}
| result/WAD_RAY_RATIO==a,Errors.MATH_MULTIPLICATION_OVERFLOW | 285,951 | result/WAD_RAY_RATIO==a |
Errors.MATH_MULTIPLICATION_OVERFLOW | // SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;
import {Errors} from '../helpers/Errors.sol';
/**
* @title WadRayMath library
* @author Aave
* @dev Provides mul and div function for wads (decimal numbers with 18 digits precision) and rays (decimals with 27 digits)
**/
library WadRayMath {
uint256 internal constant WAY = 1e9;
uint256 internal constant halfWAY = WAY / 2;
uint256 internal constant WAD = 1e18;
uint256 internal constant halfWAD = WAD / 2;
uint256 internal constant RAY = 1e27;
uint256 internal constant halfRAY = RAY / 2;
uint256 internal constant WAD_RAY_RATIO = 1e9;
uint256 internal constant WAY_WAD_RATIO = 1e9;
uint256 internal constant WAY_RAY_RATIO = 1e18;
/**
* @return One ray, 1e27
**/
function ray() internal pure returns (uint256) {
}
/**
* @return One wad, 1e18
**/
function wad() internal pure returns (uint256) {
}
/**
* @return One way, 1e9
**/
function way() internal pure returns (uint256) {
}
/**
* @return Half ray, 1e27/2
**/
function halfRay() internal pure returns (uint256) {
}
/**
* @return Half wad, 1e18/2
**/
function halfWad() internal pure returns (uint256) {
}
/**
* @return Half way, 1e9/2
**/
function halfWay() internal pure returns (uint256) {
}
/**
* @dev Multiplies two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a*b, in way
**/
function wayMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a/b, in way
**/
function wayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a*b, in wad
**/
function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a/b, in wad
**/
function wadDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a*b, in ray
**/
function rayMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a/b, in ray
**/
function rayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Casts ray down to wad
* @param a Ray
* @return a casted to wad, rounded half up to the nearest wad
**/
function rayToWad(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts wad up to ray
* @param a Wad
* @return a converted in ray
**/
function wadToRay(uint256 a) internal pure returns (uint256) {
}
function rayToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to ray
* @param a Way
* @return a converted in ray
**/
function wayToRay(uint256 a) internal pure returns (uint256) {
uint256 result = a * WAY_RAY_RATIO;
require(<FILL_ME>)
return result;
}
/**
* @dev Casts wad down to way
* @param a Wad
* @return a casted to way, rounded half up to the nearest way
**/
function wadToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to wad
* @param a Way
* @return a converted in wad
**/
function wayToWad(uint256 a) internal pure returns (uint256) {
}
}
| result/WAY_RAY_RATIO==a,Errors.MATH_MULTIPLICATION_OVERFLOW | 285,951 | result/WAY_RAY_RATIO==a |
Errors.MATH_MULTIPLICATION_OVERFLOW | // SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;
import {Errors} from '../helpers/Errors.sol';
/**
* @title WadRayMath library
* @author Aave
* @dev Provides mul and div function for wads (decimal numbers with 18 digits precision) and rays (decimals with 27 digits)
**/
library WadRayMath {
uint256 internal constant WAY = 1e9;
uint256 internal constant halfWAY = WAY / 2;
uint256 internal constant WAD = 1e18;
uint256 internal constant halfWAD = WAD / 2;
uint256 internal constant RAY = 1e27;
uint256 internal constant halfRAY = RAY / 2;
uint256 internal constant WAD_RAY_RATIO = 1e9;
uint256 internal constant WAY_WAD_RATIO = 1e9;
uint256 internal constant WAY_RAY_RATIO = 1e18;
/**
* @return One ray, 1e27
**/
function ray() internal pure returns (uint256) {
}
/**
* @return One wad, 1e18
**/
function wad() internal pure returns (uint256) {
}
/**
* @return One way, 1e9
**/
function way() internal pure returns (uint256) {
}
/**
* @return Half ray, 1e27/2
**/
function halfRay() internal pure returns (uint256) {
}
/**
* @return Half wad, 1e18/2
**/
function halfWad() internal pure returns (uint256) {
}
/**
* @return Half way, 1e9/2
**/
function halfWay() internal pure returns (uint256) {
}
/**
* @dev Multiplies two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a*b, in way
**/
function wayMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two way, rounding half up to the nearest way
* @param a Way
* @param b Way
* @return The result of a/b, in way
**/
function wayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a*b, in wad
**/
function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two wad, rounding half up to the nearest wad
* @param a Wad
* @param b Wad
* @return The result of a/b, in wad
**/
function wadDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a*b, in ray
**/
function rayMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two ray, rounding half up to the nearest ray
* @param a Ray
* @param b Ray
* @return The result of a/b, in ray
**/
function rayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Casts ray down to wad
* @param a Ray
* @return a casted to wad, rounded half up to the nearest wad
**/
function rayToWad(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts wad up to ray
* @param a Wad
* @return a converted in ray
**/
function wadToRay(uint256 a) internal pure returns (uint256) {
}
function rayToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to ray
* @param a Way
* @return a converted in ray
**/
function wayToRay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Casts wad down to way
* @param a Wad
* @return a casted to way, rounded half up to the nearest way
**/
function wadToWay(uint256 a) internal pure returns (uint256) {
}
/**
* @dev Converts way up to wad
* @param a Way
* @return a converted in wad
**/
function wayToWad(uint256 a) internal pure returns (uint256) {
uint256 result = a * WAY_WAD_RATIO;
require(<FILL_ME>)
return result;
}
}
| result/WAY_WAD_RATIO==a,Errors.MATH_MULTIPLICATION_OVERFLOW | 285,951 | result/WAY_WAD_RATIO==a |
"Staking time ended" | pragma solidity 0.8.0;
contract Holder is ERC1155Holder {
ERC1155 nft_contract;
ERC20 metagold_contract;
address public owner;
uint256 tokenYields = 10;
uint256 yieldTime = 1 days;
uint256 stakingTime = 365 * 5 days;
uint256 stakingStart;
mapping(uint256 => address) public stakers;
mapping(uint256 => uint256) public staking_time;
modifier tokenIdWhiteList(uint256[] memory tokenIds) {
}
modifier isStakingAlive() {
require(<FILL_ME>)
_;
}
modifier isStakingEnded() {
}
modifier onlyOwner() {
}
constructor(
address _metagold_contract,
address _nft_contractAddress,
address _owner
) {
}
function stake(uint256[] memory tokenIds, uint256[] memory tokenValues)
external
isStakingAlive
tokenIdWhiteList(tokenIds)
returns (bool)
{
}
function unstake(uint256[] memory tokenIds, uint256[] memory tokenValues)
external
returns (bool)
{
}
function claimRewrad(uint256[] memory tokenIds) external returns (bool) {
}
function CalculateYield(uint256 tokenId) public view returns (uint256) {
}
function SafeNFTWithdraw(
uint256[] memory tokenIds,
uint256[] memory tokenValues
) external returns (bool) {
}
function postStakeWithdraw() external onlyOwner isStakingEnded {
}
function changeAdmin(address _newAdmin) external onlyOwner {
}
}
| stakingTime+stakingStart>block.timestamp,"Staking time ended" | 285,975 | stakingTime+stakingStart>block.timestamp |
"Staking time not ended" | pragma solidity 0.8.0;
contract Holder is ERC1155Holder {
ERC1155 nft_contract;
ERC20 metagold_contract;
address public owner;
uint256 tokenYields = 10;
uint256 yieldTime = 1 days;
uint256 stakingTime = 365 * 5 days;
uint256 stakingStart;
mapping(uint256 => address) public stakers;
mapping(uint256 => uint256) public staking_time;
modifier tokenIdWhiteList(uint256[] memory tokenIds) {
}
modifier isStakingAlive() {
}
modifier isStakingEnded() {
require(<FILL_ME>)
_;
}
modifier onlyOwner() {
}
constructor(
address _metagold_contract,
address _nft_contractAddress,
address _owner
) {
}
function stake(uint256[] memory tokenIds, uint256[] memory tokenValues)
external
isStakingAlive
tokenIdWhiteList(tokenIds)
returns (bool)
{
}
function unstake(uint256[] memory tokenIds, uint256[] memory tokenValues)
external
returns (bool)
{
}
function claimRewrad(uint256[] memory tokenIds) external returns (bool) {
}
function CalculateYield(uint256 tokenId) public view returns (uint256) {
}
function SafeNFTWithdraw(
uint256[] memory tokenIds,
uint256[] memory tokenValues
) external returns (bool) {
}
function postStakeWithdraw() external onlyOwner isStakingEnded {
}
function changeAdmin(address _newAdmin) external onlyOwner {
}
}
| stakingTime+stakingStart<=block.timestamp,"Staking time not ended" | 285,975 | stakingTime+stakingStart<=block.timestamp |
"Opeartaor was not approved" | pragma solidity 0.8.0;
contract Holder is ERC1155Holder {
ERC1155 nft_contract;
ERC20 metagold_contract;
address public owner;
uint256 tokenYields = 10;
uint256 yieldTime = 1 days;
uint256 stakingTime = 365 * 5 days;
uint256 stakingStart;
mapping(uint256 => address) public stakers;
mapping(uint256 => uint256) public staking_time;
modifier tokenIdWhiteList(uint256[] memory tokenIds) {
}
modifier isStakingAlive() {
}
modifier isStakingEnded() {
}
modifier onlyOwner() {
}
constructor(
address _metagold_contract,
address _nft_contractAddress,
address _owner
) {
}
function stake(uint256[] memory tokenIds, uint256[] memory tokenValues)
external
isStakingAlive
tokenIdWhiteList(tokenIds)
returns (bool)
{
require(<FILL_ME>)
// user must own the nfts
for (uint256 i = 0; i < tokenIds.length; i++) {
require(
nft_contract.balanceOf(msg.sender, tokenIds[i]) == 1,
"User must own the NFT"
);
}
nft_contract.safeBatchTransferFrom(
msg.sender,
address(this),
tokenIds,
tokenValues,
""
);
for (uint256 i = 0; i < tokenIds.length; i++) {
stakers[tokenIds[i]] = msg.sender;
staking_time[tokenIds[i]] = block.timestamp;
}
return true;
}
function unstake(uint256[] memory tokenIds, uint256[] memory tokenValues)
external
returns (bool)
{
}
function claimRewrad(uint256[] memory tokenIds) external returns (bool) {
}
function CalculateYield(uint256 tokenId) public view returns (uint256) {
}
function SafeNFTWithdraw(
uint256[] memory tokenIds,
uint256[] memory tokenValues
) external returns (bool) {
}
function postStakeWithdraw() external onlyOwner isStakingEnded {
}
function changeAdmin(address _newAdmin) external onlyOwner {
}
}
| nft_contract.isApprovedForAll(msg.sender,address(this)),"Opeartaor was not approved" | 285,975 | nft_contract.isApprovedForAll(msg.sender,address(this)) |
"User must own the NFT" | pragma solidity 0.8.0;
contract Holder is ERC1155Holder {
ERC1155 nft_contract;
ERC20 metagold_contract;
address public owner;
uint256 tokenYields = 10;
uint256 yieldTime = 1 days;
uint256 stakingTime = 365 * 5 days;
uint256 stakingStart;
mapping(uint256 => address) public stakers;
mapping(uint256 => uint256) public staking_time;
modifier tokenIdWhiteList(uint256[] memory tokenIds) {
}
modifier isStakingAlive() {
}
modifier isStakingEnded() {
}
modifier onlyOwner() {
}
constructor(
address _metagold_contract,
address _nft_contractAddress,
address _owner
) {
}
function stake(uint256[] memory tokenIds, uint256[] memory tokenValues)
external
isStakingAlive
tokenIdWhiteList(tokenIds)
returns (bool)
{
require(
nft_contract.isApprovedForAll(msg.sender, address(this)),
"Opeartaor was not approved"
);
// user must own the nfts
for (uint256 i = 0; i < tokenIds.length; i++) {
require(<FILL_ME>)
}
nft_contract.safeBatchTransferFrom(
msg.sender,
address(this),
tokenIds,
tokenValues,
""
);
for (uint256 i = 0; i < tokenIds.length; i++) {
stakers[tokenIds[i]] = msg.sender;
staking_time[tokenIds[i]] = block.timestamp;
}
return true;
}
function unstake(uint256[] memory tokenIds, uint256[] memory tokenValues)
external
returns (bool)
{
}
function claimRewrad(uint256[] memory tokenIds) external returns (bool) {
}
function CalculateYield(uint256 tokenId) public view returns (uint256) {
}
function SafeNFTWithdraw(
uint256[] memory tokenIds,
uint256[] memory tokenValues
) external returns (bool) {
}
function postStakeWithdraw() external onlyOwner isStakingEnded {
}
function changeAdmin(address _newAdmin) external onlyOwner {
}
}
| nft_contract.balanceOf(msg.sender,tokenIds[i])==1,"User must own the NFT" | 285,975 | nft_contract.balanceOf(msg.sender,tokenIds[i])==1 |
"User didn't stake the contract" | pragma solidity 0.8.0;
contract Holder is ERC1155Holder {
ERC1155 nft_contract;
ERC20 metagold_contract;
address public owner;
uint256 tokenYields = 10;
uint256 yieldTime = 1 days;
uint256 stakingTime = 365 * 5 days;
uint256 stakingStart;
mapping(uint256 => address) public stakers;
mapping(uint256 => uint256) public staking_time;
modifier tokenIdWhiteList(uint256[] memory tokenIds) {
}
modifier isStakingAlive() {
}
modifier isStakingEnded() {
}
modifier onlyOwner() {
}
constructor(
address _metagold_contract,
address _nft_contractAddress,
address _owner
) {
}
function stake(uint256[] memory tokenIds, uint256[] memory tokenValues)
external
isStakingAlive
tokenIdWhiteList(tokenIds)
returns (bool)
{
}
function unstake(uint256[] memory tokenIds, uint256[] memory tokenValues)
external
returns (bool)
{
// unstake logic
uint256 _tokenYield;
for (uint256 i = 0; i < tokenIds.length; i++) {
require(<FILL_ME>)
_tokenYield += CalculateYield(tokenIds[i]);
stakers[tokenIds[i]] = address(0);
staking_time[tokenIds[i]] = 0;
}
nft_contract.safeBatchTransferFrom(
address(this),
msg.sender,
tokenIds,
tokenValues,
""
);
// user gets rewards
require(metagold_contract.transfer(msg.sender, _tokenYield), "failed");
return true;
}
function claimRewrad(uint256[] memory tokenIds) external returns (bool) {
}
function CalculateYield(uint256 tokenId) public view returns (uint256) {
}
function SafeNFTWithdraw(
uint256[] memory tokenIds,
uint256[] memory tokenValues
) external returns (bool) {
}
function postStakeWithdraw() external onlyOwner isStakingEnded {
}
function changeAdmin(address _newAdmin) external onlyOwner {
}
}
| stakers[tokenIds[i]]==msg.sender,"User didn't stake the contract" | 285,975 | stakers[tokenIds[i]]==msg.sender |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.