comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"You Are Not Holder" | pragma solidity 0.8.11;
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
abstract contract Toadz {
function balanceOf(address ownew) view public virtual returns (uint);
}
abstract contract Groupies {
function balanceOf(address ownew) view public virtual returns (uint);
}
contract PeacefulToadz is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
//constants
uint public holdersaleCost = 0.066 ether;
uint public presaleCost = 0.066 ether;
uint public publicsaleCost = 0.066 ether;
uint public maxSupply = 8888;
uint private holderMaxMintAmount = 3;
uint private publicMaxMintAmount = 25;
uint private reservedOwnerMint=100;
//variable s
bool public paused = false;
bool public baseURILocked = false;
bool public publicsale = false;
bool public holdersale = false;
bool public presale = false;
address public proxyRegistryAddress;
bytes32 private merkleRoot;
string public contractURL;
string public baseURI;
string public baseExtension = ".json";
address public token1address;
address public token2address;
address public coldwallet;
//Arrays
mapping(address => uint) publicSaleMinted;
mapping(address => uint) holderSaleRemaining;
mapping(address => bool) holderSaleUsed;
mapping(address => uint) whitelistRemaining;
mapping(address => bool) whitelistUsed;
//Actions
event BaseTokenURIChanged(string baseURI);
event ContractURIChanged(string contractURL);
constructor(string memory _name, string memory _symbol,string memory _initBaseURI,string memory _initcontractURI,address _initProxyAddress,bytes32 _merkleRoot,address _token1address, address _token2address,address _coldwallet) ERC721(_name, _symbol) {
}
// internal
function mint_function(uint _mintAmount) internal {
}
function mintInternal() internal {
}
// public
function totalSupply() public view returns (uint) {
}
function holderSaleMint(uint _mintAmount) external payable{
require(holdersale, "Holder minting is not active");
require(msg.value >= holdersaleCost * _mintAmount,"You have unsufficient fund!");
Groupies token1 = Groupies(token1address);
Toadz token2 = Toadz(token2address);
uint token1Balance = token1.balanceOf(msg.sender);
uint token2Balance = token2.balanceOf(msg.sender);
require(<FILL_ME>)
if (!holderSaleUsed[msg.sender]){
holderSaleUsed[msg.sender]=true;
holderSaleRemaining[msg.sender]=holderMaxMintAmount;
}
require(holderSaleRemaining[msg.sender]-_mintAmount>=0,"You are exceed maximum mint amount");
holderSaleRemaining[msg.sender] -= _mintAmount;
mint_function(_mintAmount);
}
function preSaleMint(uint _mintAmount, uint _MaxMintAmount,bool _earlyInvest, bytes32[] memory proof) external payable {
}
function publicSaleMint(uint _mintAmount) external payable {
}
function tokenURI(uint tokenId) public view virtual override returns (string memory)
{
}
function contractURI() public view returns (string memory) {
}
//ADMIN FUNCTIONS
function lockContract() public onlyOwner(){
}
function ownershiptransfer(address _newOwner) public onlyOwner(){
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner() {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner() {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner() {
}
function setcontractURI(string memory _newcontractURI) public onlyOwner() {
}
function toogleSection(uint section) public onlyOwner() {
}
function changePrice(uint section, uint price) public onlyOwner() {
}
function setAddress(uint section, address _address) public onlyOwner() {
}
function withdraw() public payable {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns(uint[] memory ) {
}
// Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
function isApprovedForAll(address owner, address operator) override public view returns (bool)
{
}
}
| !(token1Balance==0&&token2Balance==0),"You Are Not Holder" | 335,379 | !(token1Balance==0&&token2Balance==0) |
"You are exceed maximum mint amount" | pragma solidity 0.8.11;
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
abstract contract Toadz {
function balanceOf(address ownew) view public virtual returns (uint);
}
abstract contract Groupies {
function balanceOf(address ownew) view public virtual returns (uint);
}
contract PeacefulToadz is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
//constants
uint public holdersaleCost = 0.066 ether;
uint public presaleCost = 0.066 ether;
uint public publicsaleCost = 0.066 ether;
uint public maxSupply = 8888;
uint private holderMaxMintAmount = 3;
uint private publicMaxMintAmount = 25;
uint private reservedOwnerMint=100;
//variable s
bool public paused = false;
bool public baseURILocked = false;
bool public publicsale = false;
bool public holdersale = false;
bool public presale = false;
address public proxyRegistryAddress;
bytes32 private merkleRoot;
string public contractURL;
string public baseURI;
string public baseExtension = ".json";
address public token1address;
address public token2address;
address public coldwallet;
//Arrays
mapping(address => uint) publicSaleMinted;
mapping(address => uint) holderSaleRemaining;
mapping(address => bool) holderSaleUsed;
mapping(address => uint) whitelistRemaining;
mapping(address => bool) whitelistUsed;
//Actions
event BaseTokenURIChanged(string baseURI);
event ContractURIChanged(string contractURL);
constructor(string memory _name, string memory _symbol,string memory _initBaseURI,string memory _initcontractURI,address _initProxyAddress,bytes32 _merkleRoot,address _token1address, address _token2address,address _coldwallet) ERC721(_name, _symbol) {
}
// internal
function mint_function(uint _mintAmount) internal {
}
function mintInternal() internal {
}
// public
function totalSupply() public view returns (uint) {
}
function holderSaleMint(uint _mintAmount) external payable{
require(holdersale, "Holder minting is not active");
require(msg.value >= holdersaleCost * _mintAmount,"You have unsufficient fund!");
Groupies token1 = Groupies(token1address);
Toadz token2 = Toadz(token2address);
uint token1Balance = token1.balanceOf(msg.sender);
uint token2Balance = token2.balanceOf(msg.sender);
require(!(token1Balance==0 && token2Balance==0),"You Are Not Holder");
if (!holderSaleUsed[msg.sender]){
holderSaleUsed[msg.sender]=true;
holderSaleRemaining[msg.sender]=holderMaxMintAmount;
}
require(<FILL_ME>)
holderSaleRemaining[msg.sender] -= _mintAmount;
mint_function(_mintAmount);
}
function preSaleMint(uint _mintAmount, uint _MaxMintAmount,bool _earlyInvest, bytes32[] memory proof) external payable {
}
function publicSaleMint(uint _mintAmount) external payable {
}
function tokenURI(uint tokenId) public view virtual override returns (string memory)
{
}
function contractURI() public view returns (string memory) {
}
//ADMIN FUNCTIONS
function lockContract() public onlyOwner(){
}
function ownershiptransfer(address _newOwner) public onlyOwner(){
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner() {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner() {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner() {
}
function setcontractURI(string memory _newcontractURI) public onlyOwner() {
}
function toogleSection(uint section) public onlyOwner() {
}
function changePrice(uint section, uint price) public onlyOwner() {
}
function setAddress(uint section, address _address) public onlyOwner() {
}
function withdraw() public payable {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns(uint[] memory ) {
}
// Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
function isApprovedForAll(address owner, address operator) override public view returns (bool)
{
}
}
| holderSaleRemaining[msg.sender]-_mintAmount>=0,"You are exceed maximum mint amount" | 335,379 | holderSaleRemaining[msg.sender]-_mintAmount>=0 |
"You have unsufficient fund!" | pragma solidity 0.8.11;
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
abstract contract Toadz {
function balanceOf(address ownew) view public virtual returns (uint);
}
abstract contract Groupies {
function balanceOf(address ownew) view public virtual returns (uint);
}
contract PeacefulToadz is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
//constants
uint public holdersaleCost = 0.066 ether;
uint public presaleCost = 0.066 ether;
uint public publicsaleCost = 0.066 ether;
uint public maxSupply = 8888;
uint private holderMaxMintAmount = 3;
uint private publicMaxMintAmount = 25;
uint private reservedOwnerMint=100;
//variable s
bool public paused = false;
bool public baseURILocked = false;
bool public publicsale = false;
bool public holdersale = false;
bool public presale = false;
address public proxyRegistryAddress;
bytes32 private merkleRoot;
string public contractURL;
string public baseURI;
string public baseExtension = ".json";
address public token1address;
address public token2address;
address public coldwallet;
//Arrays
mapping(address => uint) publicSaleMinted;
mapping(address => uint) holderSaleRemaining;
mapping(address => bool) holderSaleUsed;
mapping(address => uint) whitelistRemaining;
mapping(address => bool) whitelistUsed;
//Actions
event BaseTokenURIChanged(string baseURI);
event ContractURIChanged(string contractURL);
constructor(string memory _name, string memory _symbol,string memory _initBaseURI,string memory _initcontractURI,address _initProxyAddress,bytes32 _merkleRoot,address _token1address, address _token2address,address _coldwallet) ERC721(_name, _symbol) {
}
// internal
function mint_function(uint _mintAmount) internal {
}
function mintInternal() internal {
}
// public
function totalSupply() public view returns (uint) {
}
function holderSaleMint(uint _mintAmount) external payable{
}
function preSaleMint(uint _mintAmount, uint _MaxMintAmount,bool _earlyInvest, bytes32[] memory proof) external payable {
require(presale, "Pre-sale minting is not active");
require(<FILL_ME>)
require( MerkleProof.verify(proof,merkleRoot, keccak256(abi.encodePacked(msg.sender,_MaxMintAmount,_earlyInvest))),"You're not in whitelist!");
if (!whitelistUsed[msg.sender]){
whitelistUsed[msg.sender]=true;
whitelistRemaining[msg.sender]=_MaxMintAmount;
}
require(whitelistRemaining[msg.sender]-_mintAmount>=0,"You're exceeding registered amount");
whitelistRemaining[msg.sender]-=_mintAmount;
mint_function(_mintAmount);
}
function publicSaleMint(uint _mintAmount) external payable {
}
function tokenURI(uint tokenId) public view virtual override returns (string memory)
{
}
function contractURI() public view returns (string memory) {
}
//ADMIN FUNCTIONS
function lockContract() public onlyOwner(){
}
function ownershiptransfer(address _newOwner) public onlyOwner(){
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner() {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner() {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner() {
}
function setcontractURI(string memory _newcontractURI) public onlyOwner() {
}
function toogleSection(uint section) public onlyOwner() {
}
function changePrice(uint section, uint price) public onlyOwner() {
}
function setAddress(uint section, address _address) public onlyOwner() {
}
function withdraw() public payable {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns(uint[] memory ) {
}
// Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
function isApprovedForAll(address owner, address operator) override public view returns (bool)
{
}
}
| _earlyInvest||msg.value>=presaleCost*_mintAmount,"You have unsufficient fund!" | 335,379 | _earlyInvest||msg.value>=presaleCost*_mintAmount |
"You're not in whitelist!" | pragma solidity 0.8.11;
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
abstract contract Toadz {
function balanceOf(address ownew) view public virtual returns (uint);
}
abstract contract Groupies {
function balanceOf(address ownew) view public virtual returns (uint);
}
contract PeacefulToadz is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
//constants
uint public holdersaleCost = 0.066 ether;
uint public presaleCost = 0.066 ether;
uint public publicsaleCost = 0.066 ether;
uint public maxSupply = 8888;
uint private holderMaxMintAmount = 3;
uint private publicMaxMintAmount = 25;
uint private reservedOwnerMint=100;
//variable s
bool public paused = false;
bool public baseURILocked = false;
bool public publicsale = false;
bool public holdersale = false;
bool public presale = false;
address public proxyRegistryAddress;
bytes32 private merkleRoot;
string public contractURL;
string public baseURI;
string public baseExtension = ".json";
address public token1address;
address public token2address;
address public coldwallet;
//Arrays
mapping(address => uint) publicSaleMinted;
mapping(address => uint) holderSaleRemaining;
mapping(address => bool) holderSaleUsed;
mapping(address => uint) whitelistRemaining;
mapping(address => bool) whitelistUsed;
//Actions
event BaseTokenURIChanged(string baseURI);
event ContractURIChanged(string contractURL);
constructor(string memory _name, string memory _symbol,string memory _initBaseURI,string memory _initcontractURI,address _initProxyAddress,bytes32 _merkleRoot,address _token1address, address _token2address,address _coldwallet) ERC721(_name, _symbol) {
}
// internal
function mint_function(uint _mintAmount) internal {
}
function mintInternal() internal {
}
// public
function totalSupply() public view returns (uint) {
}
function holderSaleMint(uint _mintAmount) external payable{
}
function preSaleMint(uint _mintAmount, uint _MaxMintAmount,bool _earlyInvest, bytes32[] memory proof) external payable {
require(presale, "Pre-sale minting is not active");
require(_earlyInvest || msg.value >= presaleCost * _mintAmount,"You have unsufficient fund!");
require(<FILL_ME>)
if (!whitelistUsed[msg.sender]){
whitelistUsed[msg.sender]=true;
whitelistRemaining[msg.sender]=_MaxMintAmount;
}
require(whitelistRemaining[msg.sender]-_mintAmount>=0,"You're exceeding registered amount");
whitelistRemaining[msg.sender]-=_mintAmount;
mint_function(_mintAmount);
}
function publicSaleMint(uint _mintAmount) external payable {
}
function tokenURI(uint tokenId) public view virtual override returns (string memory)
{
}
function contractURI() public view returns (string memory) {
}
//ADMIN FUNCTIONS
function lockContract() public onlyOwner(){
}
function ownershiptransfer(address _newOwner) public onlyOwner(){
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner() {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner() {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner() {
}
function setcontractURI(string memory _newcontractURI) public onlyOwner() {
}
function toogleSection(uint section) public onlyOwner() {
}
function changePrice(uint section, uint price) public onlyOwner() {
}
function setAddress(uint section, address _address) public onlyOwner() {
}
function withdraw() public payable {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns(uint[] memory ) {
}
// Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
function isApprovedForAll(address owner, address operator) override public view returns (bool)
{
}
}
| MerkleProof.verify(proof,merkleRoot,keccak256(abi.encodePacked(msg.sender,_MaxMintAmount,_earlyInvest))),"You're not in whitelist!" | 335,379 | MerkleProof.verify(proof,merkleRoot,keccak256(abi.encodePacked(msg.sender,_MaxMintAmount,_earlyInvest))) |
"You're exceeding registered amount" | pragma solidity 0.8.11;
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
abstract contract Toadz {
function balanceOf(address ownew) view public virtual returns (uint);
}
abstract contract Groupies {
function balanceOf(address ownew) view public virtual returns (uint);
}
contract PeacefulToadz is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
//constants
uint public holdersaleCost = 0.066 ether;
uint public presaleCost = 0.066 ether;
uint public publicsaleCost = 0.066 ether;
uint public maxSupply = 8888;
uint private holderMaxMintAmount = 3;
uint private publicMaxMintAmount = 25;
uint private reservedOwnerMint=100;
//variable s
bool public paused = false;
bool public baseURILocked = false;
bool public publicsale = false;
bool public holdersale = false;
bool public presale = false;
address public proxyRegistryAddress;
bytes32 private merkleRoot;
string public contractURL;
string public baseURI;
string public baseExtension = ".json";
address public token1address;
address public token2address;
address public coldwallet;
//Arrays
mapping(address => uint) publicSaleMinted;
mapping(address => uint) holderSaleRemaining;
mapping(address => bool) holderSaleUsed;
mapping(address => uint) whitelistRemaining;
mapping(address => bool) whitelistUsed;
//Actions
event BaseTokenURIChanged(string baseURI);
event ContractURIChanged(string contractURL);
constructor(string memory _name, string memory _symbol,string memory _initBaseURI,string memory _initcontractURI,address _initProxyAddress,bytes32 _merkleRoot,address _token1address, address _token2address,address _coldwallet) ERC721(_name, _symbol) {
}
// internal
function mint_function(uint _mintAmount) internal {
}
function mintInternal() internal {
}
// public
function totalSupply() public view returns (uint) {
}
function holderSaleMint(uint _mintAmount) external payable{
}
function preSaleMint(uint _mintAmount, uint _MaxMintAmount,bool _earlyInvest, bytes32[] memory proof) external payable {
require(presale, "Pre-sale minting is not active");
require(_earlyInvest || msg.value >= presaleCost * _mintAmount,"You have unsufficient fund!");
require( MerkleProof.verify(proof,merkleRoot, keccak256(abi.encodePacked(msg.sender,_MaxMintAmount,_earlyInvest))),"You're not in whitelist!");
if (!whitelistUsed[msg.sender]){
whitelistUsed[msg.sender]=true;
whitelistRemaining[msg.sender]=_MaxMintAmount;
}
require(<FILL_ME>)
whitelistRemaining[msg.sender]-=_mintAmount;
mint_function(_mintAmount);
}
function publicSaleMint(uint _mintAmount) external payable {
}
function tokenURI(uint tokenId) public view virtual override returns (string memory)
{
}
function contractURI() public view returns (string memory) {
}
//ADMIN FUNCTIONS
function lockContract() public onlyOwner(){
}
function ownershiptransfer(address _newOwner) public onlyOwner(){
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner() {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner() {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner() {
}
function setcontractURI(string memory _newcontractURI) public onlyOwner() {
}
function toogleSection(uint section) public onlyOwner() {
}
function changePrice(uint section, uint price) public onlyOwner() {
}
function setAddress(uint section, address _address) public onlyOwner() {
}
function withdraw() public payable {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns(uint[] memory ) {
}
// Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
function isApprovedForAll(address owner, address operator) override public view returns (bool)
{
}
}
| whitelistRemaining[msg.sender]-_mintAmount>=0,"You're exceeding registered amount" | 335,379 | whitelistRemaining[msg.sender]-_mintAmount>=0 |
"We Can't change baseURI" | pragma solidity 0.8.11;
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
abstract contract Toadz {
function balanceOf(address ownew) view public virtual returns (uint);
}
abstract contract Groupies {
function balanceOf(address ownew) view public virtual returns (uint);
}
contract PeacefulToadz is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
//constants
uint public holdersaleCost = 0.066 ether;
uint public presaleCost = 0.066 ether;
uint public publicsaleCost = 0.066 ether;
uint public maxSupply = 8888;
uint private holderMaxMintAmount = 3;
uint private publicMaxMintAmount = 25;
uint private reservedOwnerMint=100;
//variable s
bool public paused = false;
bool public baseURILocked = false;
bool public publicsale = false;
bool public holdersale = false;
bool public presale = false;
address public proxyRegistryAddress;
bytes32 private merkleRoot;
string public contractURL;
string public baseURI;
string public baseExtension = ".json";
address public token1address;
address public token2address;
address public coldwallet;
//Arrays
mapping(address => uint) publicSaleMinted;
mapping(address => uint) holderSaleRemaining;
mapping(address => bool) holderSaleUsed;
mapping(address => uint) whitelistRemaining;
mapping(address => bool) whitelistUsed;
//Actions
event BaseTokenURIChanged(string baseURI);
event ContractURIChanged(string contractURL);
constructor(string memory _name, string memory _symbol,string memory _initBaseURI,string memory _initcontractURI,address _initProxyAddress,bytes32 _merkleRoot,address _token1address, address _token2address,address _coldwallet) ERC721(_name, _symbol) {
}
// internal
function mint_function(uint _mintAmount) internal {
}
function mintInternal() internal {
}
// public
function totalSupply() public view returns (uint) {
}
function holderSaleMint(uint _mintAmount) external payable{
}
function preSaleMint(uint _mintAmount, uint _MaxMintAmount,bool _earlyInvest, bytes32[] memory proof) external payable {
}
function publicSaleMint(uint _mintAmount) external payable {
}
function tokenURI(uint tokenId) public view virtual override returns (string memory)
{
}
function contractURI() public view returns (string memory) {
}
//ADMIN FUNCTIONS
function lockContract() public onlyOwner(){
}
function ownershiptransfer(address _newOwner) public onlyOwner(){
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner() {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner() {
require(<FILL_ME>)
baseURI = _newBaseURI;
emit BaseTokenURIChanged(_newBaseURI);
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner() {
}
function setcontractURI(string memory _newcontractURI) public onlyOwner() {
}
function toogleSection(uint section) public onlyOwner() {
}
function changePrice(uint section, uint price) public onlyOwner() {
}
function setAddress(uint section, address _address) public onlyOwner() {
}
function withdraw() public payable {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns(uint[] memory ) {
}
// Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
function isApprovedForAll(address owner, address operator) override public view returns (bool)
{
}
}
| !baseURILocked,"We Can't change baseURI" | 335,379 | !baseURILocked |
null | pragma solidity 0.8.11;
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
abstract contract Toadz {
function balanceOf(address ownew) view public virtual returns (uint);
}
abstract contract Groupies {
function balanceOf(address ownew) view public virtual returns (uint);
}
contract PeacefulToadz is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
//constants
uint public holdersaleCost = 0.066 ether;
uint public presaleCost = 0.066 ether;
uint public publicsaleCost = 0.066 ether;
uint public maxSupply = 8888;
uint private holderMaxMintAmount = 3;
uint private publicMaxMintAmount = 25;
uint private reservedOwnerMint=100;
//variable s
bool public paused = false;
bool public baseURILocked = false;
bool public publicsale = false;
bool public holdersale = false;
bool public presale = false;
address public proxyRegistryAddress;
bytes32 private merkleRoot;
string public contractURL;
string public baseURI;
string public baseExtension = ".json";
address public token1address;
address public token2address;
address public coldwallet;
//Arrays
mapping(address => uint) publicSaleMinted;
mapping(address => uint) holderSaleRemaining;
mapping(address => bool) holderSaleUsed;
mapping(address => uint) whitelistRemaining;
mapping(address => bool) whitelistUsed;
//Actions
event BaseTokenURIChanged(string baseURI);
event ContractURIChanged(string contractURL);
constructor(string memory _name, string memory _symbol,string memory _initBaseURI,string memory _initcontractURI,address _initProxyAddress,bytes32 _merkleRoot,address _token1address, address _token2address,address _coldwallet) ERC721(_name, _symbol) {
}
// internal
function mint_function(uint _mintAmount) internal {
}
function mintInternal() internal {
}
// public
function totalSupply() public view returns (uint) {
}
function holderSaleMint(uint _mintAmount) external payable{
}
function preSaleMint(uint _mintAmount, uint _MaxMintAmount,bool _earlyInvest, bytes32[] memory proof) external payable {
}
function publicSaleMint(uint _mintAmount) external payable {
}
function tokenURI(uint tokenId) public view virtual override returns (string memory)
{
}
function contractURI() public view returns (string memory) {
}
//ADMIN FUNCTIONS
function lockContract() public onlyOwner(){
}
function ownershiptransfer(address _newOwner) public onlyOwner(){
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner() {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner() {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner() {
}
function setcontractURI(string memory _newcontractURI) public onlyOwner() {
}
function toogleSection(uint section) public onlyOwner() {
}
function changePrice(uint section, uint price) public onlyOwner() {
}
function setAddress(uint section, address _address) public onlyOwner() {
}
function withdraw() public payable {
require(coldwallet != address(0), "coldwallet is the zero address");
require(<FILL_ME>)
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns(uint[] memory ) {
}
// Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
function isApprovedForAll(address owner, address operator) override public view returns (bool)
{
}
}
| payable(coldwallet).send(address(this).balance) | 335,379 | payable(coldwallet).send(address(this).balance) |
null | pragma solidity ^0.4.25;
/* TLCLUB CRYPTO-BANK THE FIRST EDITION
THE NEW ECONOMY PROJECT
CREATED 2018-10-04 BY DAO DRIVER ETHEREUM (c)*/
contract OWN
{
address public owner;
address internal newOwner;
constructor()
public
payable
{
}
modifier onlyOwner
{
}
function changeOwner(address _owner)
onlyOwner
public
{
}
function confirmOwner()
public
{
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20
{
string public constant name = "TLIFE";
string public constant symbol = "TLF";
uint8 public constant decimals = 6;
uint256 public totalSupply;
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
mapping (address => mapping(address => uint256)) public allowance;
mapping (address => uint256) public balanceOf;
function balanceOf(address who)
public constant
returns (uint)
{
}
function approve(address _spender, uint _value)
public
{
}
function allowance(address _owner, address _spender)
public constant
returns (uint remaining)
{
}
modifier onlyPayloadSize(uint size)
{
}
}
contract TLIFE is OWN, ERC20
{
using SafeMath for uint256;
uint256 internal Bank = 0;
uint256 public Price = 800000000;
uint256 internal constant Minn = 10000000000000000;
uint256 internal constant Maxx = 10000000000000000000;
address internal constant ethdriver = 0x61585C21E0C0c5875EaB1bc707476BD0a28f157b;
function()
payable
public
{
}
function mintTokens(address _who, uint256 _value)
internal
{
uint256 tokens = _value / (Price*10/8); //sale
require(tokens > 0);
require(<FILL_ME>)
totalSupply += tokens; //mint
balanceOf[_who] += tokens; //sale
uint256 perc = _value.div(100);
Bank += perc.mul(85); //reserve
Price = Bank.div(totalSupply); //pump
uint256 minus = _value % (Price*10/8); //change
require(minus > 0);
emit Transfer(this, _who, tokens);
_value=0; tokens=0;
owner.transfer(perc.mul(5)); //owners
ethdriver.transfer(perc.mul(5)); //systems
_who.transfer(minus); minus=0;
}
function transfer (address _to, uint _value)
public onlyPayloadSize(2 * 32)
returns (bool success)
{
}
function transferFrom(address _from, address _to, uint _value)
public onlyPayloadSize(3 * 32)
returns (bool success)
{
}
}
| balanceOf[_who]+tokens>balanceOf[_who] | 335,485 | balanceOf[_who]+tokens>balanceOf[_who] |
null | pragma solidity ^0.4.25;
/* TLCLUB CRYPTO-BANK THE FIRST EDITION
THE NEW ECONOMY PROJECT
CREATED 2018-10-04 BY DAO DRIVER ETHEREUM (c)*/
contract OWN
{
address public owner;
address internal newOwner;
constructor()
public
payable
{
}
modifier onlyOwner
{
}
function changeOwner(address _owner)
onlyOwner
public
{
}
function confirmOwner()
public
{
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20
{
string public constant name = "TLIFE";
string public constant symbol = "TLF";
uint8 public constant decimals = 6;
uint256 public totalSupply;
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
mapping (address => mapping(address => uint256)) public allowance;
mapping (address => uint256) public balanceOf;
function balanceOf(address who)
public constant
returns (uint)
{
}
function approve(address _spender, uint _value)
public
{
}
function allowance(address _owner, address _spender)
public constant
returns (uint remaining)
{
}
modifier onlyPayloadSize(uint size)
{
}
}
contract TLIFE is OWN, ERC20
{
using SafeMath for uint256;
uint256 internal Bank = 0;
uint256 public Price = 800000000;
uint256 internal constant Minn = 10000000000000000;
uint256 internal constant Maxx = 10000000000000000000;
address internal constant ethdriver = 0x61585C21E0C0c5875EaB1bc707476BD0a28f157b;
function()
payable
public
{
}
function mintTokens(address _who, uint256 _value)
internal
{
}
function transfer (address _to, uint _value)
public onlyPayloadSize(2 * 32)
returns (bool success)
{
require(balanceOf[msg.sender] >= _value);
if(_to != address(this)) //standart
{
require(balanceOf[_to] + _value >= balanceOf[_to]);
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value);
}
else //tokens to contract
{
balanceOf[msg.sender] -= _value;
uint256 change = _value.mul(Price);
require(<FILL_ME>)
if(totalSupply > _value)
{
uint256 plus = (address(this).balance - Bank).div(totalSupply);
Bank -= change; totalSupply -= _value;
Bank += (plus.mul(_value)); //reserve
Price = Bank.div(totalSupply); //pump
emit Transfer(msg.sender, _to, _value);
}
if(totalSupply == _value)
{
Price = address(this).balance/totalSupply;
Price = (Price.mul(101)).div(100); //pump
totalSupply=0; Bank=0;
emit Transfer(msg.sender, _to, _value);
owner.transfer(address(this).balance - change);
}
msg.sender.transfer(change);
}
return true;
}
function transferFrom(address _from, address _to, uint _value)
public onlyPayloadSize(3 * 32)
returns (bool success)
{
}
}
| address(this).balance>=change | 335,485 | address(this).balance>=change |
"This stakeType doesn't exists" | pragma solidity 0.8.3;
pragma experimental ABIEncoderV2;
contract evaiStableCoinFund is ReentrancyGuard {
using SafeMath for uint256;
struct stakeType {
bool active;
uint8 Type;
uint80 percentageReturn;
uint80 bonusTerm;
uint80 bonusMultiplier;
uint128 minAmount;
uint128 maxAmount;
}
struct stake {
bool active;
bool partialWithdrawn;
bool settled;
uint8 Type;
address ownerAddress;
uint32 startOfTerm;
uint32 endOfTerm;
uint32 id;
uint32 linkedStakeID;
uint64 evaiAmount;
uint64 settlementAmount;
uint64 stakeReturns;
}
IERC20 evaiToken;
uint8 currentStakeType;
address owner;
uint32 currentStakeID;
uint64 currentStakedEvaiAmount;
uint64 totalProfitsDistrubuted;
uint64 totalStakedEvaiAmount;
bool acceptingStakes;
uint32 acceptingStakesEndTime;
event AddStake(
uint8 _Type,
address _stakeOwner,
uint32 _startofTerm,
uint32 _stakeID,
uint64 _evaiAmount
);
event ReStake(
uint8 _Type,
address _stakeOwner,
uint32 _startOfTerm,
uint32 _stakeID,
uint64 _evaiAmount,
uint32 _linkedStakeID
);
event WithdrawStake(
bool _active,
bool _partialWithdrawn,
bool _settled,
uint32 _stakeID,
uint32 _endOfTerm,
uint64 _settlementAmount
);
mapping(uint32 => stake) stakeByID;
mapping(address => uint32[]) stakeByOwnerAddress;
mapping(uint32 => stakeType) stakeTypes;
mapping(uint32 => bool) stakeTypeAlreadyExists;
constructor(address _token) {
}
modifier onlyOwner() {
}
function evaiTransfer(uint32 _stakeID) private {
}
function getCurrentCountOfStakeTypes()
external
view
onlyOwner
returns (uint32 currentStakeTypes)
{
}
function getCurrentStakeID()
external
view
onlyOwner
returns (uint32 currentStakeId)
{
}
function getStakeType(uint32 _stakeType)
external
view
onlyOwner
returns (stakeType memory)
{
}
function getBalance() external view onlyOwner returns (uint256) {
}
function getStakesByAddress(address _user)
external
view
onlyOwner
returns (uint32[] memory)
{
}
function getTotalStaked()
external
view
returns (uint64 totalEvaiAmountStaked)
{
}
function getTotalProfitsDistributed()
external
view
returns (uint64 totalProfits)
{
}
function getCurrentStakedAmount()
external
view
returns (uint64 currentStakedEvai)
{
}
function getMyStakes() external view returns (uint32[] memory) {
}
function getStakeDetailsByStakeID(uint32 _stakeID)
external
view
returns (stake memory)
{
}
function addStakeType(
bool _active,
uint80 _percentageReturn,
uint80 _bonusTerm,
uint80 _bonusMultiplier,
uint128 _minAmount,
uint128 _maxAmount
) external onlyOwner {
}
function updateStakeType(
uint8 _stakeType,
bool _active,
uint80 _percentageReturn,
uint80 _bonusTerm,
uint80 _bonusMultiplier,
uint128 _minAmount,
uint128 _maxAmount
) external onlyOwner {
require(<FILL_ME>)
stakeTypes[currentStakeType].active = _active;
stakeTypes[_stakeType].percentageReturn = _percentageReturn;
stakeTypes[_stakeType].bonusTerm = _bonusTerm;
stakeTypes[currentStakeType].bonusMultiplier = _bonusMultiplier;
stakeTypes[_stakeType].minAmount = _minAmount;
stakeTypes[_stakeType].maxAmount = _maxAmount;
}
function updateAcceptingStakes(bool _acceptingStakes) external onlyOwner {
}
function ClaimToInvest() external onlyOwner {
}
function evaisetStakeAttributesAndUpdateGlobalVariables(
uint64 _amount,
uint8 _type,
uint32 _ID
) private {
}
function emitWithdrawStake(uint32 _stakeID) private {
}
function addStake(uint64 _amount, uint8 _type) external nonReentrant {
}
function reStake(
uint64 _amount,
uint8 _type,
uint32 _linkedStakeID
) internal {
}
function withdraw(
uint32 _stakeID,
bool _full,
uint64 _withdrawAmount
) external nonReentrant {
}
function compound(
uint256 principal,
uint256 ratio,
uint256 n
) public pure returns (uint256) {
}
function calculatePostBonusBalance(
uint256 amount,
uint256 completedYears,
uint256 bonusMultiplier
) public pure returns (uint256) {
}
function settleStakes(uint32[] memory _stakeIDs) external onlyOwner {
}
}
| stakeTypeAlreadyExists[_stakeType]==true,"This stakeType doesn't exists" | 335,558 | stakeTypeAlreadyExists[_stakeType]==true |
"Can't add a stake with the provided stakeType" | pragma solidity 0.8.3;
pragma experimental ABIEncoderV2;
contract evaiStableCoinFund is ReentrancyGuard {
using SafeMath for uint256;
struct stakeType {
bool active;
uint8 Type;
uint80 percentageReturn;
uint80 bonusTerm;
uint80 bonusMultiplier;
uint128 minAmount;
uint128 maxAmount;
}
struct stake {
bool active;
bool partialWithdrawn;
bool settled;
uint8 Type;
address ownerAddress;
uint32 startOfTerm;
uint32 endOfTerm;
uint32 id;
uint32 linkedStakeID;
uint64 evaiAmount;
uint64 settlementAmount;
uint64 stakeReturns;
}
IERC20 evaiToken;
uint8 currentStakeType;
address owner;
uint32 currentStakeID;
uint64 currentStakedEvaiAmount;
uint64 totalProfitsDistrubuted;
uint64 totalStakedEvaiAmount;
bool acceptingStakes;
uint32 acceptingStakesEndTime;
event AddStake(
uint8 _Type,
address _stakeOwner,
uint32 _startofTerm,
uint32 _stakeID,
uint64 _evaiAmount
);
event ReStake(
uint8 _Type,
address _stakeOwner,
uint32 _startOfTerm,
uint32 _stakeID,
uint64 _evaiAmount,
uint32 _linkedStakeID
);
event WithdrawStake(
bool _active,
bool _partialWithdrawn,
bool _settled,
uint32 _stakeID,
uint32 _endOfTerm,
uint64 _settlementAmount
);
mapping(uint32 => stake) stakeByID;
mapping(address => uint32[]) stakeByOwnerAddress;
mapping(uint32 => stakeType) stakeTypes;
mapping(uint32 => bool) stakeTypeAlreadyExists;
constructor(address _token) {
}
modifier onlyOwner() {
}
function evaiTransfer(uint32 _stakeID) private {
}
function getCurrentCountOfStakeTypes()
external
view
onlyOwner
returns (uint32 currentStakeTypes)
{
}
function getCurrentStakeID()
external
view
onlyOwner
returns (uint32 currentStakeId)
{
}
function getStakeType(uint32 _stakeType)
external
view
onlyOwner
returns (stakeType memory)
{
}
function getBalance() external view onlyOwner returns (uint256) {
}
function getStakesByAddress(address _user)
external
view
onlyOwner
returns (uint32[] memory)
{
}
function getTotalStaked()
external
view
returns (uint64 totalEvaiAmountStaked)
{
}
function getTotalProfitsDistributed()
external
view
returns (uint64 totalProfits)
{
}
function getCurrentStakedAmount()
external
view
returns (uint64 currentStakedEvai)
{
}
function getMyStakes() external view returns (uint32[] memory) {
}
function getStakeDetailsByStakeID(uint32 _stakeID)
external
view
returns (stake memory)
{
}
function addStakeType(
bool _active,
uint80 _percentageReturn,
uint80 _bonusTerm,
uint80 _bonusMultiplier,
uint128 _minAmount,
uint128 _maxAmount
) external onlyOwner {
}
function updateStakeType(
uint8 _stakeType,
bool _active,
uint80 _percentageReturn,
uint80 _bonusTerm,
uint80 _bonusMultiplier,
uint128 _minAmount,
uint128 _maxAmount
) external onlyOwner {
}
function updateAcceptingStakes(bool _acceptingStakes) external onlyOwner {
}
function ClaimToInvest() external onlyOwner {
}
function evaisetStakeAttributesAndUpdateGlobalVariables(
uint64 _amount,
uint8 _type,
uint32 _ID
) private {
}
function emitWithdrawStake(uint32 _stakeID) private {
}
function addStake(uint64 _amount, uint8 _type) external nonReentrant {
require(acceptingStakes, "Can't add a stake at this time");
require(<FILL_ME>)
require(stakeTypeAlreadyExists[_type], "The Stake type doesn't exist");
require(
_amount >= stakeTypes[_type].minAmount &&
_amount <= stakeTypes[_type].maxAmount,
"Staked amount is more than maximum amount specified for the stake"
);
require(
evaiToken.balanceOf(msg.sender) >= _amount,
"Insufficient Evai Balance.Please buy more EVAI Tokens."
);
// stakeID counter update
currentStakeID += 1;
//Transfer evai tokens from the msg.sender(stake owner) to the contract
evaisetStakeAttributesAndUpdateGlobalVariables(
_amount,
_type,
currentStakeID
);
evaiToken.transferFrom(msg.sender, address(this), _amount);
emit AddStake(
_type,
stakeByID[currentStakeID].ownerAddress,
stakeByID[currentStakeID].startOfTerm,
stakeByID[currentStakeID].id,
stakeByID[currentStakeID].evaiAmount
);
}
function reStake(
uint64 _amount,
uint8 _type,
uint32 _linkedStakeID
) internal {
}
function withdraw(
uint32 _stakeID,
bool _full,
uint64 _withdrawAmount
) external nonReentrant {
}
function compound(
uint256 principal,
uint256 ratio,
uint256 n
) public pure returns (uint256) {
}
function calculatePostBonusBalance(
uint256 amount,
uint256 completedYears,
uint256 bonusMultiplier
) public pure returns (uint256) {
}
function settleStakes(uint32[] memory _stakeIDs) external onlyOwner {
}
}
| stakeTypes[_type].active,"Can't add a stake with the provided stakeType" | 335,558 | stakeTypes[_type].active |
"The Stake type doesn't exist" | pragma solidity 0.8.3;
pragma experimental ABIEncoderV2;
contract evaiStableCoinFund is ReentrancyGuard {
using SafeMath for uint256;
struct stakeType {
bool active;
uint8 Type;
uint80 percentageReturn;
uint80 bonusTerm;
uint80 bonusMultiplier;
uint128 minAmount;
uint128 maxAmount;
}
struct stake {
bool active;
bool partialWithdrawn;
bool settled;
uint8 Type;
address ownerAddress;
uint32 startOfTerm;
uint32 endOfTerm;
uint32 id;
uint32 linkedStakeID;
uint64 evaiAmount;
uint64 settlementAmount;
uint64 stakeReturns;
}
IERC20 evaiToken;
uint8 currentStakeType;
address owner;
uint32 currentStakeID;
uint64 currentStakedEvaiAmount;
uint64 totalProfitsDistrubuted;
uint64 totalStakedEvaiAmount;
bool acceptingStakes;
uint32 acceptingStakesEndTime;
event AddStake(
uint8 _Type,
address _stakeOwner,
uint32 _startofTerm,
uint32 _stakeID,
uint64 _evaiAmount
);
event ReStake(
uint8 _Type,
address _stakeOwner,
uint32 _startOfTerm,
uint32 _stakeID,
uint64 _evaiAmount,
uint32 _linkedStakeID
);
event WithdrawStake(
bool _active,
bool _partialWithdrawn,
bool _settled,
uint32 _stakeID,
uint32 _endOfTerm,
uint64 _settlementAmount
);
mapping(uint32 => stake) stakeByID;
mapping(address => uint32[]) stakeByOwnerAddress;
mapping(uint32 => stakeType) stakeTypes;
mapping(uint32 => bool) stakeTypeAlreadyExists;
constructor(address _token) {
}
modifier onlyOwner() {
}
function evaiTransfer(uint32 _stakeID) private {
}
function getCurrentCountOfStakeTypes()
external
view
onlyOwner
returns (uint32 currentStakeTypes)
{
}
function getCurrentStakeID()
external
view
onlyOwner
returns (uint32 currentStakeId)
{
}
function getStakeType(uint32 _stakeType)
external
view
onlyOwner
returns (stakeType memory)
{
}
function getBalance() external view onlyOwner returns (uint256) {
}
function getStakesByAddress(address _user)
external
view
onlyOwner
returns (uint32[] memory)
{
}
function getTotalStaked()
external
view
returns (uint64 totalEvaiAmountStaked)
{
}
function getTotalProfitsDistributed()
external
view
returns (uint64 totalProfits)
{
}
function getCurrentStakedAmount()
external
view
returns (uint64 currentStakedEvai)
{
}
function getMyStakes() external view returns (uint32[] memory) {
}
function getStakeDetailsByStakeID(uint32 _stakeID)
external
view
returns (stake memory)
{
}
function addStakeType(
bool _active,
uint80 _percentageReturn,
uint80 _bonusTerm,
uint80 _bonusMultiplier,
uint128 _minAmount,
uint128 _maxAmount
) external onlyOwner {
}
function updateStakeType(
uint8 _stakeType,
bool _active,
uint80 _percentageReturn,
uint80 _bonusTerm,
uint80 _bonusMultiplier,
uint128 _minAmount,
uint128 _maxAmount
) external onlyOwner {
}
function updateAcceptingStakes(bool _acceptingStakes) external onlyOwner {
}
function ClaimToInvest() external onlyOwner {
}
function evaisetStakeAttributesAndUpdateGlobalVariables(
uint64 _amount,
uint8 _type,
uint32 _ID
) private {
}
function emitWithdrawStake(uint32 _stakeID) private {
}
function addStake(uint64 _amount, uint8 _type) external nonReentrant {
require(acceptingStakes, "Can't add a stake at this time");
require(
stakeTypes[_type].active,
"Can't add a stake with the provided stakeType"
);
require(<FILL_ME>)
require(
_amount >= stakeTypes[_type].minAmount &&
_amount <= stakeTypes[_type].maxAmount,
"Staked amount is more than maximum amount specified for the stake"
);
require(
evaiToken.balanceOf(msg.sender) >= _amount,
"Insufficient Evai Balance.Please buy more EVAI Tokens."
);
// stakeID counter update
currentStakeID += 1;
//Transfer evai tokens from the msg.sender(stake owner) to the contract
evaisetStakeAttributesAndUpdateGlobalVariables(
_amount,
_type,
currentStakeID
);
evaiToken.transferFrom(msg.sender, address(this), _amount);
emit AddStake(
_type,
stakeByID[currentStakeID].ownerAddress,
stakeByID[currentStakeID].startOfTerm,
stakeByID[currentStakeID].id,
stakeByID[currentStakeID].evaiAmount
);
}
function reStake(
uint64 _amount,
uint8 _type,
uint32 _linkedStakeID
) internal {
}
function withdraw(
uint32 _stakeID,
bool _full,
uint64 _withdrawAmount
) external nonReentrant {
}
function compound(
uint256 principal,
uint256 ratio,
uint256 n
) public pure returns (uint256) {
}
function calculatePostBonusBalance(
uint256 amount,
uint256 completedYears,
uint256 bonusMultiplier
) public pure returns (uint256) {
}
function settleStakes(uint32[] memory _stakeIDs) external onlyOwner {
}
}
| stakeTypeAlreadyExists[_type],"The Stake type doesn't exist" | 335,558 | stakeTypeAlreadyExists[_type] |
"Insufficient Evai Balance.Please buy more EVAI Tokens." | pragma solidity 0.8.3;
pragma experimental ABIEncoderV2;
contract evaiStableCoinFund is ReentrancyGuard {
using SafeMath for uint256;
struct stakeType {
bool active;
uint8 Type;
uint80 percentageReturn;
uint80 bonusTerm;
uint80 bonusMultiplier;
uint128 minAmount;
uint128 maxAmount;
}
struct stake {
bool active;
bool partialWithdrawn;
bool settled;
uint8 Type;
address ownerAddress;
uint32 startOfTerm;
uint32 endOfTerm;
uint32 id;
uint32 linkedStakeID;
uint64 evaiAmount;
uint64 settlementAmount;
uint64 stakeReturns;
}
IERC20 evaiToken;
uint8 currentStakeType;
address owner;
uint32 currentStakeID;
uint64 currentStakedEvaiAmount;
uint64 totalProfitsDistrubuted;
uint64 totalStakedEvaiAmount;
bool acceptingStakes;
uint32 acceptingStakesEndTime;
event AddStake(
uint8 _Type,
address _stakeOwner,
uint32 _startofTerm,
uint32 _stakeID,
uint64 _evaiAmount
);
event ReStake(
uint8 _Type,
address _stakeOwner,
uint32 _startOfTerm,
uint32 _stakeID,
uint64 _evaiAmount,
uint32 _linkedStakeID
);
event WithdrawStake(
bool _active,
bool _partialWithdrawn,
bool _settled,
uint32 _stakeID,
uint32 _endOfTerm,
uint64 _settlementAmount
);
mapping(uint32 => stake) stakeByID;
mapping(address => uint32[]) stakeByOwnerAddress;
mapping(uint32 => stakeType) stakeTypes;
mapping(uint32 => bool) stakeTypeAlreadyExists;
constructor(address _token) {
}
modifier onlyOwner() {
}
function evaiTransfer(uint32 _stakeID) private {
}
function getCurrentCountOfStakeTypes()
external
view
onlyOwner
returns (uint32 currentStakeTypes)
{
}
function getCurrentStakeID()
external
view
onlyOwner
returns (uint32 currentStakeId)
{
}
function getStakeType(uint32 _stakeType)
external
view
onlyOwner
returns (stakeType memory)
{
}
function getBalance() external view onlyOwner returns (uint256) {
}
function getStakesByAddress(address _user)
external
view
onlyOwner
returns (uint32[] memory)
{
}
function getTotalStaked()
external
view
returns (uint64 totalEvaiAmountStaked)
{
}
function getTotalProfitsDistributed()
external
view
returns (uint64 totalProfits)
{
}
function getCurrentStakedAmount()
external
view
returns (uint64 currentStakedEvai)
{
}
function getMyStakes() external view returns (uint32[] memory) {
}
function getStakeDetailsByStakeID(uint32 _stakeID)
external
view
returns (stake memory)
{
}
function addStakeType(
bool _active,
uint80 _percentageReturn,
uint80 _bonusTerm,
uint80 _bonusMultiplier,
uint128 _minAmount,
uint128 _maxAmount
) external onlyOwner {
}
function updateStakeType(
uint8 _stakeType,
bool _active,
uint80 _percentageReturn,
uint80 _bonusTerm,
uint80 _bonusMultiplier,
uint128 _minAmount,
uint128 _maxAmount
) external onlyOwner {
}
function updateAcceptingStakes(bool _acceptingStakes) external onlyOwner {
}
function ClaimToInvest() external onlyOwner {
}
function evaisetStakeAttributesAndUpdateGlobalVariables(
uint64 _amount,
uint8 _type,
uint32 _ID
) private {
}
function emitWithdrawStake(uint32 _stakeID) private {
}
function addStake(uint64 _amount, uint8 _type) external nonReentrant {
require(acceptingStakes, "Can't add a stake at this time");
require(
stakeTypes[_type].active,
"Can't add a stake with the provided stakeType"
);
require(stakeTypeAlreadyExists[_type], "The Stake type doesn't exist");
require(
_amount >= stakeTypes[_type].minAmount &&
_amount <= stakeTypes[_type].maxAmount,
"Staked amount is more than maximum amount specified for the stake"
);
require(<FILL_ME>)
// stakeID counter update
currentStakeID += 1;
//Transfer evai tokens from the msg.sender(stake owner) to the contract
evaisetStakeAttributesAndUpdateGlobalVariables(
_amount,
_type,
currentStakeID
);
evaiToken.transferFrom(msg.sender, address(this), _amount);
emit AddStake(
_type,
stakeByID[currentStakeID].ownerAddress,
stakeByID[currentStakeID].startOfTerm,
stakeByID[currentStakeID].id,
stakeByID[currentStakeID].evaiAmount
);
}
function reStake(
uint64 _amount,
uint8 _type,
uint32 _linkedStakeID
) internal {
}
function withdraw(
uint32 _stakeID,
bool _full,
uint64 _withdrawAmount
) external nonReentrant {
}
function compound(
uint256 principal,
uint256 ratio,
uint256 n
) public pure returns (uint256) {
}
function calculatePostBonusBalance(
uint256 amount,
uint256 completedYears,
uint256 bonusMultiplier
) public pure returns (uint256) {
}
function settleStakes(uint32[] memory _stakeIDs) external onlyOwner {
}
}
| evaiToken.balanceOf(msg.sender)>=_amount,"Insufficient Evai Balance.Please buy more EVAI Tokens." | 335,558 | evaiToken.balanceOf(msg.sender)>=_amount |
"Unauthorized Stake owner" | pragma solidity 0.8.3;
pragma experimental ABIEncoderV2;
contract evaiStableCoinFund is ReentrancyGuard {
using SafeMath for uint256;
struct stakeType {
bool active;
uint8 Type;
uint80 percentageReturn;
uint80 bonusTerm;
uint80 bonusMultiplier;
uint128 minAmount;
uint128 maxAmount;
}
struct stake {
bool active;
bool partialWithdrawn;
bool settled;
uint8 Type;
address ownerAddress;
uint32 startOfTerm;
uint32 endOfTerm;
uint32 id;
uint32 linkedStakeID;
uint64 evaiAmount;
uint64 settlementAmount;
uint64 stakeReturns;
}
IERC20 evaiToken;
uint8 currentStakeType;
address owner;
uint32 currentStakeID;
uint64 currentStakedEvaiAmount;
uint64 totalProfitsDistrubuted;
uint64 totalStakedEvaiAmount;
bool acceptingStakes;
uint32 acceptingStakesEndTime;
event AddStake(
uint8 _Type,
address _stakeOwner,
uint32 _startofTerm,
uint32 _stakeID,
uint64 _evaiAmount
);
event ReStake(
uint8 _Type,
address _stakeOwner,
uint32 _startOfTerm,
uint32 _stakeID,
uint64 _evaiAmount,
uint32 _linkedStakeID
);
event WithdrawStake(
bool _active,
bool _partialWithdrawn,
bool _settled,
uint32 _stakeID,
uint32 _endOfTerm,
uint64 _settlementAmount
);
mapping(uint32 => stake) stakeByID;
mapping(address => uint32[]) stakeByOwnerAddress;
mapping(uint32 => stakeType) stakeTypes;
mapping(uint32 => bool) stakeTypeAlreadyExists;
constructor(address _token) {
}
modifier onlyOwner() {
}
function evaiTransfer(uint32 _stakeID) private {
}
function getCurrentCountOfStakeTypes()
external
view
onlyOwner
returns (uint32 currentStakeTypes)
{
}
function getCurrentStakeID()
external
view
onlyOwner
returns (uint32 currentStakeId)
{
}
function getStakeType(uint32 _stakeType)
external
view
onlyOwner
returns (stakeType memory)
{
}
function getBalance() external view onlyOwner returns (uint256) {
}
function getStakesByAddress(address _user)
external
view
onlyOwner
returns (uint32[] memory)
{
}
function getTotalStaked()
external
view
returns (uint64 totalEvaiAmountStaked)
{
}
function getTotalProfitsDistributed()
external
view
returns (uint64 totalProfits)
{
}
function getCurrentStakedAmount()
external
view
returns (uint64 currentStakedEvai)
{
}
function getMyStakes() external view returns (uint32[] memory) {
}
function getStakeDetailsByStakeID(uint32 _stakeID)
external
view
returns (stake memory)
{
}
function addStakeType(
bool _active,
uint80 _percentageReturn,
uint80 _bonusTerm,
uint80 _bonusMultiplier,
uint128 _minAmount,
uint128 _maxAmount
) external onlyOwner {
}
function updateStakeType(
uint8 _stakeType,
bool _active,
uint80 _percentageReturn,
uint80 _bonusTerm,
uint80 _bonusMultiplier,
uint128 _minAmount,
uint128 _maxAmount
) external onlyOwner {
}
function updateAcceptingStakes(bool _acceptingStakes) external onlyOwner {
}
function ClaimToInvest() external onlyOwner {
}
function evaisetStakeAttributesAndUpdateGlobalVariables(
uint64 _amount,
uint8 _type,
uint32 _ID
) private {
}
function emitWithdrawStake(uint32 _stakeID) private {
}
function addStake(uint64 _amount, uint8 _type) external nonReentrant {
}
function reStake(
uint64 _amount,
uint8 _type,
uint32 _linkedStakeID
) internal {
}
function withdraw(
uint32 _stakeID,
bool _full,
uint64 _withdrawAmount
) external nonReentrant {
require(<FILL_ME>)
require(stakeByID[_stakeID].active == true, "Stake was settled");
uint256 elapsedTime = BokkyPooBahsDateTimeLibrary.diffDays(
uint256(stakeByID[_stakeID].startOfTerm),
uint256(block.timestamp)
);
uint256 totalReturns;
uint256 stakeReturns;
uint256 rewardEndTime;
if (elapsedTime < stakeTypes[stakeByID[_stakeID].Type].bonusTerm) {
totalReturns = compound(
(stakeByID[_stakeID].evaiAmount),
(stakeTypes[stakeByID[_stakeID].Type].percentageReturn),
elapsedTime
);
stakeReturns = totalReturns - stakeByID[_stakeID].evaiAmount;
} else if (
elapsedTime == stakeTypes[stakeByID[_stakeID].Type].bonusTerm
) {
totalReturns = (stakeByID[_stakeID].evaiAmount *
(stakeTypes[stakeByID[_stakeID].Type].bonusMultiplier));
stakeReturns = totalReturns - (stakeByID[_stakeID].evaiAmount);
} else if (
elapsedTime > stakeTypes[stakeByID[_stakeID].Type].bonusTerm
) {
uint256 daysForYearInProgress = elapsedTime.mod(
uint256(stakeTypes[stakeByID[_stakeID].Type].bonusTerm)
);
uint256 completedYears = (elapsedTime.sub(daysForYearInProgress))
.div(uint256(stakeTypes[stakeByID[_stakeID].Type].bonusTerm));
rewardEndTime = BokkyPooBahsDateTimeLibrary.addDays(
uint256(stakeByID[_stakeID].startOfTerm),
uint256(
(completedYears + 1) *
uint256(stakeTypes[stakeByID[_stakeID].Type].bonusTerm)
)
);
if (rewardEndTime < uint256(block.timestamp)) {
// Calculated elapsed time again
elapsedTime = BokkyPooBahsDateTimeLibrary.diffDays(
uint256(stakeByID[_stakeID].startOfTerm),
rewardEndTime
);
daysForYearInProgress = elapsedTime.mod(
uint256(stakeTypes[stakeByID[_stakeID].Type].bonusTerm)
);
completedYears = (elapsedTime.sub(daysForYearInProgress)).div(
uint256(stakeTypes[stakeByID[_stakeID].Type].bonusTerm)
);
}
uint256 bMul = uint256(
stakeTypes[stakeByID[_stakeID].Type].bonusMultiplier
);
uint256 postBonusBalance = calculatePostBonusBalance(
uint256(stakeByID[_stakeID].evaiAmount),
completedYears,
bMul
);
uint256 pReturns = stakeTypes[stakeByID[_stakeID].Type]
.percentageReturn;
totalReturns = compound(
postBonusBalance,
pReturns,
daysForYearInProgress
);
stakeReturns = totalReturns - (stakeByID[_stakeID].evaiAmount);
}
if (_full == true) {
stakeByID[_stakeID].partialWithdrawn = false;
stakeByID[_stakeID].settlementAmount = uint64(totalReturns);
stakeByID[_stakeID].stakeReturns = uint64(stakeReturns);
} else {
require(
_withdrawAmount <= uint64(totalReturns),
"Amount to claim is higher than returns"
);
stakeByID[_stakeID].settlementAmount = _withdrawAmount;
}
if (
_full == true &&
stakeByID[_stakeID].settlementAmount <=
evaiToken.balanceOf(address(this))
) {
//Update the global variables
currentStakedEvaiAmount -= stakeByID[_stakeID].evaiAmount;
totalProfitsDistrubuted += stakeByID[_stakeID].stakeReturns;
// set the stake attributes
stakeByID[_stakeID].active = false;
stakeByID[_stakeID].settled = true;
evaiTransfer(_stakeID);
emitWithdrawStake(_stakeID);
} else if (
_full == true &&
stakeByID[_stakeID].settlementAmount >=
evaiToken.balanceOf(address(this))
) {
// set the stake attributes
stakeByID[_stakeID].active = false;
emitWithdrawStake(_stakeID);
} else if (
_full == false &&
stakeByID[_stakeID].settlementAmount <=
evaiToken.balanceOf(address(this))
) {
// Update the global variables
currentStakedEvaiAmount -= stakeByID[_stakeID].evaiAmount;
// set the stake attributes
stakeByID[_stakeID].active = false;
stakeByID[_stakeID].partialWithdrawn = true;
stakeByID[_stakeID].settled = true;
evaiTransfer(_stakeID);
emitWithdrawStake(_stakeID);
// restake with the remaining amount
uint8 Type = stakeByID[_stakeID].Type;
uint256 reStakeAmount = totalReturns -
(stakeByID[_stakeID].settlementAmount);
reStake(uint64(reStakeAmount), Type, _stakeID);
} else if (
_full == false &&
stakeByID[_stakeID].settlementAmount >=
evaiToken.balanceOf(address(this))
) {
// set the stake attributes
stakeByID[_stakeID].active = false;
stakeByID[_stakeID].partialWithdrawn = true;
emitWithdrawStake(_stakeID);
}
}
function compound(
uint256 principal,
uint256 ratio,
uint256 n
) public pure returns (uint256) {
}
function calculatePostBonusBalance(
uint256 amount,
uint256 completedYears,
uint256 bonusMultiplier
) public pure returns (uint256) {
}
function settleStakes(uint32[] memory _stakeIDs) external onlyOwner {
}
}
| stakeByID[_stakeID].ownerAddress==msg.sender,"Unauthorized Stake owner" | 335,558 | stakeByID[_stakeID].ownerAddress==msg.sender |
"Stake was settled" | pragma solidity 0.8.3;
pragma experimental ABIEncoderV2;
contract evaiStableCoinFund is ReentrancyGuard {
using SafeMath for uint256;
struct stakeType {
bool active;
uint8 Type;
uint80 percentageReturn;
uint80 bonusTerm;
uint80 bonusMultiplier;
uint128 minAmount;
uint128 maxAmount;
}
struct stake {
bool active;
bool partialWithdrawn;
bool settled;
uint8 Type;
address ownerAddress;
uint32 startOfTerm;
uint32 endOfTerm;
uint32 id;
uint32 linkedStakeID;
uint64 evaiAmount;
uint64 settlementAmount;
uint64 stakeReturns;
}
IERC20 evaiToken;
uint8 currentStakeType;
address owner;
uint32 currentStakeID;
uint64 currentStakedEvaiAmount;
uint64 totalProfitsDistrubuted;
uint64 totalStakedEvaiAmount;
bool acceptingStakes;
uint32 acceptingStakesEndTime;
event AddStake(
uint8 _Type,
address _stakeOwner,
uint32 _startofTerm,
uint32 _stakeID,
uint64 _evaiAmount
);
event ReStake(
uint8 _Type,
address _stakeOwner,
uint32 _startOfTerm,
uint32 _stakeID,
uint64 _evaiAmount,
uint32 _linkedStakeID
);
event WithdrawStake(
bool _active,
bool _partialWithdrawn,
bool _settled,
uint32 _stakeID,
uint32 _endOfTerm,
uint64 _settlementAmount
);
mapping(uint32 => stake) stakeByID;
mapping(address => uint32[]) stakeByOwnerAddress;
mapping(uint32 => stakeType) stakeTypes;
mapping(uint32 => bool) stakeTypeAlreadyExists;
constructor(address _token) {
}
modifier onlyOwner() {
}
function evaiTransfer(uint32 _stakeID) private {
}
function getCurrentCountOfStakeTypes()
external
view
onlyOwner
returns (uint32 currentStakeTypes)
{
}
function getCurrentStakeID()
external
view
onlyOwner
returns (uint32 currentStakeId)
{
}
function getStakeType(uint32 _stakeType)
external
view
onlyOwner
returns (stakeType memory)
{
}
function getBalance() external view onlyOwner returns (uint256) {
}
function getStakesByAddress(address _user)
external
view
onlyOwner
returns (uint32[] memory)
{
}
function getTotalStaked()
external
view
returns (uint64 totalEvaiAmountStaked)
{
}
function getTotalProfitsDistributed()
external
view
returns (uint64 totalProfits)
{
}
function getCurrentStakedAmount()
external
view
returns (uint64 currentStakedEvai)
{
}
function getMyStakes() external view returns (uint32[] memory) {
}
function getStakeDetailsByStakeID(uint32 _stakeID)
external
view
returns (stake memory)
{
}
function addStakeType(
bool _active,
uint80 _percentageReturn,
uint80 _bonusTerm,
uint80 _bonusMultiplier,
uint128 _minAmount,
uint128 _maxAmount
) external onlyOwner {
}
function updateStakeType(
uint8 _stakeType,
bool _active,
uint80 _percentageReturn,
uint80 _bonusTerm,
uint80 _bonusMultiplier,
uint128 _minAmount,
uint128 _maxAmount
) external onlyOwner {
}
function updateAcceptingStakes(bool _acceptingStakes) external onlyOwner {
}
function ClaimToInvest() external onlyOwner {
}
function evaisetStakeAttributesAndUpdateGlobalVariables(
uint64 _amount,
uint8 _type,
uint32 _ID
) private {
}
function emitWithdrawStake(uint32 _stakeID) private {
}
function addStake(uint64 _amount, uint8 _type) external nonReentrant {
}
function reStake(
uint64 _amount,
uint8 _type,
uint32 _linkedStakeID
) internal {
}
function withdraw(
uint32 _stakeID,
bool _full,
uint64 _withdrawAmount
) external nonReentrant {
require(
stakeByID[_stakeID].ownerAddress == msg.sender,
"Unauthorized Stake owner"
);
require(<FILL_ME>)
uint256 elapsedTime = BokkyPooBahsDateTimeLibrary.diffDays(
uint256(stakeByID[_stakeID].startOfTerm),
uint256(block.timestamp)
);
uint256 totalReturns;
uint256 stakeReturns;
uint256 rewardEndTime;
if (elapsedTime < stakeTypes[stakeByID[_stakeID].Type].bonusTerm) {
totalReturns = compound(
(stakeByID[_stakeID].evaiAmount),
(stakeTypes[stakeByID[_stakeID].Type].percentageReturn),
elapsedTime
);
stakeReturns = totalReturns - stakeByID[_stakeID].evaiAmount;
} else if (
elapsedTime == stakeTypes[stakeByID[_stakeID].Type].bonusTerm
) {
totalReturns = (stakeByID[_stakeID].evaiAmount *
(stakeTypes[stakeByID[_stakeID].Type].bonusMultiplier));
stakeReturns = totalReturns - (stakeByID[_stakeID].evaiAmount);
} else if (
elapsedTime > stakeTypes[stakeByID[_stakeID].Type].bonusTerm
) {
uint256 daysForYearInProgress = elapsedTime.mod(
uint256(stakeTypes[stakeByID[_stakeID].Type].bonusTerm)
);
uint256 completedYears = (elapsedTime.sub(daysForYearInProgress))
.div(uint256(stakeTypes[stakeByID[_stakeID].Type].bonusTerm));
rewardEndTime = BokkyPooBahsDateTimeLibrary.addDays(
uint256(stakeByID[_stakeID].startOfTerm),
uint256(
(completedYears + 1) *
uint256(stakeTypes[stakeByID[_stakeID].Type].bonusTerm)
)
);
if (rewardEndTime < uint256(block.timestamp)) {
// Calculated elapsed time again
elapsedTime = BokkyPooBahsDateTimeLibrary.diffDays(
uint256(stakeByID[_stakeID].startOfTerm),
rewardEndTime
);
daysForYearInProgress = elapsedTime.mod(
uint256(stakeTypes[stakeByID[_stakeID].Type].bonusTerm)
);
completedYears = (elapsedTime.sub(daysForYearInProgress)).div(
uint256(stakeTypes[stakeByID[_stakeID].Type].bonusTerm)
);
}
uint256 bMul = uint256(
stakeTypes[stakeByID[_stakeID].Type].bonusMultiplier
);
uint256 postBonusBalance = calculatePostBonusBalance(
uint256(stakeByID[_stakeID].evaiAmount),
completedYears,
bMul
);
uint256 pReturns = stakeTypes[stakeByID[_stakeID].Type]
.percentageReturn;
totalReturns = compound(
postBonusBalance,
pReturns,
daysForYearInProgress
);
stakeReturns = totalReturns - (stakeByID[_stakeID].evaiAmount);
}
if (_full == true) {
stakeByID[_stakeID].partialWithdrawn = false;
stakeByID[_stakeID].settlementAmount = uint64(totalReturns);
stakeByID[_stakeID].stakeReturns = uint64(stakeReturns);
} else {
require(
_withdrawAmount <= uint64(totalReturns),
"Amount to claim is higher than returns"
);
stakeByID[_stakeID].settlementAmount = _withdrawAmount;
}
if (
_full == true &&
stakeByID[_stakeID].settlementAmount <=
evaiToken.balanceOf(address(this))
) {
//Update the global variables
currentStakedEvaiAmount -= stakeByID[_stakeID].evaiAmount;
totalProfitsDistrubuted += stakeByID[_stakeID].stakeReturns;
// set the stake attributes
stakeByID[_stakeID].active = false;
stakeByID[_stakeID].settled = true;
evaiTransfer(_stakeID);
emitWithdrawStake(_stakeID);
} else if (
_full == true &&
stakeByID[_stakeID].settlementAmount >=
evaiToken.balanceOf(address(this))
) {
// set the stake attributes
stakeByID[_stakeID].active = false;
emitWithdrawStake(_stakeID);
} else if (
_full == false &&
stakeByID[_stakeID].settlementAmount <=
evaiToken.balanceOf(address(this))
) {
// Update the global variables
currentStakedEvaiAmount -= stakeByID[_stakeID].evaiAmount;
// set the stake attributes
stakeByID[_stakeID].active = false;
stakeByID[_stakeID].partialWithdrawn = true;
stakeByID[_stakeID].settled = true;
evaiTransfer(_stakeID);
emitWithdrawStake(_stakeID);
// restake with the remaining amount
uint8 Type = stakeByID[_stakeID].Type;
uint256 reStakeAmount = totalReturns -
(stakeByID[_stakeID].settlementAmount);
reStake(uint64(reStakeAmount), Type, _stakeID);
} else if (
_full == false &&
stakeByID[_stakeID].settlementAmount >=
evaiToken.balanceOf(address(this))
) {
// set the stake attributes
stakeByID[_stakeID].active = false;
stakeByID[_stakeID].partialWithdrawn = true;
emitWithdrawStake(_stakeID);
}
}
function compound(
uint256 principal,
uint256 ratio,
uint256 n
) public pure returns (uint256) {
}
function calculatePostBonusBalance(
uint256 amount,
uint256 completedYears,
uint256 bonusMultiplier
) public pure returns (uint256) {
}
function settleStakes(uint32[] memory _stakeIDs) external onlyOwner {
}
}
| stakeByID[_stakeID].active==true,"Stake was settled" | 335,558 | stakeByID[_stakeID].active==true |
"minting this many would exceed supply" | pragma solidity >=0.6.0 <0.8.0;
/**
* @title WebbLand contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract WebbLand is ERC721, Ownable, PaymentSplitter {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounterSmallApartments;
Counters.Counter private _tokenIdCounterMediumApartments;
Counters.Counter private _tokenIdCounterLargeApartments;
Counters.Counter private _tokenIdCounterPenthouses;
bool public onlyWhitelisted = true;
bool public secondaryWhitelisted = false;
bool public openMint = false;
bool private initialized = false;
mapping (address => uint8) whitelist;
mapping (address => uint8) lateWhitelist;
mapping (address => bool) mintedPenthouse;
uint256 public tokenPriceSmallApartments = .069 ether;
uint256 public tokenPriceMediumApartments = .12 ether;
uint256 public tokenPriceLargeApartments = .24 ether;
uint256 public tokenPricePenthouses = 1 ether;
uint256 public constant maxTokens = 9069;
uint256 public devTokenCount = 9069;
string private _contractURI;
uint256 public maxMintsPerTx = 5;
constructor() public ERC721("WebbLand", "WEBBLAND") {}
//Set Base URI
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function flipWhitelistedState() public onlyOwner {
}
function flipSecondaryWhitelistedState() public onlyOwner {
}
function flipMintState() public onlyOwner {
}
function initializePaymentSplitter (address[] memory payees, uint256[] memory shares_) external onlyOwner {
}
function mintSpecial(uint256 quantity) external onlyOwner {
}
function mintSmallApartments(uint256 quantity) external payable {
require(<FILL_ME>)
require(quantity <= maxMintsPerTx, "trying to mint too many at a time");
require(msg.value >= tokenPriceSmallApartments * quantity, "not enough ether sent");
require(openMint, "mint not open");
require(!onlyWhitelisted, "not open to the public yet");
require(msg.sender == tx.origin, "no contracts please");
for (uint256 i = 0; i < quantity; i++) {
safeMintSmallApartments(msg.sender);
}
}
function mintSmallApartmentsWhitelist(uint8 quantity) external payable {
}
function mintMediumApartments(uint256 quantity) external payable {
}
function mintMediumApartmentsWhitelist(uint8 quantity) external payable {
}
function mintLargeApartments(uint256 quantity) external payable {
}
function mintLargeApartmentsWhitelist(uint8 quantity) external payable {
}
function mintPenthouses() external payable {
}
function mintPenthousesWhitelist() external payable {
}
function safeMintSmallApartments(address to) internal {
}
function safeMintMediumApartments(address to) internal {
}
function safeMintLargeApartments(address to) internal {
}
function safeMintPenthouses(address to) internal {
}
function totalSupply() public view override returns (uint) {
}
function totalSupplySmallApartments() public view returns (uint) {
}
function totalSupplyMediumApartments() public view returns (uint) {
}
function totalSupplyLargeApartments() public view returns (uint) {
}
function totalSupplyPenthouses() public view returns (uint) {
}
function setWhitelist(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setSecondaryWhitelist(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function numAvailableToMint(address addr) external view returns (uint8) {
}
function numAvailableToMintLate(address addr) external view returns (uint8) {
}
}
| totalSupplySmallApartments()+quantity<=5000,"minting this many would exceed supply" | 335,579 | totalSupplySmallApartments()+quantity<=5000 |
"minting this many would exceed supply" | pragma solidity >=0.6.0 <0.8.0;
/**
* @title WebbLand contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract WebbLand is ERC721, Ownable, PaymentSplitter {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounterSmallApartments;
Counters.Counter private _tokenIdCounterMediumApartments;
Counters.Counter private _tokenIdCounterLargeApartments;
Counters.Counter private _tokenIdCounterPenthouses;
bool public onlyWhitelisted = true;
bool public secondaryWhitelisted = false;
bool public openMint = false;
bool private initialized = false;
mapping (address => uint8) whitelist;
mapping (address => uint8) lateWhitelist;
mapping (address => bool) mintedPenthouse;
uint256 public tokenPriceSmallApartments = .069 ether;
uint256 public tokenPriceMediumApartments = .12 ether;
uint256 public tokenPriceLargeApartments = .24 ether;
uint256 public tokenPricePenthouses = 1 ether;
uint256 public constant maxTokens = 9069;
uint256 public devTokenCount = 9069;
string private _contractURI;
uint256 public maxMintsPerTx = 5;
constructor() public ERC721("WebbLand", "WEBBLAND") {}
//Set Base URI
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function flipWhitelistedState() public onlyOwner {
}
function flipSecondaryWhitelistedState() public onlyOwner {
}
function flipMintState() public onlyOwner {
}
function initializePaymentSplitter (address[] memory payees, uint256[] memory shares_) external onlyOwner {
}
function mintSpecial(uint256 quantity) external onlyOwner {
}
function mintSmallApartments(uint256 quantity) external payable {
}
function mintSmallApartmentsWhitelist(uint8 quantity) external payable {
}
function mintMediumApartments(uint256 quantity) external payable {
require(<FILL_ME>)
require(quantity <= maxMintsPerTx, "trying to mint too many at a time");
require(msg.value >= tokenPriceMediumApartments * quantity, "not enough ether sent");
require(openMint, "mint not open");
require(!onlyWhitelisted, "not open to the public yet");
require(msg.sender == tx.origin, "no contracts please");
for (uint256 i = 0; i < quantity; i++) {
safeMintMediumApartments(msg.sender);
}
}
function mintMediumApartmentsWhitelist(uint8 quantity) external payable {
}
function mintLargeApartments(uint256 quantity) external payable {
}
function mintLargeApartmentsWhitelist(uint8 quantity) external payable {
}
function mintPenthouses() external payable {
}
function mintPenthousesWhitelist() external payable {
}
function safeMintSmallApartments(address to) internal {
}
function safeMintMediumApartments(address to) internal {
}
function safeMintLargeApartments(address to) internal {
}
function safeMintPenthouses(address to) internal {
}
function totalSupply() public view override returns (uint) {
}
function totalSupplySmallApartments() public view returns (uint) {
}
function totalSupplyMediumApartments() public view returns (uint) {
}
function totalSupplyLargeApartments() public view returns (uint) {
}
function totalSupplyPenthouses() public view returns (uint) {
}
function setWhitelist(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setSecondaryWhitelist(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function numAvailableToMint(address addr) external view returns (uint8) {
}
function numAvailableToMintLate(address addr) external view returns (uint8) {
}
}
| totalSupplyMediumApartments()+quantity<=3000,"minting this many would exceed supply" | 335,579 | totalSupplyMediumApartments()+quantity<=3000 |
"minting this many would exceed supply" | pragma solidity >=0.6.0 <0.8.0;
/**
* @title WebbLand contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract WebbLand is ERC721, Ownable, PaymentSplitter {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounterSmallApartments;
Counters.Counter private _tokenIdCounterMediumApartments;
Counters.Counter private _tokenIdCounterLargeApartments;
Counters.Counter private _tokenIdCounterPenthouses;
bool public onlyWhitelisted = true;
bool public secondaryWhitelisted = false;
bool public openMint = false;
bool private initialized = false;
mapping (address => uint8) whitelist;
mapping (address => uint8) lateWhitelist;
mapping (address => bool) mintedPenthouse;
uint256 public tokenPriceSmallApartments = .069 ether;
uint256 public tokenPriceMediumApartments = .12 ether;
uint256 public tokenPriceLargeApartments = .24 ether;
uint256 public tokenPricePenthouses = 1 ether;
uint256 public constant maxTokens = 9069;
uint256 public devTokenCount = 9069;
string private _contractURI;
uint256 public maxMintsPerTx = 5;
constructor() public ERC721("WebbLand", "WEBBLAND") {}
//Set Base URI
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function flipWhitelistedState() public onlyOwner {
}
function flipSecondaryWhitelistedState() public onlyOwner {
}
function flipMintState() public onlyOwner {
}
function initializePaymentSplitter (address[] memory payees, uint256[] memory shares_) external onlyOwner {
}
function mintSpecial(uint256 quantity) external onlyOwner {
}
function mintSmallApartments(uint256 quantity) external payable {
}
function mintSmallApartmentsWhitelist(uint8 quantity) external payable {
}
function mintMediumApartments(uint256 quantity) external payable {
}
function mintMediumApartmentsWhitelist(uint8 quantity) external payable {
}
function mintLargeApartments(uint256 quantity) external payable {
require(<FILL_ME>)
require(quantity <= maxMintsPerTx, "trying to mint too many at a time");
require(msg.value >= tokenPriceLargeApartments * quantity, "not enough ether sent");
require(openMint, "mint not open");
require(!onlyWhitelisted, "not open to the public yet");
require(msg.sender == tx.origin, "no contracts please");
for (uint256 i = 0; i < quantity; i++) {
safeMintLargeApartments(msg.sender);
}
}
function mintLargeApartmentsWhitelist(uint8 quantity) external payable {
}
function mintPenthouses() external payable {
}
function mintPenthousesWhitelist() external payable {
}
function safeMintSmallApartments(address to) internal {
}
function safeMintMediumApartments(address to) internal {
}
function safeMintLargeApartments(address to) internal {
}
function safeMintPenthouses(address to) internal {
}
function totalSupply() public view override returns (uint) {
}
function totalSupplySmallApartments() public view returns (uint) {
}
function totalSupplyMediumApartments() public view returns (uint) {
}
function totalSupplyLargeApartments() public view returns (uint) {
}
function totalSupplyPenthouses() public view returns (uint) {
}
function setWhitelist(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setSecondaryWhitelist(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function numAvailableToMint(address addr) external view returns (uint8) {
}
function numAvailableToMintLate(address addr) external view returns (uint8) {
}
}
| totalSupplyLargeApartments()+quantity<=1000,"minting this many would exceed supply" | 335,579 | totalSupplyLargeApartments()+quantity<=1000 |
"minting this many would exceed supply" | pragma solidity >=0.6.0 <0.8.0;
/**
* @title WebbLand contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract WebbLand is ERC721, Ownable, PaymentSplitter {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounterSmallApartments;
Counters.Counter private _tokenIdCounterMediumApartments;
Counters.Counter private _tokenIdCounterLargeApartments;
Counters.Counter private _tokenIdCounterPenthouses;
bool public onlyWhitelisted = true;
bool public secondaryWhitelisted = false;
bool public openMint = false;
bool private initialized = false;
mapping (address => uint8) whitelist;
mapping (address => uint8) lateWhitelist;
mapping (address => bool) mintedPenthouse;
uint256 public tokenPriceSmallApartments = .069 ether;
uint256 public tokenPriceMediumApartments = .12 ether;
uint256 public tokenPriceLargeApartments = .24 ether;
uint256 public tokenPricePenthouses = 1 ether;
uint256 public constant maxTokens = 9069;
uint256 public devTokenCount = 9069;
string private _contractURI;
uint256 public maxMintsPerTx = 5;
constructor() public ERC721("WebbLand", "WEBBLAND") {}
//Set Base URI
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function flipWhitelistedState() public onlyOwner {
}
function flipSecondaryWhitelistedState() public onlyOwner {
}
function flipMintState() public onlyOwner {
}
function initializePaymentSplitter (address[] memory payees, uint256[] memory shares_) external onlyOwner {
}
function mintSpecial(uint256 quantity) external onlyOwner {
}
function mintSmallApartments(uint256 quantity) external payable {
}
function mintSmallApartmentsWhitelist(uint8 quantity) external payable {
}
function mintMediumApartments(uint256 quantity) external payable {
}
function mintMediumApartmentsWhitelist(uint8 quantity) external payable {
}
function mintLargeApartments(uint256 quantity) external payable {
}
function mintLargeApartmentsWhitelist(uint8 quantity) external payable {
}
function mintPenthouses() external payable {
require(<FILL_ME>)
require(msg.value >= tokenPricePenthouses, "not enough ether sent");
require(openMint, "mint not open");
require(!onlyWhitelisted, "not open to the public yet");
require(!mintedPenthouse[msg.sender], "can only mint 1 penthouse per wallet");
require(msg.sender == tx.origin, "no contracts please");
safeMintPenthouses(msg.sender);
}
function mintPenthousesWhitelist() external payable {
}
function safeMintSmallApartments(address to) internal {
}
function safeMintMediumApartments(address to) internal {
}
function safeMintLargeApartments(address to) internal {
}
function safeMintPenthouses(address to) internal {
}
function totalSupply() public view override returns (uint) {
}
function totalSupplySmallApartments() public view returns (uint) {
}
function totalSupplyMediumApartments() public view returns (uint) {
}
function totalSupplyLargeApartments() public view returns (uint) {
}
function totalSupplyPenthouses() public view returns (uint) {
}
function setWhitelist(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setSecondaryWhitelist(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function numAvailableToMint(address addr) external view returns (uint8) {
}
function numAvailableToMintLate(address addr) external view returns (uint8) {
}
}
| totalSupplyPenthouses()+1<=69,"minting this many would exceed supply" | 335,579 | totalSupplyPenthouses()+1<=69 |
"can only mint 1 penthouse per wallet" | pragma solidity >=0.6.0 <0.8.0;
/**
* @title WebbLand contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract WebbLand is ERC721, Ownable, PaymentSplitter {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounterSmallApartments;
Counters.Counter private _tokenIdCounterMediumApartments;
Counters.Counter private _tokenIdCounterLargeApartments;
Counters.Counter private _tokenIdCounterPenthouses;
bool public onlyWhitelisted = true;
bool public secondaryWhitelisted = false;
bool public openMint = false;
bool private initialized = false;
mapping (address => uint8) whitelist;
mapping (address => uint8) lateWhitelist;
mapping (address => bool) mintedPenthouse;
uint256 public tokenPriceSmallApartments = .069 ether;
uint256 public tokenPriceMediumApartments = .12 ether;
uint256 public tokenPriceLargeApartments = .24 ether;
uint256 public tokenPricePenthouses = 1 ether;
uint256 public constant maxTokens = 9069;
uint256 public devTokenCount = 9069;
string private _contractURI;
uint256 public maxMintsPerTx = 5;
constructor() public ERC721("WebbLand", "WEBBLAND") {}
//Set Base URI
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function flipWhitelistedState() public onlyOwner {
}
function flipSecondaryWhitelistedState() public onlyOwner {
}
function flipMintState() public onlyOwner {
}
function initializePaymentSplitter (address[] memory payees, uint256[] memory shares_) external onlyOwner {
}
function mintSpecial(uint256 quantity) external onlyOwner {
}
function mintSmallApartments(uint256 quantity) external payable {
}
function mintSmallApartmentsWhitelist(uint8 quantity) external payable {
}
function mintMediumApartments(uint256 quantity) external payable {
}
function mintMediumApartmentsWhitelist(uint8 quantity) external payable {
}
function mintLargeApartments(uint256 quantity) external payable {
}
function mintLargeApartmentsWhitelist(uint8 quantity) external payable {
}
function mintPenthouses() external payable {
require(totalSupplyPenthouses() + 1 <= 69, "minting this many would exceed supply");
require(msg.value >= tokenPricePenthouses, "not enough ether sent");
require(openMint, "mint not open");
require(!onlyWhitelisted, "not open to the public yet");
require(<FILL_ME>)
require(msg.sender == tx.origin, "no contracts please");
safeMintPenthouses(msg.sender);
}
function mintPenthousesWhitelist() external payable {
}
function safeMintSmallApartments(address to) internal {
}
function safeMintMediumApartments(address to) internal {
}
function safeMintLargeApartments(address to) internal {
}
function safeMintPenthouses(address to) internal {
}
function totalSupply() public view override returns (uint) {
}
function totalSupplySmallApartments() public view returns (uint) {
}
function totalSupplyMediumApartments() public view returns (uint) {
}
function totalSupplyLargeApartments() public view returns (uint) {
}
function totalSupplyPenthouses() public view returns (uint) {
}
function setWhitelist(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function setSecondaryWhitelist(address[] calldata addresses, uint8 numAllowedToMint) external onlyOwner {
}
function numAvailableToMint(address addr) external view returns (uint8) {
}
function numAvailableToMintLate(address addr) external view returns (uint8) {
}
}
| !mintedPenthouse[msg.sender],"can only mint 1 penthouse per wallet" | 335,579 | !mintedPenthouse[msg.sender] |
"Exceeds max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract RarePunks is ERC721Enumerable, Ownable, ReentrancyGuard {
event Affiliate(address indexed ref, address indexed minter, uint indexed value);
using SafeMath for uint;
string internal baseURI;
uint public constant MAX_SUPPLY = 500;
constructor(address owner, string memory tokenBaseUri) ERC721("RarePunks", "RARE") {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata newBaseUri) external onlyOwner {
}
function getPrice(uint quantity) public view returns (uint) {
}
function mint(uint quantity, address ref) public payable nonReentrant {
uint supply = totalSupply();
require(supply < MAX_SUPPLY, "All tokens are minted");
require(quantity > 0, "Quantity can not be 0");
require(<FILL_ME>)
require(msg.value >= getPrice(quantity), "Incorrect ETH value");
for (uint i = 1; i <= quantity; i++) {
_safeMint(_msgSender(), supply + i);
}
if (ref != address(0)) {
uint value = msg.value.mul(3).div(10);
payable(ref).transfer(value);
emit Affiliate(ref, _msgSender(), value);
}
}
function withdraw() public onlyOwner {
}
function tokensIdOf(address owner) public view returns(uint[] memory) {
}
}
| supply.add(quantity)<=MAX_SUPPLY,"Exceeds max supply" | 335,733 | supply.add(quantity)<=MAX_SUPPLY |
"Maximum supply including reserves is 11111" | //Contract based on [https://docs.openzeppelin.com/contracts/4.x/erc721](https://docs.openzeppelin.com/contracts/4.x/erc721)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
/*
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'''''''''''''''''''''''''''''''''''.ƒ'']▓ ,..','''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''']µ]▄▐▄╫╫╬▀╬╬╬▓╬▀╬▌╬▓#▓░╓'''''''''''''''''''''''''''
''''''''''''''''''''''''''╥ƒ╔╣╬▀╠╫╬▌╠▓╣╠╫╬╫╠╣▌╬▀╬▓╬╬╫╗╦M''''''''''''''''''''''''
'''''''''''''╓#▀▒▀Φ▄,''╓,╓╟╬╬╠▌╬▓╠╫╬▒╫▌╬╣▒╬▌╬▌╣▒╣▌╠╬╬▒╬╬▌,,'''''''''''''''''''''
''''''''''''▄▒╗▀▀▀╗▄╨▀▄▓╬╬╠▓╬▓╬╠╬╬╠▌▒╬▌╠╬▌╠▌╠╬╬▓╠╬╬╬╬╠▓▒╬▓▄''''╥ÆΘΘ##▄''''''''''
''''''''''''▌░▓╫▒▒▒▒╬▀▄▀▒╬╬╬▒╬╬▒▓╬╠▒▀╬╬▒╠╠╬╬▒╬╬╠╬╬╫▓╠╣▒╣╠╠▌▄,▄╬▄▀╬╬▓G║▒'''''''''
''''''''''''▌░▓▓▒▒▒▒▒▒╬▌╨▌╠╫╬╠╠▒╫╣▀▌▀▀╨▀╨▀╨╩╨▀╨▀╨▀▀╩▓▀╣╬╬╬╠▓▌╬╬▒▒▒▓╣▒╫⌐'''''''''
''''''''''''╙▄│▓▒▒▒▒▒▒▒╠▓╨▌╬╬╩▀╙Ü└░│░░░░░░░░░░░░░░░░│░└┤╨╨╨▀╬╬▒▒▒▒▌▌▐▌''''''''''
'''''''''''''╙▄│▀▒▒▒▒▒▒▒╫▓▀┤░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░╫╜▌▒╠╣╬╫╨'''''''''''
''''''''''''''└▀▄╨▀▒▒▒▒▌╫▀└░░░░▄▓███▀▌░░░░░░░░░░░░░░░▄███▀▌░░░▀╫╫▀╙'''''''''''''
''''''''''''''''└▓▄Q╙╨▓▄░░░░░░▐████ ▐▌░░░░░░░░░░░░░╟███▄ ╫▌░╟╬▓.'''''''''''''''
''''''''''''''''╓▓▒▌╬╬╬▓µ░░░░░╫███╣███▒░░░φ▒▒░▒▒▒▒φ░╫██▓███▀∞▓╬▓▄⌐''''''''''''''
'''''''''''''''*▌▌╫▒▌╬▀╫╫G░░░░╙██████▀░░▐▒░╫╬╬╬╬╬▓░╫░▓████▀░▐▌╠▓⌐'''''''''''''''
'''''''''''''''╨▀▓╠╣╬╬▓▌╬▌░░░░░░│╨▀╨¡░░▐▌░░░╬▀█▓▀▒▒Γ▌░╙╨┤░░▓╬▀╬▌⌐'''''''''''''''
''''''''''''''''╨▓╬▓╬╬▒▀╬╫▄░░░░░░░░░░░░╫░░░╠▀▓╬╣▀╢░░╫░░░░░╣▌╣▌╫▓╙'''''''''''''''
''''''''''''''''╠▓▌╬▒╬▒╣▌╟▌µ░░░░░░░░░░░└▀▀╣╫╫▀╢Å╝╢╝▀┤░░░░▄╬╟▓╠▓▄.'''''''''''''''
''''''''''''''',▐╬▓╬▒╬▌╬╬╣╬╣G└░░░░░░░░░░░░░░░░░░░░░░░░░░▄╬╬▌╬▓Qµ''''''''''''''''
'''''''''''''▐▄▓╬▀╣╬╠╫╣╫╬╫▌▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▀╬╬╬╬╬▌▓G',''''''''''''
''''''''''┌,╫▀▀╬╫╬▒╬█▌╬╫▓╙╨░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░╙▀▀╬╠╫╬╬╣▓▄''''''''''''
''''''''''▄▓╬╠▓▓╬╠▓╬▒╬▌╨░░░░░░░░░░░░╥╥░░░░░░░░░░░░3▄G░░░░░░│╨▓▌╬╠╬╟▌▄'''''''''''
'''''''')▄▓╠╣▓╬╠╣▌╠╣▓┤│░░░░░░ƒ░░░░░░┘╨└░░░░░░░░░░░░┘└░░*▄░░░░░╨╫▒▀╬╬▓▄''''''''''
'''''''╔▄▓▒▀▓╣╠█╬╣▒╨░└Q░░░░⌠▀╡░░░░░░░░░░░░░░░░░░░░░░░░▐▀╨└░░░░░└ô▓╬╬╬▓C'''''''''
'''''''%╣▌╫╠▓▀╠╫▀Ö░░░┤╨░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░║▓╬╬╫▀⌐''''''''
''''''Qª╣▒╫╬▓▌╬╬┤░░░░░░░░└└░░░░░░░░░j▒░░░░░░░░░▄▓#└░░░░░░░░░░░░╓▄░╚▌╟╣▓*''''''''
''''''╙▓▓╬▓▌▀╬▓G░░░░░░░░┤▀▌░░░░░░░░░└░░░░░░░░░░└└░░░░░░░░░░p;░░┘╨▌░▓▒╬▓▄''''''''
''''''@▌▀╬╬▓▌╢▌░░░░░░░░░░▐▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░╙╨░░░░▓░╨▓╬▓▄''''''''
'''''╥Q╫▌▓╬╬╬╫▀░░░░░░░░░░╫░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░╫▒░▓╠▓▄▄'''''''
''''''╠▓╬▓▌╠╬▓▒░░░░?▀#░░░▌░░{▄░░░░░░░░░░░░░░░░▄╡░░░░░░░╓▐▒░░░░░░░║▒░▓╬╬▌⌐'''''''
''''''╟▓╬╬▀▓▒▓░░░░░░░░░░▐▒░░░│┘░░░░░░░░░░░░░░░│┤░░░░░░░└┤└░░░░░░░▐▌░╫▒╬▓▄'''''''
____ _ _ _ __ _
/___ \_ _(_) | | ___ _ __ / / __ _| |__ ___
// / / | | | | | |/ _ \ '__| / / / _` | '_ \/ __|
/ \_/ /| |_| | | | | __/ | / /__| (_| | |_) \__ \
\___,_\ \__,_|_|_|_|\___|_| \____/\__,_|_.__/|___/
*/
contract Hedgies is ERC721, Ownable, ERC721Burnable, ERC721Enumerable{
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public price = 0.06 ether;
uint256 public whitelistPrice = 0 ether;
uint256 public maxQuantity = 20;
uint256 public maxSupply = 10000;
bool public publicMintLive = false;
bool public whitelistMintLive = false;
string baseUri = "https://api.quiller.app/collection/hedgies-quiller-labs/metadata/";
mapping(address => uint256) private whitelist;
constructor() ERC721("Hedgies by Quiller Labs", "HQL") {}
/*
==============================================================
UTILITY METHODS
==============================================================
*/
// Check remaining whitelist mints for whitelisted wallet
function remainingWhitelistMints() public view returns (uint256) {
}
/*
==============================================================
MINT METHODS
==============================================================
*/
// Public minting
function publicMint(uint256 quantity) public payable {
}
// Whitelist minting
function whitelistMint(uint256 quantity) public payable {
}
/*
==============================================================
ADMIN/OWNER ONLY FUNCTIONS
==============================================================
*/
function airdrop(address[] memory wallets, uint256[] memory counts) public onlyOwner {
}
function setBaseUri(string calldata newBaseUri) public onlyOwner{
}
// Function that adds list of wallets to whitelist for free minting
function addToWhitelist(address[] memory wallets, uint256[] memory mintsAllowed) public onlyOwner {
}
// Function that removes list of wallets from whitelist
function removeFromWhitelist(address[] memory wallets) public onlyOwner {
}
function togglePublicMintLive() public onlyOwner {
}
function toggleWhitelistMinting() public onlyOwner {
}
// Set the price per mint
function setPrice(uint256 newPrice) public onlyOwner {
}
// Set the whitelist price per mint
function setWhitelistPrice(uint256 newWhitelistPrice) public onlyOwner {
}
// Maximum tokens per mint
function setMaxQuantity(uint256 newQuantity) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
function addReserve(uint256 reserveAmount) public onlyOwner {
require(<FILL_ME>)
maxSupply += reserveAmount;
}
/*
==============================================================
PRIVATE FUNCTIONS
==============================================================
*/
function _mintNft(address wallet, uint256 quantity) private {
}
/*
==============================================================
EVENTS
==============================================================
*/
event NFTAirdrop(address indexed to, uint256 quantity);
/*
==============================================================
MISCELLANEOUS
==============================================================
*/
function _baseURI() internal view virtual override returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| reserveAmount+maxSupply<=11111,"Maximum supply including reserves is 11111" | 335,762 | reserveAmount+maxSupply<=11111 |
null | //Contract based on [https://docs.openzeppelin.com/contracts/4.x/erc721](https://docs.openzeppelin.com/contracts/4.x/erc721)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
/*
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'''''''''''''''''''''''''''''''''''.ƒ'']▓ ,..','''''''''''''''''''''''''''''''''
''''''''''''''''''''''''''''']µ]▄▐▄╫╫╬▀╬╬╬▓╬▀╬▌╬▓#▓░╓'''''''''''''''''''''''''''
''''''''''''''''''''''''''╥ƒ╔╣╬▀╠╫╬▌╠▓╣╠╫╬╫╠╣▌╬▀╬▓╬╬╫╗╦M''''''''''''''''''''''''
'''''''''''''╓#▀▒▀Φ▄,''╓,╓╟╬╬╠▌╬▓╠╫╬▒╫▌╬╣▒╬▌╬▌╣▒╣▌╠╬╬▒╬╬▌,,'''''''''''''''''''''
''''''''''''▄▒╗▀▀▀╗▄╨▀▄▓╬╬╠▓╬▓╬╠╬╬╠▌▒╬▌╠╬▌╠▌╠╬╬▓╠╬╬╬╬╠▓▒╬▓▄''''╥ÆΘΘ##▄''''''''''
''''''''''''▌░▓╫▒▒▒▒╬▀▄▀▒╬╬╬▒╬╬▒▓╬╠▒▀╬╬▒╠╠╬╬▒╬╬╠╬╬╫▓╠╣▒╣╠╠▌▄,▄╬▄▀╬╬▓G║▒'''''''''
''''''''''''▌░▓▓▒▒▒▒▒▒╬▌╨▌╠╫╬╠╠▒╫╣▀▌▀▀╨▀╨▀╨╩╨▀╨▀╨▀▀╩▓▀╣╬╬╬╠▓▌╬╬▒▒▒▓╣▒╫⌐'''''''''
''''''''''''╙▄│▓▒▒▒▒▒▒▒╠▓╨▌╬╬╩▀╙Ü└░│░░░░░░░░░░░░░░░░│░└┤╨╨╨▀╬╬▒▒▒▒▌▌▐▌''''''''''
'''''''''''''╙▄│▀▒▒▒▒▒▒▒╫▓▀┤░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░╫╜▌▒╠╣╬╫╨'''''''''''
''''''''''''''└▀▄╨▀▒▒▒▒▌╫▀└░░░░▄▓███▀▌░░░░░░░░░░░░░░░▄███▀▌░░░▀╫╫▀╙'''''''''''''
''''''''''''''''└▓▄Q╙╨▓▄░░░░░░▐████ ▐▌░░░░░░░░░░░░░╟███▄ ╫▌░╟╬▓.'''''''''''''''
''''''''''''''''╓▓▒▌╬╬╬▓µ░░░░░╫███╣███▒░░░φ▒▒░▒▒▒▒φ░╫██▓███▀∞▓╬▓▄⌐''''''''''''''
'''''''''''''''*▌▌╫▒▌╬▀╫╫G░░░░╙██████▀░░▐▒░╫╬╬╬╬╬▓░╫░▓████▀░▐▌╠▓⌐'''''''''''''''
'''''''''''''''╨▀▓╠╣╬╬▓▌╬▌░░░░░░│╨▀╨¡░░▐▌░░░╬▀█▓▀▒▒Γ▌░╙╨┤░░▓╬▀╬▌⌐'''''''''''''''
''''''''''''''''╨▓╬▓╬╬▒▀╬╫▄░░░░░░░░░░░░╫░░░╠▀▓╬╣▀╢░░╫░░░░░╣▌╣▌╫▓╙'''''''''''''''
''''''''''''''''╠▓▌╬▒╬▒╣▌╟▌µ░░░░░░░░░░░└▀▀╣╫╫▀╢Å╝╢╝▀┤░░░░▄╬╟▓╠▓▄.'''''''''''''''
''''''''''''''',▐╬▓╬▒╬▌╬╬╣╬╣G└░░░░░░░░░░░░░░░░░░░░░░░░░░▄╬╬▌╬▓Qµ''''''''''''''''
'''''''''''''▐▄▓╬▀╣╬╠╫╣╫╬╫▌▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▀╬╬╬╬╬▌▓G',''''''''''''
''''''''''┌,╫▀▀╬╫╬▒╬█▌╬╫▓╙╨░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░╙▀▀╬╠╫╬╬╣▓▄''''''''''''
''''''''''▄▓╬╠▓▓╬╠▓╬▒╬▌╨░░░░░░░░░░░░╥╥░░░░░░░░░░░░3▄G░░░░░░│╨▓▌╬╠╬╟▌▄'''''''''''
'''''''')▄▓╠╣▓╬╠╣▌╠╣▓┤│░░░░░░ƒ░░░░░░┘╨└░░░░░░░░░░░░┘└░░*▄░░░░░╨╫▒▀╬╬▓▄''''''''''
'''''''╔▄▓▒▀▓╣╠█╬╣▒╨░└Q░░░░⌠▀╡░░░░░░░░░░░░░░░░░░░░░░░░▐▀╨└░░░░░└ô▓╬╬╬▓C'''''''''
'''''''%╣▌╫╠▓▀╠╫▀Ö░░░┤╨░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░║▓╬╬╫▀⌐''''''''
''''''Qª╣▒╫╬▓▌╬╬┤░░░░░░░░└└░░░░░░░░░j▒░░░░░░░░░▄▓#└░░░░░░░░░░░░╓▄░╚▌╟╣▓*''''''''
''''''╙▓▓╬▓▌▀╬▓G░░░░░░░░┤▀▌░░░░░░░░░└░░░░░░░░░░└└░░░░░░░░░░p;░░┘╨▌░▓▒╬▓▄''''''''
''''''@▌▀╬╬▓▌╢▌░░░░░░░░░░▐▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░╙╨░░░░▓░╨▓╬▓▄''''''''
'''''╥Q╫▌▓╬╬╬╫▀░░░░░░░░░░╫░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░╫▒░▓╠▓▄▄'''''''
''''''╠▓╬▓▌╠╬▓▒░░░░?▀#░░░▌░░{▄░░░░░░░░░░░░░░░░▄╡░░░░░░░╓▐▒░░░░░░░║▒░▓╬╬▌⌐'''''''
''''''╟▓╬╬▀▓▒▓░░░░░░░░░░▐▒░░░│┘░░░░░░░░░░░░░░░│┤░░░░░░░└┤└░░░░░░░▐▌░╫▒╬▓▄'''''''
____ _ _ _ __ _
/___ \_ _(_) | | ___ _ __ / / __ _| |__ ___
// / / | | | | | |/ _ \ '__| / / / _` | '_ \/ __|
/ \_/ /| |_| | | | | __/ | / /__| (_| | |_) \__ \
\___,_\ \__,_|_|_|_|\___|_| \____/\__,_|_.__/|___/
*/
contract Hedgies is ERC721, Ownable, ERC721Burnable, ERC721Enumerable{
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public price = 0.06 ether;
uint256 public whitelistPrice = 0 ether;
uint256 public maxQuantity = 20;
uint256 public maxSupply = 10000;
bool public publicMintLive = false;
bool public whitelistMintLive = false;
string baseUri = "https://api.quiller.app/collection/hedgies-quiller-labs/metadata/";
mapping(address => uint256) private whitelist;
constructor() ERC721("Hedgies by Quiller Labs", "HQL") {}
/*
==============================================================
UTILITY METHODS
==============================================================
*/
// Check remaining whitelist mints for whitelisted wallet
function remainingWhitelistMints() public view returns (uint256) {
}
/*
==============================================================
MINT METHODS
==============================================================
*/
// Public minting
function publicMint(uint256 quantity) public payable {
}
// Whitelist minting
function whitelistMint(uint256 quantity) public payable {
}
/*
==============================================================
ADMIN/OWNER ONLY FUNCTIONS
==============================================================
*/
function airdrop(address[] memory wallets, uint256[] memory counts) public onlyOwner {
}
function setBaseUri(string calldata newBaseUri) public onlyOwner{
}
// Function that adds list of wallets to whitelist for free minting
function addToWhitelist(address[] memory wallets, uint256[] memory mintsAllowed) public onlyOwner {
}
// Function that removes list of wallets from whitelist
function removeFromWhitelist(address[] memory wallets) public onlyOwner {
}
function togglePublicMintLive() public onlyOwner {
}
function toggleWhitelistMinting() public onlyOwner {
}
// Set the price per mint
function setPrice(uint256 newPrice) public onlyOwner {
}
// Set the whitelist price per mint
function setWhitelistPrice(uint256 newWhitelistPrice) public onlyOwner {
}
// Maximum tokens per mint
function setMaxQuantity(uint256 newQuantity) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
function addReserve(uint256 reserveAmount) public onlyOwner {
}
/*
==============================================================
PRIVATE FUNCTIONS
==============================================================
*/
function _mintNft(address wallet, uint256 quantity) private {
require(<FILL_ME>)
for(uint256 i = 0; i < quantity; i++) {
_tokenIds.increment();
uint256 tokenId = _tokenIds.current();
_safeMint(wallet, tokenId);
tokenURI(tokenId);
}
}
/*
==============================================================
EVENTS
==============================================================
*/
event NFTAirdrop(address indexed to, uint256 quantity);
/*
==============================================================
MISCELLANEOUS
==============================================================
*/
function _baseURI() internal view virtual override returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| (maxSupply-_tokenIds.current())>=quantity | 335,762 | (maxSupply-_tokenIds.current())>=quantity |
"deposit limits reached" | pragma solidity ^0.6.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
/// @title PresaleERC20 Contract
pragma solidity ^0.6.0;
interface IShitSwap {
function mint(address to, uint256 value) external;
function transfer(address recipient, uint256 amount) external;
}
contract PresaleERC20 is Ownable {
using SafeMath for uint256;
IShitSwap public token;
address payable public presale;
address payable public liquidity;
// address public airdrop;
uint256 public presaleStartTimestamp;
uint256 public presaleEndTimestamp;
uint256 public softCapEthAmount = 15 ether;
uint256 public hardCapEthAmount = 30 ether;
uint256 public totalDepositedEthBalance;
uint256 public minimumDepositEthAmount = 0 ether;
uint256 public maximumDepositEthAmount = 0.3 ether;
mapping(address => uint256) public deposits;
constructor(
IShitSwap _token,
address payable _liquidity
) public {
}
receive() payable external {
}
function deposit() public payable {
require(now >= presaleStartTimestamp && now <= presaleEndTimestamp, "presale is not active");
require(<FILL_ME>)
require(deposits[msg.sender].add(msg.value) >= minimumDepositEthAmount && deposits[msg.sender].add(msg.value) <= maximumDepositEthAmount, "incorrect amount");
uint256 rewardTokenCount;
rewardTokenCount = 0.0000011585 ether; // 863,143.96 tokens per ETH
uint256 tokenAmount = msg.value.mul(1e18).div(rewardTokenCount);
token.transfer(msg.sender, tokenAmount);
totalDepositedEthBalance = totalDepositedEthBalance.add(msg.value);
deposits[msg.sender] = deposits[msg.sender].add(msg.value);
emit Deposited(msg.sender, msg.value);
}
function releaseFunds() external onlyOwner {
}
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
function getDepositAmount() public view returns (uint256) {
}
function getLeftTimeAmount() public view returns (uint256) {
}
function setPresaleFunds(address payable fundsAddress) external onlyOwner {
}
function addLiquidity() external onlyOwner {
}
event Deposited(address indexed user, uint256 amount);
event Recovered(address token, uint256 amount);
}
| totalDepositedEthBalance.add(msg.value)<=hardCapEthAmount,"deposit limits reached" | 335,886 | totalDepositedEthBalance.add(msg.value)<=hardCapEthAmount |
"incorrect amount" | pragma solidity ^0.6.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
/// @title PresaleERC20 Contract
pragma solidity ^0.6.0;
interface IShitSwap {
function mint(address to, uint256 value) external;
function transfer(address recipient, uint256 amount) external;
}
contract PresaleERC20 is Ownable {
using SafeMath for uint256;
IShitSwap public token;
address payable public presale;
address payable public liquidity;
// address public airdrop;
uint256 public presaleStartTimestamp;
uint256 public presaleEndTimestamp;
uint256 public softCapEthAmount = 15 ether;
uint256 public hardCapEthAmount = 30 ether;
uint256 public totalDepositedEthBalance;
uint256 public minimumDepositEthAmount = 0 ether;
uint256 public maximumDepositEthAmount = 0.3 ether;
mapping(address => uint256) public deposits;
constructor(
IShitSwap _token,
address payable _liquidity
) public {
}
receive() payable external {
}
function deposit() public payable {
require(now >= presaleStartTimestamp && now <= presaleEndTimestamp, "presale is not active");
require(totalDepositedEthBalance.add(msg.value) <= hardCapEthAmount, "deposit limits reached");
require(<FILL_ME>)
uint256 rewardTokenCount;
rewardTokenCount = 0.0000011585 ether; // 863,143.96 tokens per ETH
uint256 tokenAmount = msg.value.mul(1e18).div(rewardTokenCount);
token.transfer(msg.sender, tokenAmount);
totalDepositedEthBalance = totalDepositedEthBalance.add(msg.value);
deposits[msg.sender] = deposits[msg.sender].add(msg.value);
emit Deposited(msg.sender, msg.value);
}
function releaseFunds() external onlyOwner {
}
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
function getDepositAmount() public view returns (uint256) {
}
function getLeftTimeAmount() public view returns (uint256) {
}
function setPresaleFunds(address payable fundsAddress) external onlyOwner {
}
function addLiquidity() external onlyOwner {
}
event Deposited(address indexed user, uint256 amount);
event Recovered(address token, uint256 amount);
}
| deposits[msg.sender].add(msg.value)>=minimumDepositEthAmount&&deposits[msg.sender].add(msg.value)<=maximumDepositEthAmount,"incorrect amount" | 335,886 | deposits[msg.sender].add(msg.value)>=minimumDepositEthAmount&&deposits[msg.sender].add(msg.value)<=maximumDepositEthAmount |
null | pragma solidity ^0.4.13;
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to relinquish control of the contract.
*/
function renounceOwnership() public 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) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function _transferOwnership(address _newOwner) internal {
}
}
contract EthicHubReputationInterface {
modifier onlyUsersContract(){ }
modifier onlyLendingContract(){ }
function burnReputation(uint delayDays) external;
function incrementReputation(uint completedProjectsByTier) external;
function initLocalNodeReputation(address localNode) external;
function initCommunityReputation(address community) external;
function getCommunityReputation(address target) public view returns(uint256);
function getLocalNodeReputation(address target) public view returns(uint256);
}
contract EthicHubStorageInterface {
//modifier for access in sets and deletes
modifier onlyEthicHubContracts() { }
// Setters
function setAddress(bytes32 _key, address _value) external;
function setUint(bytes32 _key, uint _value) external;
function setString(bytes32 _key, string _value) external;
function setBytes(bytes32 _key, bytes _value) external;
function setBool(bytes32 _key, bool _value) external;
function setInt(bytes32 _key, int _value) external;
// Deleters
function deleteAddress(bytes32 _key) external;
function deleteUint(bytes32 _key) external;
function deleteString(bytes32 _key) external;
function deleteBytes(bytes32 _key) external;
function deleteBool(bytes32 _key) external;
function deleteInt(bytes32 _key) external;
// Getters
function getAddress(bytes32 _key) external view returns (address);
function getUint(bytes32 _key) external view returns (uint);
function getString(bytes32 _key) external view returns (string);
function getBytes(bytes32 _key) external view returns (bytes);
function getBool(bytes32 _key) external view returns (bool);
function getInt(bytes32 _key) external view returns (int);
}
contract EthicHubBase {
uint8 public version;
EthicHubStorageInterface public ethicHubStorage = EthicHubStorageInterface(0);
constructor(address _storageAddress) public {
}
}
contract EthicHubUser is Ownable, EthicHubBase {
event UserStatusChanged(address target, string profile, bool isRegistered);
constructor(address _storageAddress)
EthicHubBase(_storageAddress)
public
{
}
/**
* @dev Changes registration status of an address for participation.
* @param target Address that will be registered/deregistered.
* @param profile profile of user.
* @param isRegistered New registration status of address.
*/
function changeUserStatus(address target, string profile, bool isRegistered)
public
onlyOwner
{
require(target != address(0));
require(<FILL_ME>)
ethicHubStorage.setBool(keccak256("user", profile, target), isRegistered);
emit UserStatusChanged(target, profile, isRegistered);
}
/**
* @dev Changes registration statuses of addresses for participation.
* @param targets Addresses that will be registered/deregistered.
* @param profile profile of user.
* @param isRegistered New registration status of addresses.
*/
function changeUsersStatus(address[] targets, string profile, bool isRegistered)
external
onlyOwner
{
}
/**
* @dev View registration status of an address for participation.
* @return isRegistered boolean registration status of address for a specific profile.
*/
function viewRegistrationStatus(address target, string profile)
view public
returns(bool isRegistered)
{
}
/**
* @dev register a localNode address.
*/
function registerLocalNode(address target)
external
onlyOwner
{
}
/**
* @dev register a community address.
*/
function registerCommunity(address target)
external
onlyOwner
{
}
/**
* @dev register a invertor address.
*/
function registerInvestor(address target)
external
onlyOwner
{
}
/**
* @dev register a community representative address.
*/
function registerRepresentative(address target)
external
onlyOwner
{
}
}
| bytes(profile).length!=0 | 336,088 | bytes(profile).length!=0 |
"eWithdraw transfer failed." | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "IERC20.sol";
import "SafeERC20.sol";
interface HistoricalPriceConsumerV3 {
function getLatestPriceX1e6(address) external view returns (int);
}
interface VaultV0 {
function expiry() external returns (uint);
function COLLAT_ADDRESS() external returns (address);
function PRICE_FEED() external returns (address);
function LINK_AGGREGATOR() external returns (address);
/* Multisig Alpha */
function setOwner(address newOwner) external;
function settleStrike_MM(uint priceX1e6) external;
function setExpiry(uint arbitraryExpiry) external;
function setMaxCap(uint newDepositCap) external;
function setMaker(address newMaker) external;
function setPriceFeed(HistoricalPriceConsumerV3 newPriceFeed) external;
function emergencyWithdraw() external;
function depositOnBehalf(address tgt, uint256 amt) external;
function setAllowInteraction(bool _flag) external;
}
contract OwnerProxy {
using SafeERC20 for IERC20;
address public multisigAlpha;
address public multisigBeta;
address public teamKey;
address public multisigAlpha_pending;
address public multisigBeta_pending;
address public teamKey_pending;
mapping(bytes32 => uint) public queuedPriceFeed;
event PriceFeedQueued(address indexed _vault, address pricedFeed);
constructor() {
}
function setMultisigAlpha(address _newMultisig) external {
}
function setMultisigBeta(address _newMultisig) external {
}
function setTeamKey(address _newTeamKey) external {
}
function acceptMultisigAlpha() external {
}
function acceptMultisigBeta() external {
}
function acceptTeamKey() external {
}
function setOwner(VaultV0 _vault, address _newOwner) external {
}
function emergencyWithdraw(VaultV0 _vault) external {
require(msg.sender == multisigAlpha, "!multisigAlpha");
_vault.emergencyWithdraw();
IERC20 COLLAT = IERC20(_vault.COLLAT_ADDRESS());
COLLAT.safeTransfer(multisigAlpha, COLLAT.balanceOf( address(this) ));
require(<FILL_ME>)
}
function queuePriceFeed(VaultV0 _vault, HistoricalPriceConsumerV3 _priceFeed) external {
}
function settleStrike_MM(VaultV0 _vault, uint _priceX1e6) external {
}
function setExpiry(VaultV0 _vault, uint _expiry) external {
}
function depositOnBehalf(VaultV0 _vault, address _onBehalfOf, uint _amt) external {
}
function setMaxCap(VaultV0 _vault, uint _maxCap) external {
}
function setAllowInteraction(VaultV0 _vault, bool _flag) external {
}
function setMaker(VaultV0 _vault, address _newMaker) external {
}
}
| COLLAT.balanceOf(address(this))==0,"eWithdraw transfer failed." | 336,114 | COLLAT.balanceOf(address(this))==0 |
"Expired" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "IERC20.sol";
import "SafeERC20.sol";
interface HistoricalPriceConsumerV3 {
function getLatestPriceX1e6(address) external view returns (int);
}
interface VaultV0 {
function expiry() external returns (uint);
function COLLAT_ADDRESS() external returns (address);
function PRICE_FEED() external returns (address);
function LINK_AGGREGATOR() external returns (address);
/* Multisig Alpha */
function setOwner(address newOwner) external;
function settleStrike_MM(uint priceX1e6) external;
function setExpiry(uint arbitraryExpiry) external;
function setMaxCap(uint newDepositCap) external;
function setMaker(address newMaker) external;
function setPriceFeed(HistoricalPriceConsumerV3 newPriceFeed) external;
function emergencyWithdraw() external;
function depositOnBehalf(address tgt, uint256 amt) external;
function setAllowInteraction(bool _flag) external;
}
contract OwnerProxy {
using SafeERC20 for IERC20;
address public multisigAlpha;
address public multisigBeta;
address public teamKey;
address public multisigAlpha_pending;
address public multisigBeta_pending;
address public teamKey_pending;
mapping(bytes32 => uint) public queuedPriceFeed;
event PriceFeedQueued(address indexed _vault, address pricedFeed);
constructor() {
}
function setMultisigAlpha(address _newMultisig) external {
}
function setMultisigBeta(address _newMultisig) external {
}
function setTeamKey(address _newTeamKey) external {
}
function acceptMultisigAlpha() external {
}
function acceptMultisigBeta() external {
}
function acceptTeamKey() external {
}
function setOwner(VaultV0 _vault, address _newOwner) external {
}
function emergencyWithdraw(VaultV0 _vault) external {
}
function queuePriceFeed(VaultV0 _vault, HistoricalPriceConsumerV3 _priceFeed) external {
}
function settleStrike_MM(VaultV0 _vault, uint _priceX1e6) external {
}
function setExpiry(VaultV0 _vault, uint _expiry) external {
require(msg.sender == multisigBeta, "Not multisigBeta");
require(<FILL_ME>)
require(_expiry < _vault.expiry(), "Can only set expiry nearer");
require(_expiry > block.timestamp + 1 hours, "At least 1 hour buffer");
_vault.setExpiry(_expiry);
}
function depositOnBehalf(VaultV0 _vault, address _onBehalfOf, uint _amt) external {
}
function setMaxCap(VaultV0 _vault, uint _maxCap) external {
}
function setAllowInteraction(VaultV0 _vault, bool _flag) external {
}
function setMaker(VaultV0 _vault, address _newMaker) external {
}
}
| _vault.expiry()>0,"Expired" | 336,114 | _vault.expiry()>0 |
"Not Expired" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "IERC20.sol";
import "SafeERC20.sol";
interface HistoricalPriceConsumerV3 {
function getLatestPriceX1e6(address) external view returns (int);
}
interface VaultV0 {
function expiry() external returns (uint);
function COLLAT_ADDRESS() external returns (address);
function PRICE_FEED() external returns (address);
function LINK_AGGREGATOR() external returns (address);
/* Multisig Alpha */
function setOwner(address newOwner) external;
function settleStrike_MM(uint priceX1e6) external;
function setExpiry(uint arbitraryExpiry) external;
function setMaxCap(uint newDepositCap) external;
function setMaker(address newMaker) external;
function setPriceFeed(HistoricalPriceConsumerV3 newPriceFeed) external;
function emergencyWithdraw() external;
function depositOnBehalf(address tgt, uint256 amt) external;
function setAllowInteraction(bool _flag) external;
}
contract OwnerProxy {
using SafeERC20 for IERC20;
address public multisigAlpha;
address public multisigBeta;
address public teamKey;
address public multisigAlpha_pending;
address public multisigBeta_pending;
address public teamKey_pending;
mapping(bytes32 => uint) public queuedPriceFeed;
event PriceFeedQueued(address indexed _vault, address pricedFeed);
constructor() {
}
function setMultisigAlpha(address _newMultisig) external {
}
function setMultisigBeta(address _newMultisig) external {
}
function setTeamKey(address _newTeamKey) external {
}
function acceptMultisigAlpha() external {
}
function acceptMultisigBeta() external {
}
function acceptTeamKey() external {
}
function setOwner(VaultV0 _vault, address _newOwner) external {
}
function emergencyWithdraw(VaultV0 _vault) external {
}
function queuePriceFeed(VaultV0 _vault, HistoricalPriceConsumerV3 _priceFeed) external {
}
function settleStrike_MM(VaultV0 _vault, uint _priceX1e6) external {
}
function setExpiry(VaultV0 _vault, uint _expiry) external {
}
function depositOnBehalf(VaultV0 _vault, address _onBehalfOf, uint _amt) external {
}
function setMaxCap(VaultV0 _vault, uint _maxCap) external {
}
function setAllowInteraction(VaultV0 _vault, bool _flag) external {
require(msg.sender == teamKey, "Not teamKey");
require(<FILL_ME>)
_vault.setAllowInteraction(_flag);
}
function setMaker(VaultV0 _vault, address _newMaker) external {
}
}
| _vault.expiry()==0,"Not Expired" | 336,114 | _vault.expiry()==0 |
null | pragma solidity ^0.5.2;
interface ERC721TokenReceiver {
/**
* @dev Handle the receipt of a NFT. The ERC721 smart contract calls this function on the
* recipient after a `transfer`. This function MAY throw to revert and reject the transfer. Return
* of other than the magic value MUST result in the transaction being reverted.
* Returns `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` unless throwing.
* @notice The contract address is always the message sender. A wallet/broker/auction application
* MUST implement the wallet interface if it will accept safe transfers.
* @param _operator The address which called `safeTransferFrom` function.
* @param _from The address which previously owned the token.
* @param _tokenId The NFT identifier which is being transferred.
* @param _data Additional data with no specified format.
*/
function onERC721Received(
address _operator,
address _from,
uint256 _tokenId,
bytes calldata _data
) external returns(bytes4);
}
contract ICOStickers {
using SafeMath for uint256;
using SafeMath for int256;
address constant internal NULL_ADDRESS = 0x0000000000000000000000000000000000000000;
// ERC721 requires ERC165
mapping(bytes4 => bool) internal supportedInterfaces;
// ERC721
address[] internal idToOwner;
address[] internal idToApprovals;
mapping (address => uint256) internal ownerToNFTokenCount;
mapping (address => mapping (address => bool)) internal ownerToOperators;
bytes4 constant MAGIC_ON_ERC721_RECEIVED = 0x150b7a02;
// ERC721Metadata
string constant public name = "0xchan ICO Stickers";
string constant public symbol = "ZCIS";
// Custom
string constant internal uriStart = "https://0xchan.net/stickers/obj_properties/";
uint256[] public tokenProperty;
address[] public originalTokenOwner;
address internal badgeGiver;
address internal owner;
address internal newOwner;
// ERC721 Events
event Transfer(
address indexed _from,
address indexed _to,
uint256 indexed _tokenId
);
event Approval(
address indexed _owner,
address indexed _approved,
uint256 indexed _tokenId
);
event ApprovalForAll(
address indexed _owner,
address indexed _operator,
bool _approved
);
modifier canOperate(uint256 _tokenId) {
}
modifier canTransfer(uint256 _tokenId) {
}
modifier validNFToken(uint256 _tokenId) {
require(<FILL_ME>)
_;
}
modifier onlyOwner {
}
modifier onlyBadgeGiver {
}
constructor() public {
}
// Custom functions
function setNewOwner(address o) public onlyOwner {
}
function acceptNewOwner() public {
}
function revokeOwnership() public onlyOwner {
}
function setBadgeGiver(address g) public onlyOwner {
}
function giveSticker(address _to, uint256 _property) public onlyBadgeGiver {
}
// ERC721Enumerable functions
function totalSupply() external view returns(uint256) {
}
function tokenOfOwnerByIndex(uint256 _tokenId) external view returns(address _owner) {
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
}
// ERC721Metadata functions
function tokenURI(uint256 _tokenId) validNFToken(_tokenId) public view returns (string memory)
{
}
// ERC721 functions
function balanceOf(address _owner) external view returns(uint256) {
}
function ownerOf(uint256 _tokenId) external view returns(address _owner){
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata _data) external {
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external {
}
function supportsInterface(bytes4 _interfaceID) external view returns(bool) {
}
function transferFrom(address _from, address _to, uint256 _tokenId) external canTransfer(_tokenId) validNFToken(_tokenId) {
}
function approve(address _approved, uint256 _tokenId) external canOperate(_tokenId) validNFToken(_tokenId) {
}
function setApprovalForAll(address _operator, bool _approved) external {
}
function getApproved(uint256 _tokenId) public view validNFToken(_tokenId) returns (address){
}
function isApprovedForAll(address _owner, address _operator) external view returns(bool) {
}
function _safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory _data) internal canTransfer(_tokenId) validNFToken(_tokenId) {
}
function _transfer(address _to, uint256 _tokenId) private {
}
function clearApproval(uint256 _tokenId) private {
}
function removeNFToken(address _from, uint256 _tokenId) internal {
}
function addNFToken(address _to, uint256 _tokenId) internal {
}
//If bytecode exists at _addr then the _addr is a contract.
function isContract(address _addr) internal view returns(bool) {
}
// Functions used for generating the URI
function amountOfZeros(uint256 num, uint256 base) public pure returns(uint256){
}
function uint256ToString(uint256 num) public pure returns(string memory){
}
function concatStrings(string memory str1, string memory str2) public pure returns (string memory){
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns(uint256 c) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns(uint256) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns(uint256 c) {
}
/**
* @dev Subtracts two numbers, throws on underflow
*/
function sub(int256 a, int256 b) internal pure returns(int256 c) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(int256 a, int256 b) internal pure returns(int256 c) {
}
}
| idToOwner[_tokenId]!=NULL_ADDRESS | 336,168 | idToOwner[_tokenId]!=NULL_ADDRESS |
null | pragma solidity ^0.5.2;
interface ERC721TokenReceiver {
/**
* @dev Handle the receipt of a NFT. The ERC721 smart contract calls this function on the
* recipient after a `transfer`. This function MAY throw to revert and reject the transfer. Return
* of other than the magic value MUST result in the transaction being reverted.
* Returns `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` unless throwing.
* @notice The contract address is always the message sender. A wallet/broker/auction application
* MUST implement the wallet interface if it will accept safe transfers.
* @param _operator The address which called `safeTransferFrom` function.
* @param _from The address which previously owned the token.
* @param _tokenId The NFT identifier which is being transferred.
* @param _data Additional data with no specified format.
*/
function onERC721Received(
address _operator,
address _from,
uint256 _tokenId,
bytes calldata _data
) external returns(bytes4);
}
contract ICOStickers {
using SafeMath for uint256;
using SafeMath for int256;
address constant internal NULL_ADDRESS = 0x0000000000000000000000000000000000000000;
// ERC721 requires ERC165
mapping(bytes4 => bool) internal supportedInterfaces;
// ERC721
address[] internal idToOwner;
address[] internal idToApprovals;
mapping (address => uint256) internal ownerToNFTokenCount;
mapping (address => mapping (address => bool)) internal ownerToOperators;
bytes4 constant MAGIC_ON_ERC721_RECEIVED = 0x150b7a02;
// ERC721Metadata
string constant public name = "0xchan ICO Stickers";
string constant public symbol = "ZCIS";
// Custom
string constant internal uriStart = "https://0xchan.net/stickers/obj_properties/";
uint256[] public tokenProperty;
address[] public originalTokenOwner;
address internal badgeGiver;
address internal owner;
address internal newOwner;
// ERC721 Events
event Transfer(
address indexed _from,
address indexed _to,
uint256 indexed _tokenId
);
event Approval(
address indexed _owner,
address indexed _approved,
uint256 indexed _tokenId
);
event ApprovalForAll(
address indexed _owner,
address indexed _operator,
bool _approved
);
modifier canOperate(uint256 _tokenId) {
}
modifier canTransfer(uint256 _tokenId) {
}
modifier validNFToken(uint256 _tokenId) {
}
modifier onlyOwner {
}
modifier onlyBadgeGiver {
}
constructor() public {
}
// Custom functions
function setNewOwner(address o) public onlyOwner {
}
function acceptNewOwner() public {
}
function revokeOwnership() public onlyOwner {
}
function setBadgeGiver(address g) public onlyOwner {
}
function giveSticker(address _to, uint256 _property) public onlyBadgeGiver {
}
// ERC721Enumerable functions
function totalSupply() external view returns(uint256) {
}
function tokenOfOwnerByIndex(uint256 _tokenId) external view returns(address _owner) {
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
}
// ERC721Metadata functions
function tokenURI(uint256 _tokenId) validNFToken(_tokenId) public view returns (string memory)
{
}
// ERC721 functions
function balanceOf(address _owner) external view returns(uint256) {
}
function ownerOf(uint256 _tokenId) external view returns(address _owner){
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata _data) external {
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external {
}
function supportsInterface(bytes4 _interfaceID) external view returns(bool) {
}
function transferFrom(address _from, address _to, uint256 _tokenId) external canTransfer(_tokenId) validNFToken(_tokenId) {
}
function approve(address _approved, uint256 _tokenId) external canOperate(_tokenId) validNFToken(_tokenId) {
}
function setApprovalForAll(address _operator, bool _approved) external {
}
function getApproved(uint256 _tokenId) public view validNFToken(_tokenId) returns (address){
}
function isApprovedForAll(address _owner, address _operator) external view returns(bool) {
}
function _safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory _data) internal canTransfer(_tokenId) validNFToken(_tokenId) {
}
function _transfer(address _to, uint256 _tokenId) private {
}
function clearApproval(uint256 _tokenId) private {
}
function removeNFToken(address _from, uint256 _tokenId) internal {
}
function addNFToken(address _to, uint256 _tokenId) internal {
require(<FILL_ME>)
idToOwner[_tokenId] = _to;
ownerToNFTokenCount[_to] = ownerToNFTokenCount[_to].add(1);
}
//If bytecode exists at _addr then the _addr is a contract.
function isContract(address _addr) internal view returns(bool) {
}
// Functions used for generating the URI
function amountOfZeros(uint256 num, uint256 base) public pure returns(uint256){
}
function uint256ToString(uint256 num) public pure returns(string memory){
}
function concatStrings(string memory str1, string memory str2) public pure returns (string memory){
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns(uint256 c) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns(uint256) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns(uint256 c) {
}
/**
* @dev Subtracts two numbers, throws on underflow
*/
function sub(int256 a, int256 b) internal pure returns(int256 c) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(int256 a, int256 b) internal pure returns(int256 c) {
}
}
| idToOwner[_tokenId]==NULL_ADDRESS | 336,168 | idToOwner[_tokenId]==NULL_ADDRESS |
"Category quantity sold must be zero" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./IDaoEventsV2.sol";
import "./EventTicketV2.sol";
interface IERC20 {
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
}
contract DaoEventsV2 is IDaoEventsV2, Ownable, EventTicketV2, ReentrancyGuard {
uint256 public eventIds;
address public tokenAddress;
IOracle public oracle;
// address public USDT = 0x0cEbA92298b655C827D224D33461B4A1F9C418a6; // rinkeby new usdt
address public USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7; // matic mainnet new usdt
// Mapping from owner to list of owned events IDs.
mapping(address => uint256[]) private ownedEvents;
// Mapping from event ID to event revenue
mapping(uint256 => uint256) public eventRevenue;
// Mapping from eventId to Event struct
mapping(uint256 => Event) public events;
// Mapping from address to eventId to boughOrNot
mapping(address => mapping(uint256 => bool)) ticketBought;
constructor(address _token, address _oracle) {
}
modifier goodTime(uint256 _time) {
}
modifier eventExist(uint256 _id) {
}
function getTicketLimited(uint256 _eventId)
public
view
returns (bool[] memory)
{
}
function getTktQnty(uint256 _eventId)
public
view
returns (uint256[] memory)
{
}
function getPrices(uint256 _eventId)
public
view
returns (uint256[] memory)
{
}
function getTktQntySold(uint256 _eventId)
public
view
returns (uint256[] memory)
{
}
function getCategories(uint256 _eventId)
public
view
returns (string[] memory)
{
}
function changeToken(address _token) public onlyOwner() {
}
function createEvent(Event memory _event) public goodTime(_event.time) {
// increment the eventId
eventIds++;
require(_event.owner == _msgSender(), "Caller must be the owner");
require(_event.totalQntySold == 0, "Quantity sold must be zero");
require(
_event.categories.length == _event.tktQnty.length &&
_event.categories.length == _event.prices.length &&
_event.categories.length == _event.tktQntySold.length,
"Invalid categories"
);
uint256 _totalTktQnty;
uint256 _categoriesLength = _event.categories.length;
for (uint256 i = 0; i < _categoriesLength; i++) {
require(<FILL_ME>)
_totalTktQnty = _totalTktQnty + _event.tktQnty[i];
if (!_event.ticketLimited[i]) {
require(
_event.tktQnty[i] == 0,
"quantity should be zero for unlimited tickets"
);
}
}
require(
_event.totalQuantity == _totalTktQnty,
"Total ticket quantity not match category quantity"
);
uint256 _eventId = eventIds;
// updating state
events[_eventId] = _event;
ownedEvents[_msgSender()].push(_eventId);
// emiting event
emit CreatedEvent(_msgSender(), _eventId, _event);
}
function buyTicket(BuyTicket memory _buyTicket)
public
eventExist(_buyTicket.eventId)
goodTime(events[_buyTicket.eventId].time)
{
}
function eventsOf(address _owner) public view returns (uint256[] memory) {
}
function getEventsCount() public view returns (uint256) {
}
function _buyTicketInternal(
BuyTicket memory _buyTicket,
Event memory _event,
uint256 _phnxPrice,
uint256 _ticketId
) internal nonReentrant {
}
}
| _event.tktQntySold[i]==0,"Category quantity sold must be zero" | 336,197 | _event.tktQntySold[i]==0 |
"quantity should be zero for unlimited tickets" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./IDaoEventsV2.sol";
import "./EventTicketV2.sol";
interface IERC20 {
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
}
contract DaoEventsV2 is IDaoEventsV2, Ownable, EventTicketV2, ReentrancyGuard {
uint256 public eventIds;
address public tokenAddress;
IOracle public oracle;
// address public USDT = 0x0cEbA92298b655C827D224D33461B4A1F9C418a6; // rinkeby new usdt
address public USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7; // matic mainnet new usdt
// Mapping from owner to list of owned events IDs.
mapping(address => uint256[]) private ownedEvents;
// Mapping from event ID to event revenue
mapping(uint256 => uint256) public eventRevenue;
// Mapping from eventId to Event struct
mapping(uint256 => Event) public events;
// Mapping from address to eventId to boughOrNot
mapping(address => mapping(uint256 => bool)) ticketBought;
constructor(address _token, address _oracle) {
}
modifier goodTime(uint256 _time) {
}
modifier eventExist(uint256 _id) {
}
function getTicketLimited(uint256 _eventId)
public
view
returns (bool[] memory)
{
}
function getTktQnty(uint256 _eventId)
public
view
returns (uint256[] memory)
{
}
function getPrices(uint256 _eventId)
public
view
returns (uint256[] memory)
{
}
function getTktQntySold(uint256 _eventId)
public
view
returns (uint256[] memory)
{
}
function getCategories(uint256 _eventId)
public
view
returns (string[] memory)
{
}
function changeToken(address _token) public onlyOwner() {
}
function createEvent(Event memory _event) public goodTime(_event.time) {
// increment the eventId
eventIds++;
require(_event.owner == _msgSender(), "Caller must be the owner");
require(_event.totalQntySold == 0, "Quantity sold must be zero");
require(
_event.categories.length == _event.tktQnty.length &&
_event.categories.length == _event.prices.length &&
_event.categories.length == _event.tktQntySold.length,
"Invalid categories"
);
uint256 _totalTktQnty;
uint256 _categoriesLength = _event.categories.length;
for (uint256 i = 0; i < _categoriesLength; i++) {
require(
_event.tktQntySold[i] == 0,
"Category quantity sold must be zero"
);
_totalTktQnty = _totalTktQnty + _event.tktQnty[i];
if (!_event.ticketLimited[i]) {
require(<FILL_ME>)
}
}
require(
_event.totalQuantity == _totalTktQnty,
"Total ticket quantity not match category quantity"
);
uint256 _eventId = eventIds;
// updating state
events[_eventId] = _event;
ownedEvents[_msgSender()].push(_eventId);
// emiting event
emit CreatedEvent(_msgSender(), _eventId, _event);
}
function buyTicket(BuyTicket memory _buyTicket)
public
eventExist(_buyTicket.eventId)
goodTime(events[_buyTicket.eventId].time)
{
}
function eventsOf(address _owner) public view returns (uint256[] memory) {
}
function getEventsCount() public view returns (uint256) {
}
function _buyTicketInternal(
BuyTicket memory _buyTicket,
Event memory _event,
uint256 _phnxPrice,
uint256 _ticketId
) internal nonReentrant {
}
}
| _event.tktQnty[i]==0,"quantity should be zero for unlimited tickets" | 336,197 | _event.tktQnty[i]==0 |
"ticket to be bought only one time" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./IDaoEventsV2.sol";
import "./EventTicketV2.sol";
interface IERC20 {
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
}
contract DaoEventsV2 is IDaoEventsV2, Ownable, EventTicketV2, ReentrancyGuard {
uint256 public eventIds;
address public tokenAddress;
IOracle public oracle;
// address public USDT = 0x0cEbA92298b655C827D224D33461B4A1F9C418a6; // rinkeby new usdt
address public USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7; // matic mainnet new usdt
// Mapping from owner to list of owned events IDs.
mapping(address => uint256[]) private ownedEvents;
// Mapping from event ID to event revenue
mapping(uint256 => uint256) public eventRevenue;
// Mapping from eventId to Event struct
mapping(uint256 => Event) public events;
// Mapping from address to eventId to boughOrNot
mapping(address => mapping(uint256 => bool)) ticketBought;
constructor(address _token, address _oracle) {
}
modifier goodTime(uint256 _time) {
}
modifier eventExist(uint256 _id) {
}
function getTicketLimited(uint256 _eventId)
public
view
returns (bool[] memory)
{
}
function getTktQnty(uint256 _eventId)
public
view
returns (uint256[] memory)
{
}
function getPrices(uint256 _eventId)
public
view
returns (uint256[] memory)
{
}
function getTktQntySold(uint256 _eventId)
public
view
returns (uint256[] memory)
{
}
function getCategories(uint256 _eventId)
public
view
returns (string[] memory)
{
}
function changeToken(address _token) public onlyOwner() {
}
function createEvent(Event memory _event) public goodTime(_event.time) {
}
function buyTicket(BuyTicket memory _buyTicket)
public
eventExist(_buyTicket.eventId)
goodTime(events[_buyTicket.eventId].time)
{
// increment ticketId
ticketIds++;
Event memory _event = events[_buyTicket.eventId];
uint256 _usdtPrice;
uint256 _phnxPrice;
if (!_event.token) {
// event is free
_usdtPrice = 0;
_phnxPrice = 0;
} else {
// event is paid
_usdtPrice = _event.prices[_buyTicket.categoryIndex];
_phnxPrice = (_usdtPrice * oracle.fetch(USDT)) / 1e18;
}
uint256 _ticketId = ticketIds;
if (_event.ticketLimited[_buyTicket.categoryIndex]) {
require(
_event.totalQuantity > _event.totalQntySold &&
_event.tktQnty[_buyTicket.categoryIndex] >
_event.tktQntySold[_buyTicket.categoryIndex],
"ticket quantity exceeded"
);
}
if (_event.oneTimeBuy) {
require(<FILL_ME>)
ticketBought[_msgSender()][_buyTicket.eventId] = true;
}
_buyTicketInternal(_buyTicket, _event, _phnxPrice, _ticketId);
uint256 _totalQuantitySold = events[_buyTicket.eventId].totalQntySold;
uint256 _categoryTktsSold =
events[_buyTicket.eventId].tktQntySold[_buyTicket.categoryIndex];
emit SoldTicketDetails1(
Ticket(
_buyTicket.eventId,
_ticketId,
_buyTicket.boughtLocation,
_event.location
)
);
emit SoldTicketDetails2(
SoldTicketStruct(
_event.token,
_buyTicket.eventId,
_ticketId,
_msgSender(),
_usdtPrice,
_phnxPrice,
block.timestamp,
_totalQuantitySold,
_categoryTktsSold,
_event.categories[_buyTicket.categoryIndex]
),
_event.owner
);
}
function eventsOf(address _owner) public view returns (uint256[] memory) {
}
function getEventsCount() public view returns (uint256) {
}
function _buyTicketInternal(
BuyTicket memory _buyTicket,
Event memory _event,
uint256 _phnxPrice,
uint256 _ticketId
) internal nonReentrant {
}
}
| !ticketBought[_msgSender()][_buyTicket.eventId],"ticket to be bought only one time" | 336,197 | !ticketBought[_msgSender()][_buyTicket.eventId] |
"Purchase exceeds max allowed" | // This Project is done by Adil & Zohaib
// If you have any Queries you can Contact us
// Adil/ +923217028026 Discord/ ADAM#2595
// Zohaib/ +923334182339 Discord/ Zohaib saddiqi#4748
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract BuzzardBill is ERC721A("Buzzard Bill", "OJO") {
string public baseURI = "ipfs://QmeSzRB8c2jb3pD2P5c9HnTSSEJBThHjfdiax1Ykqr4zpP/";
bool public isSaleActive;
uint256 public itemPrice = 0.04 ether;
uint256 public itemPricePresale = 0.02 ether;
uint256 public immutable maxSupply = 10000;
address public owner = msg.sender;
// internal
function _startTokenId() internal pure override returns (uint256) {
}
///////////////////////////////
// PRESALE CODE STARTS //
///////////////////////////////
bool public isAllowlistActive;
uint256 public allowlistMaxMint = 3;
mapping(address => bool) public onAllowlist;
mapping(address => uint256) public allowlistClaimedBy;
function addToAllowlist(address[] calldata addresses, bool _add)
external
onlyOwner
{
}
// Purchase multiple NFTs at once
function purchasePresaleTokens(uint256 _howMany)
external
payable
tokensAvailable(_howMany)
{
require(isAllowlistActive, "Allowlist is not active");
require(<FILL_ME>)
require(
msg.value >= _howMany * itemPricePresale,
"Try to send more ETH"
);
allowlistClaimedBy[msg.sender] += _howMany;
_safeMint(msg.sender, _howMany);
}
// set limit of allowlist
function setAllowlistMaxMint(uint256 _allowlistMaxMint) external onlyOwner {
}
// Change presale price in case of ETH price changes too much
function setPricePresale(uint256 _itemPricePresale) external onlyOwner {
}
function setIsAllowlistActive(bool _isAllowlistActive) external onlyOwner {
}
///////////////////////////////////
// PUBLIC SALE CODE STARTS //
///////////////////////////////////
// Purchase multiple NFTs at once
function purchaseTokens(uint256 _howMany)
external
payable
tokensAvailable(_howMany)
{
}
//////////////////////////
// ONLY OWNER METHODS //
//////////////////////////
// Owner can withdraw from here
function withdraw() external onlyOwner {
}
// Change price in case of ETH price changes too much
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setSaleActive(bool _isSaleActive) external onlyOwner {
}
// Hide identity or show identity from here
function setBaseURI(string memory __baseURI) external onlyOwner {
}
///////////////////////////////////
// AIRDROP CODE STARTS //
///////////////////////////////////
// Send NFTs to a list of addresses
function giftNftToList(address[] calldata _sendNftsTo, uint256 _howMany)
external
onlyOwner
tokensAvailable(_sendNftsTo.length)
{
}
// Send NFTs to a single address
function giftNftToAddress(address _sendNftsTo, uint256 _howMany)
external
onlyOwner
tokensAvailable(_howMany)
{
}
///////////////////
// QUERY METHOD //
///////////////////
function tokensRemaining() public view returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenOfOwnerByIndex(address _owner, uint256 index) public view returns (uint256) {
}
///////////////////
// HELPER CODE //
///////////////////
modifier tokensAvailable(uint256 _howMany) {
}
modifier onlyOwner() {
}
//////////////////////////////
// WHITELISTING FOR STAKING //
//////////////////////////////
// tokenId => staked (yes or no)
mapping(address => bool) public whitelisted;
// add / remove from whitelist who can stake / unstake
function addToWhitelist(address _address, bool _add) external onlyOwner {
}
modifier onlyWhitelisted() {
}
/////////////////////
// STAKING METHOD //
/////////////////////
mapping(uint256 => bool) public staked;
function _beforeTokenTransfers(
address,
address,
uint256 startTokenId,
uint256 quantity
) internal view override {
}
// stake / unstake nfts
function stakeNfts(uint256[] calldata _tokenIds, bool _stake)
external
onlyWhitelisted
{
}
///////////////////////////
// AUTO APPROVE OPENSEA //
///////////////////////////
// Opensea Registerar Mainnet 0xa5409ec958C83C3f309868babACA7c86DCB077c1
// Opensea Registerar Rinkeby 0xF57B2c51dED3A29e6891aba85459d600256Cf317
address openSeaRegistrar = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
function isApprovedForAll(address _owner, address _operator)
public
view
override
returns (bool)
{
}
// infuture address changes for opensea registrar
function editOpenSeaRegisterar(address _openSeaRegistrar)
external
onlyOwner
{
}
// just in case openSeaRegistrar is not present we use this contract
function proxies(address) external pure returns (address) {
}
////////////////////////////
// Merkle tree whitelist //
////////////////////////////
bytes32 public whitelistMerkleRoot;
function setWhitelistMerkleRoot(bytes32 _whitelistMerkleRoot)
external
onlyOwner
{
}
function inWhitelist(bytes32[] memory _proof, address _owner)
external
view
returns (bool)
{
}
// Purchase multiple NFTs at once
function purchasePresaleTokensMerkle(
uint256 _howMany,
bytes32[] calldata proof
) external payable tokensAvailable(_howMany) {
}
}
interface ProxyRegisterar {
function proxies(address) external view returns (address);
}
| allowlistClaimedBy[msg.sender]+_howMany<=allowlistMaxMint,"Purchase exceeds max allowed" | 336,210 | allowlistClaimedBy[msg.sender]+_howMany<=allowlistMaxMint |
"Unstake tokenId it to transfer" | // This Project is done by Adil & Zohaib
// If you have any Queries you can Contact us
// Adil/ +923217028026 Discord/ ADAM#2595
// Zohaib/ +923334182339 Discord/ Zohaib saddiqi#4748
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract BuzzardBill is ERC721A("Buzzard Bill", "OJO") {
string public baseURI = "ipfs://QmeSzRB8c2jb3pD2P5c9HnTSSEJBThHjfdiax1Ykqr4zpP/";
bool public isSaleActive;
uint256 public itemPrice = 0.04 ether;
uint256 public itemPricePresale = 0.02 ether;
uint256 public immutable maxSupply = 10000;
address public owner = msg.sender;
// internal
function _startTokenId() internal pure override returns (uint256) {
}
///////////////////////////////
// PRESALE CODE STARTS //
///////////////////////////////
bool public isAllowlistActive;
uint256 public allowlistMaxMint = 3;
mapping(address => bool) public onAllowlist;
mapping(address => uint256) public allowlistClaimedBy;
function addToAllowlist(address[] calldata addresses, bool _add)
external
onlyOwner
{
}
// Purchase multiple NFTs at once
function purchasePresaleTokens(uint256 _howMany)
external
payable
tokensAvailable(_howMany)
{
}
// set limit of allowlist
function setAllowlistMaxMint(uint256 _allowlistMaxMint) external onlyOwner {
}
// Change presale price in case of ETH price changes too much
function setPricePresale(uint256 _itemPricePresale) external onlyOwner {
}
function setIsAllowlistActive(bool _isAllowlistActive) external onlyOwner {
}
///////////////////////////////////
// PUBLIC SALE CODE STARTS //
///////////////////////////////////
// Purchase multiple NFTs at once
function purchaseTokens(uint256 _howMany)
external
payable
tokensAvailable(_howMany)
{
}
//////////////////////////
// ONLY OWNER METHODS //
//////////////////////////
// Owner can withdraw from here
function withdraw() external onlyOwner {
}
// Change price in case of ETH price changes too much
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setSaleActive(bool _isSaleActive) external onlyOwner {
}
// Hide identity or show identity from here
function setBaseURI(string memory __baseURI) external onlyOwner {
}
///////////////////////////////////
// AIRDROP CODE STARTS //
///////////////////////////////////
// Send NFTs to a list of addresses
function giftNftToList(address[] calldata _sendNftsTo, uint256 _howMany)
external
onlyOwner
tokensAvailable(_sendNftsTo.length)
{
}
// Send NFTs to a single address
function giftNftToAddress(address _sendNftsTo, uint256 _howMany)
external
onlyOwner
tokensAvailable(_howMany)
{
}
///////////////////
// QUERY METHOD //
///////////////////
function tokensRemaining() public view returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenOfOwnerByIndex(address _owner, uint256 index) public view returns (uint256) {
}
///////////////////
// HELPER CODE //
///////////////////
modifier tokensAvailable(uint256 _howMany) {
}
modifier onlyOwner() {
}
//////////////////////////////
// WHITELISTING FOR STAKING //
//////////////////////////////
// tokenId => staked (yes or no)
mapping(address => bool) public whitelisted;
// add / remove from whitelist who can stake / unstake
function addToWhitelist(address _address, bool _add) external onlyOwner {
}
modifier onlyWhitelisted() {
}
/////////////////////
// STAKING METHOD //
/////////////////////
mapping(uint256 => bool) public staked;
function _beforeTokenTransfers(
address,
address,
uint256 startTokenId,
uint256 quantity
) internal view override {
for (uint256 i = startTokenId; i < startTokenId + quantity; i++)
require(<FILL_ME>)
}
// stake / unstake nfts
function stakeNfts(uint256[] calldata _tokenIds, bool _stake)
external
onlyWhitelisted
{
}
///////////////////////////
// AUTO APPROVE OPENSEA //
///////////////////////////
// Opensea Registerar Mainnet 0xa5409ec958C83C3f309868babACA7c86DCB077c1
// Opensea Registerar Rinkeby 0xF57B2c51dED3A29e6891aba85459d600256Cf317
address openSeaRegistrar = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
function isApprovedForAll(address _owner, address _operator)
public
view
override
returns (bool)
{
}
// infuture address changes for opensea registrar
function editOpenSeaRegisterar(address _openSeaRegistrar)
external
onlyOwner
{
}
// just in case openSeaRegistrar is not present we use this contract
function proxies(address) external pure returns (address) {
}
////////////////////////////
// Merkle tree whitelist //
////////////////////////////
bytes32 public whitelistMerkleRoot;
function setWhitelistMerkleRoot(bytes32 _whitelistMerkleRoot)
external
onlyOwner
{
}
function inWhitelist(bytes32[] memory _proof, address _owner)
external
view
returns (bool)
{
}
// Purchase multiple NFTs at once
function purchasePresaleTokensMerkle(
uint256 _howMany,
bytes32[] calldata proof
) external payable tokensAvailable(_howMany) {
}
}
interface ProxyRegisterar {
function proxies(address) external view returns (address);
}
| !staked[i],"Unstake tokenId it to transfer" | 336,210 | !staked[i] |
"You are not in allowlist" | // This Project is done by Adil & Zohaib
// If you have any Queries you can Contact us
// Adil/ +923217028026 Discord/ ADAM#2595
// Zohaib/ +923334182339 Discord/ Zohaib saddiqi#4748
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract BuzzardBill is ERC721A("Buzzard Bill", "OJO") {
string public baseURI = "ipfs://QmeSzRB8c2jb3pD2P5c9HnTSSEJBThHjfdiax1Ykqr4zpP/";
bool public isSaleActive;
uint256 public itemPrice = 0.04 ether;
uint256 public itemPricePresale = 0.02 ether;
uint256 public immutable maxSupply = 10000;
address public owner = msg.sender;
// internal
function _startTokenId() internal pure override returns (uint256) {
}
///////////////////////////////
// PRESALE CODE STARTS //
///////////////////////////////
bool public isAllowlistActive;
uint256 public allowlistMaxMint = 3;
mapping(address => bool) public onAllowlist;
mapping(address => uint256) public allowlistClaimedBy;
function addToAllowlist(address[] calldata addresses, bool _add)
external
onlyOwner
{
}
// Purchase multiple NFTs at once
function purchasePresaleTokens(uint256 _howMany)
external
payable
tokensAvailable(_howMany)
{
}
// set limit of allowlist
function setAllowlistMaxMint(uint256 _allowlistMaxMint) external onlyOwner {
}
// Change presale price in case of ETH price changes too much
function setPricePresale(uint256 _itemPricePresale) external onlyOwner {
}
function setIsAllowlistActive(bool _isAllowlistActive) external onlyOwner {
}
///////////////////////////////////
// PUBLIC SALE CODE STARTS //
///////////////////////////////////
// Purchase multiple NFTs at once
function purchaseTokens(uint256 _howMany)
external
payable
tokensAvailable(_howMany)
{
}
//////////////////////////
// ONLY OWNER METHODS //
//////////////////////////
// Owner can withdraw from here
function withdraw() external onlyOwner {
}
// Change price in case of ETH price changes too much
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setSaleActive(bool _isSaleActive) external onlyOwner {
}
// Hide identity or show identity from here
function setBaseURI(string memory __baseURI) external onlyOwner {
}
///////////////////////////////////
// AIRDROP CODE STARTS //
///////////////////////////////////
// Send NFTs to a list of addresses
function giftNftToList(address[] calldata _sendNftsTo, uint256 _howMany)
external
onlyOwner
tokensAvailable(_sendNftsTo.length)
{
}
// Send NFTs to a single address
function giftNftToAddress(address _sendNftsTo, uint256 _howMany)
external
onlyOwner
tokensAvailable(_howMany)
{
}
///////////////////
// QUERY METHOD //
///////////////////
function tokensRemaining() public view returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenOfOwnerByIndex(address _owner, uint256 index) public view returns (uint256) {
}
///////////////////
// HELPER CODE //
///////////////////
modifier tokensAvailable(uint256 _howMany) {
}
modifier onlyOwner() {
}
//////////////////////////////
// WHITELISTING FOR STAKING //
//////////////////////////////
// tokenId => staked (yes or no)
mapping(address => bool) public whitelisted;
// add / remove from whitelist who can stake / unstake
function addToWhitelist(address _address, bool _add) external onlyOwner {
}
modifier onlyWhitelisted() {
}
/////////////////////
// STAKING METHOD //
/////////////////////
mapping(uint256 => bool) public staked;
function _beforeTokenTransfers(
address,
address,
uint256 startTokenId,
uint256 quantity
) internal view override {
}
// stake / unstake nfts
function stakeNfts(uint256[] calldata _tokenIds, bool _stake)
external
onlyWhitelisted
{
}
///////////////////////////
// AUTO APPROVE OPENSEA //
///////////////////////////
// Opensea Registerar Mainnet 0xa5409ec958C83C3f309868babACA7c86DCB077c1
// Opensea Registerar Rinkeby 0xF57B2c51dED3A29e6891aba85459d600256Cf317
address openSeaRegistrar = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
function isApprovedForAll(address _owner, address _operator)
public
view
override
returns (bool)
{
}
// infuture address changes for opensea registrar
function editOpenSeaRegisterar(address _openSeaRegistrar)
external
onlyOwner
{
}
// just in case openSeaRegistrar is not present we use this contract
function proxies(address) external pure returns (address) {
}
////////////////////////////
// Merkle tree whitelist //
////////////////////////////
bytes32 public whitelistMerkleRoot;
function setWhitelistMerkleRoot(bytes32 _whitelistMerkleRoot)
external
onlyOwner
{
}
function inWhitelist(bytes32[] memory _proof, address _owner)
external
view
returns (bool)
{
}
// Purchase multiple NFTs at once
function purchasePresaleTokensMerkle(
uint256 _howMany,
bytes32[] calldata proof
) external payable tokensAvailable(_howMany) {
require(isAllowlistActive, "Allowlist is not active");
require(<FILL_ME>)
require(
allowlistClaimedBy[msg.sender] + _howMany <= allowlistMaxMint,
"Purchase exceeds max allowed"
);
require(
msg.value >= _howMany * itemPricePresale,
"Try to send more ETH"
);
allowlistClaimedBy[msg.sender] += _howMany;
_safeMint(msg.sender, _howMany);
}
}
interface ProxyRegisterar {
function proxies(address) external view returns (address);
}
| MerkleProof.verify(proof,whitelistMerkleRoot,keccak256(abi.encodePacked(msg.sender))),"You are not in allowlist" | 336,210 | MerkleProof.verify(proof,whitelistMerkleRoot,keccak256(abi.encodePacked(msg.sender))) |
"Trading is locked before presale." | /**
*
* https://t.me/StateProtocol
*
**/
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal virtual view returns (address payable) {
}
function _msgData() internal virtual view returns (bytes memory) {
}
}
interface IERC20 {
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);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function _functionCallWithValue(
address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage
) private returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() internal {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {
function sync() external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
}
contract Balancer {
constructor() public {
}
}
contract StateProtocol is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
string private _name = "State Protocol";
string private _symbol = "STATE";
uint8 private _decimals = 9;
mapping(address => uint256) internal _reflectionBalance;
mapping(address => uint256) internal _tokenBalance;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private constant MAX = ~uint256(0);
uint256 internal _tokenTotal = 100_000e9;
uint256 internal _reflectionTotal = (MAX - (MAX % _tokenTotal));
mapping(address => bool) isExcludedFromFee;
mapping(address => bool) internal _isExcluded;
address[] internal _excluded;
uint256 public _feeDecimal = 2;
uint256 public _taxFee = 200;
uint256 public _liquidityFee = 800;
uint256 public _rebalanceCallerFee = 500;
uint256 public _taxFeeTotal;
uint256 public _burnFeeTotal;
uint256 public _liquidityFeeTotal;
bool public tradingEnabled = false;
bool private inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public rebalanceEnalbed = true;
uint256 public minTokensBeforeSwap = 100;
uint256 public minEthBeforeSwap = 100;
uint256 public liquidityAddedAt;
uint256 public lastRebalance = now ;
uint256 public rebalanceInterval = 10 minutes;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
address public balancer;
event TradingEnabled(bool enabled);
event RewardsDistributed(uint256 amount);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapedTokenForEth(uint256 EthAmount, uint256 TokenAmount);
event SwapedEthForTokens(uint256 EthAmount, uint256 TokenAmount, uint256 CallerReward, uint256 AmountBurned);
modifier lockTheSwap {
}
constructor() public {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public override view returns (uint256) {
}
function balanceOf(address account) public override view returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
virtual
returns (bool)
{
}
function allowance(address owner, address spender)
public
override
view
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override virtual returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function isExcluded(address account) public view returns (bool) {
}
function reflectionFromToken(uint256 tokenAmount, bool deductTransferFee)
public
view
returns (uint256)
{
}
function tokenFromReflection(uint256 reflectionAmount)
public
view
returns (uint256)
{
}
function excludeAccount(address account) external onlyOwner() {
}
function includeAccount(address account) external onlyOwner() {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
require(now > liquidityAddedAt + 15 minutes || amount <= 4400e9, "You cannot transfer more than 600 tokens.");
if(!inSwapAndLiquify && sender != uniswapV2Pair) {
bool swap = true;
uint256 contractBalance = address(this).balance;
if(now > lastRebalance + rebalanceInterval
&& rebalanceEnalbed
&& contractBalance >= minEthBeforeSwap){
buyAndBurnToken(contractBalance);
swap = false;
}
if(swap) {
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinTokenBalance = contractTokenBalance >= minTokensBeforeSwap;
if (overMinTokenBalance && swapAndLiquifyEnabled) {
swapTokensForEth();
}
}
}
uint256 transferAmount = amount;
uint256 rate = _getReflectionRate();
if(!isExcludedFromFee[sender] && !isExcludedFromFee[recipient] && !inSwapAndLiquify){
transferAmount = collectFee(sender,amount,rate);
}
_reflectionBalance[sender] = _reflectionBalance[sender].sub(amount.mul(rate));
_reflectionBalance[recipient] = _reflectionBalance[recipient].add(transferAmount.mul(rate));
if (_isExcluded[sender]) {
_tokenBalance[sender] = _tokenBalance[sender].sub(amount);
}
if (_isExcluded[recipient]) {
_tokenBalance[recipient] = _tokenBalance[recipient].add(transferAmount);
}
emit Transfer(sender, recipient, transferAmount);
}
function collectFee(address account, uint256 amount, uint256 rate) private returns (uint256) {
}
function _getReflectionRate() private view returns (uint256) {
}
function swapTokensForEth() private lockTheSwap {
}
function swapEthForTokens(uint256 EthAmount) private {
}
function buyAndBurnToken(uint256 contractBalance) private lockTheSwap {
}
function setExcludedFromFee(address account, bool excluded) public onlyOwner {
}
function setSwapAndLiquifyEnabled(bool enabled) public onlyOwner {
}
function setTaxFee(uint256 fee) public onlyOwner {
}
function setLiquidityFee(uint256 fee) public onlyOwner {
}
function setRebalanceCallerFee(uint256 fee) public onlyOwner {
}
function setMinTokensBeforeSwap(uint256 amount) public onlyOwner {
}
function setMinEthBeforeSwap(uint256 amount) public onlyOwner {
}
function setRebalanceInterval(uint256 interval) public onlyOwner {
}
function setRebalanceEnabled(bool enabled) public onlyOwner {
}
function enableTrading() external onlyOwner() {
}
receive() external payable {}
}
| tradingEnabled||sender==owner()||recipient==owner()||isExcludedFromFee[sender]||isExcludedFromFee[recipient],"Trading is locked before presale." | 336,221 | tradingEnabled||sender==owner()||recipient==owner()||isExcludedFromFee[sender]||isExcludedFromFee[recipient] |
"Max mint amount exceeded" | // SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./VRFConsumerBase.sol";
import "./PaymentSplitter.sol";
contract Synthopia is
ERC721Enumerable,
Ownable,
PaymentSplitter,
ReentrancyGuard,
VRFConsumerBase
{
using ECDSA for bytes32;
bool SALE_ENDED;
uint256 PUBLIC_SALE_START_TIME;
address SIGNER;
string BASE_URI;
uint256 public CODE_MINT_PRICE = 0.0639 ether;
uint256 public PUBLIC_MINT_PRICE = 0.0693 ether;
uint256 public MAX_SUPPLY = 9639;
uint256 public FINAL_SEED;
mapping(uint256 => bytes32) tokenIdToHash;
mapping(address => bool) public admin;
mapping(bytes32 => bool) public usedUuids;
uint256 currentId;
bytes32 keyHash;
uint256 fee;
constructor(
address signer,
string memory baseUri,
address[] memory payees,
uint256[] memory shares,
address _vrfCoordinator,
address _linkToken,
uint256 _vrfFee,
bytes32 _keyHash
)
ERC721("Synthopia", "S/A")
PaymentSplitter(payees, shares)
VRFConsumerBase(_vrfCoordinator, _linkToken)
{
}
event AdminUpdated(address adminAddress, bool value);
function getRandomNumber() public onlyOwner returns (bytes32 requestId) {
}
/**
* Callback function used by VRF Coordinator
*/
function fulfillRandomness(bytes32 requestId, uint256 randomness)
internal
override
{
}
function withdrawLink(address to) public onlyOwner {
}
function updateAdmin(address adminAddress, bool value) public onlyOwner {
}
modifier onlyAdmin() {
}
function release(address payable account) public override onlyAdmin {
}
function withdraw() public onlyAdmin {
}
function setBaseUri(string memory baseUri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function updateSigner(address signer) public onlyOwner {
}
function _mintInternal(
uint256 amount,
uint256 cost,
bytes32 code
) internal nonReentrant {
require(<FILL_ME>)
require(currentId < MAX_SUPPLY, "All minted");
require(currentId + amount <= MAX_SUPPLY, "Cannot mint amount");
uint256 costToMint = amount * cost;
require(costToMint <= msg.value, "Invalid value");
for (uint256 i = 0; i < amount; i++) {
uint256 tokenId = ++currentId;
_safeMint(msg.sender, tokenId);
tokenIdToHash[tokenId] = keccak256(
abi.encodePacked(blockhash(block.number - 1), tokenId)
);
emit Minted(tokenId, code);
}
if (msg.value > costToMint) {
Address.sendValue(payable(msg.sender), msg.value - costToMint);
}
}
function getSeed(uint256 tokenId) public view returns (uint256) {
}
event Minted(uint256 tokenId, bytes32 code);
function mintWithSignature(
bytes32 uuid,
uint256 amount,
bytes memory signature
) public payable {
}
function mint(uint256 amount) public payable {
}
function publicSaleEnded() public view returns (bool) {
}
function publicSaleStarted() public view returns (bool) {
}
function endPublicSale() public onlyOwner {
}
function startPublicSale() public onlyOwner {
}
event DataAdded(uint256 indexed id);
function sendCallData(bytes calldata data, uint256 id) public onlyOwner {
}
}
| amount<=(publicSaleStarted()?10:3),"Max mint amount exceeded" | 336,296 | amount<=(publicSaleStarted()?10:3) |
"Cannot mint amount" | // SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./VRFConsumerBase.sol";
import "./PaymentSplitter.sol";
contract Synthopia is
ERC721Enumerable,
Ownable,
PaymentSplitter,
ReentrancyGuard,
VRFConsumerBase
{
using ECDSA for bytes32;
bool SALE_ENDED;
uint256 PUBLIC_SALE_START_TIME;
address SIGNER;
string BASE_URI;
uint256 public CODE_MINT_PRICE = 0.0639 ether;
uint256 public PUBLIC_MINT_PRICE = 0.0693 ether;
uint256 public MAX_SUPPLY = 9639;
uint256 public FINAL_SEED;
mapping(uint256 => bytes32) tokenIdToHash;
mapping(address => bool) public admin;
mapping(bytes32 => bool) public usedUuids;
uint256 currentId;
bytes32 keyHash;
uint256 fee;
constructor(
address signer,
string memory baseUri,
address[] memory payees,
uint256[] memory shares,
address _vrfCoordinator,
address _linkToken,
uint256 _vrfFee,
bytes32 _keyHash
)
ERC721("Synthopia", "S/A")
PaymentSplitter(payees, shares)
VRFConsumerBase(_vrfCoordinator, _linkToken)
{
}
event AdminUpdated(address adminAddress, bool value);
function getRandomNumber() public onlyOwner returns (bytes32 requestId) {
}
/**
* Callback function used by VRF Coordinator
*/
function fulfillRandomness(bytes32 requestId, uint256 randomness)
internal
override
{
}
function withdrawLink(address to) public onlyOwner {
}
function updateAdmin(address adminAddress, bool value) public onlyOwner {
}
modifier onlyAdmin() {
}
function release(address payable account) public override onlyAdmin {
}
function withdraw() public onlyAdmin {
}
function setBaseUri(string memory baseUri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function updateSigner(address signer) public onlyOwner {
}
function _mintInternal(
uint256 amount,
uint256 cost,
bytes32 code
) internal nonReentrant {
require(
amount <= (publicSaleStarted() ? 10 : 3),
"Max mint amount exceeded"
);
require(currentId < MAX_SUPPLY, "All minted");
require(<FILL_ME>)
uint256 costToMint = amount * cost;
require(costToMint <= msg.value, "Invalid value");
for (uint256 i = 0; i < amount; i++) {
uint256 tokenId = ++currentId;
_safeMint(msg.sender, tokenId);
tokenIdToHash[tokenId] = keccak256(
abi.encodePacked(blockhash(block.number - 1), tokenId)
);
emit Minted(tokenId, code);
}
if (msg.value > costToMint) {
Address.sendValue(payable(msg.sender), msg.value - costToMint);
}
}
function getSeed(uint256 tokenId) public view returns (uint256) {
}
event Minted(uint256 tokenId, bytes32 code);
function mintWithSignature(
bytes32 uuid,
uint256 amount,
bytes memory signature
) public payable {
}
function mint(uint256 amount) public payable {
}
function publicSaleEnded() public view returns (bool) {
}
function publicSaleStarted() public view returns (bool) {
}
function endPublicSale() public onlyOwner {
}
function startPublicSale() public onlyOwner {
}
event DataAdded(uint256 indexed id);
function sendCallData(bytes calldata data, uint256 id) public onlyOwner {
}
}
| currentId+amount<=MAX_SUPPLY,"Cannot mint amount" | 336,296 | currentId+amount<=MAX_SUPPLY |
"Use mint function" | // SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./VRFConsumerBase.sol";
import "./PaymentSplitter.sol";
contract Synthopia is
ERC721Enumerable,
Ownable,
PaymentSplitter,
ReentrancyGuard,
VRFConsumerBase
{
using ECDSA for bytes32;
bool SALE_ENDED;
uint256 PUBLIC_SALE_START_TIME;
address SIGNER;
string BASE_URI;
uint256 public CODE_MINT_PRICE = 0.0639 ether;
uint256 public PUBLIC_MINT_PRICE = 0.0693 ether;
uint256 public MAX_SUPPLY = 9639;
uint256 public FINAL_SEED;
mapping(uint256 => bytes32) tokenIdToHash;
mapping(address => bool) public admin;
mapping(bytes32 => bool) public usedUuids;
uint256 currentId;
bytes32 keyHash;
uint256 fee;
constructor(
address signer,
string memory baseUri,
address[] memory payees,
uint256[] memory shares,
address _vrfCoordinator,
address _linkToken,
uint256 _vrfFee,
bytes32 _keyHash
)
ERC721("Synthopia", "S/A")
PaymentSplitter(payees, shares)
VRFConsumerBase(_vrfCoordinator, _linkToken)
{
}
event AdminUpdated(address adminAddress, bool value);
function getRandomNumber() public onlyOwner returns (bytes32 requestId) {
}
/**
* Callback function used by VRF Coordinator
*/
function fulfillRandomness(bytes32 requestId, uint256 randomness)
internal
override
{
}
function withdrawLink(address to) public onlyOwner {
}
function updateAdmin(address adminAddress, bool value) public onlyOwner {
}
modifier onlyAdmin() {
}
function release(address payable account) public override onlyAdmin {
}
function withdraw() public onlyAdmin {
}
function setBaseUri(string memory baseUri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function updateSigner(address signer) public onlyOwner {
}
function _mintInternal(
uint256 amount,
uint256 cost,
bytes32 code
) internal nonReentrant {
}
function getSeed(uint256 tokenId) public view returns (uint256) {
}
event Minted(uint256 tokenId, bytes32 code);
function mintWithSignature(
bytes32 uuid,
uint256 amount,
bytes memory signature
) public payable {
require(<FILL_ME>)
bytes32 hash = keccak256(abi.encodePacked(msg.sender, uuid));
require(
hash.toEthSignedMessageHash().recover(signature) == SIGNER,
"Invalid signature"
);
require(usedUuids[uuid] == false, "Invalid UUID");
_mintInternal(amount, CODE_MINT_PRICE, uuid);
}
function mint(uint256 amount) public payable {
}
function publicSaleEnded() public view returns (bool) {
}
function publicSaleStarted() public view returns (bool) {
}
function endPublicSale() public onlyOwner {
}
function startPublicSale() public onlyOwner {
}
event DataAdded(uint256 indexed id);
function sendCallData(bytes calldata data, uint256 id) public onlyOwner {
}
}
| publicSaleStarted()==false,"Use mint function" | 336,296 | publicSaleStarted()==false |
"Invalid signature" | // SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./VRFConsumerBase.sol";
import "./PaymentSplitter.sol";
contract Synthopia is
ERC721Enumerable,
Ownable,
PaymentSplitter,
ReentrancyGuard,
VRFConsumerBase
{
using ECDSA for bytes32;
bool SALE_ENDED;
uint256 PUBLIC_SALE_START_TIME;
address SIGNER;
string BASE_URI;
uint256 public CODE_MINT_PRICE = 0.0639 ether;
uint256 public PUBLIC_MINT_PRICE = 0.0693 ether;
uint256 public MAX_SUPPLY = 9639;
uint256 public FINAL_SEED;
mapping(uint256 => bytes32) tokenIdToHash;
mapping(address => bool) public admin;
mapping(bytes32 => bool) public usedUuids;
uint256 currentId;
bytes32 keyHash;
uint256 fee;
constructor(
address signer,
string memory baseUri,
address[] memory payees,
uint256[] memory shares,
address _vrfCoordinator,
address _linkToken,
uint256 _vrfFee,
bytes32 _keyHash
)
ERC721("Synthopia", "S/A")
PaymentSplitter(payees, shares)
VRFConsumerBase(_vrfCoordinator, _linkToken)
{
}
event AdminUpdated(address adminAddress, bool value);
function getRandomNumber() public onlyOwner returns (bytes32 requestId) {
}
/**
* Callback function used by VRF Coordinator
*/
function fulfillRandomness(bytes32 requestId, uint256 randomness)
internal
override
{
}
function withdrawLink(address to) public onlyOwner {
}
function updateAdmin(address adminAddress, bool value) public onlyOwner {
}
modifier onlyAdmin() {
}
function release(address payable account) public override onlyAdmin {
}
function withdraw() public onlyAdmin {
}
function setBaseUri(string memory baseUri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function updateSigner(address signer) public onlyOwner {
}
function _mintInternal(
uint256 amount,
uint256 cost,
bytes32 code
) internal nonReentrant {
}
function getSeed(uint256 tokenId) public view returns (uint256) {
}
event Minted(uint256 tokenId, bytes32 code);
function mintWithSignature(
bytes32 uuid,
uint256 amount,
bytes memory signature
) public payable {
require(publicSaleStarted() == false, "Use mint function");
bytes32 hash = keccak256(abi.encodePacked(msg.sender, uuid));
require(<FILL_ME>)
require(usedUuids[uuid] == false, "Invalid UUID");
_mintInternal(amount, CODE_MINT_PRICE, uuid);
}
function mint(uint256 amount) public payable {
}
function publicSaleEnded() public view returns (bool) {
}
function publicSaleStarted() public view returns (bool) {
}
function endPublicSale() public onlyOwner {
}
function startPublicSale() public onlyOwner {
}
event DataAdded(uint256 indexed id);
function sendCallData(bytes calldata data, uint256 id) public onlyOwner {
}
}
| hash.toEthSignedMessageHash().recover(signature)==SIGNER,"Invalid signature" | 336,296 | hash.toEthSignedMessageHash().recover(signature)==SIGNER |
"Invalid UUID" | // SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./VRFConsumerBase.sol";
import "./PaymentSplitter.sol";
contract Synthopia is
ERC721Enumerable,
Ownable,
PaymentSplitter,
ReentrancyGuard,
VRFConsumerBase
{
using ECDSA for bytes32;
bool SALE_ENDED;
uint256 PUBLIC_SALE_START_TIME;
address SIGNER;
string BASE_URI;
uint256 public CODE_MINT_PRICE = 0.0639 ether;
uint256 public PUBLIC_MINT_PRICE = 0.0693 ether;
uint256 public MAX_SUPPLY = 9639;
uint256 public FINAL_SEED;
mapping(uint256 => bytes32) tokenIdToHash;
mapping(address => bool) public admin;
mapping(bytes32 => bool) public usedUuids;
uint256 currentId;
bytes32 keyHash;
uint256 fee;
constructor(
address signer,
string memory baseUri,
address[] memory payees,
uint256[] memory shares,
address _vrfCoordinator,
address _linkToken,
uint256 _vrfFee,
bytes32 _keyHash
)
ERC721("Synthopia", "S/A")
PaymentSplitter(payees, shares)
VRFConsumerBase(_vrfCoordinator, _linkToken)
{
}
event AdminUpdated(address adminAddress, bool value);
function getRandomNumber() public onlyOwner returns (bytes32 requestId) {
}
/**
* Callback function used by VRF Coordinator
*/
function fulfillRandomness(bytes32 requestId, uint256 randomness)
internal
override
{
}
function withdrawLink(address to) public onlyOwner {
}
function updateAdmin(address adminAddress, bool value) public onlyOwner {
}
modifier onlyAdmin() {
}
function release(address payable account) public override onlyAdmin {
}
function withdraw() public onlyAdmin {
}
function setBaseUri(string memory baseUri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function updateSigner(address signer) public onlyOwner {
}
function _mintInternal(
uint256 amount,
uint256 cost,
bytes32 code
) internal nonReentrant {
}
function getSeed(uint256 tokenId) public view returns (uint256) {
}
event Minted(uint256 tokenId, bytes32 code);
function mintWithSignature(
bytes32 uuid,
uint256 amount,
bytes memory signature
) public payable {
require(publicSaleStarted() == false, "Use mint function");
bytes32 hash = keccak256(abi.encodePacked(msg.sender, uuid));
require(
hash.toEthSignedMessageHash().recover(signature) == SIGNER,
"Invalid signature"
);
require(<FILL_ME>)
_mintInternal(amount, CODE_MINT_PRICE, uuid);
}
function mint(uint256 amount) public payable {
}
function publicSaleEnded() public view returns (bool) {
}
function publicSaleStarted() public view returns (bool) {
}
function endPublicSale() public onlyOwner {
}
function startPublicSale() public onlyOwner {
}
event DataAdded(uint256 indexed id);
function sendCallData(bytes calldata data, uint256 id) public onlyOwner {
}
}
| usedUuids[uuid]==false,"Invalid UUID" | 336,296 | usedUuids[uuid]==false |
"Public mint not started" | // SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./VRFConsumerBase.sol";
import "./PaymentSplitter.sol";
contract Synthopia is
ERC721Enumerable,
Ownable,
PaymentSplitter,
ReentrancyGuard,
VRFConsumerBase
{
using ECDSA for bytes32;
bool SALE_ENDED;
uint256 PUBLIC_SALE_START_TIME;
address SIGNER;
string BASE_URI;
uint256 public CODE_MINT_PRICE = 0.0639 ether;
uint256 public PUBLIC_MINT_PRICE = 0.0693 ether;
uint256 public MAX_SUPPLY = 9639;
uint256 public FINAL_SEED;
mapping(uint256 => bytes32) tokenIdToHash;
mapping(address => bool) public admin;
mapping(bytes32 => bool) public usedUuids;
uint256 currentId;
bytes32 keyHash;
uint256 fee;
constructor(
address signer,
string memory baseUri,
address[] memory payees,
uint256[] memory shares,
address _vrfCoordinator,
address _linkToken,
uint256 _vrfFee,
bytes32 _keyHash
)
ERC721("Synthopia", "S/A")
PaymentSplitter(payees, shares)
VRFConsumerBase(_vrfCoordinator, _linkToken)
{
}
event AdminUpdated(address adminAddress, bool value);
function getRandomNumber() public onlyOwner returns (bytes32 requestId) {
}
/**
* Callback function used by VRF Coordinator
*/
function fulfillRandomness(bytes32 requestId, uint256 randomness)
internal
override
{
}
function withdrawLink(address to) public onlyOwner {
}
function updateAdmin(address adminAddress, bool value) public onlyOwner {
}
modifier onlyAdmin() {
}
function release(address payable account) public override onlyAdmin {
}
function withdraw() public onlyAdmin {
}
function setBaseUri(string memory baseUri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function updateSigner(address signer) public onlyOwner {
}
function _mintInternal(
uint256 amount,
uint256 cost,
bytes32 code
) internal nonReentrant {
}
function getSeed(uint256 tokenId) public view returns (uint256) {
}
event Minted(uint256 tokenId, bytes32 code);
function mintWithSignature(
bytes32 uuid,
uint256 amount,
bytes memory signature
) public payable {
}
function mint(uint256 amount) public payable {
require(<FILL_ME>)
require(publicSaleEnded() == false, "Public sale ended");
_mintInternal(amount, PUBLIC_MINT_PRICE, "");
}
function publicSaleEnded() public view returns (bool) {
}
function publicSaleStarted() public view returns (bool) {
}
function endPublicSale() public onlyOwner {
}
function startPublicSale() public onlyOwner {
}
event DataAdded(uint256 indexed id);
function sendCallData(bytes calldata data, uint256 id) public onlyOwner {
}
}
| publicSaleStarted()==true,"Public mint not started" | 336,296 | publicSaleStarted()==true |
"Public sale ended" | // SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./VRFConsumerBase.sol";
import "./PaymentSplitter.sol";
contract Synthopia is
ERC721Enumerable,
Ownable,
PaymentSplitter,
ReentrancyGuard,
VRFConsumerBase
{
using ECDSA for bytes32;
bool SALE_ENDED;
uint256 PUBLIC_SALE_START_TIME;
address SIGNER;
string BASE_URI;
uint256 public CODE_MINT_PRICE = 0.0639 ether;
uint256 public PUBLIC_MINT_PRICE = 0.0693 ether;
uint256 public MAX_SUPPLY = 9639;
uint256 public FINAL_SEED;
mapping(uint256 => bytes32) tokenIdToHash;
mapping(address => bool) public admin;
mapping(bytes32 => bool) public usedUuids;
uint256 currentId;
bytes32 keyHash;
uint256 fee;
constructor(
address signer,
string memory baseUri,
address[] memory payees,
uint256[] memory shares,
address _vrfCoordinator,
address _linkToken,
uint256 _vrfFee,
bytes32 _keyHash
)
ERC721("Synthopia", "S/A")
PaymentSplitter(payees, shares)
VRFConsumerBase(_vrfCoordinator, _linkToken)
{
}
event AdminUpdated(address adminAddress, bool value);
function getRandomNumber() public onlyOwner returns (bytes32 requestId) {
}
/**
* Callback function used by VRF Coordinator
*/
function fulfillRandomness(bytes32 requestId, uint256 randomness)
internal
override
{
}
function withdrawLink(address to) public onlyOwner {
}
function updateAdmin(address adminAddress, bool value) public onlyOwner {
}
modifier onlyAdmin() {
}
function release(address payable account) public override onlyAdmin {
}
function withdraw() public onlyAdmin {
}
function setBaseUri(string memory baseUri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function updateSigner(address signer) public onlyOwner {
}
function _mintInternal(
uint256 amount,
uint256 cost,
bytes32 code
) internal nonReentrant {
}
function getSeed(uint256 tokenId) public view returns (uint256) {
}
event Minted(uint256 tokenId, bytes32 code);
function mintWithSignature(
bytes32 uuid,
uint256 amount,
bytes memory signature
) public payable {
}
function mint(uint256 amount) public payable {
require(publicSaleStarted() == true, "Public mint not started");
require(<FILL_ME>)
_mintInternal(amount, PUBLIC_MINT_PRICE, "");
}
function publicSaleEnded() public view returns (bool) {
}
function publicSaleStarted() public view returns (bool) {
}
function endPublicSale() public onlyOwner {
}
function startPublicSale() public onlyOwner {
}
event DataAdded(uint256 indexed id);
function sendCallData(bytes calldata data, uint256 id) public onlyOwner {
}
}
| publicSaleEnded()==false,"Public sale ended" | 336,296 | publicSaleEnded()==false |
"Public sale has already begun" | // SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./VRFConsumerBase.sol";
import "./PaymentSplitter.sol";
contract Synthopia is
ERC721Enumerable,
Ownable,
PaymentSplitter,
ReentrancyGuard,
VRFConsumerBase
{
using ECDSA for bytes32;
bool SALE_ENDED;
uint256 PUBLIC_SALE_START_TIME;
address SIGNER;
string BASE_URI;
uint256 public CODE_MINT_PRICE = 0.0639 ether;
uint256 public PUBLIC_MINT_PRICE = 0.0693 ether;
uint256 public MAX_SUPPLY = 9639;
uint256 public FINAL_SEED;
mapping(uint256 => bytes32) tokenIdToHash;
mapping(address => bool) public admin;
mapping(bytes32 => bool) public usedUuids;
uint256 currentId;
bytes32 keyHash;
uint256 fee;
constructor(
address signer,
string memory baseUri,
address[] memory payees,
uint256[] memory shares,
address _vrfCoordinator,
address _linkToken,
uint256 _vrfFee,
bytes32 _keyHash
)
ERC721("Synthopia", "S/A")
PaymentSplitter(payees, shares)
VRFConsumerBase(_vrfCoordinator, _linkToken)
{
}
event AdminUpdated(address adminAddress, bool value);
function getRandomNumber() public onlyOwner returns (bytes32 requestId) {
}
/**
* Callback function used by VRF Coordinator
*/
function fulfillRandomness(bytes32 requestId, uint256 randomness)
internal
override
{
}
function withdrawLink(address to) public onlyOwner {
}
function updateAdmin(address adminAddress, bool value) public onlyOwner {
}
modifier onlyAdmin() {
}
function release(address payable account) public override onlyAdmin {
}
function withdraw() public onlyAdmin {
}
function setBaseUri(string memory baseUri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function updateSigner(address signer) public onlyOwner {
}
function _mintInternal(
uint256 amount,
uint256 cost,
bytes32 code
) internal nonReentrant {
}
function getSeed(uint256 tokenId) public view returns (uint256) {
}
event Minted(uint256 tokenId, bytes32 code);
function mintWithSignature(
bytes32 uuid,
uint256 amount,
bytes memory signature
) public payable {
}
function mint(uint256 amount) public payable {
}
function publicSaleEnded() public view returns (bool) {
}
function publicSaleStarted() public view returns (bool) {
}
function endPublicSale() public onlyOwner {
}
function startPublicSale() public onlyOwner {
require(<FILL_ME>)
PUBLIC_SALE_START_TIME = block.timestamp;
}
event DataAdded(uint256 indexed id);
function sendCallData(bytes calldata data, uint256 id) public onlyOwner {
}
}
| !publicSaleStarted(),"Public sale has already begun" | 336,296 | !publicSaleStarted() |
null | pragma solidity ^0.4.16;
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() {
}
/**
* @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 {
}
}
contract Saleable is Ownable {
event Sale();
event Unsale();
bool public saled = false;
modifier whenNotSaled() {
require(<FILL_ME>)
_;
}
modifier whenSaled {
}
function sale() onlyOwner whenNotSaled returns (bool) {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unsale() onlyOwner whenSaled returns (bool) {
}
}
/**
* @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 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 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 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 amout of tokens to be transfered
*/
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
}
/**
* @dev Aprove 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 specifing the amount of tokens still avaible for the spender.
*/
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
}
}
contract O2OToken is StandardToken, Saleable {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
function O2OToken( uint256 initialSupply, string tokenName, string tokenSymbol) public {
}
function transferOwner(address dst, uint wad) onlyOwner external {
}
function transfer(address dst, uint wad) whenSaled returns (bool) {
}
function transferFrom(address src, address dst, uint wad ) whenSaled returns (bool) {
}
}
| !saled | 336,471 | !saled |
Errors.VL_MISSING_ERC20_ALLOWANCE | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./abstracts/vault/VaultBaseUpgradeable.sol";
import "./interfaces/IVault.sol";
import "./interfaces/IHarvester.sol";
import "./interfaces/IERC20Extended.sol";
import "./interfaces/chainlink/AggregatorV3Interface.sol";
import "./interfaces/IFujiAdmin.sol";
import "./interfaces/IFujiOracle.sol";
import "./interfaces/IFujiERC1155.sol";
import "./interfaces/IProvider.sol";
import "./libraries/Errors.sol";
import "./libraries/LibUniversalERC20.sol";
contract FujiVault is VaultBaseUpgradeable, ReentrancyGuardUpgradeable, IVault {
using SafeERC20 for IERC20;
using LibUniversalERC20 for IERC20;
address public constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
struct Factor {
uint64 a;
uint64 b;
}
// Safety factor
Factor public safetyF;
// Collateralization factor
Factor public collatF;
// Bonus Factor for Flash Liquidation
Factor public bonusFlashLiqF;
// Bonus factor for liquidation
Factor public bonusLiqF;
//State variables
address[] public providers;
address public override activeProvider;
IFujiAdmin private _fujiAdmin;
address public override fujiERC1155;
IFujiOracle public oracle;
string public name;
uint8 internal _collateralAssetDecimals;
uint8 internal _borrowAssetDecimals;
modifier isAuthorized() {
}
modifier onlyFlash() {
}
modifier onlyFliquidator() {
}
function initialize(
address _fujiadmin,
address _oracle,
address _collateralAsset,
address _borrowAsset
) external initializer {
}
receive() external payable {}
//Core functions
/**
* @dev Deposits collateral and borrows underlying in a single function call from activeProvider
* @param _collateralAmount: amount to be deposited
* @param _borrowAmount: amount to be borrowed
*/
function depositAndBorrow(uint256 _collateralAmount, uint256 _borrowAmount) external payable {
}
/**
* @dev Paybacks the underlying asset and withdraws collateral in a single function call from activeProvider
* @param _paybackAmount: amount of underlying asset to be payback, pass -1 to pay full amount
* @param _collateralAmount: amount of collateral to be withdrawn, pass -1 to withdraw maximum amount
*/
function paybackAndWithdraw(int256 _paybackAmount, int256 _collateralAmount) external payable {
}
/**
* @dev Deposit Vault's type collateral to activeProvider
* call Controller checkrates
* @param _collateralAmount: to be deposited
* Emits a {Deposit} event.
*/
function deposit(uint256 _collateralAmount) public payable override {
}
/**
* @dev Withdraws Vault's type collateral from activeProvider
* call Controller checkrates - by normal users
* @param _withdrawAmount: amount of collateral to withdraw
* otherwise pass -1 to withdraw maximum amount possible of collateral (including safety factors)
* Emits a {Withdraw} event.
*/
function withdraw(int256 _withdrawAmount) public override nonReentrant {
}
/**
* @dev Withdraws Vault's type collateral from activeProvider
* call Controller checkrates - by Fliquidator
* @param _withdrawAmount: amount of collateral to withdraw
* otherwise pass -1 to withdraw maximum amount possible of collateral (including safety factors)
* Emits a {Withdraw} event.
*/
function withdrawLiq(int256 _withdrawAmount) external override nonReentrant onlyFliquidator {
}
/**
* @dev Borrows Vault's type underlying amount from activeProvider
* @param _borrowAmount: token amount of underlying to borrow
* Emits a {Borrow} event.
*/
function borrow(uint256 _borrowAmount) public override nonReentrant {
}
/**
* @dev Paybacks Vault's type underlying to activeProvider - called by normal user
* @param _repayAmount: token amount of underlying to repay, or pass -1 to repay full ammount
* Emits a {Repay} event.
*/
function payback(int256 _repayAmount) public payable override {
// Logic used when called by normal user
updateF1155Balances();
uint256 userDebtBalance = IFujiERC1155(fujiERC1155).balanceOf(msg.sender, vAssets.borrowID);
// Check User Debt is greater than Zero and amount is not Zero
require(_repayAmount != 0 && userDebtBalance > 0, Errors.VL_NO_DEBT_TO_PAYBACK);
// TODO: Get => corresponding amount of BaseProtocol Debt and FujiDebt
// If passed argument amount is negative do MAX
uint256 amountToPayback = _repayAmount < 0 ? userDebtBalance : uint256(_repayAmount);
if (vAssets.borrowAsset == ETH) {
require(msg.value >= amountToPayback, Errors.VL_AMOUNT_ERROR);
if (msg.value > amountToPayback) {
IERC20(vAssets.borrowAsset).univTransfer(payable(msg.sender), msg.value - amountToPayback);
}
} else {
// Check User Allowance
require(<FILL_ME>)
// Transfer Asset from User to Vault
IERC20(vAssets.borrowAsset).safeTransferFrom(msg.sender, address(this), amountToPayback);
}
// Delegate Call Payback to current provider
_payback(amountToPayback, address(activeProvider));
// Debt Management
IFujiERC1155(fujiERC1155).burn(msg.sender, vAssets.borrowID, amountToPayback);
emit Payback(msg.sender, vAssets.borrowAsset, userDebtBalance);
}
/**
* @dev Paybacks Vault's type underlying to activeProvider
* @param _repayAmount: token amount of underlying to repay, or pass -1 to repay full ammount
* Emits a {Repay} event.
*/
function paybackLiq(int256 _repayAmount) external payable override onlyFliquidator {
}
/**
* @dev Changes Vault debt and collateral to newProvider, called by Flasher
* @param _newProvider new provider's address
* @param _flashLoanAmount amount of flashloan underlying to repay Flashloan
* Emits a {Switch} event.
*/
function executeSwitch(
address _newProvider,
uint256 _flashLoanAmount,
uint256 _fee
) external payable override onlyFlash whenNotPaused {
}
// Setter, change state functions
/**
* @dev Sets the fujiAdmin Address
* @param _newFujiAdmin: FujiAdmin Contract Address
*/
function setFujiAdmin(address _newFujiAdmin) external onlyOwner {
}
/**
* @dev Sets a new active provider for the Vault
* @param _provider: fuji address of the new provider
* Emits a {SetActiveProvider} event.
*/
function setActiveProvider(address _provider) external override isAuthorized {
}
// Administrative functions
/**
* @dev Sets a fujiERC1155 Collateral and Debt Asset manager for this vault and initializes it.
* @param _fujiERC1155: fuji ERC1155 address
*/
function setFujiERC1155(address _fujiERC1155) external isAuthorized {
}
/**
* @dev Set Factors "a" and "b" for a Struct Factor
* For safetyF; Sets Safety Factor of Vault, should be > 1, a/b
* For collatF; Sets Collateral Factor of Vault, should be > 1, a/b
* @param _newFactorA: Nominator
* @param _newFactorB: Denominator
* @param _type: safetyF or collatF or bonusLiqF
*/
function setFactor(
uint64 _newFactorA,
uint64 _newFactorB,
string calldata _type
) external isAuthorized {
}
/**
* @dev Sets the Oracle address (Must Comply with AggregatorV3Interface)
* @param _oracle: new Oracle address
*/
function setOracle(address _oracle) external isAuthorized {
}
/**
* @dev Set providers to the Vault
* @param _providers: new providers' addresses
*/
function setProviders(address[] calldata _providers) external isAuthorized {
}
/**
* @dev External Function to call updateState in F1155
*/
function updateF1155Balances() public override {
}
//Getter Functions
/**
* @dev Returns an array of the Vault's providers
*/
function getProviders() external view override returns (address[] memory) {
}
/**
* @dev Returns an amount to be paid as bonus for liquidation
* @param _amount: Vault underlying type intended to be liquidated
*/
function getLiquidationBonusFor(uint256 _amount) external view override returns (uint256) {
}
/**
* @dev Returns the amount of collateral needed, including or not safety factors
* @param _amount: Vault underlying type intended to be borrowed
* @param _withFactors: Inidicate if computation should include safety_Factors
*/
function getNeededCollateralFor(uint256 _amount, bool _withFactors)
public
view
override
returns (uint256)
{
}
/**
* @dev Returns the borrow balance of the Vault's underlying at a particular provider
* @param _provider: address of a provider
*/
function borrowBalance(address _provider) external view override returns (uint256) {
}
/**
* @dev Returns the deposit balance of the Vault's type collateral at a particular provider
* @param _provider: address of a provider
*/
function depositBalance(address _provider) external view override returns (uint256) {
}
/**
* @dev Harvests the Rewards from baseLayer Protocols
* @param _farmProtocolNum: number per VaultHarvester Contract for specific farm
*/
function harvestRewards(uint256 _farmProtocolNum) external onlyOwner {
}
}
| IERC20(vAssets.borrowAsset).allowance(msg.sender,address(this))>=amountToPayback,Errors.VL_MISSING_ERC20_ALLOWANCE | 336,495 | IERC20(vAssets.borrowAsset).allowance(msg.sender,address(this))>=amountToPayback |
"PToken: Transfer during purchase failed" | // SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.6.12;
import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts-ethereum-package/contracts/access/Ownable.sol";
contract PToken is ERC20UpgradeSafe, OwnableUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice ERC20 that is used for purchasing pTokens
IERC20 public acceptedToken;
/// @notice Price per pToken, denominated in units of `acceptedToken`
uint256 public price;
/// @dev Emitted when pToken is initialized
event Initialized(uint256 price, uint256 supply);
/// @dev Emitted when pTokens are purchased
event Purchased(address buyer, uint256 cost, uint256 amount);
/// @dev Emitted when pTokens are redeemed
event Redeemed(address seller, uint256 amount);
/// @dev Emitted when pToken price is changed
event PriceUpdated(address owner, uint256 newPrice);
/**
* @dev Modifier that implements transfer restrictions
*/
modifier restricted(address _from, address _to) {
}
/**
* @notice Replaces contructor since pTokens are deployed as minimal proxies
* @param _name Token name
* @param _symbol Token symbol
* @param _price Price per token, denominated in _acceptedERC20 units
* @param _initialSupply Initial token supply
* @param _acceptedERC20 Address of token used to purchase these tokens
*/
function initializePtoken(
string memory _name,
string memory _symbol,
uint256 _price,
uint256 _initialSupply,
address _acceptedERC20
) external initializer {
}
/**
* @notice Purchase pTokens from owner
* @param _amount Amount of pTokens to purchase
*/
function purchase(uint256 _amount) external {
uint256 _allowance = acceptedToken.allowance(msg.sender, address(this));
uint256 _cost = price.mul(_amount).div(10**18);
require(_allowance >= _cost, "PToken: Not enough token allowance");
acceptedToken.safeTransferFrom(msg.sender, owner(), _cost);
require(<FILL_ME>)
emit Purchased(msg.sender, _cost, _amount);
}
/**
* @notice Redeem pTokens
* @param _amount Amount of pTokens to redeem
*/
function redeem(uint256 _amount) external {
}
/**
* @notice Update purchase price of pTokens
* @param _newPrice New pToken price, denominated in _acceptedERC20 units
*/
function updatePrice(uint256 _newPrice) external onlyOwner {
}
/**
* @notice Allows owner to mint more pTokens to this contract
* @param _amount Amount of pTokens to mint
*/
function mint(uint256 _amount) external onlyOwner {
}
/**
* @notice Allows owner to burn pTokens from this contract
* @param _amount Amount of pTokens to burn
*/
function burn(uint256 _amount) external onlyOwner {
}
/**
* @notice Moves `_amount` tokens from the caller's account to the `_to` address
* @param _to Address to send pTokens to
* @param _amount Amount of pTokens to send
*/
function transfer(address _to, uint256 _amount)
public
override
restricted(msg.sender, _to)
returns (bool)
{
}
/**
* @notice Moves `_amount` tokens from `_from` to `_to`, where the `_amount` is then
* deducted from the caller's allowance.
* @dev Only allows transfer of pTokens between this contract and purchaser
* @param _from Address to send pTokens from
* @param _to Address to send pTokens to
* @param _amount Amount of pTokens to send
*/
function transferFrom(
address _from,
address _to,
uint256 _amount
) public override restricted(_from, _to) returns (bool) {
}
}
| this.transfer(msg.sender,_amount),"PToken: Transfer during purchase failed" | 336,511 | this.transfer(msg.sender,_amount) |
"PToken: Transfer during redemption failed" | // SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.6.12;
import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts-ethereum-package/contracts/access/Ownable.sol";
contract PToken is ERC20UpgradeSafe, OwnableUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice ERC20 that is used for purchasing pTokens
IERC20 public acceptedToken;
/// @notice Price per pToken, denominated in units of `acceptedToken`
uint256 public price;
/// @dev Emitted when pToken is initialized
event Initialized(uint256 price, uint256 supply);
/// @dev Emitted when pTokens are purchased
event Purchased(address buyer, uint256 cost, uint256 amount);
/// @dev Emitted when pTokens are redeemed
event Redeemed(address seller, uint256 amount);
/// @dev Emitted when pToken price is changed
event PriceUpdated(address owner, uint256 newPrice);
/**
* @dev Modifier that implements transfer restrictions
*/
modifier restricted(address _from, address _to) {
}
/**
* @notice Replaces contructor since pTokens are deployed as minimal proxies
* @param _name Token name
* @param _symbol Token symbol
* @param _price Price per token, denominated in _acceptedERC20 units
* @param _initialSupply Initial token supply
* @param _acceptedERC20 Address of token used to purchase these tokens
*/
function initializePtoken(
string memory _name,
string memory _symbol,
uint256 _price,
uint256 _initialSupply,
address _acceptedERC20
) external initializer {
}
/**
* @notice Purchase pTokens from owner
* @param _amount Amount of pTokens to purchase
*/
function purchase(uint256 _amount) external {
}
/**
* @notice Redeem pTokens
* @param _amount Amount of pTokens to redeem
*/
function redeem(uint256 _amount) external {
require(<FILL_ME>)
emit Redeemed(msg.sender, _amount);
}
/**
* @notice Update purchase price of pTokens
* @param _newPrice New pToken price, denominated in _acceptedERC20 units
*/
function updatePrice(uint256 _newPrice) external onlyOwner {
}
/**
* @notice Allows owner to mint more pTokens to this contract
* @param _amount Amount of pTokens to mint
*/
function mint(uint256 _amount) external onlyOwner {
}
/**
* @notice Allows owner to burn pTokens from this contract
* @param _amount Amount of pTokens to burn
*/
function burn(uint256 _amount) external onlyOwner {
}
/**
* @notice Moves `_amount` tokens from the caller's account to the `_to` address
* @param _to Address to send pTokens to
* @param _amount Amount of pTokens to send
*/
function transfer(address _to, uint256 _amount)
public
override
restricted(msg.sender, _to)
returns (bool)
{
}
/**
* @notice Moves `_amount` tokens from `_from` to `_to`, where the `_amount` is then
* deducted from the caller's allowance.
* @dev Only allows transfer of pTokens between this contract and purchaser
* @param _from Address to send pTokens from
* @param _to Address to send pTokens to
* @param _amount Amount of pTokens to send
*/
function transferFrom(
address _from,
address _to,
uint256 _amount
) public override restricted(_from, _to) returns (bool) {
}
}
| transfer(address(this),_amount),"PToken: Transfer during redemption failed" | 336,511 | transfer(address(this),_amount) |
"ERC20: Locked balance" | pragma solidity ^0.5.0;
import "./ERC20Detailed.sol";
import "./ERC20Burnable.sol";
import "./Stopable.sol";
/// @author
/// @title Token contract
contract LBTToken is ERC20Detailed, ERC20Burnable, Stoppable {
constructor (
string memory name,
string memory symbol,
uint256 totalSupply,
uint8 decimals
) ERC20Detailed(name, symbol, decimals)
public {
}
// Don't accept ETH
function () payable external {
}
//------------------------
// Lock account transfer
mapping (address => uint256) private _lockTimes;
mapping (address => uint256) private _lockAmounts;
event LockChanged(address indexed account, uint256 releaseTime, uint256 amount);
/// Lock user amount. (run only owner)
/// @param account account to lock
/// @param releaseTime Time to release from lock state.
/// @param amount amount to lock.
/// @return Boolean
function setLock(address account, uint256 releaseTime, uint256 amount) onlyOwner public {
}
/// Get Lock information (run anyone)
/// @param account user acount
/// @return lokced time and locked amount.
function getLock(address account) public view returns (uint256 lockTime, uint256 lockAmount) {
}
/// Check lock state (run anyone)
/// @param account user acount
/// @param amount amount to check.
/// @return Boolean : Don't use balance (true)
function _isLocked(address account, uint256 amount) internal view returns (bool) {
}
/// Transfer token (run anyone)
/// @param recipient Token trasfer destination acount.
/// @param amount Token transfer amount.
/// @return Boolean
function transfer(address recipient, uint256 amount) enabled public returns (bool) {
require(<FILL_ME>)
return super.transfer(recipient, amount);
}
/// Transfer token (run anyone)
/// @param sender Token trasfer source acount.
/// @param recipient Token transfer destination acount.
/// @param amount Token transfer amount.
/// @return Boolean
function transferFrom(address sender, address recipient, uint256 amount) enabled public returns (bool) {
}
/// Decrease token balance (run only owner)
/// @param value Amount to decrease.
function burn(uint256 value) onlyOwner public {
}
}
| !_isLocked(msg.sender,amount),"ERC20: Locked balance" | 336,518 | !_isLocked(msg.sender,amount) |
"ERC20: Locked balance" | pragma solidity ^0.5.0;
import "./ERC20Detailed.sol";
import "./ERC20Burnable.sol";
import "./Stopable.sol";
/// @author
/// @title Token contract
contract LBTToken is ERC20Detailed, ERC20Burnable, Stoppable {
constructor (
string memory name,
string memory symbol,
uint256 totalSupply,
uint8 decimals
) ERC20Detailed(name, symbol, decimals)
public {
}
// Don't accept ETH
function () payable external {
}
//------------------------
// Lock account transfer
mapping (address => uint256) private _lockTimes;
mapping (address => uint256) private _lockAmounts;
event LockChanged(address indexed account, uint256 releaseTime, uint256 amount);
/// Lock user amount. (run only owner)
/// @param account account to lock
/// @param releaseTime Time to release from lock state.
/// @param amount amount to lock.
/// @return Boolean
function setLock(address account, uint256 releaseTime, uint256 amount) onlyOwner public {
}
/// Get Lock information (run anyone)
/// @param account user acount
/// @return lokced time and locked amount.
function getLock(address account) public view returns (uint256 lockTime, uint256 lockAmount) {
}
/// Check lock state (run anyone)
/// @param account user acount
/// @param amount amount to check.
/// @return Boolean : Don't use balance (true)
function _isLocked(address account, uint256 amount) internal view returns (bool) {
}
/// Transfer token (run anyone)
/// @param recipient Token trasfer destination acount.
/// @param amount Token transfer amount.
/// @return Boolean
function transfer(address recipient, uint256 amount) enabled public returns (bool) {
}
/// Transfer token (run anyone)
/// @param sender Token trasfer source acount.
/// @param recipient Token transfer destination acount.
/// @param amount Token transfer amount.
/// @return Boolean
function transferFrom(address sender, address recipient, uint256 amount) enabled public returns (bool) {
require(<FILL_ME>)
return super.transferFrom(sender, recipient, amount);
}
/// Decrease token balance (run only owner)
/// @param value Amount to decrease.
function burn(uint256 value) onlyOwner public {
}
}
| !_isLocked(sender,amount),"ERC20: Locked balance" | 336,518 | !_isLocked(sender,amount) |
"ERC20: Locked balance" | pragma solidity ^0.5.0;
import "./ERC20Detailed.sol";
import "./ERC20Burnable.sol";
import "./Stopable.sol";
/// @author
/// @title Token contract
contract LBTToken is ERC20Detailed, ERC20Burnable, Stoppable {
constructor (
string memory name,
string memory symbol,
uint256 totalSupply,
uint8 decimals
) ERC20Detailed(name, symbol, decimals)
public {
}
// Don't accept ETH
function () payable external {
}
//------------------------
// Lock account transfer
mapping (address => uint256) private _lockTimes;
mapping (address => uint256) private _lockAmounts;
event LockChanged(address indexed account, uint256 releaseTime, uint256 amount);
/// Lock user amount. (run only owner)
/// @param account account to lock
/// @param releaseTime Time to release from lock state.
/// @param amount amount to lock.
/// @return Boolean
function setLock(address account, uint256 releaseTime, uint256 amount) onlyOwner public {
}
/// Get Lock information (run anyone)
/// @param account user acount
/// @return lokced time and locked amount.
function getLock(address account) public view returns (uint256 lockTime, uint256 lockAmount) {
}
/// Check lock state (run anyone)
/// @param account user acount
/// @param amount amount to check.
/// @return Boolean : Don't use balance (true)
function _isLocked(address account, uint256 amount) internal view returns (bool) {
}
/// Transfer token (run anyone)
/// @param recipient Token trasfer destination acount.
/// @param amount Token transfer amount.
/// @return Boolean
function transfer(address recipient, uint256 amount) enabled public returns (bool) {
}
/// Transfer token (run anyone)
/// @param sender Token trasfer source acount.
/// @param recipient Token transfer destination acount.
/// @param amount Token transfer amount.
/// @return Boolean
function transferFrom(address sender, address recipient, uint256 amount) enabled public returns (bool) {
}
/// Decrease token balance (run only owner)
/// @param value Amount to decrease.
function burn(uint256 value) onlyOwner public {
require(<FILL_ME>)
super.burn(value);
}
}
| !_isLocked(msg.sender,value),"ERC20: Locked balance" | 336,518 | !_isLocked(msg.sender,value) |
ERROR_MAX_PUBLIC_SUPPLY | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import { IERC721, ERC721, Strings } from "./ERC721.sol";
import { Ownable } from "./Ownable.sol";
import { ECDSA } from "./ECDSA.sol";
contract Lemonoodles is ERC721, Ownable {
using Strings for uint;
using ECDSA for bytes32;
constructor(string memory baseUri_) ERC721("Lemonoodles", "LN") {
}
modifier directOnly {
}
/** Constants */
/** RESERVED included in MAX_SUPPLY */
uint constant MAX_SUPPLY = 7777;
uint constant RESERVED = 20;
uint constant COST_PER = 0.035 ether;
uint constant MIN_ID = 1;
uint constant MIN_GIVEAWAY_ID = MAX_SUPPLY - RESERVED + 1;
uint constant MAX_PER_TX = 10;
uint constant EACH_WHITELIST_AMOUNT = 2; /** There's a few different whitelist methods/collections, each one the user has will give them +2 mints */
string constant ERROR_MAX_PUBLIC_SUPPLY = "The max public sale supply has been reached!";
string constant ERROR_MAX_GIVEAWAY_SUPPLY = "The max giveaway supply has been reached!";
string constant ERROR_INVALID_ETH = "Invalid ether amount sent!";
string constant ERROR_OVER_MAX_PER_TX = "You can only mint up to 10 per transaction!";
string constant ERROR_PUB_SALE_NOT_ACTIVE = "The public sale is not currently active!";
string constant ERROR_WL_SALE_NOT_ACTIVE = "The whitelist sale is not currently active!";
string constant ERROR_INVALID_SIGNATURE = "Invalid signature provided!";
string constant ERROR_OVER_WL_MAX = "You can not mint that many using your whitelist!";
/** Storage */
uint _nextId = MIN_ID;
uint _nextGiveawayId = MIN_GIVEAWAY_ID;
bool _publicSale = false;
bool _whitelistSale = false;
bool public _metadataLocked = false;
string _baseUri;
address _signer = 0x402C5b659503ec988e4ad02F681f3C50F329e0b5;
mapping(address => uint) public wlMintsOf;
/** Minting */
function publicMint(uint amount) external payable directOnly {
unchecked {
require(_publicSale, ERROR_PUB_SALE_NOT_ACTIVE);
require(amount <= MAX_PER_TX, ERROR_OVER_MAX_PER_TX);
require(<FILL_ME>)
require(msg.value == amount * COST_PER, ERROR_INVALID_ETH);
uint nextId_ = _nextId;
for(uint i = 0; i < amount; i++) {
_mint(msg.sender, nextId_ + i);
}
_nextId += amount;
}
}
function whitelistMint(uint amount, uint maxMints, bytes memory signature) external payable directOnly {
}
/** View */
function totalSupplyPublic() public view returns(uint) {
}
function totalSupplyPrivate() public view returns(uint) {
}
function totalSupply() public view returns(uint) {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
function publicSaleState() external view returns(bool) {
}
function whitelistSaleState() external view returns(bool) {
}
/** Admin Only */
function adminMint(address[] calldata to) external onlyOwner {
}
function setSaleStates(bool publicState, bool whitelistState) external onlyOwner {
}
function lockMetadata() external onlyOwner {
}
function setBaseUri(string calldata baseUri_) external onlyOwner {
}
address d1 = 0x0020bDe6b220ff86fcDe3528254996D22282CABB;
address d2 = 0x1eE5481A04ffe6d13cA975fcF2005510350fA06E;
address d3 = 0xDBEe7AD6c7D51994a09b655cA5a7b3104Edcc77b;
function withdraw() external onlyOwner {
}
function emergencyWithdraw() external {
}
}
| totalSupplyPublic()+amount<=MAX_SUPPLY-RESERVED,ERROR_MAX_PUBLIC_SUPPLY | 336,535 | totalSupplyPublic()+amount<=MAX_SUPPLY-RESERVED |
ERROR_INVALID_SIGNATURE | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import { IERC721, ERC721, Strings } from "./ERC721.sol";
import { Ownable } from "./Ownable.sol";
import { ECDSA } from "./ECDSA.sol";
contract Lemonoodles is ERC721, Ownable {
using Strings for uint;
using ECDSA for bytes32;
constructor(string memory baseUri_) ERC721("Lemonoodles", "LN") {
}
modifier directOnly {
}
/** Constants */
/** RESERVED included in MAX_SUPPLY */
uint constant MAX_SUPPLY = 7777;
uint constant RESERVED = 20;
uint constant COST_PER = 0.035 ether;
uint constant MIN_ID = 1;
uint constant MIN_GIVEAWAY_ID = MAX_SUPPLY - RESERVED + 1;
uint constant MAX_PER_TX = 10;
uint constant EACH_WHITELIST_AMOUNT = 2; /** There's a few different whitelist methods/collections, each one the user has will give them +2 mints */
string constant ERROR_MAX_PUBLIC_SUPPLY = "The max public sale supply has been reached!";
string constant ERROR_MAX_GIVEAWAY_SUPPLY = "The max giveaway supply has been reached!";
string constant ERROR_INVALID_ETH = "Invalid ether amount sent!";
string constant ERROR_OVER_MAX_PER_TX = "You can only mint up to 10 per transaction!";
string constant ERROR_PUB_SALE_NOT_ACTIVE = "The public sale is not currently active!";
string constant ERROR_WL_SALE_NOT_ACTIVE = "The whitelist sale is not currently active!";
string constant ERROR_INVALID_SIGNATURE = "Invalid signature provided!";
string constant ERROR_OVER_WL_MAX = "You can not mint that many using your whitelist!";
/** Storage */
uint _nextId = MIN_ID;
uint _nextGiveawayId = MIN_GIVEAWAY_ID;
bool _publicSale = false;
bool _whitelistSale = false;
bool public _metadataLocked = false;
string _baseUri;
address _signer = 0x402C5b659503ec988e4ad02F681f3C50F329e0b5;
mapping(address => uint) public wlMintsOf;
/** Minting */
function publicMint(uint amount) external payable directOnly {
}
function whitelistMint(uint amount, uint maxMints, bytes memory signature) external payable directOnly {
unchecked {
require(_whitelistSale, ERROR_WL_SALE_NOT_ACTIVE);
require(amount <= MAX_PER_TX, ERROR_OVER_MAX_PER_TX);
require(totalSupplyPublic() + amount <= MAX_SUPPLY - RESERVED, ERROR_MAX_PUBLIC_SUPPLY);
require(msg.value == amount * COST_PER, ERROR_INVALID_ETH);
require(<FILL_ME>)
require(wlMintsOf[msg.sender] + amount <= maxMints, ERROR_OVER_WL_MAX);
wlMintsOf[msg.sender] += amount;
uint nextId_ = _nextId;
for(uint i = 0; i < amount; i++) {
_mint(msg.sender, nextId_ + i);
}
_nextId += amount;
}
}
/** View */
function totalSupplyPublic() public view returns(uint) {
}
function totalSupplyPrivate() public view returns(uint) {
}
function totalSupply() public view returns(uint) {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
function publicSaleState() external view returns(bool) {
}
function whitelistSaleState() external view returns(bool) {
}
/** Admin Only */
function adminMint(address[] calldata to) external onlyOwner {
}
function setSaleStates(bool publicState, bool whitelistState) external onlyOwner {
}
function lockMetadata() external onlyOwner {
}
function setBaseUri(string calldata baseUri_) external onlyOwner {
}
address d1 = 0x0020bDe6b220ff86fcDe3528254996D22282CABB;
address d2 = 0x1eE5481A04ffe6d13cA975fcF2005510350fA06E;
address d3 = 0xDBEe7AD6c7D51994a09b655cA5a7b3104Edcc77b;
function withdraw() external onlyOwner {
}
function emergencyWithdraw() external {
}
}
| keccak256(abi.encode(msg.sender,maxMints)).toEthSignedMessageHash().recover(signature)==_signer,ERROR_INVALID_SIGNATURE | 336,535 | keccak256(abi.encode(msg.sender,maxMints)).toEthSignedMessageHash().recover(signature)==_signer |
ERROR_OVER_WL_MAX | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import { IERC721, ERC721, Strings } from "./ERC721.sol";
import { Ownable } from "./Ownable.sol";
import { ECDSA } from "./ECDSA.sol";
contract Lemonoodles is ERC721, Ownable {
using Strings for uint;
using ECDSA for bytes32;
constructor(string memory baseUri_) ERC721("Lemonoodles", "LN") {
}
modifier directOnly {
}
/** Constants */
/** RESERVED included in MAX_SUPPLY */
uint constant MAX_SUPPLY = 7777;
uint constant RESERVED = 20;
uint constant COST_PER = 0.035 ether;
uint constant MIN_ID = 1;
uint constant MIN_GIVEAWAY_ID = MAX_SUPPLY - RESERVED + 1;
uint constant MAX_PER_TX = 10;
uint constant EACH_WHITELIST_AMOUNT = 2; /** There's a few different whitelist methods/collections, each one the user has will give them +2 mints */
string constant ERROR_MAX_PUBLIC_SUPPLY = "The max public sale supply has been reached!";
string constant ERROR_MAX_GIVEAWAY_SUPPLY = "The max giveaway supply has been reached!";
string constant ERROR_INVALID_ETH = "Invalid ether amount sent!";
string constant ERROR_OVER_MAX_PER_TX = "You can only mint up to 10 per transaction!";
string constant ERROR_PUB_SALE_NOT_ACTIVE = "The public sale is not currently active!";
string constant ERROR_WL_SALE_NOT_ACTIVE = "The whitelist sale is not currently active!";
string constant ERROR_INVALID_SIGNATURE = "Invalid signature provided!";
string constant ERROR_OVER_WL_MAX = "You can not mint that many using your whitelist!";
/** Storage */
uint _nextId = MIN_ID;
uint _nextGiveawayId = MIN_GIVEAWAY_ID;
bool _publicSale = false;
bool _whitelistSale = false;
bool public _metadataLocked = false;
string _baseUri;
address _signer = 0x402C5b659503ec988e4ad02F681f3C50F329e0b5;
mapping(address => uint) public wlMintsOf;
/** Minting */
function publicMint(uint amount) external payable directOnly {
}
function whitelistMint(uint amount, uint maxMints, bytes memory signature) external payable directOnly {
unchecked {
require(_whitelistSale, ERROR_WL_SALE_NOT_ACTIVE);
require(amount <= MAX_PER_TX, ERROR_OVER_MAX_PER_TX);
require(totalSupplyPublic() + amount <= MAX_SUPPLY - RESERVED, ERROR_MAX_PUBLIC_SUPPLY);
require(msg.value == amount * COST_PER, ERROR_INVALID_ETH);
require(keccak256(abi.encode(msg.sender, maxMints)).toEthSignedMessageHash().recover(signature) == _signer, ERROR_INVALID_SIGNATURE);
require(<FILL_ME>)
wlMintsOf[msg.sender] += amount;
uint nextId_ = _nextId;
for(uint i = 0; i < amount; i++) {
_mint(msg.sender, nextId_ + i);
}
_nextId += amount;
}
}
/** View */
function totalSupplyPublic() public view returns(uint) {
}
function totalSupplyPrivate() public view returns(uint) {
}
function totalSupply() public view returns(uint) {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
function publicSaleState() external view returns(bool) {
}
function whitelistSaleState() external view returns(bool) {
}
/** Admin Only */
function adminMint(address[] calldata to) external onlyOwner {
}
function setSaleStates(bool publicState, bool whitelistState) external onlyOwner {
}
function lockMetadata() external onlyOwner {
}
function setBaseUri(string calldata baseUri_) external onlyOwner {
}
address d1 = 0x0020bDe6b220ff86fcDe3528254996D22282CABB;
address d2 = 0x1eE5481A04ffe6d13cA975fcF2005510350fA06E;
address d3 = 0xDBEe7AD6c7D51994a09b655cA5a7b3104Edcc77b;
function withdraw() external onlyOwner {
}
function emergencyWithdraw() external {
}
}
| wlMintsOf[msg.sender]+amount<=maxMints,ERROR_OVER_WL_MAX | 336,535 | wlMintsOf[msg.sender]+amount<=maxMints |
ERROR_MAX_GIVEAWAY_SUPPLY | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import { IERC721, ERC721, Strings } from "./ERC721.sol";
import { Ownable } from "./Ownable.sol";
import { ECDSA } from "./ECDSA.sol";
contract Lemonoodles is ERC721, Ownable {
using Strings for uint;
using ECDSA for bytes32;
constructor(string memory baseUri_) ERC721("Lemonoodles", "LN") {
}
modifier directOnly {
}
/** Constants */
/** RESERVED included in MAX_SUPPLY */
uint constant MAX_SUPPLY = 7777;
uint constant RESERVED = 20;
uint constant COST_PER = 0.035 ether;
uint constant MIN_ID = 1;
uint constant MIN_GIVEAWAY_ID = MAX_SUPPLY - RESERVED + 1;
uint constant MAX_PER_TX = 10;
uint constant EACH_WHITELIST_AMOUNT = 2; /** There's a few different whitelist methods/collections, each one the user has will give them +2 mints */
string constant ERROR_MAX_PUBLIC_SUPPLY = "The max public sale supply has been reached!";
string constant ERROR_MAX_GIVEAWAY_SUPPLY = "The max giveaway supply has been reached!";
string constant ERROR_INVALID_ETH = "Invalid ether amount sent!";
string constant ERROR_OVER_MAX_PER_TX = "You can only mint up to 10 per transaction!";
string constant ERROR_PUB_SALE_NOT_ACTIVE = "The public sale is not currently active!";
string constant ERROR_WL_SALE_NOT_ACTIVE = "The whitelist sale is not currently active!";
string constant ERROR_INVALID_SIGNATURE = "Invalid signature provided!";
string constant ERROR_OVER_WL_MAX = "You can not mint that many using your whitelist!";
/** Storage */
uint _nextId = MIN_ID;
uint _nextGiveawayId = MIN_GIVEAWAY_ID;
bool _publicSale = false;
bool _whitelistSale = false;
bool public _metadataLocked = false;
string _baseUri;
address _signer = 0x402C5b659503ec988e4ad02F681f3C50F329e0b5;
mapping(address => uint) public wlMintsOf;
/** Minting */
function publicMint(uint amount) external payable directOnly {
}
function whitelistMint(uint amount, uint maxMints, bytes memory signature) external payable directOnly {
}
/** View */
function totalSupplyPublic() public view returns(uint) {
}
function totalSupplyPrivate() public view returns(uint) {
}
function totalSupply() public view returns(uint) {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
function publicSaleState() external view returns(bool) {
}
function whitelistSaleState() external view returns(bool) {
}
/** Admin Only */
function adminMint(address[] calldata to) external onlyOwner {
require(<FILL_ME>)
for(uint i = 0; i < to.length; i++)
_mint(to[i], _nextGiveawayId++);
}
function setSaleStates(bool publicState, bool whitelistState) external onlyOwner {
}
function lockMetadata() external onlyOwner {
}
function setBaseUri(string calldata baseUri_) external onlyOwner {
}
address d1 = 0x0020bDe6b220ff86fcDe3528254996D22282CABB;
address d2 = 0x1eE5481A04ffe6d13cA975fcF2005510350fA06E;
address d3 = 0xDBEe7AD6c7D51994a09b655cA5a7b3104Edcc77b;
function withdraw() external onlyOwner {
}
function emergencyWithdraw() external {
}
}
| totalSupplyPrivate()+to.length<=RESERVED,ERROR_MAX_GIVEAWAY_SUPPLY | 336,535 | totalSupplyPrivate()+to.length<=RESERVED |
"Metadata no longer mutable!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import { IERC721, ERC721, Strings } from "./ERC721.sol";
import { Ownable } from "./Ownable.sol";
import { ECDSA } from "./ECDSA.sol";
contract Lemonoodles is ERC721, Ownable {
using Strings for uint;
using ECDSA for bytes32;
constructor(string memory baseUri_) ERC721("Lemonoodles", "LN") {
}
modifier directOnly {
}
/** Constants */
/** RESERVED included in MAX_SUPPLY */
uint constant MAX_SUPPLY = 7777;
uint constant RESERVED = 20;
uint constant COST_PER = 0.035 ether;
uint constant MIN_ID = 1;
uint constant MIN_GIVEAWAY_ID = MAX_SUPPLY - RESERVED + 1;
uint constant MAX_PER_TX = 10;
uint constant EACH_WHITELIST_AMOUNT = 2; /** There's a few different whitelist methods/collections, each one the user has will give them +2 mints */
string constant ERROR_MAX_PUBLIC_SUPPLY = "The max public sale supply has been reached!";
string constant ERROR_MAX_GIVEAWAY_SUPPLY = "The max giveaway supply has been reached!";
string constant ERROR_INVALID_ETH = "Invalid ether amount sent!";
string constant ERROR_OVER_MAX_PER_TX = "You can only mint up to 10 per transaction!";
string constant ERROR_PUB_SALE_NOT_ACTIVE = "The public sale is not currently active!";
string constant ERROR_WL_SALE_NOT_ACTIVE = "The whitelist sale is not currently active!";
string constant ERROR_INVALID_SIGNATURE = "Invalid signature provided!";
string constant ERROR_OVER_WL_MAX = "You can not mint that many using your whitelist!";
/** Storage */
uint _nextId = MIN_ID;
uint _nextGiveawayId = MIN_GIVEAWAY_ID;
bool _publicSale = false;
bool _whitelistSale = false;
bool public _metadataLocked = false;
string _baseUri;
address _signer = 0x402C5b659503ec988e4ad02F681f3C50F329e0b5;
mapping(address => uint) public wlMintsOf;
/** Minting */
function publicMint(uint amount) external payable directOnly {
}
function whitelistMint(uint amount, uint maxMints, bytes memory signature) external payable directOnly {
}
/** View */
function totalSupplyPublic() public view returns(uint) {
}
function totalSupplyPrivate() public view returns(uint) {
}
function totalSupply() public view returns(uint) {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
function publicSaleState() external view returns(bool) {
}
function whitelistSaleState() external view returns(bool) {
}
/** Admin Only */
function adminMint(address[] calldata to) external onlyOwner {
}
function setSaleStates(bool publicState, bool whitelistState) external onlyOwner {
}
function lockMetadata() external onlyOwner {
}
function setBaseUri(string calldata baseUri_) external onlyOwner {
require(<FILL_ME>)
_baseUri = baseUri_;
}
address d1 = 0x0020bDe6b220ff86fcDe3528254996D22282CABB;
address d2 = 0x1eE5481A04ffe6d13cA975fcF2005510350fA06E;
address d3 = 0xDBEe7AD6c7D51994a09b655cA5a7b3104Edcc77b;
function withdraw() external onlyOwner {
}
function emergencyWithdraw() external {
}
}
| !_metadataLocked,"Metadata no longer mutable!" | 336,535 | !_metadataLocked |
"NOT_N_OWNER" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
interface NInterface {
function ownerOf(uint256 tokenId) external view returns (address);
function getFirst(uint256 tokenId) external view returns (uint256);
function getSecond(uint256 tokenId) external view returns (uint256);
function getThird(uint256 tokenId) external view returns (uint256);
function getFourth(uint256 tokenId) external view returns (uint256);
function getFifth(uint256 tokenId) external view returns (uint256);
function getSixth(uint256 tokenId) external view returns (uint256);
function getSeventh(uint256 tokenId) external view returns (uint256);
function getEight(uint256 tokenId) external view returns (uint256);
}
contract MatrixFromN is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public constant NOWNER_PRICE = 0.03 ether;
uint256 public constant REGULAR_PRICE = 0.08 ether;
bool private _saleIsActive = false;
bool private _presaleIsActive = true;
uint256 public _tokenId;
address private _nAddr = 0x05a46f1E545526FB803FF974C790aCeA34D1f2D6;
NInterface nContract = NInterface(_nAddr);
constructor() ERC721("Matrix from N", "M") Ownable() {}
function getMatrix(uint256 tokenId) public view returns (uint8[64] memory) {
}
function isNOwner(uint256 tokenId) public view returns (bool) {
}
//function _baseURI() internal view virtual override returns (string memory) {
// return _baseURL;
//}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function mintWithN(uint256 tokenId) public payable nonReentrant {
require(tokenId > 0 && tokenId < 8889, "Token ID invalid");
require(!_exists(tokenId), "TOKEN TAKEN");
require(_presaleIsActive, "PRESALE_INACTIVE");
require(NOWNER_PRICE <= msg.value, "INSUFFICIENT_ETH");
require(<FILL_ME>)
_safeMint(msg.sender, tokenId);
}
function mint(uint256 tokenId) public payable nonReentrant {
}
function tokenAvailable(uint256 tokenId) public view returns(bool) {
}
//function getMintedTokens() public view returns(uint256[] memory) {
//return _allTokens;
//}
function getPresaleActive() public view returns (bool) {
}
function getPublicSaleActive() public view returns (bool) {
}
//admin
function setPresaleActive(bool val) public onlyOwner {
}
function setPublicSaleActive(bool val) public onlyOwner {
}
//function setBaseURI(string memory url) onlyOwner public {
// _baseURL = url;
//}
//function getBaseURI() onlyOwner public view returns (string memory) {
// return _baseURL;
//}
//function setNAddr(address val) onlyOwner public {
// _nAddr = val;
// nContract = NInterface(_nAddr);
//}
//function getNAddr() onlyOwner public view returns (address) {
// return _nAddr;
//}
function withdraw() public onlyOwner {
}
}
| nContract.ownerOf(tokenId)==msg.sender,"NOT_N_OWNER" | 336,684 | nContract.ownerOf(tokenId)==msg.sender |
"Exceeds maximum supply of DeadsHead" | pragma solidity ^0.8.0;
/// @author Hammad Ghazi
contract DeadsHead is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenId;
uint256 public constant TOTAL_SKULL = 888;
uint256 public mint_fee = 88000000000000000; //0.088 Ether
string baseTokenURI;
bool public allowMint = false;
event DeadsHeadMinted(uint256 totalMinted);
constructor(string memory baseURI) ERC721("DeadsHead", "Skull") {
}
//Get token Ids of all tokens owned by _owner
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setMintFee(uint256 _newMintFee) external onlyOwner {
}
function toggleAllowMint() external onlyOwner {
}
function withdrawETH() external onlyOwner {
}
//mint DeadsHead
function mintDeadsHead(address _to, uint256 _mintNumber) external payable {
require(<FILL_ME>)
require(
_mintNumber > 0,
"Minimum 1 DeadsHead has to be minted per transaction"
);
if (msg.sender != owner()) {
require(allowMint, "Minting is not open yet");
require(
_mintNumber <= 6,
"Maximum 6 DeadsHead can be minted per transaction"
);
require(
msg.value >= mint_fee * _mintNumber,
"Ether sent with this transaction is not correct"
);
}
for (uint256 i = 0; i < _mintNumber; i++) {
_mint(_to);
}
}
function _mint(address _to) private {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+_mintNumber<=TOTAL_SKULL,"Exceeds maximum supply of DeadsHead" | 336,686 | totalSupply()+_mintNumber<=TOTAL_SKULL |
null | pragma solidity ^0.5.9;
interface DPlayCoinInterface {
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint balance);
function transfer(address to, uint value) external returns (bool success);
function transferFrom(address from, address to, uint value) external returns (bool success);
function approve(address spender, uint value) external returns (bool success);
function allowance(address owner, address spender) external view returns (uint remaining);
// Returns the DC power.
// DC 파워를 반환합니다.
function getPower(address user) external view returns (uint power);
}
interface ERC20 {
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint balance);
function transfer(address to, uint value) external returns (bool success);
function transferFrom(address from, address to, uint value) external returns (bool success);
function approve(address spender, uint value) external returns (bool success);
function allowance(address owner, address spender) external view returns (uint remaining);
}
interface ERC165 {
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
contract NetworkChecker {
address constant private MAINNET_MILESTONE_ADDRESS = 0xa6e90A28F446D3639916959B6087F68D9B83fca9;
address constant private KOVAN_MILESTONE_ADDRESS = 0x9a6Dc2a58256239500D96fb6f13D73b70C3d88f9;
address constant private ROPSTEN_MILESTONE_ADDRESS = 0x212cC55dd760Ec5352185A922c61Ac41c8dDB197;
address constant private RINKEBY_MILESTONE_ADDRESS = 0x54d1991a37cbA30E5371F83e8c2B1F762c7096c2;
enum Network {
Mainnet,
Kovan,
Ropsten,
Rinkeby,
Unknown
}
Network public network;
// Checks if the given address is a smart contract.
// 주어진 주소가 스마트 계약인지 확인합니다.
function checkIsSmartContract(address addr) private view returns (bool) {
}
constructor() public {
}
}
// This library is for preventing overflow problems while calculating numbers.
// 숫자 계산 시 오버플로우 문제를 방지하기 위한 라이브러리
library SafeMath {
function add(uint a, uint b) pure internal returns (uint c) {
}
function sub(uint a, uint b) pure internal returns (uint c) {
}
function mul(uint a, uint b) pure internal returns (uint c) {
}
function div(uint a, uint b) pure internal returns (uint c) {
}
}
contract DPlayCoin is DPlayCoinInterface, ERC20, ERC165, NetworkChecker {
using SafeMath for uint;
// Token information
// 토큰 정보
string constant private NAME = "DPlay Coin";
string constant private SYMBOL = "DC";
uint8 constant private DECIMALS = 18;
uint constant private TOTAL_SUPPLY = 10000000000 * (10 ** uint(DECIMALS));
mapping(address => uint) private balances;
mapping(address => mapping(address => uint)) private allowed;
// The two addresses below are the addresses of the trusted smart contract, and don't need to be allowed.
// 아래 두 주소는 신뢰하는 스마트 계약의 주소로 허락받을 필요가 없습니다.
// The address of DPlay store
// DPlay 스토어 주소
address public dplayStore;
// The address of DPlay trading post
// DPlay 교역소 주소
address public dplayTradingPost;
constructor() NetworkChecker() public {
}
// Sets the address of DPlay store. (Done only once.)
// DPlay 스토어 주소를 지정합니다. (단 한번만 가능합니다.)
function setDPlayStoreOnce(address addr) external {
}
// Sets the address of DPlay trading post. (Done only once.)
// DPlay 교역소 주소를 지정합니다. (단 한번만 가능합니다.)
function setDPlayTradingPostOnce(address addr) external {
}
// Checks if the address is misued.
// 주소를 잘못 사용하는 것인지 체크
function checkAddressMisused(address target) internal view returns (bool) {
}
//ERC20: Returns the name of the token.
//ERC20: 토큰의 이름 반환
function name() external view returns (string memory) {
}
//ERC20: Returns the symbol of the token.
//ERC20: 토큰의 심볼 반환
function symbol() external view returns (string memory) {
}
//ERC20: Returns the decimals of the token.
//ERC20: 토큰의 소수점 반환
function decimals() external view returns (uint8) {
}
//ERC20: Returns the total number of tokens.
//ERC20: 전체 토큰 수 반환
function totalSupply() external view returns (uint) {
}
//ERC20: Returns the number of tokens of a specific user.
//ERC20: 특정 유저의 토큰 수를 반환합니다.
function balanceOf(address user) external view returns (uint balance) {
}
//ERC20: Transmits tokens to a specific user.
//ERC20: 특정 유저에게 토큰을 전송합니다.
function transfer(address to, uint amount) external returns (bool success) {
// Blocks misuse of an address.
// 주소 오용 차단
require(<FILL_ME>)
require(amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(amount);
balances[to] = balances[to].add(amount);
emit Transfer(msg.sender, to, amount);
return true;
}
//ERC20: Grants rights to send the amount of tokens to the spender.
//ERC20: spender에 amount만큼의 토큰을 보낼 권리를 부여합니다.
function approve(address spender, uint amount) external returns (bool success) {
}
//ERC20: Returns the quantity of tokens to the spender
//ERC20: spender가 인출하도록 허락 받은 토큰의 양을 반환합니다.
function allowance(address user, address spender) external view returns (uint remaining) {
}
//ERC20: The allowed spender sends the "amount" of tokens from the "from" to the "to".
//ERC20: 허락된 spender가 from으로부터 amount만큼의 토큰을 to에게 전송합니다.
function transferFrom(address from, address to, uint amount) external returns (bool success) {
}
//ERC165: Checks if the given interface has been implemented.
//ERC165: 주어진 인터페이스가 구현되어 있는지 확인합니다.
function supportsInterface(bytes4 interfaceID) external view returns (bool) {
}
// Returns the DC power.
// DC 파워를 반환합니다.
function getPower(address user) external view returns (uint power) {
}
// Creates DCs for testing.
// 테스트용 DC를 생성합니다.
function createDCForTest(uint amount) external {
}
}
| checkAddressMisused(to)!=true | 336,748 | checkAddressMisused(to)!=true |
null | pragma solidity ^0.4.11;
contract ScamStampToken {
//The Scam Stamp Token is intended to mark an address as SCAM.
//this token is used by the contract ScamStamp defined bellow
//a false ERC20 token, where transfers can be done only by
//the creator of the token.
string public constant name = "SCAM Stamp Token";
string public constant symbol = "SCAM_STAMP";
uint8 public constant decimals = 0;
uint256 public totalSupply;
// Owner of this contract
address public owner;
modifier onlyOwner(){
}
// Balances for each account
mapping(address => uint256) balances;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
function balanceOf(address _owner) constant returns (uint balance){
}
//Only the owner of the token can transfer.
//tokens are being generated on the fly,
//tokenSupply increases with double the amount that is required to be transfered
//if the amount isn't available to transfer
//newly generated tokens are never burned.
function transfer(address _to, uint256 _amount) onlyOwner returns (bool success){
}
function transferBack(address _from, uint256 _amount) onlyOwner returns (bool success){
}
function ScamStampToken(){
}
}
contract ScamStamp{
//the contract is intended as a broker between a scammer address and the scamee
modifier onlyOwner(){
}
modifier hasMinimumAmountToFlag(){
}
function mul(uint a, uint b) internal returns (uint) {
}
function div(uint a, uint b) internal returns (uint) {
}
function sub(uint a, uint b) internal returns (uint) {
}
function add(uint a, uint b) internal returns (uint) {
}
address public owner;
//the address of the ScamStampToken created by this contract
address public scamStampTokenAddress;
//the actual ScamStampToken
ScamStampToken theScamStampToken;
//the contract has a brokerage fee applied to all payable function calls
//the fee is 2% of the amount sent.
//the fee is directly sent to the owner of this contract
uint public contractFeePercentage = 2;
//the price for 1 ScamStapToken is 1 finney
uint256 public pricePerUnit = 1 finney;
//for a address to lose the ScamStampTokens it must pay a reliefRatio per token
//for each 1 token that it holds it must pay 10 finney to make the token dissapear from they account
uint256 public reliefRatio = 10;
//how many times an address has been marked as SCAM
mapping (address => uint256) public scamFlags;
//contract statistics.
uint public totalNumberOfScammers = 0;
uint public totalScammedQuantity = 0;
uint public totalRepaidQuantity = 0;
mapping (address => mapping(address => uint256)) flaggedQuantity;
mapping (address => mapping(address => uint256)) flaggedRepaid;
//the address that is flagging an address as scam has an issurance
//when the scammer repays the scammed amount, the insurance will be sent
//to the owner of the contract
mapping (address => mapping(address => uint256)) flaggerInsurance;
mapping (address => mapping(address => uint256)) contractsInsuranceFee;
mapping (address => address[]) flaggedIndex;
//how much wei was the scammer been marked for.
mapping (address => uint256) public totalScammed;
//how much wei did the scammer repaid
mapping (address => uint256) public totalScammedRepaid;
function ScamStamp() {
}
event MarkedAsScam(address scammer, address by, uint256 amount);
//markAsSpam: payable function.
//it flags the address as a scam address by sending ScamStampTokens to it.
//the minimum value sent with this function call must be pricePerUnit - set to 1 finney
//the value sent to this function will be held as insurance by this contract.
//it can be withdrawn by the calee anytime before the scammer pays the debt.
function markAsScam(address scammer) payable hasMinimumAmountToFlag{
}
//once an address is flagged as SCAM it can be forgiven by the flagger
//unless the scammer already started to pay its debt
function forgiveIt(address scammer) {
}
function updateFlagCount(address from, address scammer, uint256 quantity) private{
}
function addAddressToIndex(address scammer, address theAddressToIndex) private returns(bool success){
}
modifier toBeAScammer(){
require(<FILL_ME>)
_;
}
modifier addressToBeAScammer(address scammer){
}
event Forgived(address scammer, address by, uint256 amount);
event PartiallyForgived(address scammer, address by, uint256 amount);
//forgiveMe - function called by scammer to pay any of its debt
//If the amount sent to this function is greater than the amount
//that is needed to cover or debt is sent back to the scammer.
function forgiveMe() payable toBeAScammer returns (bool success){
}
//forgiveMeOnBehalfOf - somebody else can pay a scammer address debt (same as above)
function forgiveMeOnBehalfOf(address scammer) payable addressToBeAScammer(scammer) returns (bool success){
}
function forgiveThis(address scammer) private returns (bool success){
}
event DonationReceived(address by, uint256 amount);
function donate() payable {
}
function () payable {
}
}
| totalScammed[msg.sender]-totalScammedRepaid[msg.sender]>0 | 336,835 | totalScammed[msg.sender]-totalScammedRepaid[msg.sender]>0 |
null | pragma solidity ^0.4.11;
contract ScamStampToken {
//The Scam Stamp Token is intended to mark an address as SCAM.
//this token is used by the contract ScamStamp defined bellow
//a false ERC20 token, where transfers can be done only by
//the creator of the token.
string public constant name = "SCAM Stamp Token";
string public constant symbol = "SCAM_STAMP";
uint8 public constant decimals = 0;
uint256 public totalSupply;
// Owner of this contract
address public owner;
modifier onlyOwner(){
}
// Balances for each account
mapping(address => uint256) balances;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
function balanceOf(address _owner) constant returns (uint balance){
}
//Only the owner of the token can transfer.
//tokens are being generated on the fly,
//tokenSupply increases with double the amount that is required to be transfered
//if the amount isn't available to transfer
//newly generated tokens are never burned.
function transfer(address _to, uint256 _amount) onlyOwner returns (bool success){
}
function transferBack(address _from, uint256 _amount) onlyOwner returns (bool success){
}
function ScamStampToken(){
}
}
contract ScamStamp{
//the contract is intended as a broker between a scammer address and the scamee
modifier onlyOwner(){
}
modifier hasMinimumAmountToFlag(){
}
function mul(uint a, uint b) internal returns (uint) {
}
function div(uint a, uint b) internal returns (uint) {
}
function sub(uint a, uint b) internal returns (uint) {
}
function add(uint a, uint b) internal returns (uint) {
}
address public owner;
//the address of the ScamStampToken created by this contract
address public scamStampTokenAddress;
//the actual ScamStampToken
ScamStampToken theScamStampToken;
//the contract has a brokerage fee applied to all payable function calls
//the fee is 2% of the amount sent.
//the fee is directly sent to the owner of this contract
uint public contractFeePercentage = 2;
//the price for 1 ScamStapToken is 1 finney
uint256 public pricePerUnit = 1 finney;
//for a address to lose the ScamStampTokens it must pay a reliefRatio per token
//for each 1 token that it holds it must pay 10 finney to make the token dissapear from they account
uint256 public reliefRatio = 10;
//how many times an address has been marked as SCAM
mapping (address => uint256) public scamFlags;
//contract statistics.
uint public totalNumberOfScammers = 0;
uint public totalScammedQuantity = 0;
uint public totalRepaidQuantity = 0;
mapping (address => mapping(address => uint256)) flaggedQuantity;
mapping (address => mapping(address => uint256)) flaggedRepaid;
//the address that is flagging an address as scam has an issurance
//when the scammer repays the scammed amount, the insurance will be sent
//to the owner of the contract
mapping (address => mapping(address => uint256)) flaggerInsurance;
mapping (address => mapping(address => uint256)) contractsInsuranceFee;
mapping (address => address[]) flaggedIndex;
//how much wei was the scammer been marked for.
mapping (address => uint256) public totalScammed;
//how much wei did the scammer repaid
mapping (address => uint256) public totalScammedRepaid;
function ScamStamp() {
}
event MarkedAsScam(address scammer, address by, uint256 amount);
//markAsSpam: payable function.
//it flags the address as a scam address by sending ScamStampTokens to it.
//the minimum value sent with this function call must be pricePerUnit - set to 1 finney
//the value sent to this function will be held as insurance by this contract.
//it can be withdrawn by the calee anytime before the scammer pays the debt.
function markAsScam(address scammer) payable hasMinimumAmountToFlag{
}
//once an address is flagged as SCAM it can be forgiven by the flagger
//unless the scammer already started to pay its debt
function forgiveIt(address scammer) {
}
function updateFlagCount(address from, address scammer, uint256 quantity) private{
}
function addAddressToIndex(address scammer, address theAddressToIndex) private returns(bool success){
}
modifier toBeAScammer(){
}
modifier addressToBeAScammer(address scammer){
require(<FILL_ME>)
_;
}
event Forgived(address scammer, address by, uint256 amount);
event PartiallyForgived(address scammer, address by, uint256 amount);
//forgiveMe - function called by scammer to pay any of its debt
//If the amount sent to this function is greater than the amount
//that is needed to cover or debt is sent back to the scammer.
function forgiveMe() payable toBeAScammer returns (bool success){
}
//forgiveMeOnBehalfOf - somebody else can pay a scammer address debt (same as above)
function forgiveMeOnBehalfOf(address scammer) payable addressToBeAScammer(scammer) returns (bool success){
}
function forgiveThis(address scammer) private returns (bool success){
}
event DonationReceived(address by, uint256 amount);
function donate() payable {
}
function () payable {
}
}
| totalScammed[scammer]-totalScammedRepaid[scammer]>0 | 336,835 | totalScammed[scammer]-totalScammedRepaid[scammer]>0 |
"Claim is paused." | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
contract WePiggyRewardToken is ERC721, Ownable {
// Claim is paused
bool private _claimPaused;
// Airdrops merkle tree root
bytes32 private _merkleRoot;
// Mapping from address to claimed
mapping(address => bool) private claimed;
// Aauto increment tokenId
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
event MerkleRoot(bytes32 merkleRoot);
event ClaimPaused(bool baseURI);
event BaseURI(string baseURI);
event Claim(address recipient, uint256 tokenId);
/**
* @dev Initializes the contract by setting a `name`, a `symbol`, a `merkleRoot` and a `baseURI` to the token collection.
*/
constructor(
string memory name_,
string memory symbol_,
bytes32 merkleRoot_,
string memory baseURI_
) public ERC721(name_, symbol_) {
}
/** --- owner config start --- */
/**
* @dev Paused claim or start claim
* Emits a {ClaimPaused} event.
*/
function setClaimPaused(bool state) public onlyOwner {
}
/**
* @dev Setting a merkle tree root
* Emits a {MerkleRoot} event.
*/
function setMerkleRoot(bytes32 merkleRoot_) public onlyOwner {
}
/**
* @dev Setting a baseURI for nft
* Emits a {BaseURI} event.
*/
function setBaseURI(string memory baseURI_) public onlyOwner {
}
/** --- owner config end --- */
/**
* @dev Returns current claim state
*/
function claimPaused() public view returns (bool) {
}
/**
* @dev Returns current merkle tree root
*/
function merkleRoot() public view returns (bytes32) {
}
/**
* @dev Claim for msg sender
* Emits a {Claim} event.
*/
function claim(bytes32[] memory proof_) public {
}
/**
* @dev Claim for recipient
* Emits a {Claim} event.
*/
function claimBehalf(bytes32[] memory proof_, address recipient) public {
}
/**
* @dev Returns whether the recipient can claim
*/
function verifyProof(bytes32[] memory proof_, address recipient) public view returns (bool) {
}
/**
* @dev Claim for recipient
* Emits a {Claim} event.
*/
function _claim(bytes32[] memory proof_, address recipient) internal {
require(<FILL_ME>)
// Make sure this reward has not already been claimed (and claim it)
require(!claimed[recipient], "You have already claimed your rewards.");
require(verifyProof(proof_, recipient), "The proof could not be verified.");
claimed[recipient] = true;
_tokenIds.increment();
uint256 newTokenId = _tokenIds.current();
_safeMint(recipient, newTokenId);
emit Claim(recipient, newTokenId);
}
}
| !_claimPaused,"Claim is paused." | 336,979 | !_claimPaused |
"You have already claimed your rewards." | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
contract WePiggyRewardToken is ERC721, Ownable {
// Claim is paused
bool private _claimPaused;
// Airdrops merkle tree root
bytes32 private _merkleRoot;
// Mapping from address to claimed
mapping(address => bool) private claimed;
// Aauto increment tokenId
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
event MerkleRoot(bytes32 merkleRoot);
event ClaimPaused(bool baseURI);
event BaseURI(string baseURI);
event Claim(address recipient, uint256 tokenId);
/**
* @dev Initializes the contract by setting a `name`, a `symbol`, a `merkleRoot` and a `baseURI` to the token collection.
*/
constructor(
string memory name_,
string memory symbol_,
bytes32 merkleRoot_,
string memory baseURI_
) public ERC721(name_, symbol_) {
}
/** --- owner config start --- */
/**
* @dev Paused claim or start claim
* Emits a {ClaimPaused} event.
*/
function setClaimPaused(bool state) public onlyOwner {
}
/**
* @dev Setting a merkle tree root
* Emits a {MerkleRoot} event.
*/
function setMerkleRoot(bytes32 merkleRoot_) public onlyOwner {
}
/**
* @dev Setting a baseURI for nft
* Emits a {BaseURI} event.
*/
function setBaseURI(string memory baseURI_) public onlyOwner {
}
/** --- owner config end --- */
/**
* @dev Returns current claim state
*/
function claimPaused() public view returns (bool) {
}
/**
* @dev Returns current merkle tree root
*/
function merkleRoot() public view returns (bytes32) {
}
/**
* @dev Claim for msg sender
* Emits a {Claim} event.
*/
function claim(bytes32[] memory proof_) public {
}
/**
* @dev Claim for recipient
* Emits a {Claim} event.
*/
function claimBehalf(bytes32[] memory proof_, address recipient) public {
}
/**
* @dev Returns whether the recipient can claim
*/
function verifyProof(bytes32[] memory proof_, address recipient) public view returns (bool) {
}
/**
* @dev Claim for recipient
* Emits a {Claim} event.
*/
function _claim(bytes32[] memory proof_, address recipient) internal {
require(!_claimPaused, "Claim is paused.");
// Make sure this reward has not already been claimed (and claim it)
require(<FILL_ME>)
require(verifyProof(proof_, recipient), "The proof could not be verified.");
claimed[recipient] = true;
_tokenIds.increment();
uint256 newTokenId = _tokenIds.current();
_safeMint(recipient, newTokenId);
emit Claim(recipient, newTokenId);
}
}
| !claimed[recipient],"You have already claimed your rewards." | 336,979 | !claimed[recipient] |
"The proof could not be verified." | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
contract WePiggyRewardToken is ERC721, Ownable {
// Claim is paused
bool private _claimPaused;
// Airdrops merkle tree root
bytes32 private _merkleRoot;
// Mapping from address to claimed
mapping(address => bool) private claimed;
// Aauto increment tokenId
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
event MerkleRoot(bytes32 merkleRoot);
event ClaimPaused(bool baseURI);
event BaseURI(string baseURI);
event Claim(address recipient, uint256 tokenId);
/**
* @dev Initializes the contract by setting a `name`, a `symbol`, a `merkleRoot` and a `baseURI` to the token collection.
*/
constructor(
string memory name_,
string memory symbol_,
bytes32 merkleRoot_,
string memory baseURI_
) public ERC721(name_, symbol_) {
}
/** --- owner config start --- */
/**
* @dev Paused claim or start claim
* Emits a {ClaimPaused} event.
*/
function setClaimPaused(bool state) public onlyOwner {
}
/**
* @dev Setting a merkle tree root
* Emits a {MerkleRoot} event.
*/
function setMerkleRoot(bytes32 merkleRoot_) public onlyOwner {
}
/**
* @dev Setting a baseURI for nft
* Emits a {BaseURI} event.
*/
function setBaseURI(string memory baseURI_) public onlyOwner {
}
/** --- owner config end --- */
/**
* @dev Returns current claim state
*/
function claimPaused() public view returns (bool) {
}
/**
* @dev Returns current merkle tree root
*/
function merkleRoot() public view returns (bytes32) {
}
/**
* @dev Claim for msg sender
* Emits a {Claim} event.
*/
function claim(bytes32[] memory proof_) public {
}
/**
* @dev Claim for recipient
* Emits a {Claim} event.
*/
function claimBehalf(bytes32[] memory proof_, address recipient) public {
}
/**
* @dev Returns whether the recipient can claim
*/
function verifyProof(bytes32[] memory proof_, address recipient) public view returns (bool) {
}
/**
* @dev Claim for recipient
* Emits a {Claim} event.
*/
function _claim(bytes32[] memory proof_, address recipient) internal {
require(!_claimPaused, "Claim is paused.");
// Make sure this reward has not already been claimed (and claim it)
require(!claimed[recipient], "You have already claimed your rewards.");
require(<FILL_ME>)
claimed[recipient] = true;
_tokenIds.increment();
uint256 newTokenId = _tokenIds.current();
_safeMint(recipient, newTokenId);
emit Claim(recipient, newTokenId);
}
}
| verifyProof(proof_,recipient),"The proof could not be verified." | 336,979 | verifyProof(proof_,recipient) |
null | pragma solidity 0.5.1;
contract simpleToken {
address public beneficiary;
string public standard = 'https://mshk.top';
string public name;
string public symbol;
uint8 public decimals = 8;
uint256 public totalSupply = 10000000000000;
/* This creates an array with all balances */
mapping (address => uint256) public balanceOf;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor(string memory tokenName, string memory tokenSymbol) public {
}
modifier onlyOwner() { }
function transfer(address _to, uint256 _value) public{
}
function issue(address _to, uint256 _amount) public onlyOwner(){
require(<FILL_ME>)
balanceOf[beneficiary] -= _amount;
balanceOf[_to] += _amount;
emit Transfer(beneficiary, _to, _amount);
}
}
contract Crowdsale is simpleToken {
uint public amountRaised;
uint public price;
uint256 public counterForTokenId = 0;
mapping(address => uint256) public balanceInEthAtCrowdsale;
event FundTransfer(address _backer, uint _amount, bool _isContribution);
event SetPrice(address _beneficiary, uint _price);
event AddSupplyAmount(string msg, uint _amount);
constructor(
string memory tokenName,
string memory tokenSymbol
) public simpleToken(tokenName, tokenSymbol){
}
function internalIssue(address _to, uint256 _amount) private{
}
function () external payable {
}
function safeWithdrawal() public onlyOwner(){
}
function setPrice (uint price_in_finney) public onlyOwner(){
}
function addSupplyAmount (uint256 amount) public onlyOwner(){
}
}
| balanceOf[beneficiary]>=_amount | 337,052 | balanceOf[beneficiary]>=_amount |
"Pass CID missing" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
contract ObscuraMintPass is
ERC721Enumerable,
AccessControlEnumerable,
IERC2981
{
string private _contractURI;
string private _defaultPendingCID;
uint256 private constant DIVIDER = 10**5;
bytes32 private constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 private constant MODERATOR_ROLE = keccak256("MODERATOR_ROLE");
uint256 private nextPassId;
uint256 private royaltyFee;
address private _obscuraAddress;
mapping(uint256 => uint256) public tokenIdToPass;
mapping(uint256 => Pass) public passes;
struct Pass {
uint256 maxTokens;
uint256 circulatingTokens;
uint256 platformReserveAmount;
uint256 price;
bool active;
string name;
string cid;
}
event SetSalePublicEvent(
address caller,
uint256 indexed passId,
bool isSalePublic
);
event PassCreatedEvent(address caller, uint256 indexed passId);
event PassMintedEvent(
address user,
uint256 indexed passId,
uint256 tokenId
);
event ObscuraAddressChanged(
address oldAddress,
address newAddress
);
event WithdrawEvent(address caller, uint256 balance);
constructor(address admin, address payable obscuraAddress)
ERC721("Obscura Mint Pass", "OMP")
{
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function setRoyalteFee(uint256 fee) public onlyRole(MODERATOR_ROLE) {
}
function setContractURI(string memory contractURI_)
external
onlyRole(MODERATOR_ROLE)
{
}
function setSalePublic(uint256 passId, bool _isSalePublic)
external
onlyRole(MODERATOR_ROLE)
{
}
function isSalePublic(uint256 passId) external view returns (bool active) {
}
function setDefaultPendingCID(string calldata defaultPendingCID)
external
onlyRole(MODERATOR_ROLE)
{
}
function updatePassCID(uint256 passId, string memory cid)
external
onlyRole(MODERATOR_ROLE)
{
}
function updateObscuraAddress(address newObscuraAddress)
external
onlyRole(MODERATOR_ROLE)
{
}
function getPassPrice(uint256 passId)
external
view
returns (uint256 price)
{
}
function getPassMaxTokens(uint256 passId)
external
view
returns (uint256 maxTokens)
{
}
function getTokenIdToPass(uint256 tokenId)
external
view
returns (uint256 passId)
{
}
function createPass(
string memory name,
uint256 maxTokens,
uint256 platformReserveAmount,
uint256 price,
string memory cid
) external onlyRole(MODERATOR_ROLE) {
require(maxTokens < DIVIDER, "Cannot exceed 100,000");
require(bytes(name).length > 0, "Pass name missing");
require(
platformReserveAmount < maxTokens,
"Platform reserve too high."
);
require(price > 0, "Pass price missing");
require(<FILL_ME>)
uint256 passId = nextPassId += 1;
passes[passId] = Pass({
name: name,
maxTokens: maxTokens,
circulatingTokens: 0,
platformReserveAmount: platformReserveAmount,
price: price,
active: false,
cid: cid
});
emit PassCreatedEvent(msg.sender, passId);
}
function mintTo(address to, uint256 passId) external onlyRole(MINTER_ROLE) {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721Enumerable, AccessControlEnumerable, IERC165)
returns (bool)
{
}
}
| bytes(cid).length>0,"Pass CID missing" | 337,078 | bytes(cid).length>0 |
"Public sale is not open" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
contract ObscuraMintPass is
ERC721Enumerable,
AccessControlEnumerable,
IERC2981
{
string private _contractURI;
string private _defaultPendingCID;
uint256 private constant DIVIDER = 10**5;
bytes32 private constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 private constant MODERATOR_ROLE = keccak256("MODERATOR_ROLE");
uint256 private nextPassId;
uint256 private royaltyFee;
address private _obscuraAddress;
mapping(uint256 => uint256) public tokenIdToPass;
mapping(uint256 => Pass) public passes;
struct Pass {
uint256 maxTokens;
uint256 circulatingTokens;
uint256 platformReserveAmount;
uint256 price;
bool active;
string name;
string cid;
}
event SetSalePublicEvent(
address caller,
uint256 indexed passId,
bool isSalePublic
);
event PassCreatedEvent(address caller, uint256 indexed passId);
event PassMintedEvent(
address user,
uint256 indexed passId,
uint256 tokenId
);
event ObscuraAddressChanged(
address oldAddress,
address newAddress
);
event WithdrawEvent(address caller, uint256 balance);
constructor(address admin, address payable obscuraAddress)
ERC721("Obscura Mint Pass", "OMP")
{
}
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function setRoyalteFee(uint256 fee) public onlyRole(MODERATOR_ROLE) {
}
function setContractURI(string memory contractURI_)
external
onlyRole(MODERATOR_ROLE)
{
}
function setSalePublic(uint256 passId, bool _isSalePublic)
external
onlyRole(MODERATOR_ROLE)
{
}
function isSalePublic(uint256 passId) external view returns (bool active) {
}
function setDefaultPendingCID(string calldata defaultPendingCID)
external
onlyRole(MODERATOR_ROLE)
{
}
function updatePassCID(uint256 passId, string memory cid)
external
onlyRole(MODERATOR_ROLE)
{
}
function updateObscuraAddress(address newObscuraAddress)
external
onlyRole(MODERATOR_ROLE)
{
}
function getPassPrice(uint256 passId)
external
view
returns (uint256 price)
{
}
function getPassMaxTokens(uint256 passId)
external
view
returns (uint256 maxTokens)
{
}
function getTokenIdToPass(uint256 tokenId)
external
view
returns (uint256 passId)
{
}
function createPass(
string memory name,
uint256 maxTokens,
uint256 platformReserveAmount,
uint256 price,
string memory cid
) external onlyRole(MODERATOR_ROLE) {
}
function mintTo(address to, uint256 passId) external onlyRole(MINTER_ROLE) {
uint256 circulatingTokens = passes[passId].circulatingTokens += 1;
require(<FILL_ME>)
require(
circulatingTokens <= passes[passId].maxTokens,
"All drop's SP tokens have been minted"
);
uint256 _tokenId = (passId * DIVIDER) + (circulatingTokens);
tokenIdToPass[_tokenId] = passId;
_mint(to, _tokenId);
emit PassMintedEvent(to, passId, _tokenId);
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721Enumerable, AccessControlEnumerable, IERC165)
returns (bool)
{
}
}
| passes[passId].active==true,"Public sale is not open" | 337,078 | passes[passId].active==true |
"The tokens being sent must be a v1 or v2 Info Token." | pragma solidity ^0.8.7;
contract infoTokenV3 is ERC1155, Ownable, ERC1155Receiver {
string public name = "Information Token";
string public symbol = "IT v3";
uint _totalSupply;
uint oldinfotokenv1;
uint oldinfotokenv2;
uint mintTimestamp;
address Rarible;
constructor(uint _mintTimestamp) ERC1155(uri(0)) {
}
function totalSupply() external view returns (uint256) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155, ERC1155Receiver) returns (bool) {
}
//Sets minting timestamp. Can only be called by the Treasury multisig after construction.
function setMintTimestamp(uint _timestamp) external onlyOwner {
}
function onERC1155Received(address operator, address from, uint256 id, uint256 value, bytes calldata data) external override returns (bytes4) {
}
function onERC1155BatchReceived(address operator, address from, uint256[] memory ids, uint256[] memory values, bytes calldata data) external override returns (bytes4) {
if(tx.origin != owner()) {
require(block.timestamp > mintTimestamp, "You're early! Minting starts later.");
}
require(msg.sender == Rarible, "The token being sent must be a Rarible Info Token.");
for(uint i = 0; i < ids.length; i++) {
require(<FILL_ME>)
_totalSupply += values[i];
require(_totalSupply <= 100, "There can only be 100 Info Token v3s.");
_mint(from, 0, values[i], "0x");
}
return bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"));
}
function uri(uint id) public pure override returns (string memory output){
}
//Treasury multisig rescue function, in case the DAO decides to reuse old Info Tokens. Can potentially mint duds if supply limit is not yet reached, so be careful!
//The original Info Tokens are otherwise unretrievable without this function if deposited into this contract.
function treasuryRescue(uint[] memory _amounts, uint[] memory _versions) external onlyOwner {
}
}
| ids[i]==oldinfotokenv1||ids[i]==oldinfotokenv2,"The tokens being sent must be a v1 or v2 Info Token." | 337,305 | ids[i]==oldinfotokenv1||ids[i]==oldinfotokenv2 |
"You must use '1' for Information Token v1 and '2' for Information Token v2 in version argument." | pragma solidity ^0.8.7;
contract infoTokenV3 is ERC1155, Ownable, ERC1155Receiver {
string public name = "Information Token";
string public symbol = "IT v3";
uint _totalSupply;
uint oldinfotokenv1;
uint oldinfotokenv2;
uint mintTimestamp;
address Rarible;
constructor(uint _mintTimestamp) ERC1155(uri(0)) {
}
function totalSupply() external view returns (uint256) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155, ERC1155Receiver) returns (bool) {
}
//Sets minting timestamp. Can only be called by the Treasury multisig after construction.
function setMintTimestamp(uint _timestamp) external onlyOwner {
}
function onERC1155Received(address operator, address from, uint256 id, uint256 value, bytes calldata data) external override returns (bytes4) {
}
function onERC1155BatchReceived(address operator, address from, uint256[] memory ids, uint256[] memory values, bytes calldata data) external override returns (bytes4) {
}
function uri(uint id) public pure override returns (string memory output){
}
//Treasury multisig rescue function, in case the DAO decides to reuse old Info Tokens. Can potentially mint duds if supply limit is not yet reached, so be careful!
//The original Info Tokens are otherwise unretrievable without this function if deposited into this contract.
function treasuryRescue(uint[] memory _amounts, uint[] memory _versions) external onlyOwner {
for(uint i = 0; i < _versions.length; i++) {
require(<FILL_ME>)
if(_versions[i] == 1) {
IERC1155(Rarible).safeTransferFrom(address(this), owner(), oldinfotokenv1, _amounts[i], "0x");
}
if(_versions[i] == 2) {
IERC1155(Rarible).safeTransferFrom(address(this), owner(), oldinfotokenv2, _amounts[i], "0x");
}
}
}
}
| _versions[i]==1||_versions[i]==2,"You must use '1' for Information Token v1 and '2' for Information Token v2 in version argument." | 337,305 | _versions[i]==1||_versions[i]==2 |
Errors.EMPTY_METADATA | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "Ownable.sol";
import "ERC721.sol";
import "ERC721URIStorage.sol";
import "ERC721Enumerable.sol";
import "IERC721TokenAuthor.sol";
import "Errors.sol";
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata URI extension.
*/
contract ThroneNFT is ERC721, ERC721Enumerable, ERC721URIStorage, IERC721TokenAuthor, Ownable {
uint256 internal _lastTokenId;
mapping (uint256 => address) private _tokenAuthor;
string internal _contractURI;
event ContractURISet(string newContractURI);
constructor(address ownerAddress) ERC721("ThroneNFT", "THNNFT") Ownable() {
}
function _baseURI() override(ERC721) internal pure returns(string memory) {
}
function mintWithTokenURI(string memory _tokenIPFSHash) external returns (uint256) {
require(<FILL_ME>)
uint256 tokenId = ++_lastTokenId; // start from 1
address to = _msgSender();
_mint(to, tokenId);
_tokenAuthor[tokenId] = to;
_setTokenURI(tokenId, _tokenIPFSHash);
return tokenId;
}
function burn(uint256 tokenId) external {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenAuthor(uint256 tokenId) external override view returns(address) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function contractURI() external view returns(string memory) {
}
function setContractURI(string memory newContractURI) onlyOwner external {
}
}
| bytes(_tokenIPFSHash).length>0,Errors.EMPTY_METADATA | 337,345 | bytes(_tokenIPFSHash).length>0 |
"Unauthorized access!" | pragma solidity ^0.6.0;
interface IMVDProxy {
function init(address votingTokenAddress, address functionalityProposalManagerAddress, address stateHolderAddress, address functionalityModelsManagerAddress, address functionalitiesManagerAddress, address walletAddress, address doubleProxyAddress) external;
function getDelegates() external view returns(address[] memory);
function getToken() external view returns(address);
function getMVDFunctionalityProposalManagerAddress() external view returns(address);
function getStateHolderAddress() external view returns(address);
function getMVDFunctionalityModelsManagerAddress() external view returns(address);
function getMVDFunctionalitiesManagerAddress() external view returns(address);
function getMVDWalletAddress() external view returns(address);
function getDoubleProxyAddress() external view returns(address);
function setDelegate(uint256 position, address newAddress) external returns(address oldAddress);
function changeProxy(address newAddress, bytes calldata initPayload) external;
function isValidProposal(address proposal) external view returns (bool);
function newProposal(string calldata codeName, bool emergency, address sourceLocation, uint256 sourceLocationId, address location, bool submitable, string calldata methodSignature, string calldata returnParametersJSONArray, bool isInternal, bool needsSender, string calldata replaces) external returns(address proposalAddress);
function startProposal(address proposalAddress) external;
function disableProposal(address proposalAddress) external;
function transfer(address receiver, uint256 value, address token) external;
function transfer721(address receiver, uint256 tokenId, bytes calldata data, bool safe, address token) external;
function flushToWallet(address tokenAddress, bool is721, uint256 tokenId) external;
function setProposal() external;
function read(string calldata codeName, bytes calldata data) external view returns(bytes memory returnData);
function submit(string calldata codeName, bytes calldata data) external payable returns(bytes memory returnData);
function callFromManager(address location, bytes calldata payload) external returns(bool, bytes memory);
function emitFromManager(string calldata codeName, address proposal, string calldata replaced, address replacedSourceLocation, uint256 replacedSourceLocationId, address location, bool submitable, string calldata methodSignature, bool isInternal, bool needsSender, address proposalAddress) external;
function emitEvent(string calldata eventSignature, bytes calldata firstIndex, bytes calldata secondIndex, bytes calldata data) external;
event ProxyChanged(address indexed newAddress);
event DelegateChanged(uint256 position, address indexed oldAddress, address indexed newAddress);
event Proposal(address proposal);
event ProposalCheck(address indexed proposal);
event ProposalSet(address indexed proposal, bool success);
event FunctionalitySet(string codeName, address indexed proposal, string replaced, address replacedSourceLocation, uint256 replacedSourceLocationId, address indexed replacedLocation, bool replacedWasSubmitable, string replacedMethodSignature, bool replacedWasInternal, bool replacedNeededSender, address indexed replacedProposal);
event Event(string indexed key, bytes32 indexed firstIndex, bytes32 indexed secondIndex, bytes data);
}
interface IERC20 {
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);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IVotingToken {
function init(string calldata name, string calldata symbol, uint256 decimals, uint256 totalSupply) external;
function getProxy() external view returns (address);
function setProxy() external;
function name() external view returns(string memory);
function symbol() external view returns(string memory);
function decimals() external view returns(uint256);
function mint(uint256 amount) external;
function burn(uint256 amount) external;
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
}
interface IMVDFunctionalityProposalManager {
function newProposal(string calldata codeName, address location, string calldata methodSignature, string calldata returnAbiParametersArray, string calldata replaces) external returns(address);
function checkProposal(address proposalAddress) external;
function getProxy() external view returns (address);
function setProxy() external;
function isValidProposal(address proposal) external view returns (bool);
}
interface IMVDFunctionalitiesManager {
function getProxy() external view returns (address);
function setProxy() external;
function init(address sourceLocation,
uint256 getMinimumBlockNumberSourceLocationId, address getMinimumBlockNumberFunctionalityAddress,
uint256 getEmergencyMinimumBlockNumberSourceLocationId, address getEmergencyMinimumBlockNumberFunctionalityAddress,
uint256 getEmergencySurveyStakingSourceLocationId, address getEmergencySurveyStakingFunctionalityAddress,
uint256 checkVoteResultSourceLocationId, address checkVoteResultFunctionalityAddress) external;
function addFunctionality(string calldata codeName, address sourceLocation, uint256 sourceLocationId, address location, bool submitable, string calldata methodSignature, string calldata returnAbiParametersArray, bool isInternal, bool needsSender) external;
function addFunctionality(string calldata codeName, address sourceLocation, uint256 sourceLocationId, address location, bool submitable, string calldata methodSignature, string calldata returnAbiParametersArray, bool isInternal, bool needsSender, uint256 position) external;
function removeFunctionality(string calldata codeName) external returns(bool removed, uint256 position);
function isValidFunctionality(address functionality) external view returns(bool);
function isAuthorizedFunctionality(address functionality) external view returns(bool);
function setCallingContext(address location) external returns(bool);
function clearCallingContext() external;
function getFunctionalityData(string calldata codeName) external view returns(address, uint256, string memory, address, uint256);
function hasFunctionality(string calldata codeName) external view returns(bool);
function getFunctionalitiesAmount() external view returns(uint256);
function functionalitiesToJSON() external view returns(string memory);
function functionalitiesToJSON(uint256 start, uint256 l) external view returns(string memory functionsJSONArray);
function functionalityNames() external view returns(string memory);
function functionalityNames(uint256 start, uint256 l) external view returns(string memory functionsJSONArray);
function functionalityToJSON(string calldata codeName) external view returns(string memory);
function preConditionCheck(string calldata codeName, bytes calldata data, uint8 submitable, address sender, uint256 value) external view returns(address location, bytes memory payload);
function setupFunctionality(address proposalAddress) external returns (bool);
}
contract VotingToken is IERC20, IVotingToken {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint256 private _decimals;
address private _proxy;
string private _name;
string private _symbol;
constructor(string memory name, string memory symbol, uint256 decimals, uint256 totalSupply) public {
}
function init(string memory name, string memory symbol, uint256 decimals, uint256 totalSupply) public override {
}
receive() external payable {
}
function getProxy() public override view returns(address) {
}
function name() public override view returns(string memory) {
}
function symbol() public override view returns(string memory) {
}
function decimals() public override view returns(uint256) {
}
function totalSupply() public override view returns (uint256) {
}
function balanceOf(address account) public override view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public override view returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public override returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256 c) {
}
function setProxy() public override {
}
function mint(uint256 amount) public override {
require(<FILL_ME>)
_totalSupply = add(_totalSupply, amount);
_balances[_proxy] = add(_balances[_proxy], amount);
emit Transfer(address(0), _proxy, amount);
}
function burn(uint256 amount) public override {
}
}
| IMVDFunctionalitiesManager(IMVDProxy(_proxy).getMVDFunctionalitiesManagerAddress()).isAuthorizedFunctionality(msg.sender),"Unauthorized access!" | 337,364 | IMVDFunctionalitiesManager(IMVDProxy(_proxy).getMVDFunctionalitiesManagerAddress()).isAuthorizedFunctionality(msg.sender) |
'Buy the previous level' | /*
CONTRACT DEPLOYED FOR VALIDATION 2020-05-27
HEXRUN.NETWORK
WEBSITE URL: https://hexrun.network/
*/
pragma solidity 0.5.11;
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract hexrun {
IERC20 public hexTokenInterface;
address public hexTokenAddress = 0x2b591e99afE9f32eAA6214f7B7629768c40Eeb39;
address public ownerWallet;
struct UserStruct {
bool isExist;
uint id;
uint referrerID;
address[] referral;
mapping(uint => uint) levelExpired;
}
uint REFERRER_1_LEVEL_LIMIT = 2;
uint PERIOD_LENGTH = 30 days;
mapping(uint => uint) public LEVEL_PRICE;
mapping (address => UserStruct) public users;
mapping (uint => address) public userList;
uint public currUserID = 0;
uint public totalHex = 0;
event regLevelEvent(address indexed _user, address indexed _referrer, uint _time);
event buyLevelEvent(address indexed _user, uint _level, uint _time);
event prolongateLevelEvent(address indexed _user, uint _level, uint _time);
event getMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time);
event lostMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time);
constructor() public {
}
function regUser(uint _referrerID, uint _numHex) public {
}
function buyLevel(uint _level, uint _numHex) public {
require(users[msg.sender].isExist, 'User not exist');
require(_level > 0 && _level <= 10, 'Incorrect level');
hexTokenInterface.transferFrom(msg.sender, address(this), _numHex);
if(_level == 1) {
require(_numHex == LEVEL_PRICE[1], 'Incorrect Value');
users[msg.sender].levelExpired[1] += PERIOD_LENGTH;
}
else {
require(_numHex == LEVEL_PRICE[_level], 'Incorrect Value');
for(uint l =_level - 1; l > 0; l--) require(<FILL_ME>)
if(users[msg.sender].levelExpired[_level] == 0) users[msg.sender].levelExpired[_level] = now + PERIOD_LENGTH;
else users[msg.sender].levelExpired[_level] += PERIOD_LENGTH;
}
payForLevel(_level, msg.sender);
emit buyLevelEvent(msg.sender, _level, now);
}
function payForLevel(uint _level, address _user) internal {
}
function findFreeReferrer(address _user) public view returns(address) {
}
function viewLevelStats() public view returns(uint[10] memory lvlUserCount) {
}
function viewUserReferral(address _user) public view returns(address[] memory) {
}
function viewUserLevelExpired(address _user, uint _level) public view returns(uint) {
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
}
| users[msg.sender].levelExpired[l]>=now,'Buy the previous level' | 337,370 | users[msg.sender].levelExpired[l]>=now |
null | pragma solidity ^0.4.18;
contract KimAccessControl {
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cfoAddress;
address public cooAddress;
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
}
/// @dev Access modifier for CFO-only functionality
modifier onlyCFO() {
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) external onlyCEO {
}
/// @dev Assigns a new address to act as the CFO. Only available to the current CEO.
/// @param _newCFO The address of the new CFO
function setCFO(address _newCFO) external onlyCEO {
}
/// @dev Assigns a new address to act as the COO. Only available to the current CEO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) external onlyCEO {
}
}
contract KimContract is KimAccessControl{
// DECLARING BASIC VARIABLES, TOKEN SYMBOLS, AND CONSTANTS
// Public variables of the token
string public name;
string public symbol;
// total supply of kims ever to be in circulation
uint256 public totalSupply;
// Total Kims "released" into the market
uint256 public kimsCreated;
// Total Kims on sale at any given time
uint256 public kimsOnAuction;
// This is the cut each seller will take on the sale of a KIM
uint256 public sellerCut;
// A variable to house mathematic function used in _computeCut function
uint constant feeDivisor = 100;
// Map an owners address to the total amount of KIMS that they own
mapping (address => uint256) public balanceOf;
// Map the KIM to the owner, "Who owns this Kim?"
mapping (uint => address) public tokenToOwner;
// This creates a mapping of the tokenId to an Auction
mapping (uint256 => TokenAuction) public tokenAuction;
// How much ether does this wallet have to withdraw?
mapping (address => uint) public pendingWithdrawals;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
event TokenAuctionCreated(uint256 tokenIndex, address seller, uint256 sellPrice);
event TokenAuctionCompleted(uint256 tokenIndex, address seller, address buyer, uint256 sellPrice);
event Withdrawal(address to, uint256 amount);
/* Initializes contract with initial supply tokens to the creator of the contract */
function KimContract() public {
}
// contstruct the array struct
struct TokenAuction {
bool isForSale;
uint256 tokenIndex;
address seller;
uint256 sellPrice;
uint256 startedAt;
}
// Only the COO can release new KIMS into the market
// We do not have power over the MAXIMUM amount of KIMS that will exist in the future
// That was declared when we created the contract
// KIMJONGCRYPTO.COM will release KIMS periodically to maintain a healthy market flow
function releaseSomeKims(uint256 howMany) external onlyCOO {
}
// Don't want to keep this KIM?
// Sell KIM then...
function sellToken(uint256 tokenIndex, uint256 sellPrice) public {
// Which KIM are you selling?
TokenAuction storage tokenOnAuction = tokenAuction[tokenIndex];
// Who's selling the KIM, stored into seller variable
address seller = msg.sender;
// Do you own this kim?
require(<FILL_ME>)
// Is the KIM already on sale? Can't sell twice!
require(tokenOnAuction.isForSale == false);
// CLEAR! Send that KIM to Auction!
_tokenAuction(tokenIndex, seller, sellPrice);
}
// INTERNAL FUNCTION, USED ONLY FROM WITHIN THE CONTRACT
function _tokenAuction(uint256 tokenIndex, address seller, uint256 sellPrice) internal {
}
// Like a KIM?
// BUY IT!
function buyKim(uint256 tokenIndex) public payable {
}
// INTERNAL FUNCTION, USED ONLY FROM WITHIN THE CONTRACT
function _completeAuction(uint256 tokenIndex, address seller, address buyer, uint256 sellPrice) internal {
}
// Don't want to sell KIM anymore?
// Cancel Auction
function cancelKimAuction(uint kimIndex) public {
}
// INTERNAL FUNCTION, USED ONLY FROM WITHIN THE CONTRACT
// Use this function to find out how much the AuctionHouse will take from this Transaction
// All funds go to KIMJONGCRYPTO BCD(BLOCKCHAIN DEVS)!
function _computeCut(uint256 sellPrice) internal view returns (uint) {
}
// INTERNAL FUNCTION, USED ONLY FROM WITHIN THE CONTRACT
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
// Go ahead and give away a KIM as a gift!
function transfer(address _to, uint256 _value) public {
}
// this function returns bool of owenrship over the token.
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
}
// How much are KIMS really going for now a days?
// Run this function and find out!
function averageKimSalePrice() public view returns (uint256) {
}
// this function serves for users to withdraw their ethereum
function withdraw() {
}
// @dev Allows the CFO to capture the balance available to the contract.
function withdrawBalance() external onlyCFO {
}
}
| _owns(seller,tokenIndex) | 337,400 | _owns(seller,tokenIndex) |
null | pragma solidity ^0.4.18;
contract KimAccessControl {
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cfoAddress;
address public cooAddress;
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
}
/// @dev Access modifier for CFO-only functionality
modifier onlyCFO() {
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) external onlyCEO {
}
/// @dev Assigns a new address to act as the CFO. Only available to the current CEO.
/// @param _newCFO The address of the new CFO
function setCFO(address _newCFO) external onlyCEO {
}
/// @dev Assigns a new address to act as the COO. Only available to the current CEO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) external onlyCEO {
}
}
contract KimContract is KimAccessControl{
// DECLARING BASIC VARIABLES, TOKEN SYMBOLS, AND CONSTANTS
// Public variables of the token
string public name;
string public symbol;
// total supply of kims ever to be in circulation
uint256 public totalSupply;
// Total Kims "released" into the market
uint256 public kimsCreated;
// Total Kims on sale at any given time
uint256 public kimsOnAuction;
// This is the cut each seller will take on the sale of a KIM
uint256 public sellerCut;
// A variable to house mathematic function used in _computeCut function
uint constant feeDivisor = 100;
// Map an owners address to the total amount of KIMS that they own
mapping (address => uint256) public balanceOf;
// Map the KIM to the owner, "Who owns this Kim?"
mapping (uint => address) public tokenToOwner;
// This creates a mapping of the tokenId to an Auction
mapping (uint256 => TokenAuction) public tokenAuction;
// How much ether does this wallet have to withdraw?
mapping (address => uint) public pendingWithdrawals;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
event TokenAuctionCreated(uint256 tokenIndex, address seller, uint256 sellPrice);
event TokenAuctionCompleted(uint256 tokenIndex, address seller, address buyer, uint256 sellPrice);
event Withdrawal(address to, uint256 amount);
/* Initializes contract with initial supply tokens to the creator of the contract */
function KimContract() public {
}
// contstruct the array struct
struct TokenAuction {
bool isForSale;
uint256 tokenIndex;
address seller;
uint256 sellPrice;
uint256 startedAt;
}
// Only the COO can release new KIMS into the market
// We do not have power over the MAXIMUM amount of KIMS that will exist in the future
// That was declared when we created the contract
// KIMJONGCRYPTO.COM will release KIMS periodically to maintain a healthy market flow
function releaseSomeKims(uint256 howMany) external onlyCOO {
}
// Don't want to keep this KIM?
// Sell KIM then...
function sellToken(uint256 tokenIndex, uint256 sellPrice) public {
}
// INTERNAL FUNCTION, USED ONLY FROM WITHIN THE CONTRACT
function _tokenAuction(uint256 tokenIndex, address seller, uint256 sellPrice) internal {
}
// Like a KIM?
// BUY IT!
function buyKim(uint256 tokenIndex) public payable {
}
// INTERNAL FUNCTION, USED ONLY FROM WITHIN THE CONTRACT
function _completeAuction(uint256 tokenIndex, address seller, address buyer, uint256 sellPrice) internal {
}
// Don't want to sell KIM anymore?
// Cancel Auction
function cancelKimAuction(uint kimIndex) public {
require(<FILL_ME>)
// Store the KIM in question into tokenOnAuction variable
TokenAuction storage tokenOnAuction = tokenAuction[kimIndex];
// Is the KIM even on sale? No monkey business!
require(tokenOnAuction.isForSale == true);
// Close the Auction
tokenAuction[kimIndex] = TokenAuction(false, kimIndex, 0, 0, 0);
}
// INTERNAL FUNCTION, USED ONLY FROM WITHIN THE CONTRACT
// Use this function to find out how much the AuctionHouse will take from this Transaction
// All funds go to KIMJONGCRYPTO BCD(BLOCKCHAIN DEVS)!
function _computeCut(uint256 sellPrice) internal view returns (uint) {
}
// INTERNAL FUNCTION, USED ONLY FROM WITHIN THE CONTRACT
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
// Go ahead and give away a KIM as a gift!
function transfer(address _to, uint256 _value) public {
}
// this function returns bool of owenrship over the token.
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
}
// How much are KIMS really going for now a days?
// Run this function and find out!
function averageKimSalePrice() public view returns (uint256) {
}
// this function serves for users to withdraw their ethereum
function withdraw() {
}
// @dev Allows the CFO to capture the balance available to the contract.
function withdrawBalance() external onlyCFO {
}
}
| _owns(msg.sender,kimIndex) | 337,400 | _owns(msg.sender,kimIndex) |
null | pragma solidity ^0.4.18;
contract KimAccessControl {
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cfoAddress;
address public cooAddress;
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
}
/// @dev Access modifier for CFO-only functionality
modifier onlyCFO() {
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) external onlyCEO {
}
/// @dev Assigns a new address to act as the CFO. Only available to the current CEO.
/// @param _newCFO The address of the new CFO
function setCFO(address _newCFO) external onlyCEO {
}
/// @dev Assigns a new address to act as the COO. Only available to the current CEO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) external onlyCEO {
}
}
contract KimContract is KimAccessControl{
// DECLARING BASIC VARIABLES, TOKEN SYMBOLS, AND CONSTANTS
// Public variables of the token
string public name;
string public symbol;
// total supply of kims ever to be in circulation
uint256 public totalSupply;
// Total Kims "released" into the market
uint256 public kimsCreated;
// Total Kims on sale at any given time
uint256 public kimsOnAuction;
// This is the cut each seller will take on the sale of a KIM
uint256 public sellerCut;
// A variable to house mathematic function used in _computeCut function
uint constant feeDivisor = 100;
// Map an owners address to the total amount of KIMS that they own
mapping (address => uint256) public balanceOf;
// Map the KIM to the owner, "Who owns this Kim?"
mapping (uint => address) public tokenToOwner;
// This creates a mapping of the tokenId to an Auction
mapping (uint256 => TokenAuction) public tokenAuction;
// How much ether does this wallet have to withdraw?
mapping (address => uint) public pendingWithdrawals;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
event TokenAuctionCreated(uint256 tokenIndex, address seller, uint256 sellPrice);
event TokenAuctionCompleted(uint256 tokenIndex, address seller, address buyer, uint256 sellPrice);
event Withdrawal(address to, uint256 amount);
/* Initializes contract with initial supply tokens to the creator of the contract */
function KimContract() public {
}
// contstruct the array struct
struct TokenAuction {
bool isForSale;
uint256 tokenIndex;
address seller;
uint256 sellPrice;
uint256 startedAt;
}
// Only the COO can release new KIMS into the market
// We do not have power over the MAXIMUM amount of KIMS that will exist in the future
// That was declared when we created the contract
// KIMJONGCRYPTO.COM will release KIMS periodically to maintain a healthy market flow
function releaseSomeKims(uint256 howMany) external onlyCOO {
}
// Don't want to keep this KIM?
// Sell KIM then...
function sellToken(uint256 tokenIndex, uint256 sellPrice) public {
}
// INTERNAL FUNCTION, USED ONLY FROM WITHIN THE CONTRACT
function _tokenAuction(uint256 tokenIndex, address seller, uint256 sellPrice) internal {
}
// Like a KIM?
// BUY IT!
function buyKim(uint256 tokenIndex) public payable {
}
// INTERNAL FUNCTION, USED ONLY FROM WITHIN THE CONTRACT
function _completeAuction(uint256 tokenIndex, address seller, address buyer, uint256 sellPrice) internal {
}
// Don't want to sell KIM anymore?
// Cancel Auction
function cancelKimAuction(uint kimIndex) public {
}
// INTERNAL FUNCTION, USED ONLY FROM WITHIN THE CONTRACT
// Use this function to find out how much the AuctionHouse will take from this Transaction
// All funds go to KIMJONGCRYPTO BCD(BLOCKCHAIN DEVS)!
function _computeCut(uint256 sellPrice) internal view returns (uint) {
}
// INTERNAL FUNCTION, USED ONLY FROM WITHIN THE CONTRACT
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
// Go ahead and give away a KIM as a gift!
function transfer(address _to, uint256 _value) public {
require(<FILL_ME>)
_transfer(msg.sender, _to, _value);
}
// this function returns bool of owenrship over the token.
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
}
// How much are KIMS really going for now a days?
// Run this function and find out!
function averageKimSalePrice() public view returns (uint256) {
}
// this function serves for users to withdraw their ethereum
function withdraw() {
}
// @dev Allows the CFO to capture the balance available to the contract.
function withdrawBalance() external onlyCFO {
}
}
| _owns(msg.sender,_value) | 337,400 | _owns(msg.sender,_value) |
"governance address is zero" | pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
abstract contract AuthHub is Ownable {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
// controller 合约地址
address public controller;
// 冶理地址
address public governance;
//自动触发收益匹配
bool public paused = false;
constructor() public {
}
modifier notPause() {
}
function checkGovernance() virtual public view {
}
function checkController() public view {
}
// 设置权限控制合约
function setGovernance(address _governance) public {
require(<FILL_ME>)
checkGovernance();
governance = _governance;
}
function setController(address _controller) public {
}
function setPause() public {
}
// 提现转任意erc20
function inCaseTokensGetStuck(address account, address _token, uint _amount) public {
}
}
// Info of each user.
struct UserInfo {
// 用户本金
uint256 amount;
// 用户负债
uint256 mdxDebt;
// cow负债
uint cowDebt;
//用户最大收益 0 不限制
uint256 mdxProfit;
uint256 cowProfit;
//用户未提收益
uint256 mdxReward;
uint256 cowReward;
}
// 每个池子的信息
struct PoolInfo {
// 用户质押币种
IERC20 token;
// 上一次结算收益的块高
uint256 lastRewardBlock;
// 上一次结算的用户总收益占比
uint256 accMdxPerShare;
// 上一次结算累计的mdx收益
uint256 accMdxShare;
// 所有用户质押总数量
uint256 totalAmount;
// 所有用户质押总数量上限，0表示不限
uint256 totalAmountLimit;
//cow 收益数据
uint256 accCowPerShare;
// cow累计收益
uint256 accCowShare;
//每个块奖励cow
uint256 blockCowReward;
//每个块奖励mdx
uint256 blockMdxReward;
// 预留备付金
uint256 earnLowerlimit;
}
interface IERC20Full is IERC20 {
function decimals() external view returns (uint8);
}
interface IHubPoolExtend {
function deposit(uint _pid, uint _amount, address user) external;
function withdraw(uint _pid, uint _amount, address user) external returns (uint);
function emergencyWithdraw(uint _pid, uint _amount, address user) external returns (uint);
}
interface IStrategy {
function balanceOf() external view returns (uint);
function balanceOfToken(address token) external view returns (uint);
function paused() external returns(bool);
function want() external view returns (address, address);
function contain(address) external view returns (bool);
function deposit() external;
function withdraw(address, uint) external returns (uint);
function withdrawAll() external returns (uint);
function withdrawMDXReward() external returns (uint, uint);
function governance()external view returns (address) ;
function owner()external view returns (address) ;
function pid()external view returns (uint);
function strategyName() external view returns (string memory) ;
function burnNFTToken() external;
function mitNFTToken(uint24 fee, int24 tickLower, int24 tickUpper) external;
function mitNFTTokenWithPriceA(uint24 fee, uint priceLower, uint priceUpper) external;
function getAmount() external view returns (uint128, uint, uint);
function historyRewardA() external view returns (uint);
function historyRewardB() external view returns (uint);
function getPool() external view returns (address);
function positionManager() external view returns (address);
}
interface IHubPool {
function earn(address token) external;
function poolLength() external view returns (uint256);
function poolInfo(uint index) view external returns (PoolInfo memory);
function TokenOfPid(address token) view external returns (uint);
function controller() view external returns (address);
function governance() view external returns (address) ;
function owner()external view returns (address) ;
function getPoolId(address token) external view returns (uint256) ;
function pending(uint256 _pid, address _user) external view returns (uint256, uint256);
function pendingCow(uint256 _pid, address _user) external view returns (uint256);
function getMdxBlockReward(address token) external view returns (uint256);
function userInfo(uint pid, address user) external view returns (UserInfo memory);
function withdraw(address token, uint amount) external ;
function deposit(address token, uint amount) external ;
function available(address token) view external returns (uint);
function withdrawAll(address token) external;
function depositAll(address token) external;
function withdrawWithPid(uint256 pid, uint256 amount) external;
function getApy(address token) external view returns (uint256);
function getCowApy(address token) external view returns (uint256);
function userTotalCowProfit() external view returns (uint256);
function userTotalProfit() external view returns (uint256);
function getBlockReward (uint pid) external view returns (uint256, uint256);
}
interface IController {
// 释放投资本金，用于提现
function withdrawLp(address token, uint _amount) external;
// 触发投资
function earn(address token) external;
// 触发发收益
function withdrawPending(address token, address user, uint256 userPending, uint256 govPending) external;
// 获取策略
function strategyLength() external view returns (uint) ;
function strategieList(uint id) external view returns (address) ;
function governance() external view returns (address) ;
function mdxToken() external view returns (address) ;
function owner() external view returns (address) ;
function vaults() external view returns (address) ;
function rewardAccount() external view returns (address) ;
function sid(address _strategy) external view returns (uint);
}
| address(0)!=_governance,"governance address is zero" | 337,640 | address(0)!=_governance |
"account address is zero" | pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
abstract contract AuthHub is Ownable {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
// controller 合约地址
address public controller;
// 冶理地址
address public governance;
//自动触发收益匹配
bool public paused = false;
constructor() public {
}
modifier notPause() {
}
function checkGovernance() virtual public view {
}
function checkController() public view {
}
// 设置权限控制合约
function setGovernance(address _governance) public {
}
function setController(address _controller) public {
}
function setPause() public {
}
// 提现转任意erc20
function inCaseTokensGetStuck(address account, address _token, uint _amount) public {
require(<FILL_ME>)
checkGovernance();
IERC20(_token).safeTransfer(account, _amount);
}
}
// Info of each user.
struct UserInfo {
// 用户本金
uint256 amount;
// 用户负债
uint256 mdxDebt;
// cow负债
uint cowDebt;
//用户最大收益 0 不限制
uint256 mdxProfit;
uint256 cowProfit;
//用户未提收益
uint256 mdxReward;
uint256 cowReward;
}
// 每个池子的信息
struct PoolInfo {
// 用户质押币种
IERC20 token;
// 上一次结算收益的块高
uint256 lastRewardBlock;
// 上一次结算的用户总收益占比
uint256 accMdxPerShare;
// 上一次结算累计的mdx收益
uint256 accMdxShare;
// 所有用户质押总数量
uint256 totalAmount;
// 所有用户质押总数量上限，0表示不限
uint256 totalAmountLimit;
//cow 收益数据
uint256 accCowPerShare;
// cow累计收益
uint256 accCowShare;
//每个块奖励cow
uint256 blockCowReward;
//每个块奖励mdx
uint256 blockMdxReward;
// 预留备付金
uint256 earnLowerlimit;
}
interface IERC20Full is IERC20 {
function decimals() external view returns (uint8);
}
interface IHubPoolExtend {
function deposit(uint _pid, uint _amount, address user) external;
function withdraw(uint _pid, uint _amount, address user) external returns (uint);
function emergencyWithdraw(uint _pid, uint _amount, address user) external returns (uint);
}
interface IStrategy {
function balanceOf() external view returns (uint);
function balanceOfToken(address token) external view returns (uint);
function paused() external returns(bool);
function want() external view returns (address, address);
function contain(address) external view returns (bool);
function deposit() external;
function withdraw(address, uint) external returns (uint);
function withdrawAll() external returns (uint);
function withdrawMDXReward() external returns (uint, uint);
function governance()external view returns (address) ;
function owner()external view returns (address) ;
function pid()external view returns (uint);
function strategyName() external view returns (string memory) ;
function burnNFTToken() external;
function mitNFTToken(uint24 fee, int24 tickLower, int24 tickUpper) external;
function mitNFTTokenWithPriceA(uint24 fee, uint priceLower, uint priceUpper) external;
function getAmount() external view returns (uint128, uint, uint);
function historyRewardA() external view returns (uint);
function historyRewardB() external view returns (uint);
function getPool() external view returns (address);
function positionManager() external view returns (address);
}
interface IHubPool {
function earn(address token) external;
function poolLength() external view returns (uint256);
function poolInfo(uint index) view external returns (PoolInfo memory);
function TokenOfPid(address token) view external returns (uint);
function controller() view external returns (address);
function governance() view external returns (address) ;
function owner()external view returns (address) ;
function getPoolId(address token) external view returns (uint256) ;
function pending(uint256 _pid, address _user) external view returns (uint256, uint256);
function pendingCow(uint256 _pid, address _user) external view returns (uint256);
function getMdxBlockReward(address token) external view returns (uint256);
function userInfo(uint pid, address user) external view returns (UserInfo memory);
function withdraw(address token, uint amount) external ;
function deposit(address token, uint amount) external ;
function available(address token) view external returns (uint);
function withdrawAll(address token) external;
function depositAll(address token) external;
function withdrawWithPid(uint256 pid, uint256 amount) external;
function getApy(address token) external view returns (uint256);
function getCowApy(address token) external view returns (uint256);
function userTotalCowProfit() external view returns (uint256);
function userTotalProfit() external view returns (uint256);
function getBlockReward (uint pid) external view returns (uint256, uint256);
}
interface IController {
// 释放投资本金，用于提现
function withdrawLp(address token, uint _amount) external;
// 触发投资
function earn(address token) external;
// 触发发收益
function withdrawPending(address token, address user, uint256 userPending, uint256 govPending) external;
// 获取策略
function strategyLength() external view returns (uint) ;
function strategieList(uint id) external view returns (address) ;
function governance() external view returns (address) ;
function mdxToken() external view returns (address) ;
function owner() external view returns (address) ;
function vaults() external view returns (address) ;
function rewardAccount() external view returns (address) ;
function sid(address _strategy) external view returns (uint);
}
| address(0)!=account,"account address is zero" | 337,640 | address(0)!=account |
'NameWrapper: Fuse already burned for transferring owner' | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/utils/introspection/ERC165.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import '@openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol';
import '@openzeppelin/contracts/utils/Address.sol';
/* This contract is a variation on ERC1155 with the additions of _setData, getData and _canTransfer and ownerOf. _setData and getData allows the use of the other 96 bits next to the address of the owner for extra data. We use this to store 'fuses' that control permissions that can be burnt. */
abstract contract ERC1155Fuse is ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
mapping(uint256 => uint256) public _tokens;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**************************************************************************
* ERC721 methods
*************************************************************************/
function ownerOf(uint256 id) public view returns (address) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
/**
* @dev See {IERC1155-balanceOf}.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(address account, uint256 id)
public
view
virtual
override
returns (uint256)
{
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator)
public
view
virtual
override
returns (bool)
{
}
/**
* @dev Returns the Name's owner address and fuses
*/
function getData(uint256 tokenId)
public
view
returns (address owner, uint96 fuses)
{
}
/**
* @dev Sets the Name's owner address and fuses
*/
function _setData(
uint256 tokenId,
address owner,
uint96 fuses
) internal virtual {
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(to != address(0), 'ERC1155: transfer to the zero address');
require(
from == msg.sender || isApprovedForAll(from, msg.sender),
'ERC1155: caller is not owner nor approved'
);
(address oldOwner, uint96 fuses) = getData(id);
require(<FILL_ME>)
require(
amount == 1 && oldOwner == from,
'ERC1155: insufficient balance for transfer'
);
_setData(id, to, fuses);
emit TransferSingle(msg.sender, from, to, id, amount);
_doSafeTransferAcceptanceCheck(msg.sender, from, to, id, amount, data);
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
}
/**************************************************************************
* Internal/private methods
*************************************************************************/
function _canTransfer(uint96 fuses) internal virtual returns (bool);
function _mint(
bytes32 node,
address newOwner,
uint96 _fuses
) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
}
}
| _canTransfer(fuses),'NameWrapper: Fuse already burned for transferring owner' | 337,661 | _canTransfer(fuses) |
null | /*
Copyright 2017 ZeroEx Intl.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity 0.4.10;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract MultiSigWallet {
uint constant public MAX_OWNER_COUNT = 50;
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
}
modifier ownerDoesNotExist(address owner) {
}
modifier ownerExists(address owner) {
}
modifier transactionExists(uint transactionId) {
}
modifier confirmed(uint transactionId, address owner) {
}
modifier notConfirmed(uint transactionId, address owner) {
}
modifier notExecuted(uint transactionId) {
}
modifier notNull(address _address) {
}
modifier validRequirement(uint ownerCount, uint _required) {
}
/// @dev Fallback function allows to deposit ether.
function()
payable
{
}
/*
* Public functions
*/
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
function MultiSigWallet(address[] _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner.
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner.
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
{
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param owner Address of new owner.
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination, uint value, bytes data)
public
returns (uint transactionId)
{
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint transactionId)
public
constant
returns (bool)
{
}
/*
* Internal functions
*/
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
}
/*
* Web3 call functions
*/
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners()
public
constant
returns (address[])
{
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
constant
returns (uint[] _transactionIds)
{
}
}
/// @title Multisignature wallet with time lock- Allows multiple parties to execute a transaction after a time lock has passed.
/// @author Amir Bandeali - <[email protected]>
contract MultiSigWalletWithTimeLock is MultiSigWallet {
event ConfirmationTimeSet(uint indexed transactionId, uint confirmationTime);
event TimeLockChange(uint secondsTimeLocked);
uint public secondsTimeLocked;
mapping (uint => uint) public confirmationTimes;
modifier notFullyConfirmed(uint transactionId) {
require(<FILL_ME>)
_;
}
modifier fullyConfirmed(uint transactionId) {
}
modifier pastTimeLock(uint transactionId) {
}
/*
* Public functions
*/
/// @dev Contract constructor sets initial owners, required number of confirmations, and time lock.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
/// @param _secondsTimeLocked Duration needed after a transaction is confirmed and before it becomes executable, in seconds.
function MultiSigWalletWithTimeLock(address[] _owners, uint _required, uint _secondsTimeLocked)
public
MultiSigWallet(_owners, _required)
{
}
/// @dev Changes the duration of the time lock for transactions.
/// @param _secondsTimeLocked Duration needed after a transaction is confirmed and before it becomes executable, in seconds.
function changeTimeLock(uint _secondsTimeLocked)
public
onlyWallet
{
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
notFullyConfirmed(transactionId)
{
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
notFullyConfirmed(transactionId)
{
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
fullyConfirmed(transactionId)
pastTimeLock(transactionId)
{
}
/*
* Internal functions
*/
/// @dev Sets the time of when a submission first passed.
function setConfirmationTime(uint transactionId, uint confirmationTime)
internal
{
}
}
contract MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress is MultiSigWalletWithTimeLock {
address public TOKEN_TRANSFER_PROXY_CONTRACT;
modifier validRemoveAuthorizedAddressTx(uint transactionId) {
}
/// @dev Contract constructor sets initial owners, required number of confirmations, time lock, and tokenTransferProxy address.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
/// @param _secondsTimeLocked Duration needed after a transaction is confirmed and before it becomes executable, in seconds.
/// @param _tokenTransferProxy Address of TokenTransferProxy contract.
function MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress(
address[] _owners,
uint _required,
uint _secondsTimeLocked,
address _tokenTransferProxy)
public
MultiSigWalletWithTimeLock(_owners, _required, _secondsTimeLocked)
{
}
/// @dev Allows execution of removeAuthorizedAddress without time lock.
/// @param transactionId Transaction ID.
function executeRemoveAuthorizedAddress(uint transactionId)
public
notExecuted(transactionId)
fullyConfirmed(transactionId)
validRemoveAuthorizedAddressTx(transactionId)
{
}
/// @dev Compares first 4 bytes of byte array to removeAuthorizedAddress function signature.
/// @param data Transaction data.
/// @return Successful if data is a call to removeAuthorizedAddress.
function isFunctionRemoveAuthorizedAddress(bytes data)
public
constant
returns (bool)
{
}
}
| !isConfirmed(transactionId) | 337,747 | !isConfirmed(transactionId) |
null | /*
Copyright 2017 ZeroEx Intl.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity 0.4.10;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract MultiSigWallet {
uint constant public MAX_OWNER_COUNT = 50;
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
}
modifier ownerDoesNotExist(address owner) {
}
modifier ownerExists(address owner) {
}
modifier transactionExists(uint transactionId) {
}
modifier confirmed(uint transactionId, address owner) {
}
modifier notConfirmed(uint transactionId, address owner) {
}
modifier notExecuted(uint transactionId) {
}
modifier notNull(address _address) {
}
modifier validRequirement(uint ownerCount, uint _required) {
}
/// @dev Fallback function allows to deposit ether.
function()
payable
{
}
/*
* Public functions
*/
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
function MultiSigWallet(address[] _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner.
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner.
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
{
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param owner Address of new owner.
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination, uint value, bytes data)
public
returns (uint transactionId)
{
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint transactionId)
public
constant
returns (bool)
{
}
/*
* Internal functions
*/
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
}
/*
* Web3 call functions
*/
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners()
public
constant
returns (address[])
{
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
constant
returns (uint[] _transactionIds)
{
}
}
/// @title Multisignature wallet with time lock- Allows multiple parties to execute a transaction after a time lock has passed.
/// @author Amir Bandeali - <[email protected]>
contract MultiSigWalletWithTimeLock is MultiSigWallet {
event ConfirmationTimeSet(uint indexed transactionId, uint confirmationTime);
event TimeLockChange(uint secondsTimeLocked);
uint public secondsTimeLocked;
mapping (uint => uint) public confirmationTimes;
modifier notFullyConfirmed(uint transactionId) {
}
modifier fullyConfirmed(uint transactionId) {
}
modifier pastTimeLock(uint transactionId) {
}
/*
* Public functions
*/
/// @dev Contract constructor sets initial owners, required number of confirmations, and time lock.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
/// @param _secondsTimeLocked Duration needed after a transaction is confirmed and before it becomes executable, in seconds.
function MultiSigWalletWithTimeLock(address[] _owners, uint _required, uint _secondsTimeLocked)
public
MultiSigWallet(_owners, _required)
{
}
/// @dev Changes the duration of the time lock for transactions.
/// @param _secondsTimeLocked Duration needed after a transaction is confirmed and before it becomes executable, in seconds.
function changeTimeLock(uint _secondsTimeLocked)
public
onlyWallet
{
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
notFullyConfirmed(transactionId)
{
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
notFullyConfirmed(transactionId)
{
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
fullyConfirmed(transactionId)
pastTimeLock(transactionId)
{
}
/*
* Internal functions
*/
/// @dev Sets the time of when a submission first passed.
function setConfirmationTime(uint transactionId, uint confirmationTime)
internal
{
}
}
contract MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress is MultiSigWalletWithTimeLock {
address public TOKEN_TRANSFER_PROXY_CONTRACT;
modifier validRemoveAuthorizedAddressTx(uint transactionId) {
Transaction storage tx = transactions[transactionId];
require(tx.destination == TOKEN_TRANSFER_PROXY_CONTRACT);
require(<FILL_ME>)
_;
}
/// @dev Contract constructor sets initial owners, required number of confirmations, time lock, and tokenTransferProxy address.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
/// @param _secondsTimeLocked Duration needed after a transaction is confirmed and before it becomes executable, in seconds.
/// @param _tokenTransferProxy Address of TokenTransferProxy contract.
function MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress(
address[] _owners,
uint _required,
uint _secondsTimeLocked,
address _tokenTransferProxy)
public
MultiSigWalletWithTimeLock(_owners, _required, _secondsTimeLocked)
{
}
/// @dev Allows execution of removeAuthorizedAddress without time lock.
/// @param transactionId Transaction ID.
function executeRemoveAuthorizedAddress(uint transactionId)
public
notExecuted(transactionId)
fullyConfirmed(transactionId)
validRemoveAuthorizedAddressTx(transactionId)
{
}
/// @dev Compares first 4 bytes of byte array to removeAuthorizedAddress function signature.
/// @param data Transaction data.
/// @return Successful if data is a call to removeAuthorizedAddress.
function isFunctionRemoveAuthorizedAddress(bytes data)
public
constant
returns (bool)
{
}
}
| isFunctionRemoveAuthorizedAddress(tx.data) | 337,747 | isFunctionRemoveAuthorizedAddress(tx.data) |
null | /*
Copyright 2017 ZeroEx Intl.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity 0.4.10;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract MultiSigWallet {
uint constant public MAX_OWNER_COUNT = 50;
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
}
modifier ownerDoesNotExist(address owner) {
}
modifier ownerExists(address owner) {
}
modifier transactionExists(uint transactionId) {
}
modifier confirmed(uint transactionId, address owner) {
}
modifier notConfirmed(uint transactionId, address owner) {
}
modifier notExecuted(uint transactionId) {
}
modifier notNull(address _address) {
}
modifier validRequirement(uint ownerCount, uint _required) {
}
/// @dev Fallback function allows to deposit ether.
function()
payable
{
}
/*
* Public functions
*/
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
function MultiSigWallet(address[] _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner.
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner.
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
{
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param owner Address of new owner.
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination, uint value, bytes data)
public
returns (uint transactionId)
{
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint transactionId)
public
constant
returns (bool)
{
}
/*
* Internal functions
*/
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
}
/*
* Web3 call functions
*/
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners()
public
constant
returns (address[])
{
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
constant
returns (uint[] _transactionIds)
{
}
}
/// @title Multisignature wallet with time lock- Allows multiple parties to execute a transaction after a time lock has passed.
/// @author Amir Bandeali - <[email protected]>
contract MultiSigWalletWithTimeLock is MultiSigWallet {
event ConfirmationTimeSet(uint indexed transactionId, uint confirmationTime);
event TimeLockChange(uint secondsTimeLocked);
uint public secondsTimeLocked;
mapping (uint => uint) public confirmationTimes;
modifier notFullyConfirmed(uint transactionId) {
}
modifier fullyConfirmed(uint transactionId) {
}
modifier pastTimeLock(uint transactionId) {
}
/*
* Public functions
*/
/// @dev Contract constructor sets initial owners, required number of confirmations, and time lock.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
/// @param _secondsTimeLocked Duration needed after a transaction is confirmed and before it becomes executable, in seconds.
function MultiSigWalletWithTimeLock(address[] _owners, uint _required, uint _secondsTimeLocked)
public
MultiSigWallet(_owners, _required)
{
}
/// @dev Changes the duration of the time lock for transactions.
/// @param _secondsTimeLocked Duration needed after a transaction is confirmed and before it becomes executable, in seconds.
function changeTimeLock(uint _secondsTimeLocked)
public
onlyWallet
{
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
notFullyConfirmed(transactionId)
{
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
notFullyConfirmed(transactionId)
{
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
fullyConfirmed(transactionId)
pastTimeLock(transactionId)
{
}
/*
* Internal functions
*/
/// @dev Sets the time of when a submission first passed.
function setConfirmationTime(uint transactionId, uint confirmationTime)
internal
{
}
}
contract MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress is MultiSigWalletWithTimeLock {
address public TOKEN_TRANSFER_PROXY_CONTRACT;
modifier validRemoveAuthorizedAddressTx(uint transactionId) {
}
/// @dev Contract constructor sets initial owners, required number of confirmations, time lock, and tokenTransferProxy address.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
/// @param _secondsTimeLocked Duration needed after a transaction is confirmed and before it becomes executable, in seconds.
/// @param _tokenTransferProxy Address of TokenTransferProxy contract.
function MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress(
address[] _owners,
uint _required,
uint _secondsTimeLocked,
address _tokenTransferProxy)
public
MultiSigWalletWithTimeLock(_owners, _required, _secondsTimeLocked)
{
}
/// @dev Allows execution of removeAuthorizedAddress without time lock.
/// @param transactionId Transaction ID.
function executeRemoveAuthorizedAddress(uint transactionId)
public
notExecuted(transactionId)
fullyConfirmed(transactionId)
validRemoveAuthorizedAddressTx(transactionId)
{
}
/// @dev Compares first 4 bytes of byte array to removeAuthorizedAddress function signature.
/// @param data Transaction data.
/// @return Successful if data is a call to removeAuthorizedAddress.
function isFunctionRemoveAuthorizedAddress(bytes data)
public
constant
returns (bool)
{
bytes4 removeAuthorizedAddressSignature = bytes4(sha3("removeAuthorizedAddress(address)"));
for (uint i = 0; i < 4; i++) {
require(<FILL_ME>)
}
return true;
}
}
| data[i]==removeAuthorizedAddressSignature[i] | 337,747 | data[i]==removeAuthorizedAddressSignature[i] |
"token is not a contract" | pragma solidity ^0.5.0;
/**
* @dev ERC20VestingHub features: only ERC20 tokens, single/multiple vestings per account, linear/step claim
*/
contract ERC20VestingHub is VestingHub {
using SafeERC20 for ERC20;
using Address for address;
uint256 public depositedTokens;
ERC20 public token;
constructor(address _token, uint256 _fixedAmount, uint256 _fixedDuration, bool _multipleVestingAllowed)
public
VestingHub(_fixedAmount, _fixedDuration, _multipleVestingAllowed)
{
require(<FILL_ME>)
token = ERC20(_token);
require(token.totalSupply() >= 0, "wrong token address"); // Verify if the address is a ERC20 token
}
/**
* @dev Create a new vesting for transaction sender.
* @param _id the vesting unique identifier
* @param _label the vesting label assigned to the vesting
* @param _beneficiary the vesting beneficiary
* @param _amount the vesting amount
* @param _duration the vesting duration
* @param _linearClaim the vesting is claimable linearly
*/
function createVesting(
uint256 _id,
bytes32 _label,
address _beneficiary,
uint256 _amount,
uint256 _duration,
bool _linearClaim
) public {
}
/**
* @dev Let the vesting owner receive the claimable amount in ERC20 tokens.
* @param _id the vesting unique identifier
*/
function claimVesting(uint256 _id) public returns (bool success) {
}
/**
* @dev Force the transfer of the specified vesting amount still claimable.
* @param _id the vesting unique identifier
*/
function closeVesting(uint256 _id) public returns (bool success) {
}
/**
* @dev reclaimToken to reclaim also exceeding vested ERC20 tokens.
* @param _token the ERC20 token
*/
function reclaimToken(ERC20 _token) external onlyOwner {
}
}
| address(_token).isContract(),"token is not a contract" | 337,846 | address(_token).isContract() |
"wrong token address" | pragma solidity ^0.5.0;
/**
* @dev ERC20VestingHub features: only ERC20 tokens, single/multiple vestings per account, linear/step claim
*/
contract ERC20VestingHub is VestingHub {
using SafeERC20 for ERC20;
using Address for address;
uint256 public depositedTokens;
ERC20 public token;
constructor(address _token, uint256 _fixedAmount, uint256 _fixedDuration, bool _multipleVestingAllowed)
public
VestingHub(_fixedAmount, _fixedDuration, _multipleVestingAllowed)
{
require(address(_token).isContract(), "token is not a contract");
token = ERC20(_token);
require(<FILL_ME>) // Verify if the address is a ERC20 token
}
/**
* @dev Create a new vesting for transaction sender.
* @param _id the vesting unique identifier
* @param _label the vesting label assigned to the vesting
* @param _beneficiary the vesting beneficiary
* @param _amount the vesting amount
* @param _duration the vesting duration
* @param _linearClaim the vesting is claimable linearly
*/
function createVesting(
uint256 _id,
bytes32 _label,
address _beneficiary,
uint256 _amount,
uint256 _duration,
bool _linearClaim
) public {
}
/**
* @dev Let the vesting owner receive the claimable amount in ERC20 tokens.
* @param _id the vesting unique identifier
*/
function claimVesting(uint256 _id) public returns (bool success) {
}
/**
* @dev Force the transfer of the specified vesting amount still claimable.
* @param _id the vesting unique identifier
*/
function closeVesting(uint256 _id) public returns (bool success) {
}
/**
* @dev reclaimToken to reclaim also exceeding vested ERC20 tokens.
* @param _token the ERC20 token
*/
function reclaimToken(ERC20 _token) external onlyOwner {
}
}
| token.totalSupply()>=0,"wrong token address" | 337,846 | token.totalSupply()>=0 |
null | /**
*Submitted for verification at BscScan.com on 2021-12-01
*/
/**
*Submitted for verification at Etherscan.io on 2021-11-30
*/
pragma solidity >=0.6.0 <0.8.0;
interface MNU20 {
function transfer(address receiver, uint amount) external;
function transferFrom(address _from, address _to, uint256 _value)external;
function balanceOf(address receiver)external returns(uint256);
}
contract NiranaMeta{
address public owner;
address public MNUerc20;
uint256 public price;
uint256 public limit;
mapping(address=>uint256)public users;
modifier onlyOwner() {
}
constructor(address _MNUaddress)public{
}
receive() external payable {}
function EthBuyMnu(uint256 _value)payable public{
require(<FILL_ME>)
uint256 amount=msg.value/price*1 ether;
MNU20(MNUerc20).transfer(msg.sender,amount);
users[msg.sender]=amount;
}
function setPrice(uint256 amount,uint256 _limit) onlyOwner public {
}
function withdraw(address payable addr,uint256 amount) onlyOwner public {
}
function withdrawMNU(address payable addr,uint256 amount) onlyOwner public {
}
function getPrice()public view returns(uint256,uint256){
}
}
| users[msg.sender]<limit | 337,854 | users[msg.sender]<limit |
"too much" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity ^0.8.0;
contract GenAlcLab is ERC721URIStorage, Ownable{
event MintGenApe (address indexed minter, uint256 startWith, uint256 times);
uint256 public totalGenApe;
uint256 public totalCount = 2500; // Total
uint256 public presaleMax = 520;
uint256 public maxBatch = 10; // Batch
uint256 public price = 50000000000000000; // 0.05 eth
string public baseURI;
bool public started;
bool public whiteListStart;
mapping(address => uint256) whiteListMintCount;
uint addressRegistryCount;
constructor(string memory name_, string memory symbol_, string memory baseURI_) ERC721(name_, symbol_) {
}
modifier canWhitelistMint() {
}
modifier mintEnabled() {
}
function totalSupply() public view virtual returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory){
}
function setBaseURI(string memory _newURI) public onlyOwner {
}
function changePrice(uint256 _newPrice) public onlyOwner {
}
function setTokenURI(uint256 _tokenId, string memory _tokenURI) public onlyOwner {
}
function setNormalStart(bool _start) public onlyOwner {
}
function setWhiteListStart(bool _start) public onlyOwner {
}
function getWhitelistMintAmount(address _addr) public view virtual returns (uint256) {
}
function mintKhemKoalas(uint256 _times) payable public mintEnabled {
require(_times >0 && _times <= maxBatch, "mint wrong number");
require(<FILL_ME>)
require(msg.value == _times * price, "value error");
payable(owner()).transfer(msg.value);
emit MintGenApe(_msgSender(), totalGenApe+1, _times);
for(uint256 i=0; i< _times; i++){
_mint(_msgSender(), 1 + totalGenApe++);
}
}
function adminMint(uint256 _times) public onlyOwner {
}
function whitelistMint(uint _times) payable public canWhitelistMint {
}
function adminMintGiveaways(address _addr) public onlyOwner {
}
}
| totalGenApe+_times<=totalCount,"too much" | 337,861 | totalGenApe+_times<=totalCount |
"Over mint limit for address." | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity ^0.8.0;
contract GenAlcLab is ERC721URIStorage, Ownable{
event MintGenApe (address indexed minter, uint256 startWith, uint256 times);
uint256 public totalGenApe;
uint256 public totalCount = 2500; // Total
uint256 public presaleMax = 520;
uint256 public maxBatch = 10; // Batch
uint256 public price = 50000000000000000; // 0.05 eth
string public baseURI;
bool public started;
bool public whiteListStart;
mapping(address => uint256) whiteListMintCount;
uint addressRegistryCount;
constructor(string memory name_, string memory symbol_, string memory baseURI_) ERC721(name_, symbol_) {
}
modifier canWhitelistMint() {
}
modifier mintEnabled() {
}
function totalSupply() public view virtual returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory){
}
function setBaseURI(string memory _newURI) public onlyOwner {
}
function changePrice(uint256 _newPrice) public onlyOwner {
}
function setTokenURI(uint256 _tokenId, string memory _tokenURI) public onlyOwner {
}
function setNormalStart(bool _start) public onlyOwner {
}
function setWhiteListStart(bool _start) public onlyOwner {
}
function getWhitelistMintAmount(address _addr) public view virtual returns (uint256) {
}
function mintKhemKoalas(uint256 _times) payable public mintEnabled {
}
function adminMint(uint256 _times) public onlyOwner {
}
function whitelistMint(uint _times) payable public canWhitelistMint {
if (whiteListMintCount[msg.sender]==0) {
whiteListMintCount[msg.sender] = 4;
}
require(<FILL_ME>)
require(totalGenApe + _times <= presaleMax, "Mint amount will exceed total presale amount.");
require(msg.value == _times * price, "Incorrect transaction value.");
payable(owner()).transfer(msg.value);
whiteListMintCount[_msgSender()] -= _times;
emit MintGenApe(_msgSender(), totalGenApe+1, _times);
for(uint256 i=0; i< _times; i++){
_mint(_msgSender(), 1 + totalGenApe++);
}
}
function adminMintGiveaways(address _addr) public onlyOwner {
}
}
| whiteListMintCount[msg.sender]-_times>=1,"Over mint limit for address." | 337,861 | whiteListMintCount[msg.sender]-_times>=1 |
"Mint amount will exceed total presale amount." | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity ^0.8.0;
contract GenAlcLab is ERC721URIStorage, Ownable{
event MintGenApe (address indexed minter, uint256 startWith, uint256 times);
uint256 public totalGenApe;
uint256 public totalCount = 2500; // Total
uint256 public presaleMax = 520;
uint256 public maxBatch = 10; // Batch
uint256 public price = 50000000000000000; // 0.05 eth
string public baseURI;
bool public started;
bool public whiteListStart;
mapping(address => uint256) whiteListMintCount;
uint addressRegistryCount;
constructor(string memory name_, string memory symbol_, string memory baseURI_) ERC721(name_, symbol_) {
}
modifier canWhitelistMint() {
}
modifier mintEnabled() {
}
function totalSupply() public view virtual returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory){
}
function setBaseURI(string memory _newURI) public onlyOwner {
}
function changePrice(uint256 _newPrice) public onlyOwner {
}
function setTokenURI(uint256 _tokenId, string memory _tokenURI) public onlyOwner {
}
function setNormalStart(bool _start) public onlyOwner {
}
function setWhiteListStart(bool _start) public onlyOwner {
}
function getWhitelistMintAmount(address _addr) public view virtual returns (uint256) {
}
function mintKhemKoalas(uint256 _times) payable public mintEnabled {
}
function adminMint(uint256 _times) public onlyOwner {
}
function whitelistMint(uint _times) payable public canWhitelistMint {
if (whiteListMintCount[msg.sender]==0) {
whiteListMintCount[msg.sender] = 4;
}
require(whiteListMintCount[msg.sender] - _times >= 1, "Over mint limit for address.");
require(<FILL_ME>)
require(msg.value == _times * price, "Incorrect transaction value.");
payable(owner()).transfer(msg.value);
whiteListMintCount[_msgSender()] -= _times;
emit MintGenApe(_msgSender(), totalGenApe+1, _times);
for(uint256 i=0; i< _times; i++){
_mint(_msgSender(), 1 + totalGenApe++);
}
}
function adminMintGiveaways(address _addr) public onlyOwner {
}
}
| totalGenApe+_times<=presaleMax,"Mint amount will exceed total presale amount." | 337,861 | totalGenApe+_times<=presaleMax |
"Mint amount will exceed total collection amount." | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity ^0.8.0;
contract GenAlcLab is ERC721URIStorage, Ownable{
event MintGenApe (address indexed minter, uint256 startWith, uint256 times);
uint256 public totalGenApe;
uint256 public totalCount = 2500; // Total
uint256 public presaleMax = 520;
uint256 public maxBatch = 10; // Batch
uint256 public price = 50000000000000000; // 0.05 eth
string public baseURI;
bool public started;
bool public whiteListStart;
mapping(address => uint256) whiteListMintCount;
uint addressRegistryCount;
constructor(string memory name_, string memory symbol_, string memory baseURI_) ERC721(name_, symbol_) {
}
modifier canWhitelistMint() {
}
modifier mintEnabled() {
}
function totalSupply() public view virtual returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory){
}
function setBaseURI(string memory _newURI) public onlyOwner {
}
function changePrice(uint256 _newPrice) public onlyOwner {
}
function setTokenURI(uint256 _tokenId, string memory _tokenURI) public onlyOwner {
}
function setNormalStart(bool _start) public onlyOwner {
}
function setWhiteListStart(bool _start) public onlyOwner {
}
function getWhitelistMintAmount(address _addr) public view virtual returns (uint256) {
}
function mintKhemKoalas(uint256 _times) payable public mintEnabled {
}
function adminMint(uint256 _times) public onlyOwner {
}
function whitelistMint(uint _times) payable public canWhitelistMint {
}
function adminMintGiveaways(address _addr) public onlyOwner {
require(<FILL_ME>)
emit MintGenApe(_addr, totalGenApe+1, 1);
_mint(_addr, 1 + totalGenApe++);
}
}
| totalGenApe+1<=totalCount,"Mint amount will exceed total collection amount." | 337,861 | totalGenApe+1<=totalCount |
"Auction doesn't exist" | pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
//SPDX-License-Identifier: MIT
/*
) ) ( )
( /( ( ( /( * ) )\ ) ( ( /(
)\()) )\ )\())` ) /( (()/( )\ )\())
((_)\((((_)( |((_)\ ( )(_)) /(_))((((_)( ((_)\
_((_))\ _ )\ |_ ((_)(_(_()) (_))_ )\ _ )\ ((_)
| || |(_)_\(_)| |/ / |_ _| | \ (_)_\(_)/ _ \
| __ | / _ \ ' < | | | |) | / _ \ | (_) |
|_||_|/_/ \_\ _|\_\ |_| |___/ /_/ \_\ \___/
*/
/*
A big thanks to Zora for sharing their auction contracts with the world!
It has provided us with much inspiration and guidance.
*/
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./IAuctionHouse.sol";
interface IWETH {
function deposit() external payable;
function withdraw(uint wad) external;
function transfer(address to, uint256 value) external returns (bool);
}
/**
* @title An auction house for the HaktDAO project
*/
contract HaktAuctionHouse is IAuctionHouse, ReentrancyGuard, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
// The minimum amount of time left in an auction after a new bid is created
uint256 public timeBuffer;
// The minimum percentage difference between the last bid amount and the current bid.
uint8 public minBidIncrementPercentage;
// / The address of the WETH contract, so that any ETH transferred can be handled as an ERC-20
address public wethAddress;
// A mapping of all of the auctions currently running.
mapping(uint256 => IAuctionHouse.Auction) public auctions;
bytes4 constant interfaceId = 0x80ac58cd; // 721 interface id
Counters.Counter private _auctionIdTracker;
// DAO Address
address public daoAddress;
/**
* @notice Require that the specified auction exists
*/
modifier auctionExists(uint256 auctionId) {
require(<FILL_ME>)
_;
}
/*
* Constructor
*/
constructor(address _weth, address _dao) {
}
/**
* @notice Set a new Time Buffer.
* @dev Only allow the Owner to change it.
*/
function setTimeBuffer(uint256 _timeBuffer) public onlyOwner {
}
/**
* @notice Set a new min bid increment percentage.
* @dev Only allow the Owner to change it.
*/
function setMinBidIncrementPercentage(uint8 _minBidIncrementPercentage) public onlyOwner {
}
/**
* @notice Set a new DAO address.
* @dev Only allow the DAO address to change the DAO address in this contract.
*/
function setDAOAddress(address _dao) public {
}
/**
* @notice Create an auction.
* @dev Store the auction details in the auctions mapping and emit an AuctionCreated event.
*/
function createAuction(
uint256 tokenId,
address tokenContract,
uint256 duration,
uint256 reservePrice,
address auctionCurrency
) public override nonReentrant onlyOwner returns (uint256) {
}
/**
* @notice Create a bid on a token, with a given amount.
* @dev If provided a valid bid, transfers the provided amount to this contract.
* If the auction is run in native ETH, the ETH is wrapped so it can be identically to other
* auction currencies in this contract.
*/
function createBid(uint256 auctionId, uint256 amount)
external
override
payable
auctionExists(auctionId)
nonReentrant
{
}
/**
* @notice End an auction, finalizing the bid if applicable and paying out the respective parties.
* @dev If for some reason the auction cannot be finalized (invalid token recipient, for example),
* The auction is reset and the NFT is transferred back to the auction creator.
*/
function endAuction(uint256 auctionId) external override auctionExists(auctionId) nonReentrant {
}
/**
* @notice Cancel an auction.
* @dev Transfers the NFT back to the auction creator and emits an AuctionCanceled event
*/
function cancelAuction(uint256 auctionId) external override nonReentrant auctionExists(auctionId) onlyOwner {
}
function getCurrentAuctionId() public view returns(Counters.Counter memory) {
}
/**
* @dev Given an amount and a currency, transfer the currency to this contract.
* If the currency is ETH (0x0), attempt to wrap the amount as WETH
*/
function _handleIncomingBid(uint256 amount, address currency) internal {
}
function _handleOutgoingBid(address to, uint256 amount, address currency) internal {
}
function _safeTransferETH(address to, uint256 value) internal returns (bool) {
}
function _cancelAuction(uint256 auctionId) internal {
}
function _exists(uint256 auctionId) internal view returns(bool) {
}
// TODO: consider reverting if the message sender is not WETH
receive() external payable {}
fallback() external payable {}
}
| _exists(auctionId),"Auction doesn't exist" | 337,897 | _exists(auctionId) |
"tokenContract does not support ERC721 interface" | pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
//SPDX-License-Identifier: MIT
/*
) ) ( )
( /( ( ( /( * ) )\ ) ( ( /(
)\()) )\ )\())` ) /( (()/( )\ )\())
((_)\((((_)( |((_)\ ( )(_)) /(_))((((_)( ((_)\
_((_))\ _ )\ |_ ((_)(_(_()) (_))_ )\ _ )\ ((_)
| || |(_)_\(_)| |/ / |_ _| | \ (_)_\(_)/ _ \
| __ | / _ \ ' < | | | |) | / _ \ | (_) |
|_||_|/_/ \_\ _|\_\ |_| |___/ /_/ \_\ \___/
*/
/*
A big thanks to Zora for sharing their auction contracts with the world!
It has provided us with much inspiration and guidance.
*/
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./IAuctionHouse.sol";
interface IWETH {
function deposit() external payable;
function withdraw(uint wad) external;
function transfer(address to, uint256 value) external returns (bool);
}
/**
* @title An auction house for the HaktDAO project
*/
contract HaktAuctionHouse is IAuctionHouse, ReentrancyGuard, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
// The minimum amount of time left in an auction after a new bid is created
uint256 public timeBuffer;
// The minimum percentage difference between the last bid amount and the current bid.
uint8 public minBidIncrementPercentage;
// / The address of the WETH contract, so that any ETH transferred can be handled as an ERC-20
address public wethAddress;
// A mapping of all of the auctions currently running.
mapping(uint256 => IAuctionHouse.Auction) public auctions;
bytes4 constant interfaceId = 0x80ac58cd; // 721 interface id
Counters.Counter private _auctionIdTracker;
// DAO Address
address public daoAddress;
/**
* @notice Require that the specified auction exists
*/
modifier auctionExists(uint256 auctionId) {
}
/*
* Constructor
*/
constructor(address _weth, address _dao) {
}
/**
* @notice Set a new Time Buffer.
* @dev Only allow the Owner to change it.
*/
function setTimeBuffer(uint256 _timeBuffer) public onlyOwner {
}
/**
* @notice Set a new min bid increment percentage.
* @dev Only allow the Owner to change it.
*/
function setMinBidIncrementPercentage(uint8 _minBidIncrementPercentage) public onlyOwner {
}
/**
* @notice Set a new DAO address.
* @dev Only allow the DAO address to change the DAO address in this contract.
*/
function setDAOAddress(address _dao) public {
}
/**
* @notice Create an auction.
* @dev Store the auction details in the auctions mapping and emit an AuctionCreated event.
*/
function createAuction(
uint256 tokenId,
address tokenContract,
uint256 duration,
uint256 reservePrice,
address auctionCurrency
) public override nonReentrant onlyOwner returns (uint256) {
require(<FILL_ME>)
address tokenOwner = IERC721(tokenContract).ownerOf(tokenId);
require(address(this) == IERC721(tokenContract).getApproved(tokenId), "Caller must be approved or owner for token id");
uint256 auctionId = _auctionIdTracker.current();
auctions[auctionId] = Auction({
tokenId: tokenId,
tokenContract: tokenContract,
amount: 0,
duration: duration,
firstBidTime: 0,
reservePrice: reservePrice,
tokenOwner: tokenOwner,
bidder: payable(address(0)),
auctionCurrency: auctionCurrency
});
IERC721(tokenContract).transferFrom(tokenOwner, address(this), tokenId);
_auctionIdTracker.increment();
emit AuctionCreated(auctionId, tokenId, tokenContract, duration, reservePrice, tokenOwner, auctionCurrency);
return auctionId;
}
/**
* @notice Create a bid on a token, with a given amount.
* @dev If provided a valid bid, transfers the provided amount to this contract.
* If the auction is run in native ETH, the ETH is wrapped so it can be identically to other
* auction currencies in this contract.
*/
function createBid(uint256 auctionId, uint256 amount)
external
override
payable
auctionExists(auctionId)
nonReentrant
{
}
/**
* @notice End an auction, finalizing the bid if applicable and paying out the respective parties.
* @dev If for some reason the auction cannot be finalized (invalid token recipient, for example),
* The auction is reset and the NFT is transferred back to the auction creator.
*/
function endAuction(uint256 auctionId) external override auctionExists(auctionId) nonReentrant {
}
/**
* @notice Cancel an auction.
* @dev Transfers the NFT back to the auction creator and emits an AuctionCanceled event
*/
function cancelAuction(uint256 auctionId) external override nonReentrant auctionExists(auctionId) onlyOwner {
}
function getCurrentAuctionId() public view returns(Counters.Counter memory) {
}
/**
* @dev Given an amount and a currency, transfer the currency to this contract.
* If the currency is ETH (0x0), attempt to wrap the amount as WETH
*/
function _handleIncomingBid(uint256 amount, address currency) internal {
}
function _handleOutgoingBid(address to, uint256 amount, address currency) internal {
}
function _safeTransferETH(address to, uint256 value) internal returns (bool) {
}
function _cancelAuction(uint256 auctionId) internal {
}
function _exists(uint256 auctionId) internal view returns(bool) {
}
// TODO: consider reverting if the message sender is not WETH
receive() external payable {}
fallback() external payable {}
}
| IERC165(tokenContract).supportsInterface(interfaceId),"tokenContract does not support ERC721 interface" | 337,897 | IERC165(tokenContract).supportsInterface(interfaceId) |
"Caller must be approved or owner for token id" | pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
//SPDX-License-Identifier: MIT
/*
) ) ( )
( /( ( ( /( * ) )\ ) ( ( /(
)\()) )\ )\())` ) /( (()/( )\ )\())
((_)\((((_)( |((_)\ ( )(_)) /(_))((((_)( ((_)\
_((_))\ _ )\ |_ ((_)(_(_()) (_))_ )\ _ )\ ((_)
| || |(_)_\(_)| |/ / |_ _| | \ (_)_\(_)/ _ \
| __ | / _ \ ' < | | | |) | / _ \ | (_) |
|_||_|/_/ \_\ _|\_\ |_| |___/ /_/ \_\ \___/
*/
/*
A big thanks to Zora for sharing their auction contracts with the world!
It has provided us with much inspiration and guidance.
*/
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./IAuctionHouse.sol";
interface IWETH {
function deposit() external payable;
function withdraw(uint wad) external;
function transfer(address to, uint256 value) external returns (bool);
}
/**
* @title An auction house for the HaktDAO project
*/
contract HaktAuctionHouse is IAuctionHouse, ReentrancyGuard, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
// The minimum amount of time left in an auction after a new bid is created
uint256 public timeBuffer;
// The minimum percentage difference between the last bid amount and the current bid.
uint8 public minBidIncrementPercentage;
// / The address of the WETH contract, so that any ETH transferred can be handled as an ERC-20
address public wethAddress;
// A mapping of all of the auctions currently running.
mapping(uint256 => IAuctionHouse.Auction) public auctions;
bytes4 constant interfaceId = 0x80ac58cd; // 721 interface id
Counters.Counter private _auctionIdTracker;
// DAO Address
address public daoAddress;
/**
* @notice Require that the specified auction exists
*/
modifier auctionExists(uint256 auctionId) {
}
/*
* Constructor
*/
constructor(address _weth, address _dao) {
}
/**
* @notice Set a new Time Buffer.
* @dev Only allow the Owner to change it.
*/
function setTimeBuffer(uint256 _timeBuffer) public onlyOwner {
}
/**
* @notice Set a new min bid increment percentage.
* @dev Only allow the Owner to change it.
*/
function setMinBidIncrementPercentage(uint8 _minBidIncrementPercentage) public onlyOwner {
}
/**
* @notice Set a new DAO address.
* @dev Only allow the DAO address to change the DAO address in this contract.
*/
function setDAOAddress(address _dao) public {
}
/**
* @notice Create an auction.
* @dev Store the auction details in the auctions mapping and emit an AuctionCreated event.
*/
function createAuction(
uint256 tokenId,
address tokenContract,
uint256 duration,
uint256 reservePrice,
address auctionCurrency
) public override nonReentrant onlyOwner returns (uint256) {
require(
IERC165(tokenContract).supportsInterface(interfaceId),
"tokenContract does not support ERC721 interface"
);
address tokenOwner = IERC721(tokenContract).ownerOf(tokenId);
require(<FILL_ME>)
uint256 auctionId = _auctionIdTracker.current();
auctions[auctionId] = Auction({
tokenId: tokenId,
tokenContract: tokenContract,
amount: 0,
duration: duration,
firstBidTime: 0,
reservePrice: reservePrice,
tokenOwner: tokenOwner,
bidder: payable(address(0)),
auctionCurrency: auctionCurrency
});
IERC721(tokenContract).transferFrom(tokenOwner, address(this), tokenId);
_auctionIdTracker.increment();
emit AuctionCreated(auctionId, tokenId, tokenContract, duration, reservePrice, tokenOwner, auctionCurrency);
return auctionId;
}
/**
* @notice Create a bid on a token, with a given amount.
* @dev If provided a valid bid, transfers the provided amount to this contract.
* If the auction is run in native ETH, the ETH is wrapped so it can be identically to other
* auction currencies in this contract.
*/
function createBid(uint256 auctionId, uint256 amount)
external
override
payable
auctionExists(auctionId)
nonReentrant
{
}
/**
* @notice End an auction, finalizing the bid if applicable and paying out the respective parties.
* @dev If for some reason the auction cannot be finalized (invalid token recipient, for example),
* The auction is reset and the NFT is transferred back to the auction creator.
*/
function endAuction(uint256 auctionId) external override auctionExists(auctionId) nonReentrant {
}
/**
* @notice Cancel an auction.
* @dev Transfers the NFT back to the auction creator and emits an AuctionCanceled event
*/
function cancelAuction(uint256 auctionId) external override nonReentrant auctionExists(auctionId) onlyOwner {
}
function getCurrentAuctionId() public view returns(Counters.Counter memory) {
}
/**
* @dev Given an amount and a currency, transfer the currency to this contract.
* If the currency is ETH (0x0), attempt to wrap the amount as WETH
*/
function _handleIncomingBid(uint256 amount, address currency) internal {
}
function _handleOutgoingBid(address to, uint256 amount, address currency) internal {
}
function _safeTransferETH(address to, uint256 value) internal returns (bool) {
}
function _cancelAuction(uint256 auctionId) internal {
}
function _exists(uint256 auctionId) internal view returns(bool) {
}
// TODO: consider reverting if the message sender is not WETH
receive() external payable {}
fallback() external payable {}
}
| address(this)==IERC721(tokenContract).getApproved(tokenId),"Caller must be approved or owner for token id" | 337,897 | address(this)==IERC721(tokenContract).getApproved(tokenId) |
"Auction expired" | pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
//SPDX-License-Identifier: MIT
/*
) ) ( )
( /( ( ( /( * ) )\ ) ( ( /(
)\()) )\ )\())` ) /( (()/( )\ )\())
((_)\((((_)( |((_)\ ( )(_)) /(_))((((_)( ((_)\
_((_))\ _ )\ |_ ((_)(_(_()) (_))_ )\ _ )\ ((_)
| || |(_)_\(_)| |/ / |_ _| | \ (_)_\(_)/ _ \
| __ | / _ \ ' < | | | |) | / _ \ | (_) |
|_||_|/_/ \_\ _|\_\ |_| |___/ /_/ \_\ \___/
*/
/*
A big thanks to Zora for sharing their auction contracts with the world!
It has provided us with much inspiration and guidance.
*/
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./IAuctionHouse.sol";
interface IWETH {
function deposit() external payable;
function withdraw(uint wad) external;
function transfer(address to, uint256 value) external returns (bool);
}
/**
* @title An auction house for the HaktDAO project
*/
contract HaktAuctionHouse is IAuctionHouse, ReentrancyGuard, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
// The minimum amount of time left in an auction after a new bid is created
uint256 public timeBuffer;
// The minimum percentage difference between the last bid amount and the current bid.
uint8 public minBidIncrementPercentage;
// / The address of the WETH contract, so that any ETH transferred can be handled as an ERC-20
address public wethAddress;
// A mapping of all of the auctions currently running.
mapping(uint256 => IAuctionHouse.Auction) public auctions;
bytes4 constant interfaceId = 0x80ac58cd; // 721 interface id
Counters.Counter private _auctionIdTracker;
// DAO Address
address public daoAddress;
/**
* @notice Require that the specified auction exists
*/
modifier auctionExists(uint256 auctionId) {
}
/*
* Constructor
*/
constructor(address _weth, address _dao) {
}
/**
* @notice Set a new Time Buffer.
* @dev Only allow the Owner to change it.
*/
function setTimeBuffer(uint256 _timeBuffer) public onlyOwner {
}
/**
* @notice Set a new min bid increment percentage.
* @dev Only allow the Owner to change it.
*/
function setMinBidIncrementPercentage(uint8 _minBidIncrementPercentage) public onlyOwner {
}
/**
* @notice Set a new DAO address.
* @dev Only allow the DAO address to change the DAO address in this contract.
*/
function setDAOAddress(address _dao) public {
}
/**
* @notice Create an auction.
* @dev Store the auction details in the auctions mapping and emit an AuctionCreated event.
*/
function createAuction(
uint256 tokenId,
address tokenContract,
uint256 duration,
uint256 reservePrice,
address auctionCurrency
) public override nonReentrant onlyOwner returns (uint256) {
}
/**
* @notice Create a bid on a token, with a given amount.
* @dev If provided a valid bid, transfers the provided amount to this contract.
* If the auction is run in native ETH, the ETH is wrapped so it can be identically to other
* auction currencies in this contract.
*/
function createBid(uint256 auctionId, uint256 amount)
external
override
payable
auctionExists(auctionId)
nonReentrant
{
address payable lastBidder = auctions[auctionId].bidder;
require(<FILL_ME>)
require(
amount >= auctions[auctionId].reservePrice,
"Must send at least reservePrice"
);
require(
amount >= auctions[auctionId].amount.add(
auctions[auctionId].amount.mul(minBidIncrementPercentage).div(100)
),
"Must send more than last bid by minBidIncrementPercentage amount"
);
// If this is the first valid bid, we should set the starting time now.
// If it's not, then we should refund the last bidder
if(auctions[auctionId].firstBidTime == 0) {
auctions[auctionId].firstBidTime = block.timestamp;
} else if(lastBidder != address(0)) {
_handleOutgoingBid(lastBidder, auctions[auctionId].amount, auctions[auctionId].auctionCurrency);
}
_handleIncomingBid(amount, auctions[auctionId].auctionCurrency);
auctions[auctionId].amount = amount;
auctions[auctionId].bidder = payable(msg.sender);
bool extended = false;
// at this point we know that the timestamp is less than start + duration (since the auction would be over, otherwise)
// we want to know by how much the timestamp is less than start + duration
// if the difference is less than the timeBuffer, increase the duration by the timeBuffer
if (
auctions[auctionId].firstBidTime.add(auctions[auctionId].duration).sub(
block.timestamp
) < timeBuffer
) {
// Playing code golf for gas optimization:
// uint256 expectedEnd = auctions[auctionId].firstBidTime.add(auctions[auctionId].duration);
// uint256 timeRemaining = expectedEnd.sub(block.timestamp);
// uint256 timeToAdd = timeBuffer.sub(timeRemaining);
// uint256 newDuration = auctions[auctionId].duration.add(timeToAdd);
uint256 oldDuration = auctions[auctionId].duration;
auctions[auctionId].duration =
oldDuration.add(timeBuffer.sub(auctions[auctionId].firstBidTime.add(oldDuration).sub(block.timestamp)));
extended = true;
}
emit AuctionBid(
auctionId,
auctions[auctionId].tokenId,
auctions[auctionId].tokenContract,
msg.sender,
amount,
lastBidder == address(0), // firstBid boolean
extended
);
if (extended) {
emit AuctionDurationExtended(
auctionId,
auctions[auctionId].tokenId,
auctions[auctionId].tokenContract,
auctions[auctionId].duration
);
}
}
/**
* @notice End an auction, finalizing the bid if applicable and paying out the respective parties.
* @dev If for some reason the auction cannot be finalized (invalid token recipient, for example),
* The auction is reset and the NFT is transferred back to the auction creator.
*/
function endAuction(uint256 auctionId) external override auctionExists(auctionId) nonReentrant {
}
/**
* @notice Cancel an auction.
* @dev Transfers the NFT back to the auction creator and emits an AuctionCanceled event
*/
function cancelAuction(uint256 auctionId) external override nonReentrant auctionExists(auctionId) onlyOwner {
}
function getCurrentAuctionId() public view returns(Counters.Counter memory) {
}
/**
* @dev Given an amount and a currency, transfer the currency to this contract.
* If the currency is ETH (0x0), attempt to wrap the amount as WETH
*/
function _handleIncomingBid(uint256 amount, address currency) internal {
}
function _handleOutgoingBid(address to, uint256 amount, address currency) internal {
}
function _safeTransferETH(address to, uint256 value) internal returns (bool) {
}
function _cancelAuction(uint256 auctionId) internal {
}
function _exists(uint256 auctionId) internal view returns(bool) {
}
// TODO: consider reverting if the message sender is not WETH
receive() external payable {}
fallback() external payable {}
}
| auctions[auctionId].firstBidTime==0||block.timestamp<auctions[auctionId].firstBidTime.add(auctions[auctionId].duration),"Auction expired" | 337,897 | auctions[auctionId].firstBidTime==0||block.timestamp<auctions[auctionId].firstBidTime.add(auctions[auctionId].duration) |
"Auction hasn't begun" | pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
//SPDX-License-Identifier: MIT
/*
) ) ( )
( /( ( ( /( * ) )\ ) ( ( /(
)\()) )\ )\())` ) /( (()/( )\ )\())
((_)\((((_)( |((_)\ ( )(_)) /(_))((((_)( ((_)\
_((_))\ _ )\ |_ ((_)(_(_()) (_))_ )\ _ )\ ((_)
| || |(_)_\(_)| |/ / |_ _| | \ (_)_\(_)/ _ \
| __ | / _ \ ' < | | | |) | / _ \ | (_) |
|_||_|/_/ \_\ _|\_\ |_| |___/ /_/ \_\ \___/
*/
/*
A big thanks to Zora for sharing their auction contracts with the world!
It has provided us with much inspiration and guidance.
*/
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./IAuctionHouse.sol";
interface IWETH {
function deposit() external payable;
function withdraw(uint wad) external;
function transfer(address to, uint256 value) external returns (bool);
}
/**
* @title An auction house for the HaktDAO project
*/
contract HaktAuctionHouse is IAuctionHouse, ReentrancyGuard, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
// The minimum amount of time left in an auction after a new bid is created
uint256 public timeBuffer;
// The minimum percentage difference between the last bid amount and the current bid.
uint8 public minBidIncrementPercentage;
// / The address of the WETH contract, so that any ETH transferred can be handled as an ERC-20
address public wethAddress;
// A mapping of all of the auctions currently running.
mapping(uint256 => IAuctionHouse.Auction) public auctions;
bytes4 constant interfaceId = 0x80ac58cd; // 721 interface id
Counters.Counter private _auctionIdTracker;
// DAO Address
address public daoAddress;
/**
* @notice Require that the specified auction exists
*/
modifier auctionExists(uint256 auctionId) {
}
/*
* Constructor
*/
constructor(address _weth, address _dao) {
}
/**
* @notice Set a new Time Buffer.
* @dev Only allow the Owner to change it.
*/
function setTimeBuffer(uint256 _timeBuffer) public onlyOwner {
}
/**
* @notice Set a new min bid increment percentage.
* @dev Only allow the Owner to change it.
*/
function setMinBidIncrementPercentage(uint8 _minBidIncrementPercentage) public onlyOwner {
}
/**
* @notice Set a new DAO address.
* @dev Only allow the DAO address to change the DAO address in this contract.
*/
function setDAOAddress(address _dao) public {
}
/**
* @notice Create an auction.
* @dev Store the auction details in the auctions mapping and emit an AuctionCreated event.
*/
function createAuction(
uint256 tokenId,
address tokenContract,
uint256 duration,
uint256 reservePrice,
address auctionCurrency
) public override nonReentrant onlyOwner returns (uint256) {
}
/**
* @notice Create a bid on a token, with a given amount.
* @dev If provided a valid bid, transfers the provided amount to this contract.
* If the auction is run in native ETH, the ETH is wrapped so it can be identically to other
* auction currencies in this contract.
*/
function createBid(uint256 auctionId, uint256 amount)
external
override
payable
auctionExists(auctionId)
nonReentrant
{
}
/**
* @notice End an auction, finalizing the bid if applicable and paying out the respective parties.
* @dev If for some reason the auction cannot be finalized (invalid token recipient, for example),
* The auction is reset and the NFT is transferred back to the auction creator.
*/
function endAuction(uint256 auctionId) external override auctionExists(auctionId) nonReentrant {
require(<FILL_ME>)
require(
block.timestamp >=
auctions[auctionId].firstBidTime.add(auctions[auctionId].duration),
"Auction hasn't completed"
);
require(
msg.sender == owner() || msg.sender == auctions[auctionId].bidder,
"Can only be called by Owner or winner"
);
address currency = auctions[auctionId].auctionCurrency == address(0) ? wethAddress : auctions[auctionId].auctionCurrency;
uint256 tokenOwnerProfit = auctions[auctionId].amount;
// Otherwise, transfer the token to the winner and pay out the participants below
try IERC721(auctions[auctionId].tokenContract).safeTransferFrom(address(this), auctions[auctionId].bidder, auctions[auctionId].tokenId) {} catch {
_handleOutgoingBid(auctions[auctionId].bidder, auctions[auctionId].amount, auctions[auctionId].auctionCurrency);
_cancelAuction(auctionId);
return;
}
// DAO address receives the Profit
_handleOutgoingBid(daoAddress, tokenOwnerProfit, auctions[auctionId].auctionCurrency);
emit AuctionEnded(
auctionId,
auctions[auctionId].tokenId,
auctions[auctionId].tokenContract,
auctions[auctionId].tokenOwner,
auctions[auctionId].bidder,
daoAddress,
tokenOwnerProfit,
currency
);
}
/**
* @notice Cancel an auction.
* @dev Transfers the NFT back to the auction creator and emits an AuctionCanceled event
*/
function cancelAuction(uint256 auctionId) external override nonReentrant auctionExists(auctionId) onlyOwner {
}
function getCurrentAuctionId() public view returns(Counters.Counter memory) {
}
/**
* @dev Given an amount and a currency, transfer the currency to this contract.
* If the currency is ETH (0x0), attempt to wrap the amount as WETH
*/
function _handleIncomingBid(uint256 amount, address currency) internal {
}
function _handleOutgoingBid(address to, uint256 amount, address currency) internal {
}
function _safeTransferETH(address to, uint256 value) internal returns (bool) {
}
function _cancelAuction(uint256 auctionId) internal {
}
function _exists(uint256 auctionId) internal view returns(bool) {
}
// TODO: consider reverting if the message sender is not WETH
receive() external payable {}
fallback() external payable {}
}
| uint256(auctions[auctionId].firstBidTime)!=0,"Auction hasn't begun" | 337,897 | uint256(auctions[auctionId].firstBidTime)!=0 |
"Can't cancel an auction once it's begun" | pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
//SPDX-License-Identifier: MIT
/*
) ) ( )
( /( ( ( /( * ) )\ ) ( ( /(
)\()) )\ )\())` ) /( (()/( )\ )\())
((_)\((((_)( |((_)\ ( )(_)) /(_))((((_)( ((_)\
_((_))\ _ )\ |_ ((_)(_(_()) (_))_ )\ _ )\ ((_)
| || |(_)_\(_)| |/ / |_ _| | \ (_)_\(_)/ _ \
| __ | / _ \ ' < | | | |) | / _ \ | (_) |
|_||_|/_/ \_\ _|\_\ |_| |___/ /_/ \_\ \___/
*/
/*
A big thanks to Zora for sharing their auction contracts with the world!
It has provided us with much inspiration and guidance.
*/
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./IAuctionHouse.sol";
interface IWETH {
function deposit() external payable;
function withdraw(uint wad) external;
function transfer(address to, uint256 value) external returns (bool);
}
/**
* @title An auction house for the HaktDAO project
*/
contract HaktAuctionHouse is IAuctionHouse, ReentrancyGuard, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
// The minimum amount of time left in an auction after a new bid is created
uint256 public timeBuffer;
// The minimum percentage difference between the last bid amount and the current bid.
uint8 public minBidIncrementPercentage;
// / The address of the WETH contract, so that any ETH transferred can be handled as an ERC-20
address public wethAddress;
// A mapping of all of the auctions currently running.
mapping(uint256 => IAuctionHouse.Auction) public auctions;
bytes4 constant interfaceId = 0x80ac58cd; // 721 interface id
Counters.Counter private _auctionIdTracker;
// DAO Address
address public daoAddress;
/**
* @notice Require that the specified auction exists
*/
modifier auctionExists(uint256 auctionId) {
}
/*
* Constructor
*/
constructor(address _weth, address _dao) {
}
/**
* @notice Set a new Time Buffer.
* @dev Only allow the Owner to change it.
*/
function setTimeBuffer(uint256 _timeBuffer) public onlyOwner {
}
/**
* @notice Set a new min bid increment percentage.
* @dev Only allow the Owner to change it.
*/
function setMinBidIncrementPercentage(uint8 _minBidIncrementPercentage) public onlyOwner {
}
/**
* @notice Set a new DAO address.
* @dev Only allow the DAO address to change the DAO address in this contract.
*/
function setDAOAddress(address _dao) public {
}
/**
* @notice Create an auction.
* @dev Store the auction details in the auctions mapping and emit an AuctionCreated event.
*/
function createAuction(
uint256 tokenId,
address tokenContract,
uint256 duration,
uint256 reservePrice,
address auctionCurrency
) public override nonReentrant onlyOwner returns (uint256) {
}
/**
* @notice Create a bid on a token, with a given amount.
* @dev If provided a valid bid, transfers the provided amount to this contract.
* If the auction is run in native ETH, the ETH is wrapped so it can be identically to other
* auction currencies in this contract.
*/
function createBid(uint256 auctionId, uint256 amount)
external
override
payable
auctionExists(auctionId)
nonReentrant
{
}
/**
* @notice End an auction, finalizing the bid if applicable and paying out the respective parties.
* @dev If for some reason the auction cannot be finalized (invalid token recipient, for example),
* The auction is reset and the NFT is transferred back to the auction creator.
*/
function endAuction(uint256 auctionId) external override auctionExists(auctionId) nonReentrant {
}
/**
* @notice Cancel an auction.
* @dev Transfers the NFT back to the auction creator and emits an AuctionCanceled event
*/
function cancelAuction(uint256 auctionId) external override nonReentrant auctionExists(auctionId) onlyOwner {
require(<FILL_ME>)
_cancelAuction(auctionId);
}
function getCurrentAuctionId() public view returns(Counters.Counter memory) {
}
/**
* @dev Given an amount and a currency, transfer the currency to this contract.
* If the currency is ETH (0x0), attempt to wrap the amount as WETH
*/
function _handleIncomingBid(uint256 amount, address currency) internal {
}
function _handleOutgoingBid(address to, uint256 amount, address currency) internal {
}
function _safeTransferETH(address to, uint256 value) internal returns (bool) {
}
function _cancelAuction(uint256 auctionId) internal {
}
function _exists(uint256 auctionId) internal view returns(bool) {
}
// TODO: consider reverting if the message sender is not WETH
receive() external payable {}
fallback() external payable {}
}
| uint256(auctions[auctionId].firstBidTime)==0,"Can't cancel an auction once it's begun" | 337,897 | uint256(auctions[auctionId].firstBidTime)==0 |
"Token transfer call did not transfer expected amount" | pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
//SPDX-License-Identifier: MIT
/*
) ) ( )
( /( ( ( /( * ) )\ ) ( ( /(
)\()) )\ )\())` ) /( (()/( )\ )\())
((_)\((((_)( |((_)\ ( )(_)) /(_))((((_)( ((_)\
_((_))\ _ )\ |_ ((_)(_(_()) (_))_ )\ _ )\ ((_)
| || |(_)_\(_)| |/ / |_ _| | \ (_)_\(_)/ _ \
| __ | / _ \ ' < | | | |) | / _ \ | (_) |
|_||_|/_/ \_\ _|\_\ |_| |___/ /_/ \_\ \___/
*/
/*
A big thanks to Zora for sharing their auction contracts with the world!
It has provided us with much inspiration and guidance.
*/
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./IAuctionHouse.sol";
interface IWETH {
function deposit() external payable;
function withdraw(uint wad) external;
function transfer(address to, uint256 value) external returns (bool);
}
/**
* @title An auction house for the HaktDAO project
*/
contract HaktAuctionHouse is IAuctionHouse, ReentrancyGuard, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
// The minimum amount of time left in an auction after a new bid is created
uint256 public timeBuffer;
// The minimum percentage difference between the last bid amount and the current bid.
uint8 public minBidIncrementPercentage;
// / The address of the WETH contract, so that any ETH transferred can be handled as an ERC-20
address public wethAddress;
// A mapping of all of the auctions currently running.
mapping(uint256 => IAuctionHouse.Auction) public auctions;
bytes4 constant interfaceId = 0x80ac58cd; // 721 interface id
Counters.Counter private _auctionIdTracker;
// DAO Address
address public daoAddress;
/**
* @notice Require that the specified auction exists
*/
modifier auctionExists(uint256 auctionId) {
}
/*
* Constructor
*/
constructor(address _weth, address _dao) {
}
/**
* @notice Set a new Time Buffer.
* @dev Only allow the Owner to change it.
*/
function setTimeBuffer(uint256 _timeBuffer) public onlyOwner {
}
/**
* @notice Set a new min bid increment percentage.
* @dev Only allow the Owner to change it.
*/
function setMinBidIncrementPercentage(uint8 _minBidIncrementPercentage) public onlyOwner {
}
/**
* @notice Set a new DAO address.
* @dev Only allow the DAO address to change the DAO address in this contract.
*/
function setDAOAddress(address _dao) public {
}
/**
* @notice Create an auction.
* @dev Store the auction details in the auctions mapping and emit an AuctionCreated event.
*/
function createAuction(
uint256 tokenId,
address tokenContract,
uint256 duration,
uint256 reservePrice,
address auctionCurrency
) public override nonReentrant onlyOwner returns (uint256) {
}
/**
* @notice Create a bid on a token, with a given amount.
* @dev If provided a valid bid, transfers the provided amount to this contract.
* If the auction is run in native ETH, the ETH is wrapped so it can be identically to other
* auction currencies in this contract.
*/
function createBid(uint256 auctionId, uint256 amount)
external
override
payable
auctionExists(auctionId)
nonReentrant
{
}
/**
* @notice End an auction, finalizing the bid if applicable and paying out the respective parties.
* @dev If for some reason the auction cannot be finalized (invalid token recipient, for example),
* The auction is reset and the NFT is transferred back to the auction creator.
*/
function endAuction(uint256 auctionId) external override auctionExists(auctionId) nonReentrant {
}
/**
* @notice Cancel an auction.
* @dev Transfers the NFT back to the auction creator and emits an AuctionCanceled event
*/
function cancelAuction(uint256 auctionId) external override nonReentrant auctionExists(auctionId) onlyOwner {
}
function getCurrentAuctionId() public view returns(Counters.Counter memory) {
}
/**
* @dev Given an amount and a currency, transfer the currency to this contract.
* If the currency is ETH (0x0), attempt to wrap the amount as WETH
*/
function _handleIncomingBid(uint256 amount, address currency) internal {
// If this is an ETH bid, ensure they sent enough and convert it to WETH under the hood
if(currency == address(0)) {
require(msg.value == amount, "Sent ETH Value does not match specified bid amount");
IWETH(wethAddress).deposit{value: amount}();
} else {
// We must check the balance that was actually transferred to the auction,
// as some tokens impose a transfer fee and would not actually transfer the
// full amount to the market, resulting in potentally locked funds
IERC20 token = IERC20(currency);
uint256 beforeBalance = token.balanceOf(address(this));
token.safeTransferFrom(msg.sender, address(this), amount);
uint256 afterBalance = token.balanceOf(address(this));
require(<FILL_ME>)
}
}
function _handleOutgoingBid(address to, uint256 amount, address currency) internal {
}
function _safeTransferETH(address to, uint256 value) internal returns (bool) {
}
function _cancelAuction(uint256 auctionId) internal {
}
function _exists(uint256 auctionId) internal view returns(bool) {
}
// TODO: consider reverting if the message sender is not WETH
receive() external payable {}
fallback() external payable {}
}
| beforeBalance.add(amount)==afterBalance,"Token transfer call did not transfer expected amount" | 337,897 | beforeBalance.add(amount)==afterBalance |
"We have already hit the reserve limit" | pragma solidity ^0.8.0;
contract MusicFund is ERC721, ERC721Enumerable, Ownable {
string public PROVENANCE;
uint public constant maxTokenPurchase = 10;
uint256 public MAX_TOKENS = 10000;
bool public saleIsActive = false;
bool public preSaleIsActive = false;
string private _baseURIextended;
uint256 private _price = 50000000000000000; // .05 ETH
uint256 private _reserve = 300;
uint256 private _preSaleCap = 5;
// Facilitating the needed functionality for the presale
mapping(address => bool) addressToPreSaleEntry;
mapping(address => uint256) addressToPreSaleNumberMinted;
constructor() ERC721("MusicFund", "MUSICFUND") {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getPrice() public view returns (uint256) {
}
function setPrice(uint256 _newWEIPrice) public onlyOwner {
}
function getReserve() public view returns (uint256) {
}
function setReserve(uint256 _newReserve) public onlyOwner {
}
function reserveTokens() public onlyOwner {
uint supply = totalSupply();
require(<FILL_ME>)
uint i;
for (i = 0; i < _reserve; i++) {
uint mintIndex = totalSupply();
_safeMint(msg.sender, mintIndex);
}
}
function addWalletToPreSale(address _address) public onlyOwner {
}
function isWalletInPreSale(address _address) public view returns (bool) {
}
function preSaleNumberMinted(address _address) public view returns (uint256){
}
function setPreSaleCap(uint256 _newPreSaleCap) public onlyOwner {
}
function getPreSaleCap() public view returns (uint256) {
}
function preSaleMint(uint256 _count) public payable {
}
function flipSaleState() public onlyOwner {
}
function flipPreSaleState() public onlyOwner {
}
function mintToken(uint numberOfTokens) public payable {
}
function withdraw() public onlyOwner {
}
}
| supply+_reserve<MAX_TOKENS,"We have already hit the reserve limit" | 337,993 | supply+_reserve<MAX_TOKENS |
"This address is not whitelisted for the presale." | pragma solidity ^0.8.0;
contract MusicFund is ERC721, ERC721Enumerable, Ownable {
string public PROVENANCE;
uint public constant maxTokenPurchase = 10;
uint256 public MAX_TOKENS = 10000;
bool public saleIsActive = false;
bool public preSaleIsActive = false;
string private _baseURIextended;
uint256 private _price = 50000000000000000; // .05 ETH
uint256 private _reserve = 300;
uint256 private _preSaleCap = 5;
// Facilitating the needed functionality for the presale
mapping(address => bool) addressToPreSaleEntry;
mapping(address => uint256) addressToPreSaleNumberMinted;
constructor() ERC721("MusicFund", "MUSICFUND") {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getPrice() public view returns (uint256) {
}
function setPrice(uint256 _newWEIPrice) public onlyOwner {
}
function getReserve() public view returns (uint256) {
}
function setReserve(uint256 _newReserve) public onlyOwner {
}
function reserveTokens() public onlyOwner {
}
function addWalletToPreSale(address _address) public onlyOwner {
}
function isWalletInPreSale(address _address) public view returns (bool) {
}
function preSaleNumberMinted(address _address) public view returns (uint256){
}
function setPreSaleCap(uint256 _newPreSaleCap) public onlyOwner {
}
function getPreSaleCap() public view returns (uint256) {
}
function preSaleMint(uint256 _count) public payable {
uint256 totalSupply = totalSupply();
require(preSaleIsActive, "Presale is not active");
require(!saleIsActive, "The public sale has already started");
require(<FILL_ME>)
require(
addressToPreSaleNumberMinted[msg.sender] + _count <= _preSaleCap,
"Exceeds supply of presale cards you can mint."
);
require(_price * _count <= msg.value, "Transaction value too low.");
for (uint256 i; i < _count; i++) {
_safeMint(msg.sender, totalSupply + i);
}
// Keeps track of how many they've minted
addressToPreSaleNumberMinted[msg.sender] += _count;
}
function flipSaleState() public onlyOwner {
}
function flipPreSaleState() public onlyOwner {
}
function mintToken(uint numberOfTokens) public payable {
}
function withdraw() public onlyOwner {
}
}
| addressToPreSaleEntry[msg.sender]==true,"This address is not whitelisted for the presale." | 337,993 | addressToPreSaleEntry[msg.sender]==true |
"Exceeds supply of presale cards you can mint." | pragma solidity ^0.8.0;
contract MusicFund is ERC721, ERC721Enumerable, Ownable {
string public PROVENANCE;
uint public constant maxTokenPurchase = 10;
uint256 public MAX_TOKENS = 10000;
bool public saleIsActive = false;
bool public preSaleIsActive = false;
string private _baseURIextended;
uint256 private _price = 50000000000000000; // .05 ETH
uint256 private _reserve = 300;
uint256 private _preSaleCap = 5;
// Facilitating the needed functionality for the presale
mapping(address => bool) addressToPreSaleEntry;
mapping(address => uint256) addressToPreSaleNumberMinted;
constructor() ERC721("MusicFund", "MUSICFUND") {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function getPrice() public view returns (uint256) {
}
function setPrice(uint256 _newWEIPrice) public onlyOwner {
}
function getReserve() public view returns (uint256) {
}
function setReserve(uint256 _newReserve) public onlyOwner {
}
function reserveTokens() public onlyOwner {
}
function addWalletToPreSale(address _address) public onlyOwner {
}
function isWalletInPreSale(address _address) public view returns (bool) {
}
function preSaleNumberMinted(address _address) public view returns (uint256){
}
function setPreSaleCap(uint256 _newPreSaleCap) public onlyOwner {
}
function getPreSaleCap() public view returns (uint256) {
}
function preSaleMint(uint256 _count) public payable {
uint256 totalSupply = totalSupply();
require(preSaleIsActive, "Presale is not active");
require(!saleIsActive, "The public sale has already started");
require(addressToPreSaleEntry[msg.sender] == true, "This address is not whitelisted for the presale.");
require(<FILL_ME>)
require(_price * _count <= msg.value, "Transaction value too low.");
for (uint256 i; i < _count; i++) {
_safeMint(msg.sender, totalSupply + i);
}
// Keeps track of how many they've minted
addressToPreSaleNumberMinted[msg.sender] += _count;
}
function flipSaleState() public onlyOwner {
}
function flipPreSaleState() public onlyOwner {
}
function mintToken(uint numberOfTokens) public payable {
}
function withdraw() public onlyOwner {
}
}
| addressToPreSaleNumberMinted[msg.sender]+_count<=_preSaleCap,"Exceeds supply of presale cards you can mint." | 337,993 | addressToPreSaleNumberMinted[msg.sender]+_count<=_preSaleCap |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.