comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"ETH send failed" | pragma solidity ^0.4.24;
// produced by the Solididy File Flattener (c) David Appleton 2018
// contact : [email protected]
// released under Apache 2.0 licence
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 ERC20 {
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
}
contract V00_Marketplace is Ownable {
/**
* @notice All events have the same indexed signature offsets for easy filtering
*/
event MarketplaceData (address indexed party, bytes32 ipfsHash);
event AffiliateAdded (address indexed party, bytes32 ipfsHash);
event AffiliateRemoved (address indexed party, bytes32 ipfsHash);
event ListingCreated (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingUpdated (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingWithdrawn (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingArbitrated(address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingData (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event OfferCreated (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferAccepted (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferFinalized (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferWithdrawn (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferFundsAdded (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferDisputed (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferRuling (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash, uint ruling);
event OfferData (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
struct Listing {
address seller; // Seller wallet / identity contract / other contract
uint deposit; // Deposit in Origin Token
address depositManager; // Address that decides token distribution
}
struct Offer {
uint value; // Amount in Eth or ERC20 buyer is offering
uint commission; // Amount of commission earned if offer is finalized
uint refund; // Amount to refund buyer upon finalization
ERC20 currency; // Currency of listing
address buyer; // Buyer wallet / identity contract / other contract
address affiliate; // Address to send any commission
address arbitrator; // Address that settles disputes
uint finalizes; // Timestamp offer finalizes
uint8 status; // 0: Undefined, 1: Created, 2: Accepted, 3: Disputed
}
Listing[] public listings;
mapping(uint => Offer[]) public offers; // listingID => Offers
mapping(address => bool) public allowedAffiliates;
ERC20 public tokenAddr; // Origin Token address
constructor(address _tokenAddr) public {
}
// @dev Return the total number of listings
function totalListings() public view returns (uint) {
}
// @dev Return the total number of offers
function totalOffers(uint listingID) public view returns (uint) {
}
// @dev Seller creates listing
function createListing(bytes32 _ipfsHash, uint _deposit, address _depositManager)
public
{
}
// @dev Can only be called by token
function createListingWithSender(
address _seller,
bytes32 _ipfsHash,
uint _deposit,
address _depositManager
)
public returns (bool)
{
}
// Private
function _createListing(
address _seller,
bytes32 _ipfsHash, // IPFS JSON with details, pricing, availability
uint _deposit, // Deposit in Origin Token
address _depositManager // Address of listing depositManager
)
private
{
}
// @dev Seller updates listing
function updateListing(
uint listingID,
bytes32 _ipfsHash,
uint _additionalDeposit
) public {
}
function updateListingWithSender(
address _seller,
uint listingID,
bytes32 _ipfsHash,
uint _additionalDeposit
)
public returns (bool)
{
}
function _updateListing(
address _seller,
uint listingID,
bytes32 _ipfsHash, // Updated IPFS hash
uint _additionalDeposit // Additional deposit to add
) private {
}
// @dev Listing depositManager withdraws listing. IPFS hash contains reason for withdrawl.
function withdrawListing(uint listingID, address _target, bytes32 _ipfsHash) public {
}
// @dev Buyer makes offer.
function makeOffer(
uint listingID,
bytes32 _ipfsHash, // IPFS hash containing offer data
uint _finalizes, // Timestamp an accepted offer will finalize
address _affiliate, // Address to send any required commission to
uint256 _commission, // Amount of commission to send in Origin Token if offer finalizes
uint _value, // Offer amount in ERC20 or Eth
ERC20 _currency, // ERC20 token address or 0x0 for Eth
address _arbitrator // Escrow arbitrator
)
public
payable
{
}
// @dev Make new offer after withdrawl
function makeOffer(
uint listingID,
bytes32 _ipfsHash,
uint _finalizes,
address _affiliate,
uint256 _commission,
uint _value,
ERC20 _currency,
address _arbitrator,
uint _withdrawOfferID
)
public
payable
{
}
// @dev Seller accepts offer
function acceptOffer(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Buyer withdraws offer. IPFS hash contains reason for withdrawl.
function withdrawOffer(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Buyer adds extra funds to an accepted offer.
function addFunds(uint listingID, uint offerID, bytes32 _ipfsHash, uint _value) public payable {
}
// @dev Buyer must finalize transaction to receive commission
function finalize(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Buyer or seller can dispute transaction during finalization window
function dispute(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Called by arbitrator
function executeRuling(
uint listingID,
uint offerID,
bytes32 _ipfsHash,
uint _ruling, // 0: Seller, 1: Buyer, 2: Com + Seller, 3: Com + Buyer
uint _refund
) public {
}
// @dev Sets the amount that a seller wants to refund to a buyer.
function updateRefund(uint listingID, uint offerID, uint _refund, bytes32 _ipfsHash) public {
}
// @dev Refunds buyer in ETH or ERC20 - used by 1) executeRuling() and 2) to allow a seller to refund a purchase
function refundBuyer(uint listingID, uint offerID) private {
}
// @dev Pay seller in ETH or ERC20
function paySeller(uint listingID, uint offerID) private {
Listing storage listing = listings[listingID];
Offer storage offer = offers[listingID][offerID];
uint value = offer.value - offer.refund;
if (address(offer.currency) == 0x0) {
require(offer.buyer.send(offer.refund), "ETH refund failed");
require(<FILL_ME>)
} else {
require(
offer.currency.transfer(offer.buyer, offer.refund),
"Refund failed"
);
require(
offer.currency.transfer(listing.seller, value),
"Transfer failed"
);
}
}
// @dev Pay commission to affiliate
function payCommission(uint listingID, uint offerID) private {
}
// @dev Associate ipfs data with the marketplace
function addData(bytes32 ipfsHash) public {
}
// @dev Associate ipfs data with a listing
function addData(uint listingID, bytes32 ipfsHash) public {
}
// @dev Associate ipfs data with an offer
function addData(uint listingID, uint offerID, bytes32 ipfsHash) public {
}
// @dev Allow listing depositManager to send deposit
function sendDeposit(uint listingID, address target, uint value, bytes32 ipfsHash) public {
}
// @dev Set the address of the Origin token contract
function setTokenAddr(address _tokenAddr) public onlyOwner {
}
// @dev Add affiliate to whitelist. Set to address(this) to disable.
function addAffiliate(address _affiliate, bytes32 ipfsHash) public onlyOwner {
}
// @dev Remove affiliate from whitelist.
function removeAffiliate(address _affiliate, bytes32 ipfsHash) public onlyOwner {
}
}
| listing.seller.send(value),"ETH send failed" | 308,997 | listing.seller.send(value) |
"Refund failed" | pragma solidity ^0.4.24;
// produced by the Solididy File Flattener (c) David Appleton 2018
// contact : [email protected]
// released under Apache 2.0 licence
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 ERC20 {
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
}
contract V00_Marketplace is Ownable {
/**
* @notice All events have the same indexed signature offsets for easy filtering
*/
event MarketplaceData (address indexed party, bytes32 ipfsHash);
event AffiliateAdded (address indexed party, bytes32 ipfsHash);
event AffiliateRemoved (address indexed party, bytes32 ipfsHash);
event ListingCreated (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingUpdated (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingWithdrawn (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingArbitrated(address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingData (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event OfferCreated (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferAccepted (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferFinalized (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferWithdrawn (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferFundsAdded (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferDisputed (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferRuling (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash, uint ruling);
event OfferData (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
struct Listing {
address seller; // Seller wallet / identity contract / other contract
uint deposit; // Deposit in Origin Token
address depositManager; // Address that decides token distribution
}
struct Offer {
uint value; // Amount in Eth or ERC20 buyer is offering
uint commission; // Amount of commission earned if offer is finalized
uint refund; // Amount to refund buyer upon finalization
ERC20 currency; // Currency of listing
address buyer; // Buyer wallet / identity contract / other contract
address affiliate; // Address to send any commission
address arbitrator; // Address that settles disputes
uint finalizes; // Timestamp offer finalizes
uint8 status; // 0: Undefined, 1: Created, 2: Accepted, 3: Disputed
}
Listing[] public listings;
mapping(uint => Offer[]) public offers; // listingID => Offers
mapping(address => bool) public allowedAffiliates;
ERC20 public tokenAddr; // Origin Token address
constructor(address _tokenAddr) public {
}
// @dev Return the total number of listings
function totalListings() public view returns (uint) {
}
// @dev Return the total number of offers
function totalOffers(uint listingID) public view returns (uint) {
}
// @dev Seller creates listing
function createListing(bytes32 _ipfsHash, uint _deposit, address _depositManager)
public
{
}
// @dev Can only be called by token
function createListingWithSender(
address _seller,
bytes32 _ipfsHash,
uint _deposit,
address _depositManager
)
public returns (bool)
{
}
// Private
function _createListing(
address _seller,
bytes32 _ipfsHash, // IPFS JSON with details, pricing, availability
uint _deposit, // Deposit in Origin Token
address _depositManager // Address of listing depositManager
)
private
{
}
// @dev Seller updates listing
function updateListing(
uint listingID,
bytes32 _ipfsHash,
uint _additionalDeposit
) public {
}
function updateListingWithSender(
address _seller,
uint listingID,
bytes32 _ipfsHash,
uint _additionalDeposit
)
public returns (bool)
{
}
function _updateListing(
address _seller,
uint listingID,
bytes32 _ipfsHash, // Updated IPFS hash
uint _additionalDeposit // Additional deposit to add
) private {
}
// @dev Listing depositManager withdraws listing. IPFS hash contains reason for withdrawl.
function withdrawListing(uint listingID, address _target, bytes32 _ipfsHash) public {
}
// @dev Buyer makes offer.
function makeOffer(
uint listingID,
bytes32 _ipfsHash, // IPFS hash containing offer data
uint _finalizes, // Timestamp an accepted offer will finalize
address _affiliate, // Address to send any required commission to
uint256 _commission, // Amount of commission to send in Origin Token if offer finalizes
uint _value, // Offer amount in ERC20 or Eth
ERC20 _currency, // ERC20 token address or 0x0 for Eth
address _arbitrator // Escrow arbitrator
)
public
payable
{
}
// @dev Make new offer after withdrawl
function makeOffer(
uint listingID,
bytes32 _ipfsHash,
uint _finalizes,
address _affiliate,
uint256 _commission,
uint _value,
ERC20 _currency,
address _arbitrator,
uint _withdrawOfferID
)
public
payable
{
}
// @dev Seller accepts offer
function acceptOffer(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Buyer withdraws offer. IPFS hash contains reason for withdrawl.
function withdrawOffer(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Buyer adds extra funds to an accepted offer.
function addFunds(uint listingID, uint offerID, bytes32 _ipfsHash, uint _value) public payable {
}
// @dev Buyer must finalize transaction to receive commission
function finalize(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Buyer or seller can dispute transaction during finalization window
function dispute(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Called by arbitrator
function executeRuling(
uint listingID,
uint offerID,
bytes32 _ipfsHash,
uint _ruling, // 0: Seller, 1: Buyer, 2: Com + Seller, 3: Com + Buyer
uint _refund
) public {
}
// @dev Sets the amount that a seller wants to refund to a buyer.
function updateRefund(uint listingID, uint offerID, uint _refund, bytes32 _ipfsHash) public {
}
// @dev Refunds buyer in ETH or ERC20 - used by 1) executeRuling() and 2) to allow a seller to refund a purchase
function refundBuyer(uint listingID, uint offerID) private {
}
// @dev Pay seller in ETH or ERC20
function paySeller(uint listingID, uint offerID) private {
Listing storage listing = listings[listingID];
Offer storage offer = offers[listingID][offerID];
uint value = offer.value - offer.refund;
if (address(offer.currency) == 0x0) {
require(offer.buyer.send(offer.refund), "ETH refund failed");
require(listing.seller.send(value), "ETH send failed");
} else {
require(<FILL_ME>)
require(
offer.currency.transfer(listing.seller, value),
"Transfer failed"
);
}
}
// @dev Pay commission to affiliate
function payCommission(uint listingID, uint offerID) private {
}
// @dev Associate ipfs data with the marketplace
function addData(bytes32 ipfsHash) public {
}
// @dev Associate ipfs data with a listing
function addData(uint listingID, bytes32 ipfsHash) public {
}
// @dev Associate ipfs data with an offer
function addData(uint listingID, uint offerID, bytes32 ipfsHash) public {
}
// @dev Allow listing depositManager to send deposit
function sendDeposit(uint listingID, address target, uint value, bytes32 ipfsHash) public {
}
// @dev Set the address of the Origin token contract
function setTokenAddr(address _tokenAddr) public onlyOwner {
}
// @dev Add affiliate to whitelist. Set to address(this) to disable.
function addAffiliate(address _affiliate, bytes32 ipfsHash) public onlyOwner {
}
// @dev Remove affiliate from whitelist.
function removeAffiliate(address _affiliate, bytes32 ipfsHash) public onlyOwner {
}
}
| offer.currency.transfer(offer.buyer,offer.refund),"Refund failed" | 308,997 | offer.currency.transfer(offer.buyer,offer.refund) |
"Transfer failed" | pragma solidity ^0.4.24;
// produced by the Solididy File Flattener (c) David Appleton 2018
// contact : [email protected]
// released under Apache 2.0 licence
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 ERC20 {
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
}
contract V00_Marketplace is Ownable {
/**
* @notice All events have the same indexed signature offsets for easy filtering
*/
event MarketplaceData (address indexed party, bytes32 ipfsHash);
event AffiliateAdded (address indexed party, bytes32 ipfsHash);
event AffiliateRemoved (address indexed party, bytes32 ipfsHash);
event ListingCreated (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingUpdated (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingWithdrawn (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingArbitrated(address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingData (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event OfferCreated (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferAccepted (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferFinalized (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferWithdrawn (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferFundsAdded (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferDisputed (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferRuling (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash, uint ruling);
event OfferData (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
struct Listing {
address seller; // Seller wallet / identity contract / other contract
uint deposit; // Deposit in Origin Token
address depositManager; // Address that decides token distribution
}
struct Offer {
uint value; // Amount in Eth or ERC20 buyer is offering
uint commission; // Amount of commission earned if offer is finalized
uint refund; // Amount to refund buyer upon finalization
ERC20 currency; // Currency of listing
address buyer; // Buyer wallet / identity contract / other contract
address affiliate; // Address to send any commission
address arbitrator; // Address that settles disputes
uint finalizes; // Timestamp offer finalizes
uint8 status; // 0: Undefined, 1: Created, 2: Accepted, 3: Disputed
}
Listing[] public listings;
mapping(uint => Offer[]) public offers; // listingID => Offers
mapping(address => bool) public allowedAffiliates;
ERC20 public tokenAddr; // Origin Token address
constructor(address _tokenAddr) public {
}
// @dev Return the total number of listings
function totalListings() public view returns (uint) {
}
// @dev Return the total number of offers
function totalOffers(uint listingID) public view returns (uint) {
}
// @dev Seller creates listing
function createListing(bytes32 _ipfsHash, uint _deposit, address _depositManager)
public
{
}
// @dev Can only be called by token
function createListingWithSender(
address _seller,
bytes32 _ipfsHash,
uint _deposit,
address _depositManager
)
public returns (bool)
{
}
// Private
function _createListing(
address _seller,
bytes32 _ipfsHash, // IPFS JSON with details, pricing, availability
uint _deposit, // Deposit in Origin Token
address _depositManager // Address of listing depositManager
)
private
{
}
// @dev Seller updates listing
function updateListing(
uint listingID,
bytes32 _ipfsHash,
uint _additionalDeposit
) public {
}
function updateListingWithSender(
address _seller,
uint listingID,
bytes32 _ipfsHash,
uint _additionalDeposit
)
public returns (bool)
{
}
function _updateListing(
address _seller,
uint listingID,
bytes32 _ipfsHash, // Updated IPFS hash
uint _additionalDeposit // Additional deposit to add
) private {
}
// @dev Listing depositManager withdraws listing. IPFS hash contains reason for withdrawl.
function withdrawListing(uint listingID, address _target, bytes32 _ipfsHash) public {
}
// @dev Buyer makes offer.
function makeOffer(
uint listingID,
bytes32 _ipfsHash, // IPFS hash containing offer data
uint _finalizes, // Timestamp an accepted offer will finalize
address _affiliate, // Address to send any required commission to
uint256 _commission, // Amount of commission to send in Origin Token if offer finalizes
uint _value, // Offer amount in ERC20 or Eth
ERC20 _currency, // ERC20 token address or 0x0 for Eth
address _arbitrator // Escrow arbitrator
)
public
payable
{
}
// @dev Make new offer after withdrawl
function makeOffer(
uint listingID,
bytes32 _ipfsHash,
uint _finalizes,
address _affiliate,
uint256 _commission,
uint _value,
ERC20 _currency,
address _arbitrator,
uint _withdrawOfferID
)
public
payable
{
}
// @dev Seller accepts offer
function acceptOffer(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Buyer withdraws offer. IPFS hash contains reason for withdrawl.
function withdrawOffer(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Buyer adds extra funds to an accepted offer.
function addFunds(uint listingID, uint offerID, bytes32 _ipfsHash, uint _value) public payable {
}
// @dev Buyer must finalize transaction to receive commission
function finalize(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Buyer or seller can dispute transaction during finalization window
function dispute(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Called by arbitrator
function executeRuling(
uint listingID,
uint offerID,
bytes32 _ipfsHash,
uint _ruling, // 0: Seller, 1: Buyer, 2: Com + Seller, 3: Com + Buyer
uint _refund
) public {
}
// @dev Sets the amount that a seller wants to refund to a buyer.
function updateRefund(uint listingID, uint offerID, uint _refund, bytes32 _ipfsHash) public {
}
// @dev Refunds buyer in ETH or ERC20 - used by 1) executeRuling() and 2) to allow a seller to refund a purchase
function refundBuyer(uint listingID, uint offerID) private {
}
// @dev Pay seller in ETH or ERC20
function paySeller(uint listingID, uint offerID) private {
Listing storage listing = listings[listingID];
Offer storage offer = offers[listingID][offerID];
uint value = offer.value - offer.refund;
if (address(offer.currency) == 0x0) {
require(offer.buyer.send(offer.refund), "ETH refund failed");
require(listing.seller.send(value), "ETH send failed");
} else {
require(
offer.currency.transfer(offer.buyer, offer.refund),
"Refund failed"
);
require(<FILL_ME>)
}
}
// @dev Pay commission to affiliate
function payCommission(uint listingID, uint offerID) private {
}
// @dev Associate ipfs data with the marketplace
function addData(bytes32 ipfsHash) public {
}
// @dev Associate ipfs data with a listing
function addData(uint listingID, bytes32 ipfsHash) public {
}
// @dev Associate ipfs data with an offer
function addData(uint listingID, uint offerID, bytes32 ipfsHash) public {
}
// @dev Allow listing depositManager to send deposit
function sendDeposit(uint listingID, address target, uint value, bytes32 ipfsHash) public {
}
// @dev Set the address of the Origin token contract
function setTokenAddr(address _tokenAddr) public onlyOwner {
}
// @dev Add affiliate to whitelist. Set to address(this) to disable.
function addAffiliate(address _affiliate, bytes32 ipfsHash) public onlyOwner {
}
// @dev Remove affiliate from whitelist.
function removeAffiliate(address _affiliate, bytes32 ipfsHash) public onlyOwner {
}
}
| offer.currency.transfer(listing.seller,value),"Transfer failed" | 308,997 | offer.currency.transfer(listing.seller,value) |
"Commission transfer failed" | pragma solidity ^0.4.24;
// produced by the Solididy File Flattener (c) David Appleton 2018
// contact : [email protected]
// released under Apache 2.0 licence
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 ERC20 {
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
}
contract V00_Marketplace is Ownable {
/**
* @notice All events have the same indexed signature offsets for easy filtering
*/
event MarketplaceData (address indexed party, bytes32 ipfsHash);
event AffiliateAdded (address indexed party, bytes32 ipfsHash);
event AffiliateRemoved (address indexed party, bytes32 ipfsHash);
event ListingCreated (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingUpdated (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingWithdrawn (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingArbitrated(address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingData (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event OfferCreated (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferAccepted (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferFinalized (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferWithdrawn (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferFundsAdded (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferDisputed (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferRuling (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash, uint ruling);
event OfferData (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
struct Listing {
address seller; // Seller wallet / identity contract / other contract
uint deposit; // Deposit in Origin Token
address depositManager; // Address that decides token distribution
}
struct Offer {
uint value; // Amount in Eth or ERC20 buyer is offering
uint commission; // Amount of commission earned if offer is finalized
uint refund; // Amount to refund buyer upon finalization
ERC20 currency; // Currency of listing
address buyer; // Buyer wallet / identity contract / other contract
address affiliate; // Address to send any commission
address arbitrator; // Address that settles disputes
uint finalizes; // Timestamp offer finalizes
uint8 status; // 0: Undefined, 1: Created, 2: Accepted, 3: Disputed
}
Listing[] public listings;
mapping(uint => Offer[]) public offers; // listingID => Offers
mapping(address => bool) public allowedAffiliates;
ERC20 public tokenAddr; // Origin Token address
constructor(address _tokenAddr) public {
}
// @dev Return the total number of listings
function totalListings() public view returns (uint) {
}
// @dev Return the total number of offers
function totalOffers(uint listingID) public view returns (uint) {
}
// @dev Seller creates listing
function createListing(bytes32 _ipfsHash, uint _deposit, address _depositManager)
public
{
}
// @dev Can only be called by token
function createListingWithSender(
address _seller,
bytes32 _ipfsHash,
uint _deposit,
address _depositManager
)
public returns (bool)
{
}
// Private
function _createListing(
address _seller,
bytes32 _ipfsHash, // IPFS JSON with details, pricing, availability
uint _deposit, // Deposit in Origin Token
address _depositManager // Address of listing depositManager
)
private
{
}
// @dev Seller updates listing
function updateListing(
uint listingID,
bytes32 _ipfsHash,
uint _additionalDeposit
) public {
}
function updateListingWithSender(
address _seller,
uint listingID,
bytes32 _ipfsHash,
uint _additionalDeposit
)
public returns (bool)
{
}
function _updateListing(
address _seller,
uint listingID,
bytes32 _ipfsHash, // Updated IPFS hash
uint _additionalDeposit // Additional deposit to add
) private {
}
// @dev Listing depositManager withdraws listing. IPFS hash contains reason for withdrawl.
function withdrawListing(uint listingID, address _target, bytes32 _ipfsHash) public {
}
// @dev Buyer makes offer.
function makeOffer(
uint listingID,
bytes32 _ipfsHash, // IPFS hash containing offer data
uint _finalizes, // Timestamp an accepted offer will finalize
address _affiliate, // Address to send any required commission to
uint256 _commission, // Amount of commission to send in Origin Token if offer finalizes
uint _value, // Offer amount in ERC20 or Eth
ERC20 _currency, // ERC20 token address or 0x0 for Eth
address _arbitrator // Escrow arbitrator
)
public
payable
{
}
// @dev Make new offer after withdrawl
function makeOffer(
uint listingID,
bytes32 _ipfsHash,
uint _finalizes,
address _affiliate,
uint256 _commission,
uint _value,
ERC20 _currency,
address _arbitrator,
uint _withdrawOfferID
)
public
payable
{
}
// @dev Seller accepts offer
function acceptOffer(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Buyer withdraws offer. IPFS hash contains reason for withdrawl.
function withdrawOffer(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Buyer adds extra funds to an accepted offer.
function addFunds(uint listingID, uint offerID, bytes32 _ipfsHash, uint _value) public payable {
}
// @dev Buyer must finalize transaction to receive commission
function finalize(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Buyer or seller can dispute transaction during finalization window
function dispute(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Called by arbitrator
function executeRuling(
uint listingID,
uint offerID,
bytes32 _ipfsHash,
uint _ruling, // 0: Seller, 1: Buyer, 2: Com + Seller, 3: Com + Buyer
uint _refund
) public {
}
// @dev Sets the amount that a seller wants to refund to a buyer.
function updateRefund(uint listingID, uint offerID, uint _refund, bytes32 _ipfsHash) public {
}
// @dev Refunds buyer in ETH or ERC20 - used by 1) executeRuling() and 2) to allow a seller to refund a purchase
function refundBuyer(uint listingID, uint offerID) private {
}
// @dev Pay seller in ETH or ERC20
function paySeller(uint listingID, uint offerID) private {
}
// @dev Pay commission to affiliate
function payCommission(uint listingID, uint offerID) private {
Offer storage offer = offers[listingID][offerID];
if (offer.affiliate != 0x0) {
require(<FILL_ME>)
}
}
// @dev Associate ipfs data with the marketplace
function addData(bytes32 ipfsHash) public {
}
// @dev Associate ipfs data with a listing
function addData(uint listingID, bytes32 ipfsHash) public {
}
// @dev Associate ipfs data with an offer
function addData(uint listingID, uint offerID, bytes32 ipfsHash) public {
}
// @dev Allow listing depositManager to send deposit
function sendDeposit(uint listingID, address target, uint value, bytes32 ipfsHash) public {
}
// @dev Set the address of the Origin token contract
function setTokenAddr(address _tokenAddr) public onlyOwner {
}
// @dev Add affiliate to whitelist. Set to address(this) to disable.
function addAffiliate(address _affiliate, bytes32 ipfsHash) public onlyOwner {
}
// @dev Remove affiliate from whitelist.
function removeAffiliate(address _affiliate, bytes32 ipfsHash) public onlyOwner {
}
}
| tokenAddr.transfer(offer.affiliate,offer.commission),"Commission transfer failed" | 308,997 | tokenAddr.transfer(offer.affiliate,offer.commission) |
"Transfer failed" | pragma solidity ^0.4.24;
// produced by the Solididy File Flattener (c) David Appleton 2018
// contact : [email protected]
// released under Apache 2.0 licence
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 ERC20 {
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
}
contract V00_Marketplace is Ownable {
/**
* @notice All events have the same indexed signature offsets for easy filtering
*/
event MarketplaceData (address indexed party, bytes32 ipfsHash);
event AffiliateAdded (address indexed party, bytes32 ipfsHash);
event AffiliateRemoved (address indexed party, bytes32 ipfsHash);
event ListingCreated (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingUpdated (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingWithdrawn (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingArbitrated(address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingData (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event OfferCreated (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferAccepted (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferFinalized (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferWithdrawn (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferFundsAdded (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferDisputed (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferRuling (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash, uint ruling);
event OfferData (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
struct Listing {
address seller; // Seller wallet / identity contract / other contract
uint deposit; // Deposit in Origin Token
address depositManager; // Address that decides token distribution
}
struct Offer {
uint value; // Amount in Eth or ERC20 buyer is offering
uint commission; // Amount of commission earned if offer is finalized
uint refund; // Amount to refund buyer upon finalization
ERC20 currency; // Currency of listing
address buyer; // Buyer wallet / identity contract / other contract
address affiliate; // Address to send any commission
address arbitrator; // Address that settles disputes
uint finalizes; // Timestamp offer finalizes
uint8 status; // 0: Undefined, 1: Created, 2: Accepted, 3: Disputed
}
Listing[] public listings;
mapping(uint => Offer[]) public offers; // listingID => Offers
mapping(address => bool) public allowedAffiliates;
ERC20 public tokenAddr; // Origin Token address
constructor(address _tokenAddr) public {
}
// @dev Return the total number of listings
function totalListings() public view returns (uint) {
}
// @dev Return the total number of offers
function totalOffers(uint listingID) public view returns (uint) {
}
// @dev Seller creates listing
function createListing(bytes32 _ipfsHash, uint _deposit, address _depositManager)
public
{
}
// @dev Can only be called by token
function createListingWithSender(
address _seller,
bytes32 _ipfsHash,
uint _deposit,
address _depositManager
)
public returns (bool)
{
}
// Private
function _createListing(
address _seller,
bytes32 _ipfsHash, // IPFS JSON with details, pricing, availability
uint _deposit, // Deposit in Origin Token
address _depositManager // Address of listing depositManager
)
private
{
}
// @dev Seller updates listing
function updateListing(
uint listingID,
bytes32 _ipfsHash,
uint _additionalDeposit
) public {
}
function updateListingWithSender(
address _seller,
uint listingID,
bytes32 _ipfsHash,
uint _additionalDeposit
)
public returns (bool)
{
}
function _updateListing(
address _seller,
uint listingID,
bytes32 _ipfsHash, // Updated IPFS hash
uint _additionalDeposit // Additional deposit to add
) private {
}
// @dev Listing depositManager withdraws listing. IPFS hash contains reason for withdrawl.
function withdrawListing(uint listingID, address _target, bytes32 _ipfsHash) public {
}
// @dev Buyer makes offer.
function makeOffer(
uint listingID,
bytes32 _ipfsHash, // IPFS hash containing offer data
uint _finalizes, // Timestamp an accepted offer will finalize
address _affiliate, // Address to send any required commission to
uint256 _commission, // Amount of commission to send in Origin Token if offer finalizes
uint _value, // Offer amount in ERC20 or Eth
ERC20 _currency, // ERC20 token address or 0x0 for Eth
address _arbitrator // Escrow arbitrator
)
public
payable
{
}
// @dev Make new offer after withdrawl
function makeOffer(
uint listingID,
bytes32 _ipfsHash,
uint _finalizes,
address _affiliate,
uint256 _commission,
uint _value,
ERC20 _currency,
address _arbitrator,
uint _withdrawOfferID
)
public
payable
{
}
// @dev Seller accepts offer
function acceptOffer(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Buyer withdraws offer. IPFS hash contains reason for withdrawl.
function withdrawOffer(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Buyer adds extra funds to an accepted offer.
function addFunds(uint listingID, uint offerID, bytes32 _ipfsHash, uint _value) public payable {
}
// @dev Buyer must finalize transaction to receive commission
function finalize(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Buyer or seller can dispute transaction during finalization window
function dispute(uint listingID, uint offerID, bytes32 _ipfsHash) public {
}
// @dev Called by arbitrator
function executeRuling(
uint listingID,
uint offerID,
bytes32 _ipfsHash,
uint _ruling, // 0: Seller, 1: Buyer, 2: Com + Seller, 3: Com + Buyer
uint _refund
) public {
}
// @dev Sets the amount that a seller wants to refund to a buyer.
function updateRefund(uint listingID, uint offerID, uint _refund, bytes32 _ipfsHash) public {
}
// @dev Refunds buyer in ETH or ERC20 - used by 1) executeRuling() and 2) to allow a seller to refund a purchase
function refundBuyer(uint listingID, uint offerID) private {
}
// @dev Pay seller in ETH or ERC20
function paySeller(uint listingID, uint offerID) private {
}
// @dev Pay commission to affiliate
function payCommission(uint listingID, uint offerID) private {
}
// @dev Associate ipfs data with the marketplace
function addData(bytes32 ipfsHash) public {
}
// @dev Associate ipfs data with a listing
function addData(uint listingID, bytes32 ipfsHash) public {
}
// @dev Associate ipfs data with an offer
function addData(uint listingID, uint offerID, bytes32 ipfsHash) public {
}
// @dev Allow listing depositManager to send deposit
function sendDeposit(uint listingID, address target, uint value, bytes32 ipfsHash) public {
Listing storage listing = listings[listingID];
require(listing.depositManager == msg.sender, "depositManager must call");
require(listing.deposit >= value, "Value too high");
listing.deposit -= value;
require(<FILL_ME>)
emit ListingArbitrated(target, listingID, ipfsHash);
}
// @dev Set the address of the Origin token contract
function setTokenAddr(address _tokenAddr) public onlyOwner {
}
// @dev Add affiliate to whitelist. Set to address(this) to disable.
function addAffiliate(address _affiliate, bytes32 ipfsHash) public onlyOwner {
}
// @dev Remove affiliate from whitelist.
function removeAffiliate(address _affiliate, bytes32 ipfsHash) public onlyOwner {
}
}
| tokenAddr.transfer(target,value),"Transfer failed" | 308,997 | tokenAddr.transfer(target,value) |
null | // SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.7;
/// @notice Modern and gas efficient ERC-721 + ERC-20/EIP-2612-like implementation,
/// including the MetaData, and partially, Enumerable extensions.
contract ERC721 {
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed spender, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*///////////////////////////////////////////////////////////////
METADATA STORAGE
//////////////////////////////////////////////////////////////*/
address implementation_;
address public admin; //Lame requirement from opensea
/*///////////////////////////////////////////////////////////////
ERC-721 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 public totalSupply;
uint256 public oldSupply;
uint256 public minted;
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public ownerOf;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*///////////////////////////////////////////////////////////////
VIEW FUNCTION
//////////////////////////////////////////////////////////////*/
function owner() external view returns (address) {
}
/*///////////////////////////////////////////////////////////////
ERC-20-LIKE LOGIC
//////////////////////////////////////////////////////////////*/
function transfer(address to, uint256 tokenId) external {
}
/*///////////////////////////////////////////////////////////////
ERC-721 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) external pure returns (bool supported) {
}
function approve(address spender, uint256 tokenId) external {
}
function setApprovalForAll(address operator, bool approved) external {
}
function transferFrom(address, address to, uint256 tokenId) public {
}
function safeTransferFrom(address, address to, uint256 tokenId) external {
}
function safeTransferFrom(address, address to, uint256 tokenId, bytes memory data) public {
}
/*///////////////////////////////////////////////////////////////
INTERNAL UTILS
//////////////////////////////////////////////////////////////*/
function _transfer(address from, address to, uint256 tokenId) internal {
require(<FILL_ME>)
balanceOf[from]--;
balanceOf[to]++;
delete getApproved[tokenId];
ownerOf[tokenId] = to;
emit Transfer(msg.sender, to, tokenId);
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(uint256 tokenId) internal {
}
}
| ownerOf[tokenId]==from | 309,013 | ownerOf[tokenId]==from |
"ALREADY_MINTED" | // SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.7;
/// @notice Modern and gas efficient ERC-721 + ERC-20/EIP-2612-like implementation,
/// including the MetaData, and partially, Enumerable extensions.
contract ERC721 {
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed spender, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*///////////////////////////////////////////////////////////////
METADATA STORAGE
//////////////////////////////////////////////////////////////*/
address implementation_;
address public admin; //Lame requirement from opensea
/*///////////////////////////////////////////////////////////////
ERC-721 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 public totalSupply;
uint256 public oldSupply;
uint256 public minted;
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public ownerOf;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*///////////////////////////////////////////////////////////////
VIEW FUNCTION
//////////////////////////////////////////////////////////////*/
function owner() external view returns (address) {
}
/*///////////////////////////////////////////////////////////////
ERC-20-LIKE LOGIC
//////////////////////////////////////////////////////////////*/
function transfer(address to, uint256 tokenId) external {
}
/*///////////////////////////////////////////////////////////////
ERC-721 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) external pure returns (bool supported) {
}
function approve(address spender, uint256 tokenId) external {
}
function setApprovalForAll(address operator, bool approved) external {
}
function transferFrom(address, address to, uint256 tokenId) public {
}
function safeTransferFrom(address, address to, uint256 tokenId) external {
}
function safeTransferFrom(address, address to, uint256 tokenId, bytes memory data) public {
}
/*///////////////////////////////////////////////////////////////
INTERNAL UTILS
//////////////////////////////////////////////////////////////*/
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _mint(address to, uint256 tokenId) internal {
require(<FILL_ME>)
uint maxSupply = oldSupply + minted++;
require(totalSupply++ <= maxSupply, "MAX SUPPLY REACHED");
// This is safe because the sum of all user
// balances can't exceed type(uint256).max!
unchecked {
balanceOf[to]++;
}
ownerOf[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal {
}
}
| ownerOf[tokenId]==address(0),"ALREADY_MINTED" | 309,013 | ownerOf[tokenId]==address(0) |
"MAX SUPPLY REACHED" | // SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.7;
/// @notice Modern and gas efficient ERC-721 + ERC-20/EIP-2612-like implementation,
/// including the MetaData, and partially, Enumerable extensions.
contract ERC721 {
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed spender, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*///////////////////////////////////////////////////////////////
METADATA STORAGE
//////////////////////////////////////////////////////////////*/
address implementation_;
address public admin; //Lame requirement from opensea
/*///////////////////////////////////////////////////////////////
ERC-721 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 public totalSupply;
uint256 public oldSupply;
uint256 public minted;
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public ownerOf;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*///////////////////////////////////////////////////////////////
VIEW FUNCTION
//////////////////////////////////////////////////////////////*/
function owner() external view returns (address) {
}
/*///////////////////////////////////////////////////////////////
ERC-20-LIKE LOGIC
//////////////////////////////////////////////////////////////*/
function transfer(address to, uint256 tokenId) external {
}
/*///////////////////////////////////////////////////////////////
ERC-721 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) external pure returns (bool supported) {
}
function approve(address spender, uint256 tokenId) external {
}
function setApprovalForAll(address operator, bool approved) external {
}
function transferFrom(address, address to, uint256 tokenId) public {
}
function safeTransferFrom(address, address to, uint256 tokenId) external {
}
function safeTransferFrom(address, address to, uint256 tokenId, bytes memory data) public {
}
/*///////////////////////////////////////////////////////////////
INTERNAL UTILS
//////////////////////////////////////////////////////////////*/
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _mint(address to, uint256 tokenId) internal {
require(ownerOf[tokenId] == address(0), "ALREADY_MINTED");
uint maxSupply = oldSupply + minted++;
require(<FILL_ME>)
// This is safe because the sum of all user
// balances can't exceed type(uint256).max!
unchecked {
balanceOf[to]++;
}
ownerOf[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal {
}
}
| totalSupply++<=maxSupply,"MAX SUPPLY REACHED" | 309,013 | totalSupply++<=maxSupply |
"NOT_MINTED" | // SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.7;
/// @notice Modern and gas efficient ERC-721 + ERC-20/EIP-2612-like implementation,
/// including the MetaData, and partially, Enumerable extensions.
contract ERC721 {
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed spender, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*///////////////////////////////////////////////////////////////
METADATA STORAGE
//////////////////////////////////////////////////////////////*/
address implementation_;
address public admin; //Lame requirement from opensea
/*///////////////////////////////////////////////////////////////
ERC-721 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 public totalSupply;
uint256 public oldSupply;
uint256 public minted;
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public ownerOf;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*///////////////////////////////////////////////////////////////
VIEW FUNCTION
//////////////////////////////////////////////////////////////*/
function owner() external view returns (address) {
}
/*///////////////////////////////////////////////////////////////
ERC-20-LIKE LOGIC
//////////////////////////////////////////////////////////////*/
function transfer(address to, uint256 tokenId) external {
}
/*///////////////////////////////////////////////////////////////
ERC-721 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) external pure returns (bool supported) {
}
function approve(address spender, uint256 tokenId) external {
}
function setApprovalForAll(address operator, bool approved) external {
}
function transferFrom(address, address to, uint256 tokenId) public {
}
function safeTransferFrom(address, address to, uint256 tokenId) external {
}
function safeTransferFrom(address, address to, uint256 tokenId, bytes memory data) public {
}
/*///////////////////////////////////////////////////////////////
INTERNAL UTILS
//////////////////////////////////////////////////////////////*/
function _transfer(address from, address to, uint256 tokenId) internal {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(uint256 tokenId) internal {
address owner_ = ownerOf[tokenId];
require(<FILL_ME>)
totalSupply--;
balanceOf[owner_]--;
delete ownerOf[tokenId];
emit Transfer(owner_, address(0), tokenId);
}
}
| ownerOf[tokenId]!=address(0),"NOT_MINTED" | 309,013 | ownerOf[tokenId]!=address(0) |
"You already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";
contract GOONYFRENS is ERC1155, Ownable {
using Strings for string;
mapping(uint256 => uint256) private _totalSupply;
//constants
uint256 constant nft1 = 1;
uint256 constant nft2 = 2;
uint256 constant nft3 = 3;
uint256 constant nft4 = 4;
uint256 constant nft5 = 5;
uint256 constant nft6 = 6;
uint256 constant nft7 = 7;
uint256 constant nft8 = 8;
uint256 constant nft9 = 9;
uint256 constant nft10 = 10;
uint256 constant nft11 = 11;
uint256 constant nft12 = 12;
uint256 constant nft13 = 13;
uint256 constant nft14 = 14;
uint256 constant nft15 = 15;
uint256 public nft1s;
uint256 public nft2s;
uint256 public nft3s;
uint256 public nft4s;
uint256 public nft5s;
uint256 public nft6s;
uint256 public nft7s;
uint256 public nft8s;
uint256 public nft9s;
uint256 public nft10s;
uint256 public nft11s;
uint256 public nft12s;
uint256 public nft13s;
uint256 public nft14s;
uint256 public nft15s;
uint256 public supplyPerNFT = 500;
string public _baseURI;
string public _contractURI;
bool saleLive = false;
//mappings
mapping(address => uint256) private mintCountMap1;
mapping(address => uint256) public allowedMintCountMap1;
uint256 private maxMintPerWallet1 = 1;
mapping(address => uint256) private mintCountMap2;
mapping(address => uint256) public allowedMintCountMap2;
uint256 private maxMintPerWallet2 = 1;
mapping(address => uint256) private mintCountMap3;
mapping(address => uint256) public allowedMintCountMap3;
uint256 private maxMintPerWallet3 = 1;
mapping(address => uint256) private mintCountMap4;
mapping(address => uint256) public allowedMintCountMap4;
uint256 private maxMintPerWallet4 = 1;
mapping(address => uint256) private mintCountMap5;
mapping(address => uint256) public allowedMintCountMap5;
uint256 private maxMintPerWallet5 = 1;
mapping(address => uint256) private mintCountMap6;
mapping(address => uint256) public allowedMintCountMap6;
uint256 private maxMintPerWallet6 = 1;
mapping(address => uint256) private mintCountMap7;
mapping(address => uint256) public allowedMintCountMap7;
uint256 private maxMintPerWallet7 = 1;
mapping(address => uint256) private mintCountMap8;
mapping(address => uint256) public allowedMintCountMap8;
uint256 private maxMintPerWallet8 = 1;
mapping(address => uint256) private mintCountMap9;
mapping(address => uint256) public allowedMintCountMap9;
uint256 private maxMintPerWallet9 = 1;
mapping(address => uint256) private mintCountMap10;
mapping(address => uint256) public allowedMintCountMap10;
uint256 private maxMintPerWallet10 = 1;
mapping(address => uint256) private mintCountMap11;
mapping(address => uint256) public allowedMintCountMap11;
uint256 private maxMintPerWallet11 = 1;
mapping(address => uint256) private mintCountMap12;
mapping(address => uint256) public allowedMintCountMap12;
uint256 private maxMintPerWallet12 = 1;
mapping(address => uint256) private mintCountMap13;
mapping(address => uint256) public allowedMintCountMap13;
uint256 private maxMintPerWallet13 = 1;
mapping(address => uint256) private mintCountMap14;
mapping(address => uint256) public allowedMintCountMap14;
uint256 private maxMintPerWallet14 = 1;
mapping(address => uint256) private mintCountMap15;
mapping(address => uint256) public allowedMintCountMap15;
uint256 private maxMintPerWallet15 = 1;
constructor() ERC1155(_baseURI) {}
// claim functions
function claimnft1(uint256 qty) public { //bmc
require(saleLive,"Sale is not live yet");
require(qty == 1,"You can only mint 1");
require(<FILL_ME>)
require(tx.origin == msg.sender); //stop contract buying
require(nft1s <= supplyPerNFT);
_mint(msg.sender, nft1, qty, "");
updateMintCount1(msg.sender, qty);
nft1s += qty;
}
function claimnft2(uint256 qty) public {
}
function claimnft3(uint256 qty) public {
}
function claimnft4(uint256 qty) public {
}
function claimnft5(uint256 qty) public {
}
function claimnft6(uint256 qty) public {
}
function claimnft7(uint256 qty) public {
}
function claimnft8(uint256 qty) public {
}
function claimnft9(uint256 qty) public {
}
function claimnft10(uint256 qty) public {
}
function claimnft11(uint256 qty) public {
}
function claimnft12(uint256 qty) public {
}
function claimnft13(uint256 qty) public {
}
function claimnft14(uint256 qty) public {
}
function claimnft15(uint256 qty) public {
}
//mapping logic
function updateMintCount1(address minter, uint256 count) private {
}
function allowedMintCount1(address minter) public view returns (uint256) {
}
function setMaxPerWallet1(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount2(address minter, uint256 count) private {
}
function allowedMintCount2(address minter) public view returns (uint256) {
}
function setMaxPerWallet2(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount3(address minter, uint256 count) private {
}
function allowedMintCount3(address minter) public view returns (uint256) {
}
function setMaxPerWallet3(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount4(address minter, uint256 count) private {
}
function allowedMintCount4(address minter) public view returns (uint256) {
}
function setMaxPerWallet4(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount5(address minter, uint256 count) private {
}
function allowedMintCount5(address minter) public view returns (uint256) {
}
function setMaxPerWallet5(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount6(address minter, uint256 count) private {
}
function allowedMintCount6(address minter) public view returns (uint256) {
}
function setMaxPerWallet6(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount7(address minter, uint256 count) private {
}
function allowedMintCount7(address minter) public view returns (uint256) {
}
function setMaxPerWallet7(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount8(address minter, uint256 count) private {
}
function allowedMintCount8(address minter) public view returns (uint256) {
}
function setMaxPerWallet8(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount9(address minter, uint256 count) private {
}
function allowedMintCount9(address minter) public view returns (uint256) {
}
function setMaxPerWallet9(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount10(address minter, uint256 count) private {
}
function allowedMintCount10(address minter) public view returns (uint256) {
}
function setMaxPerWallet10(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount11(address minter, uint256 count) private {
}
function allowedMintCount11(address minter) public view returns (uint256) {
}
function setMaxPerWallet11(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount12(address minter, uint256 count) private {
}
function allowedMintCount12(address minter) public view returns (uint256) {
}
function setMaxPerWallet12(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount13(address minter, uint256 count) private {
}
function allowedMintCount13(address minter) public view returns (uint256) {
}
function setMaxPerWallet13(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount14(address minter, uint256 count) private {
}
function allowedMintCount14(address minter) public view returns (uint256) {
}
function setMaxPerWallet14(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount15(address minter, uint256 count) private {
}
function allowedMintCount15(address minter) public view returns (uint256) {
}
function setMaxPerWallet15(uint256 _newMaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory newuri) public onlyOwner {
}
function setContractURI(string memory newuri) public onlyOwner {
}
function setMaxPerNFT(uint256 _newMaxAmount) public onlyOwner {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
function totalSupply(uint256 id) public view virtual returns (uint256) {
}
function exists(uint256 id) public view virtual returns (bool) {
}
function setSale(bool _status) public onlyOwner {
}
function withdrawToOwner() external onlyOwner {
}
}
| allowedMintCount1(msg.sender)>=qty,"You already claimed" | 309,022 | allowedMintCount1(msg.sender)>=qty |
"You already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";
contract GOONYFRENS is ERC1155, Ownable {
using Strings for string;
mapping(uint256 => uint256) private _totalSupply;
//constants
uint256 constant nft1 = 1;
uint256 constant nft2 = 2;
uint256 constant nft3 = 3;
uint256 constant nft4 = 4;
uint256 constant nft5 = 5;
uint256 constant nft6 = 6;
uint256 constant nft7 = 7;
uint256 constant nft8 = 8;
uint256 constant nft9 = 9;
uint256 constant nft10 = 10;
uint256 constant nft11 = 11;
uint256 constant nft12 = 12;
uint256 constant nft13 = 13;
uint256 constant nft14 = 14;
uint256 constant nft15 = 15;
uint256 public nft1s;
uint256 public nft2s;
uint256 public nft3s;
uint256 public nft4s;
uint256 public nft5s;
uint256 public nft6s;
uint256 public nft7s;
uint256 public nft8s;
uint256 public nft9s;
uint256 public nft10s;
uint256 public nft11s;
uint256 public nft12s;
uint256 public nft13s;
uint256 public nft14s;
uint256 public nft15s;
uint256 public supplyPerNFT = 500;
string public _baseURI;
string public _contractURI;
bool saleLive = false;
//mappings
mapping(address => uint256) private mintCountMap1;
mapping(address => uint256) public allowedMintCountMap1;
uint256 private maxMintPerWallet1 = 1;
mapping(address => uint256) private mintCountMap2;
mapping(address => uint256) public allowedMintCountMap2;
uint256 private maxMintPerWallet2 = 1;
mapping(address => uint256) private mintCountMap3;
mapping(address => uint256) public allowedMintCountMap3;
uint256 private maxMintPerWallet3 = 1;
mapping(address => uint256) private mintCountMap4;
mapping(address => uint256) public allowedMintCountMap4;
uint256 private maxMintPerWallet4 = 1;
mapping(address => uint256) private mintCountMap5;
mapping(address => uint256) public allowedMintCountMap5;
uint256 private maxMintPerWallet5 = 1;
mapping(address => uint256) private mintCountMap6;
mapping(address => uint256) public allowedMintCountMap6;
uint256 private maxMintPerWallet6 = 1;
mapping(address => uint256) private mintCountMap7;
mapping(address => uint256) public allowedMintCountMap7;
uint256 private maxMintPerWallet7 = 1;
mapping(address => uint256) private mintCountMap8;
mapping(address => uint256) public allowedMintCountMap8;
uint256 private maxMintPerWallet8 = 1;
mapping(address => uint256) private mintCountMap9;
mapping(address => uint256) public allowedMintCountMap9;
uint256 private maxMintPerWallet9 = 1;
mapping(address => uint256) private mintCountMap10;
mapping(address => uint256) public allowedMintCountMap10;
uint256 private maxMintPerWallet10 = 1;
mapping(address => uint256) private mintCountMap11;
mapping(address => uint256) public allowedMintCountMap11;
uint256 private maxMintPerWallet11 = 1;
mapping(address => uint256) private mintCountMap12;
mapping(address => uint256) public allowedMintCountMap12;
uint256 private maxMintPerWallet12 = 1;
mapping(address => uint256) private mintCountMap13;
mapping(address => uint256) public allowedMintCountMap13;
uint256 private maxMintPerWallet13 = 1;
mapping(address => uint256) private mintCountMap14;
mapping(address => uint256) public allowedMintCountMap14;
uint256 private maxMintPerWallet14 = 1;
mapping(address => uint256) private mintCountMap15;
mapping(address => uint256) public allowedMintCountMap15;
uint256 private maxMintPerWallet15 = 1;
constructor() ERC1155(_baseURI) {}
// claim functions
function claimnft1(uint256 qty) public {
}
function claimnft2(uint256 qty) public { //bomb
require(saleLive,"Sale is not live yet");
require(qty == 1,"You can only mint 1");
require(<FILL_ME>)
require(tx.origin == msg.sender); //stop contract buying
require(nft2s <= supplyPerNFT);
_mint(msg.sender, nft2, qty, "");
updateMintCount2(msg.sender, qty);
nft2s += qty;
}
function claimnft3(uint256 qty) public {
}
function claimnft4(uint256 qty) public {
}
function claimnft5(uint256 qty) public {
}
function claimnft6(uint256 qty) public {
}
function claimnft7(uint256 qty) public {
}
function claimnft8(uint256 qty) public {
}
function claimnft9(uint256 qty) public {
}
function claimnft10(uint256 qty) public {
}
function claimnft11(uint256 qty) public {
}
function claimnft12(uint256 qty) public {
}
function claimnft13(uint256 qty) public {
}
function claimnft14(uint256 qty) public {
}
function claimnft15(uint256 qty) public {
}
//mapping logic
function updateMintCount1(address minter, uint256 count) private {
}
function allowedMintCount1(address minter) public view returns (uint256) {
}
function setMaxPerWallet1(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount2(address minter, uint256 count) private {
}
function allowedMintCount2(address minter) public view returns (uint256) {
}
function setMaxPerWallet2(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount3(address minter, uint256 count) private {
}
function allowedMintCount3(address minter) public view returns (uint256) {
}
function setMaxPerWallet3(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount4(address minter, uint256 count) private {
}
function allowedMintCount4(address minter) public view returns (uint256) {
}
function setMaxPerWallet4(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount5(address minter, uint256 count) private {
}
function allowedMintCount5(address minter) public view returns (uint256) {
}
function setMaxPerWallet5(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount6(address minter, uint256 count) private {
}
function allowedMintCount6(address minter) public view returns (uint256) {
}
function setMaxPerWallet6(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount7(address minter, uint256 count) private {
}
function allowedMintCount7(address minter) public view returns (uint256) {
}
function setMaxPerWallet7(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount8(address minter, uint256 count) private {
}
function allowedMintCount8(address minter) public view returns (uint256) {
}
function setMaxPerWallet8(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount9(address minter, uint256 count) private {
}
function allowedMintCount9(address minter) public view returns (uint256) {
}
function setMaxPerWallet9(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount10(address minter, uint256 count) private {
}
function allowedMintCount10(address minter) public view returns (uint256) {
}
function setMaxPerWallet10(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount11(address minter, uint256 count) private {
}
function allowedMintCount11(address minter) public view returns (uint256) {
}
function setMaxPerWallet11(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount12(address minter, uint256 count) private {
}
function allowedMintCount12(address minter) public view returns (uint256) {
}
function setMaxPerWallet12(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount13(address minter, uint256 count) private {
}
function allowedMintCount13(address minter) public view returns (uint256) {
}
function setMaxPerWallet13(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount14(address minter, uint256 count) private {
}
function allowedMintCount14(address minter) public view returns (uint256) {
}
function setMaxPerWallet14(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount15(address minter, uint256 count) private {
}
function allowedMintCount15(address minter) public view returns (uint256) {
}
function setMaxPerWallet15(uint256 _newMaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory newuri) public onlyOwner {
}
function setContractURI(string memory newuri) public onlyOwner {
}
function setMaxPerNFT(uint256 _newMaxAmount) public onlyOwner {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
function totalSupply(uint256 id) public view virtual returns (uint256) {
}
function exists(uint256 id) public view virtual returns (bool) {
}
function setSale(bool _status) public onlyOwner {
}
function withdrawToOwner() external onlyOwner {
}
}
| allowedMintCount2(msg.sender)>=qty,"You already claimed" | 309,022 | allowedMintCount2(msg.sender)>=qty |
"You already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";
contract GOONYFRENS is ERC1155, Ownable {
using Strings for string;
mapping(uint256 => uint256) private _totalSupply;
//constants
uint256 constant nft1 = 1;
uint256 constant nft2 = 2;
uint256 constant nft3 = 3;
uint256 constant nft4 = 4;
uint256 constant nft5 = 5;
uint256 constant nft6 = 6;
uint256 constant nft7 = 7;
uint256 constant nft8 = 8;
uint256 constant nft9 = 9;
uint256 constant nft10 = 10;
uint256 constant nft11 = 11;
uint256 constant nft12 = 12;
uint256 constant nft13 = 13;
uint256 constant nft14 = 14;
uint256 constant nft15 = 15;
uint256 public nft1s;
uint256 public nft2s;
uint256 public nft3s;
uint256 public nft4s;
uint256 public nft5s;
uint256 public nft6s;
uint256 public nft7s;
uint256 public nft8s;
uint256 public nft9s;
uint256 public nft10s;
uint256 public nft11s;
uint256 public nft12s;
uint256 public nft13s;
uint256 public nft14s;
uint256 public nft15s;
uint256 public supplyPerNFT = 500;
string public _baseURI;
string public _contractURI;
bool saleLive = false;
//mappings
mapping(address => uint256) private mintCountMap1;
mapping(address => uint256) public allowedMintCountMap1;
uint256 private maxMintPerWallet1 = 1;
mapping(address => uint256) private mintCountMap2;
mapping(address => uint256) public allowedMintCountMap2;
uint256 private maxMintPerWallet2 = 1;
mapping(address => uint256) private mintCountMap3;
mapping(address => uint256) public allowedMintCountMap3;
uint256 private maxMintPerWallet3 = 1;
mapping(address => uint256) private mintCountMap4;
mapping(address => uint256) public allowedMintCountMap4;
uint256 private maxMintPerWallet4 = 1;
mapping(address => uint256) private mintCountMap5;
mapping(address => uint256) public allowedMintCountMap5;
uint256 private maxMintPerWallet5 = 1;
mapping(address => uint256) private mintCountMap6;
mapping(address => uint256) public allowedMintCountMap6;
uint256 private maxMintPerWallet6 = 1;
mapping(address => uint256) private mintCountMap7;
mapping(address => uint256) public allowedMintCountMap7;
uint256 private maxMintPerWallet7 = 1;
mapping(address => uint256) private mintCountMap8;
mapping(address => uint256) public allowedMintCountMap8;
uint256 private maxMintPerWallet8 = 1;
mapping(address => uint256) private mintCountMap9;
mapping(address => uint256) public allowedMintCountMap9;
uint256 private maxMintPerWallet9 = 1;
mapping(address => uint256) private mintCountMap10;
mapping(address => uint256) public allowedMintCountMap10;
uint256 private maxMintPerWallet10 = 1;
mapping(address => uint256) private mintCountMap11;
mapping(address => uint256) public allowedMintCountMap11;
uint256 private maxMintPerWallet11 = 1;
mapping(address => uint256) private mintCountMap12;
mapping(address => uint256) public allowedMintCountMap12;
uint256 private maxMintPerWallet12 = 1;
mapping(address => uint256) private mintCountMap13;
mapping(address => uint256) public allowedMintCountMap13;
uint256 private maxMintPerWallet13 = 1;
mapping(address => uint256) private mintCountMap14;
mapping(address => uint256) public allowedMintCountMap14;
uint256 private maxMintPerWallet14 = 1;
mapping(address => uint256) private mintCountMap15;
mapping(address => uint256) public allowedMintCountMap15;
uint256 private maxMintPerWallet15 = 1;
constructor() ERC1155(_baseURI) {}
// claim functions
function claimnft1(uint256 qty) public {
}
function claimnft2(uint256 qty) public {
}
function claimnft3(uint256 qty) public { //boss
require(saleLive,"Sale is not live yet");
require(qty == 1,"You can only mint 1");
require(<FILL_ME>)
require(tx.origin == msg.sender); //stop contract buying
require(nft3s <= supplyPerNFT);
_mint(msg.sender, nft3, qty, "");
updateMintCount3(msg.sender, qty);
nft3s += qty;
}
function claimnft4(uint256 qty) public {
}
function claimnft5(uint256 qty) public {
}
function claimnft6(uint256 qty) public {
}
function claimnft7(uint256 qty) public {
}
function claimnft8(uint256 qty) public {
}
function claimnft9(uint256 qty) public {
}
function claimnft10(uint256 qty) public {
}
function claimnft11(uint256 qty) public {
}
function claimnft12(uint256 qty) public {
}
function claimnft13(uint256 qty) public {
}
function claimnft14(uint256 qty) public {
}
function claimnft15(uint256 qty) public {
}
//mapping logic
function updateMintCount1(address minter, uint256 count) private {
}
function allowedMintCount1(address minter) public view returns (uint256) {
}
function setMaxPerWallet1(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount2(address minter, uint256 count) private {
}
function allowedMintCount2(address minter) public view returns (uint256) {
}
function setMaxPerWallet2(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount3(address minter, uint256 count) private {
}
function allowedMintCount3(address minter) public view returns (uint256) {
}
function setMaxPerWallet3(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount4(address minter, uint256 count) private {
}
function allowedMintCount4(address minter) public view returns (uint256) {
}
function setMaxPerWallet4(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount5(address minter, uint256 count) private {
}
function allowedMintCount5(address minter) public view returns (uint256) {
}
function setMaxPerWallet5(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount6(address minter, uint256 count) private {
}
function allowedMintCount6(address minter) public view returns (uint256) {
}
function setMaxPerWallet6(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount7(address minter, uint256 count) private {
}
function allowedMintCount7(address minter) public view returns (uint256) {
}
function setMaxPerWallet7(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount8(address minter, uint256 count) private {
}
function allowedMintCount8(address minter) public view returns (uint256) {
}
function setMaxPerWallet8(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount9(address minter, uint256 count) private {
}
function allowedMintCount9(address minter) public view returns (uint256) {
}
function setMaxPerWallet9(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount10(address minter, uint256 count) private {
}
function allowedMintCount10(address minter) public view returns (uint256) {
}
function setMaxPerWallet10(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount11(address minter, uint256 count) private {
}
function allowedMintCount11(address minter) public view returns (uint256) {
}
function setMaxPerWallet11(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount12(address minter, uint256 count) private {
}
function allowedMintCount12(address minter) public view returns (uint256) {
}
function setMaxPerWallet12(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount13(address minter, uint256 count) private {
}
function allowedMintCount13(address minter) public view returns (uint256) {
}
function setMaxPerWallet13(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount14(address minter, uint256 count) private {
}
function allowedMintCount14(address minter) public view returns (uint256) {
}
function setMaxPerWallet14(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount15(address minter, uint256 count) private {
}
function allowedMintCount15(address minter) public view returns (uint256) {
}
function setMaxPerWallet15(uint256 _newMaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory newuri) public onlyOwner {
}
function setContractURI(string memory newuri) public onlyOwner {
}
function setMaxPerNFT(uint256 _newMaxAmount) public onlyOwner {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
function totalSupply(uint256 id) public view virtual returns (uint256) {
}
function exists(uint256 id) public view virtual returns (bool) {
}
function setSale(bool _status) public onlyOwner {
}
function withdrawToOwner() external onlyOwner {
}
}
| allowedMintCount3(msg.sender)>=qty,"You already claimed" | 309,022 | allowedMintCount3(msg.sender)>=qty |
"You already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";
contract GOONYFRENS is ERC1155, Ownable {
using Strings for string;
mapping(uint256 => uint256) private _totalSupply;
//constants
uint256 constant nft1 = 1;
uint256 constant nft2 = 2;
uint256 constant nft3 = 3;
uint256 constant nft4 = 4;
uint256 constant nft5 = 5;
uint256 constant nft6 = 6;
uint256 constant nft7 = 7;
uint256 constant nft8 = 8;
uint256 constant nft9 = 9;
uint256 constant nft10 = 10;
uint256 constant nft11 = 11;
uint256 constant nft12 = 12;
uint256 constant nft13 = 13;
uint256 constant nft14 = 14;
uint256 constant nft15 = 15;
uint256 public nft1s;
uint256 public nft2s;
uint256 public nft3s;
uint256 public nft4s;
uint256 public nft5s;
uint256 public nft6s;
uint256 public nft7s;
uint256 public nft8s;
uint256 public nft9s;
uint256 public nft10s;
uint256 public nft11s;
uint256 public nft12s;
uint256 public nft13s;
uint256 public nft14s;
uint256 public nft15s;
uint256 public supplyPerNFT = 500;
string public _baseURI;
string public _contractURI;
bool saleLive = false;
//mappings
mapping(address => uint256) private mintCountMap1;
mapping(address => uint256) public allowedMintCountMap1;
uint256 private maxMintPerWallet1 = 1;
mapping(address => uint256) private mintCountMap2;
mapping(address => uint256) public allowedMintCountMap2;
uint256 private maxMintPerWallet2 = 1;
mapping(address => uint256) private mintCountMap3;
mapping(address => uint256) public allowedMintCountMap3;
uint256 private maxMintPerWallet3 = 1;
mapping(address => uint256) private mintCountMap4;
mapping(address => uint256) public allowedMintCountMap4;
uint256 private maxMintPerWallet4 = 1;
mapping(address => uint256) private mintCountMap5;
mapping(address => uint256) public allowedMintCountMap5;
uint256 private maxMintPerWallet5 = 1;
mapping(address => uint256) private mintCountMap6;
mapping(address => uint256) public allowedMintCountMap6;
uint256 private maxMintPerWallet6 = 1;
mapping(address => uint256) private mintCountMap7;
mapping(address => uint256) public allowedMintCountMap7;
uint256 private maxMintPerWallet7 = 1;
mapping(address => uint256) private mintCountMap8;
mapping(address => uint256) public allowedMintCountMap8;
uint256 private maxMintPerWallet8 = 1;
mapping(address => uint256) private mintCountMap9;
mapping(address => uint256) public allowedMintCountMap9;
uint256 private maxMintPerWallet9 = 1;
mapping(address => uint256) private mintCountMap10;
mapping(address => uint256) public allowedMintCountMap10;
uint256 private maxMintPerWallet10 = 1;
mapping(address => uint256) private mintCountMap11;
mapping(address => uint256) public allowedMintCountMap11;
uint256 private maxMintPerWallet11 = 1;
mapping(address => uint256) private mintCountMap12;
mapping(address => uint256) public allowedMintCountMap12;
uint256 private maxMintPerWallet12 = 1;
mapping(address => uint256) private mintCountMap13;
mapping(address => uint256) public allowedMintCountMap13;
uint256 private maxMintPerWallet13 = 1;
mapping(address => uint256) private mintCountMap14;
mapping(address => uint256) public allowedMintCountMap14;
uint256 private maxMintPerWallet14 = 1;
mapping(address => uint256) private mintCountMap15;
mapping(address => uint256) public allowedMintCountMap15;
uint256 private maxMintPerWallet15 = 1;
constructor() ERC1155(_baseURI) {}
// claim functions
function claimnft1(uint256 qty) public {
}
function claimnft2(uint256 qty) public {
}
function claimnft3(uint256 qty) public {
}
function claimnft4(uint256 qty) public { //chainrun
require(saleLive,"Sale is not live yet");
require(qty == 1,"You can only mint 1");
require(<FILL_ME>)
require(tx.origin == msg.sender); //stop contract buying
require(nft4s <= supplyPerNFT);
_mint(msg.sender, nft4, qty, "");
updateMintCount4(msg.sender, qty);
nft4s += qty;
}
function claimnft5(uint256 qty) public {
}
function claimnft6(uint256 qty) public {
}
function claimnft7(uint256 qty) public {
}
function claimnft8(uint256 qty) public {
}
function claimnft9(uint256 qty) public {
}
function claimnft10(uint256 qty) public {
}
function claimnft11(uint256 qty) public {
}
function claimnft12(uint256 qty) public {
}
function claimnft13(uint256 qty) public {
}
function claimnft14(uint256 qty) public {
}
function claimnft15(uint256 qty) public {
}
//mapping logic
function updateMintCount1(address minter, uint256 count) private {
}
function allowedMintCount1(address minter) public view returns (uint256) {
}
function setMaxPerWallet1(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount2(address minter, uint256 count) private {
}
function allowedMintCount2(address minter) public view returns (uint256) {
}
function setMaxPerWallet2(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount3(address minter, uint256 count) private {
}
function allowedMintCount3(address minter) public view returns (uint256) {
}
function setMaxPerWallet3(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount4(address minter, uint256 count) private {
}
function allowedMintCount4(address minter) public view returns (uint256) {
}
function setMaxPerWallet4(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount5(address minter, uint256 count) private {
}
function allowedMintCount5(address minter) public view returns (uint256) {
}
function setMaxPerWallet5(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount6(address minter, uint256 count) private {
}
function allowedMintCount6(address minter) public view returns (uint256) {
}
function setMaxPerWallet6(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount7(address minter, uint256 count) private {
}
function allowedMintCount7(address minter) public view returns (uint256) {
}
function setMaxPerWallet7(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount8(address minter, uint256 count) private {
}
function allowedMintCount8(address minter) public view returns (uint256) {
}
function setMaxPerWallet8(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount9(address minter, uint256 count) private {
}
function allowedMintCount9(address minter) public view returns (uint256) {
}
function setMaxPerWallet9(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount10(address minter, uint256 count) private {
}
function allowedMintCount10(address minter) public view returns (uint256) {
}
function setMaxPerWallet10(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount11(address minter, uint256 count) private {
}
function allowedMintCount11(address minter) public view returns (uint256) {
}
function setMaxPerWallet11(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount12(address minter, uint256 count) private {
}
function allowedMintCount12(address minter) public view returns (uint256) {
}
function setMaxPerWallet12(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount13(address minter, uint256 count) private {
}
function allowedMintCount13(address minter) public view returns (uint256) {
}
function setMaxPerWallet13(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount14(address minter, uint256 count) private {
}
function allowedMintCount14(address minter) public view returns (uint256) {
}
function setMaxPerWallet14(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount15(address minter, uint256 count) private {
}
function allowedMintCount15(address minter) public view returns (uint256) {
}
function setMaxPerWallet15(uint256 _newMaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory newuri) public onlyOwner {
}
function setContractURI(string memory newuri) public onlyOwner {
}
function setMaxPerNFT(uint256 _newMaxAmount) public onlyOwner {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
function totalSupply(uint256 id) public view virtual returns (uint256) {
}
function exists(uint256 id) public view virtual returns (bool) {
}
function setSale(bool _status) public onlyOwner {
}
function withdrawToOwner() external onlyOwner {
}
}
| allowedMintCount4(msg.sender)>=qty,"You already claimed" | 309,022 | allowedMintCount4(msg.sender)>=qty |
"You already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";
contract GOONYFRENS is ERC1155, Ownable {
using Strings for string;
mapping(uint256 => uint256) private _totalSupply;
//constants
uint256 constant nft1 = 1;
uint256 constant nft2 = 2;
uint256 constant nft3 = 3;
uint256 constant nft4 = 4;
uint256 constant nft5 = 5;
uint256 constant nft6 = 6;
uint256 constant nft7 = 7;
uint256 constant nft8 = 8;
uint256 constant nft9 = 9;
uint256 constant nft10 = 10;
uint256 constant nft11 = 11;
uint256 constant nft12 = 12;
uint256 constant nft13 = 13;
uint256 constant nft14 = 14;
uint256 constant nft15 = 15;
uint256 public nft1s;
uint256 public nft2s;
uint256 public nft3s;
uint256 public nft4s;
uint256 public nft5s;
uint256 public nft6s;
uint256 public nft7s;
uint256 public nft8s;
uint256 public nft9s;
uint256 public nft10s;
uint256 public nft11s;
uint256 public nft12s;
uint256 public nft13s;
uint256 public nft14s;
uint256 public nft15s;
uint256 public supplyPerNFT = 500;
string public _baseURI;
string public _contractURI;
bool saleLive = false;
//mappings
mapping(address => uint256) private mintCountMap1;
mapping(address => uint256) public allowedMintCountMap1;
uint256 private maxMintPerWallet1 = 1;
mapping(address => uint256) private mintCountMap2;
mapping(address => uint256) public allowedMintCountMap2;
uint256 private maxMintPerWallet2 = 1;
mapping(address => uint256) private mintCountMap3;
mapping(address => uint256) public allowedMintCountMap3;
uint256 private maxMintPerWallet3 = 1;
mapping(address => uint256) private mintCountMap4;
mapping(address => uint256) public allowedMintCountMap4;
uint256 private maxMintPerWallet4 = 1;
mapping(address => uint256) private mintCountMap5;
mapping(address => uint256) public allowedMintCountMap5;
uint256 private maxMintPerWallet5 = 1;
mapping(address => uint256) private mintCountMap6;
mapping(address => uint256) public allowedMintCountMap6;
uint256 private maxMintPerWallet6 = 1;
mapping(address => uint256) private mintCountMap7;
mapping(address => uint256) public allowedMintCountMap7;
uint256 private maxMintPerWallet7 = 1;
mapping(address => uint256) private mintCountMap8;
mapping(address => uint256) public allowedMintCountMap8;
uint256 private maxMintPerWallet8 = 1;
mapping(address => uint256) private mintCountMap9;
mapping(address => uint256) public allowedMintCountMap9;
uint256 private maxMintPerWallet9 = 1;
mapping(address => uint256) private mintCountMap10;
mapping(address => uint256) public allowedMintCountMap10;
uint256 private maxMintPerWallet10 = 1;
mapping(address => uint256) private mintCountMap11;
mapping(address => uint256) public allowedMintCountMap11;
uint256 private maxMintPerWallet11 = 1;
mapping(address => uint256) private mintCountMap12;
mapping(address => uint256) public allowedMintCountMap12;
uint256 private maxMintPerWallet12 = 1;
mapping(address => uint256) private mintCountMap13;
mapping(address => uint256) public allowedMintCountMap13;
uint256 private maxMintPerWallet13 = 1;
mapping(address => uint256) private mintCountMap14;
mapping(address => uint256) public allowedMintCountMap14;
uint256 private maxMintPerWallet14 = 1;
mapping(address => uint256) private mintCountMap15;
mapping(address => uint256) public allowedMintCountMap15;
uint256 private maxMintPerWallet15 = 1;
constructor() ERC1155(_baseURI) {}
// claim functions
function claimnft1(uint256 qty) public {
}
function claimnft2(uint256 qty) public {
}
function claimnft3(uint256 qty) public {
}
function claimnft4(uint256 qty) public {
}
function claimnft5(uint256 qty) public { //cryptoon
require(saleLive,"Sale is not live yet");
require(qty == 1,"You can only mint 1");
require(<FILL_ME>)
require(tx.origin == msg.sender); //stop contract buying
require(nft5s <= supplyPerNFT);
_mint(msg.sender, nft5, qty, "");
updateMintCount5(msg.sender, qty);
nft5s += qty;
}
function claimnft6(uint256 qty) public {
}
function claimnft7(uint256 qty) public {
}
function claimnft8(uint256 qty) public {
}
function claimnft9(uint256 qty) public {
}
function claimnft10(uint256 qty) public {
}
function claimnft11(uint256 qty) public {
}
function claimnft12(uint256 qty) public {
}
function claimnft13(uint256 qty) public {
}
function claimnft14(uint256 qty) public {
}
function claimnft15(uint256 qty) public {
}
//mapping logic
function updateMintCount1(address minter, uint256 count) private {
}
function allowedMintCount1(address minter) public view returns (uint256) {
}
function setMaxPerWallet1(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount2(address minter, uint256 count) private {
}
function allowedMintCount2(address minter) public view returns (uint256) {
}
function setMaxPerWallet2(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount3(address minter, uint256 count) private {
}
function allowedMintCount3(address minter) public view returns (uint256) {
}
function setMaxPerWallet3(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount4(address minter, uint256 count) private {
}
function allowedMintCount4(address minter) public view returns (uint256) {
}
function setMaxPerWallet4(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount5(address minter, uint256 count) private {
}
function allowedMintCount5(address minter) public view returns (uint256) {
}
function setMaxPerWallet5(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount6(address minter, uint256 count) private {
}
function allowedMintCount6(address minter) public view returns (uint256) {
}
function setMaxPerWallet6(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount7(address minter, uint256 count) private {
}
function allowedMintCount7(address minter) public view returns (uint256) {
}
function setMaxPerWallet7(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount8(address minter, uint256 count) private {
}
function allowedMintCount8(address minter) public view returns (uint256) {
}
function setMaxPerWallet8(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount9(address minter, uint256 count) private {
}
function allowedMintCount9(address minter) public view returns (uint256) {
}
function setMaxPerWallet9(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount10(address minter, uint256 count) private {
}
function allowedMintCount10(address minter) public view returns (uint256) {
}
function setMaxPerWallet10(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount11(address minter, uint256 count) private {
}
function allowedMintCount11(address minter) public view returns (uint256) {
}
function setMaxPerWallet11(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount12(address minter, uint256 count) private {
}
function allowedMintCount12(address minter) public view returns (uint256) {
}
function setMaxPerWallet12(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount13(address minter, uint256 count) private {
}
function allowedMintCount13(address minter) public view returns (uint256) {
}
function setMaxPerWallet13(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount14(address minter, uint256 count) private {
}
function allowedMintCount14(address minter) public view returns (uint256) {
}
function setMaxPerWallet14(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount15(address minter, uint256 count) private {
}
function allowedMintCount15(address minter) public view returns (uint256) {
}
function setMaxPerWallet15(uint256 _newMaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory newuri) public onlyOwner {
}
function setContractURI(string memory newuri) public onlyOwner {
}
function setMaxPerNFT(uint256 _newMaxAmount) public onlyOwner {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
function totalSupply(uint256 id) public view virtual returns (uint256) {
}
function exists(uint256 id) public view virtual returns (bool) {
}
function setSale(bool _status) public onlyOwner {
}
function withdrawToOwner() external onlyOwner {
}
}
| allowedMintCount5(msg.sender)>=qty,"You already claimed" | 309,022 | allowedMintCount5(msg.sender)>=qty |
"You already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";
contract GOONYFRENS is ERC1155, Ownable {
using Strings for string;
mapping(uint256 => uint256) private _totalSupply;
//constants
uint256 constant nft1 = 1;
uint256 constant nft2 = 2;
uint256 constant nft3 = 3;
uint256 constant nft4 = 4;
uint256 constant nft5 = 5;
uint256 constant nft6 = 6;
uint256 constant nft7 = 7;
uint256 constant nft8 = 8;
uint256 constant nft9 = 9;
uint256 constant nft10 = 10;
uint256 constant nft11 = 11;
uint256 constant nft12 = 12;
uint256 constant nft13 = 13;
uint256 constant nft14 = 14;
uint256 constant nft15 = 15;
uint256 public nft1s;
uint256 public nft2s;
uint256 public nft3s;
uint256 public nft4s;
uint256 public nft5s;
uint256 public nft6s;
uint256 public nft7s;
uint256 public nft8s;
uint256 public nft9s;
uint256 public nft10s;
uint256 public nft11s;
uint256 public nft12s;
uint256 public nft13s;
uint256 public nft14s;
uint256 public nft15s;
uint256 public supplyPerNFT = 500;
string public _baseURI;
string public _contractURI;
bool saleLive = false;
//mappings
mapping(address => uint256) private mintCountMap1;
mapping(address => uint256) public allowedMintCountMap1;
uint256 private maxMintPerWallet1 = 1;
mapping(address => uint256) private mintCountMap2;
mapping(address => uint256) public allowedMintCountMap2;
uint256 private maxMintPerWallet2 = 1;
mapping(address => uint256) private mintCountMap3;
mapping(address => uint256) public allowedMintCountMap3;
uint256 private maxMintPerWallet3 = 1;
mapping(address => uint256) private mintCountMap4;
mapping(address => uint256) public allowedMintCountMap4;
uint256 private maxMintPerWallet4 = 1;
mapping(address => uint256) private mintCountMap5;
mapping(address => uint256) public allowedMintCountMap5;
uint256 private maxMintPerWallet5 = 1;
mapping(address => uint256) private mintCountMap6;
mapping(address => uint256) public allowedMintCountMap6;
uint256 private maxMintPerWallet6 = 1;
mapping(address => uint256) private mintCountMap7;
mapping(address => uint256) public allowedMintCountMap7;
uint256 private maxMintPerWallet7 = 1;
mapping(address => uint256) private mintCountMap8;
mapping(address => uint256) public allowedMintCountMap8;
uint256 private maxMintPerWallet8 = 1;
mapping(address => uint256) private mintCountMap9;
mapping(address => uint256) public allowedMintCountMap9;
uint256 private maxMintPerWallet9 = 1;
mapping(address => uint256) private mintCountMap10;
mapping(address => uint256) public allowedMintCountMap10;
uint256 private maxMintPerWallet10 = 1;
mapping(address => uint256) private mintCountMap11;
mapping(address => uint256) public allowedMintCountMap11;
uint256 private maxMintPerWallet11 = 1;
mapping(address => uint256) private mintCountMap12;
mapping(address => uint256) public allowedMintCountMap12;
uint256 private maxMintPerWallet12 = 1;
mapping(address => uint256) private mintCountMap13;
mapping(address => uint256) public allowedMintCountMap13;
uint256 private maxMintPerWallet13 = 1;
mapping(address => uint256) private mintCountMap14;
mapping(address => uint256) public allowedMintCountMap14;
uint256 private maxMintPerWallet14 = 1;
mapping(address => uint256) private mintCountMap15;
mapping(address => uint256) public allowedMintCountMap15;
uint256 private maxMintPerWallet15 = 1;
constructor() ERC1155(_baseURI) {}
// claim functions
function claimnft1(uint256 qty) public {
}
function claimnft2(uint256 qty) public {
}
function claimnft3(uint256 qty) public {
}
function claimnft4(uint256 qty) public {
}
function claimnft5(uint256 qty) public {
}
function claimnft6(uint256 qty) public { //dead
require(saleLive,"Sale is not live yet");
require(qty == 1,"You can only mint 1");
require(<FILL_ME>)
require(tx.origin == msg.sender); //stop contract buying
require(nft6s <= supplyPerNFT);
_mint(msg.sender, nft6, qty, "");
updateMintCount6(msg.sender, qty);
nft6s += qty;
}
function claimnft7(uint256 qty) public {
}
function claimnft8(uint256 qty) public {
}
function claimnft9(uint256 qty) public {
}
function claimnft10(uint256 qty) public {
}
function claimnft11(uint256 qty) public {
}
function claimnft12(uint256 qty) public {
}
function claimnft13(uint256 qty) public {
}
function claimnft14(uint256 qty) public {
}
function claimnft15(uint256 qty) public {
}
//mapping logic
function updateMintCount1(address minter, uint256 count) private {
}
function allowedMintCount1(address minter) public view returns (uint256) {
}
function setMaxPerWallet1(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount2(address minter, uint256 count) private {
}
function allowedMintCount2(address minter) public view returns (uint256) {
}
function setMaxPerWallet2(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount3(address minter, uint256 count) private {
}
function allowedMintCount3(address minter) public view returns (uint256) {
}
function setMaxPerWallet3(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount4(address minter, uint256 count) private {
}
function allowedMintCount4(address minter) public view returns (uint256) {
}
function setMaxPerWallet4(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount5(address minter, uint256 count) private {
}
function allowedMintCount5(address minter) public view returns (uint256) {
}
function setMaxPerWallet5(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount6(address minter, uint256 count) private {
}
function allowedMintCount6(address minter) public view returns (uint256) {
}
function setMaxPerWallet6(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount7(address minter, uint256 count) private {
}
function allowedMintCount7(address minter) public view returns (uint256) {
}
function setMaxPerWallet7(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount8(address minter, uint256 count) private {
}
function allowedMintCount8(address minter) public view returns (uint256) {
}
function setMaxPerWallet8(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount9(address minter, uint256 count) private {
}
function allowedMintCount9(address minter) public view returns (uint256) {
}
function setMaxPerWallet9(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount10(address minter, uint256 count) private {
}
function allowedMintCount10(address minter) public view returns (uint256) {
}
function setMaxPerWallet10(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount11(address minter, uint256 count) private {
}
function allowedMintCount11(address minter) public view returns (uint256) {
}
function setMaxPerWallet11(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount12(address minter, uint256 count) private {
}
function allowedMintCount12(address minter) public view returns (uint256) {
}
function setMaxPerWallet12(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount13(address minter, uint256 count) private {
}
function allowedMintCount13(address minter) public view returns (uint256) {
}
function setMaxPerWallet13(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount14(address minter, uint256 count) private {
}
function allowedMintCount14(address minter) public view returns (uint256) {
}
function setMaxPerWallet14(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount15(address minter, uint256 count) private {
}
function allowedMintCount15(address minter) public view returns (uint256) {
}
function setMaxPerWallet15(uint256 _newMaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory newuri) public onlyOwner {
}
function setContractURI(string memory newuri) public onlyOwner {
}
function setMaxPerNFT(uint256 _newMaxAmount) public onlyOwner {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
function totalSupply(uint256 id) public view virtual returns (uint256) {
}
function exists(uint256 id) public view virtual returns (bool) {
}
function setSale(bool _status) public onlyOwner {
}
function withdrawToOwner() external onlyOwner {
}
}
| allowedMintCount6(msg.sender)>=qty,"You already claimed" | 309,022 | allowedMintCount6(msg.sender)>=qty |
"You already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";
contract GOONYFRENS is ERC1155, Ownable {
using Strings for string;
mapping(uint256 => uint256) private _totalSupply;
//constants
uint256 constant nft1 = 1;
uint256 constant nft2 = 2;
uint256 constant nft3 = 3;
uint256 constant nft4 = 4;
uint256 constant nft5 = 5;
uint256 constant nft6 = 6;
uint256 constant nft7 = 7;
uint256 constant nft8 = 8;
uint256 constant nft9 = 9;
uint256 constant nft10 = 10;
uint256 constant nft11 = 11;
uint256 constant nft12 = 12;
uint256 constant nft13 = 13;
uint256 constant nft14 = 14;
uint256 constant nft15 = 15;
uint256 public nft1s;
uint256 public nft2s;
uint256 public nft3s;
uint256 public nft4s;
uint256 public nft5s;
uint256 public nft6s;
uint256 public nft7s;
uint256 public nft8s;
uint256 public nft9s;
uint256 public nft10s;
uint256 public nft11s;
uint256 public nft12s;
uint256 public nft13s;
uint256 public nft14s;
uint256 public nft15s;
uint256 public supplyPerNFT = 500;
string public _baseURI;
string public _contractURI;
bool saleLive = false;
//mappings
mapping(address => uint256) private mintCountMap1;
mapping(address => uint256) public allowedMintCountMap1;
uint256 private maxMintPerWallet1 = 1;
mapping(address => uint256) private mintCountMap2;
mapping(address => uint256) public allowedMintCountMap2;
uint256 private maxMintPerWallet2 = 1;
mapping(address => uint256) private mintCountMap3;
mapping(address => uint256) public allowedMintCountMap3;
uint256 private maxMintPerWallet3 = 1;
mapping(address => uint256) private mintCountMap4;
mapping(address => uint256) public allowedMintCountMap4;
uint256 private maxMintPerWallet4 = 1;
mapping(address => uint256) private mintCountMap5;
mapping(address => uint256) public allowedMintCountMap5;
uint256 private maxMintPerWallet5 = 1;
mapping(address => uint256) private mintCountMap6;
mapping(address => uint256) public allowedMintCountMap6;
uint256 private maxMintPerWallet6 = 1;
mapping(address => uint256) private mintCountMap7;
mapping(address => uint256) public allowedMintCountMap7;
uint256 private maxMintPerWallet7 = 1;
mapping(address => uint256) private mintCountMap8;
mapping(address => uint256) public allowedMintCountMap8;
uint256 private maxMintPerWallet8 = 1;
mapping(address => uint256) private mintCountMap9;
mapping(address => uint256) public allowedMintCountMap9;
uint256 private maxMintPerWallet9 = 1;
mapping(address => uint256) private mintCountMap10;
mapping(address => uint256) public allowedMintCountMap10;
uint256 private maxMintPerWallet10 = 1;
mapping(address => uint256) private mintCountMap11;
mapping(address => uint256) public allowedMintCountMap11;
uint256 private maxMintPerWallet11 = 1;
mapping(address => uint256) private mintCountMap12;
mapping(address => uint256) public allowedMintCountMap12;
uint256 private maxMintPerWallet12 = 1;
mapping(address => uint256) private mintCountMap13;
mapping(address => uint256) public allowedMintCountMap13;
uint256 private maxMintPerWallet13 = 1;
mapping(address => uint256) private mintCountMap14;
mapping(address => uint256) public allowedMintCountMap14;
uint256 private maxMintPerWallet14 = 1;
mapping(address => uint256) private mintCountMap15;
mapping(address => uint256) public allowedMintCountMap15;
uint256 private maxMintPerWallet15 = 1;
constructor() ERC1155(_baseURI) {}
// claim functions
function claimnft1(uint256 qty) public {
}
function claimnft2(uint256 qty) public {
}
function claimnft3(uint256 qty) public {
}
function claimnft4(uint256 qty) public {
}
function claimnft5(uint256 qty) public {
}
function claimnft6(uint256 qty) public {
}
function claimnft7(uint256 qty) public { //deebies
require(saleLive,"Sale is not live yet");
require(qty == 1,"You can only mint 1");
require(<FILL_ME>)
require(tx.origin == msg.sender); //stop contract buying
require(nft7s <= supplyPerNFT);
_mint(msg.sender, nft7, qty, "");
updateMintCount7(msg.sender, qty);
nft7s += qty;
}
function claimnft8(uint256 qty) public {
}
function claimnft9(uint256 qty) public {
}
function claimnft10(uint256 qty) public {
}
function claimnft11(uint256 qty) public {
}
function claimnft12(uint256 qty) public {
}
function claimnft13(uint256 qty) public {
}
function claimnft14(uint256 qty) public {
}
function claimnft15(uint256 qty) public {
}
//mapping logic
function updateMintCount1(address minter, uint256 count) private {
}
function allowedMintCount1(address minter) public view returns (uint256) {
}
function setMaxPerWallet1(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount2(address minter, uint256 count) private {
}
function allowedMintCount2(address minter) public view returns (uint256) {
}
function setMaxPerWallet2(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount3(address minter, uint256 count) private {
}
function allowedMintCount3(address minter) public view returns (uint256) {
}
function setMaxPerWallet3(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount4(address minter, uint256 count) private {
}
function allowedMintCount4(address minter) public view returns (uint256) {
}
function setMaxPerWallet4(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount5(address minter, uint256 count) private {
}
function allowedMintCount5(address minter) public view returns (uint256) {
}
function setMaxPerWallet5(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount6(address minter, uint256 count) private {
}
function allowedMintCount6(address minter) public view returns (uint256) {
}
function setMaxPerWallet6(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount7(address minter, uint256 count) private {
}
function allowedMintCount7(address minter) public view returns (uint256) {
}
function setMaxPerWallet7(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount8(address minter, uint256 count) private {
}
function allowedMintCount8(address minter) public view returns (uint256) {
}
function setMaxPerWallet8(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount9(address minter, uint256 count) private {
}
function allowedMintCount9(address minter) public view returns (uint256) {
}
function setMaxPerWallet9(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount10(address minter, uint256 count) private {
}
function allowedMintCount10(address minter) public view returns (uint256) {
}
function setMaxPerWallet10(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount11(address minter, uint256 count) private {
}
function allowedMintCount11(address minter) public view returns (uint256) {
}
function setMaxPerWallet11(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount12(address minter, uint256 count) private {
}
function allowedMintCount12(address minter) public view returns (uint256) {
}
function setMaxPerWallet12(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount13(address minter, uint256 count) private {
}
function allowedMintCount13(address minter) public view returns (uint256) {
}
function setMaxPerWallet13(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount14(address minter, uint256 count) private {
}
function allowedMintCount14(address minter) public view returns (uint256) {
}
function setMaxPerWallet14(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount15(address minter, uint256 count) private {
}
function allowedMintCount15(address minter) public view returns (uint256) {
}
function setMaxPerWallet15(uint256 _newMaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory newuri) public onlyOwner {
}
function setContractURI(string memory newuri) public onlyOwner {
}
function setMaxPerNFT(uint256 _newMaxAmount) public onlyOwner {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
function totalSupply(uint256 id) public view virtual returns (uint256) {
}
function exists(uint256 id) public view virtual returns (bool) {
}
function setSale(bool _status) public onlyOwner {
}
function withdrawToOwner() external onlyOwner {
}
}
| allowedMintCount7(msg.sender)>=qty,"You already claimed" | 309,022 | allowedMintCount7(msg.sender)>=qty |
"You already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";
contract GOONYFRENS is ERC1155, Ownable {
using Strings for string;
mapping(uint256 => uint256) private _totalSupply;
//constants
uint256 constant nft1 = 1;
uint256 constant nft2 = 2;
uint256 constant nft3 = 3;
uint256 constant nft4 = 4;
uint256 constant nft5 = 5;
uint256 constant nft6 = 6;
uint256 constant nft7 = 7;
uint256 constant nft8 = 8;
uint256 constant nft9 = 9;
uint256 constant nft10 = 10;
uint256 constant nft11 = 11;
uint256 constant nft12 = 12;
uint256 constant nft13 = 13;
uint256 constant nft14 = 14;
uint256 constant nft15 = 15;
uint256 public nft1s;
uint256 public nft2s;
uint256 public nft3s;
uint256 public nft4s;
uint256 public nft5s;
uint256 public nft6s;
uint256 public nft7s;
uint256 public nft8s;
uint256 public nft9s;
uint256 public nft10s;
uint256 public nft11s;
uint256 public nft12s;
uint256 public nft13s;
uint256 public nft14s;
uint256 public nft15s;
uint256 public supplyPerNFT = 500;
string public _baseURI;
string public _contractURI;
bool saleLive = false;
//mappings
mapping(address => uint256) private mintCountMap1;
mapping(address => uint256) public allowedMintCountMap1;
uint256 private maxMintPerWallet1 = 1;
mapping(address => uint256) private mintCountMap2;
mapping(address => uint256) public allowedMintCountMap2;
uint256 private maxMintPerWallet2 = 1;
mapping(address => uint256) private mintCountMap3;
mapping(address => uint256) public allowedMintCountMap3;
uint256 private maxMintPerWallet3 = 1;
mapping(address => uint256) private mintCountMap4;
mapping(address => uint256) public allowedMintCountMap4;
uint256 private maxMintPerWallet4 = 1;
mapping(address => uint256) private mintCountMap5;
mapping(address => uint256) public allowedMintCountMap5;
uint256 private maxMintPerWallet5 = 1;
mapping(address => uint256) private mintCountMap6;
mapping(address => uint256) public allowedMintCountMap6;
uint256 private maxMintPerWallet6 = 1;
mapping(address => uint256) private mintCountMap7;
mapping(address => uint256) public allowedMintCountMap7;
uint256 private maxMintPerWallet7 = 1;
mapping(address => uint256) private mintCountMap8;
mapping(address => uint256) public allowedMintCountMap8;
uint256 private maxMintPerWallet8 = 1;
mapping(address => uint256) private mintCountMap9;
mapping(address => uint256) public allowedMintCountMap9;
uint256 private maxMintPerWallet9 = 1;
mapping(address => uint256) private mintCountMap10;
mapping(address => uint256) public allowedMintCountMap10;
uint256 private maxMintPerWallet10 = 1;
mapping(address => uint256) private mintCountMap11;
mapping(address => uint256) public allowedMintCountMap11;
uint256 private maxMintPerWallet11 = 1;
mapping(address => uint256) private mintCountMap12;
mapping(address => uint256) public allowedMintCountMap12;
uint256 private maxMintPerWallet12 = 1;
mapping(address => uint256) private mintCountMap13;
mapping(address => uint256) public allowedMintCountMap13;
uint256 private maxMintPerWallet13 = 1;
mapping(address => uint256) private mintCountMap14;
mapping(address => uint256) public allowedMintCountMap14;
uint256 private maxMintPerWallet14 = 1;
mapping(address => uint256) private mintCountMap15;
mapping(address => uint256) public allowedMintCountMap15;
uint256 private maxMintPerWallet15 = 1;
constructor() ERC1155(_baseURI) {}
// claim functions
function claimnft1(uint256 qty) public {
}
function claimnft2(uint256 qty) public {
}
function claimnft3(uint256 qty) public {
}
function claimnft4(uint256 qty) public {
}
function claimnft5(uint256 qty) public {
}
function claimnft6(uint256 qty) public {
}
function claimnft7(uint256 qty) public {
}
function claimnft8(uint256 qty) public { //dizzy
require(saleLive,"Sale is not live yet");
require(qty == 1,"You can only mint 1");
require(<FILL_ME>)
require(tx.origin == msg.sender); //stop contract buying
require(nft8s <= supplyPerNFT);
_mint(msg.sender, nft8, qty, "");
updateMintCount8(msg.sender, qty);
nft8s += qty;
}
function claimnft9(uint256 qty) public {
}
function claimnft10(uint256 qty) public {
}
function claimnft11(uint256 qty) public {
}
function claimnft12(uint256 qty) public {
}
function claimnft13(uint256 qty) public {
}
function claimnft14(uint256 qty) public {
}
function claimnft15(uint256 qty) public {
}
//mapping logic
function updateMintCount1(address minter, uint256 count) private {
}
function allowedMintCount1(address minter) public view returns (uint256) {
}
function setMaxPerWallet1(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount2(address minter, uint256 count) private {
}
function allowedMintCount2(address minter) public view returns (uint256) {
}
function setMaxPerWallet2(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount3(address minter, uint256 count) private {
}
function allowedMintCount3(address minter) public view returns (uint256) {
}
function setMaxPerWallet3(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount4(address minter, uint256 count) private {
}
function allowedMintCount4(address minter) public view returns (uint256) {
}
function setMaxPerWallet4(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount5(address minter, uint256 count) private {
}
function allowedMintCount5(address minter) public view returns (uint256) {
}
function setMaxPerWallet5(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount6(address minter, uint256 count) private {
}
function allowedMintCount6(address minter) public view returns (uint256) {
}
function setMaxPerWallet6(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount7(address minter, uint256 count) private {
}
function allowedMintCount7(address minter) public view returns (uint256) {
}
function setMaxPerWallet7(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount8(address minter, uint256 count) private {
}
function allowedMintCount8(address minter) public view returns (uint256) {
}
function setMaxPerWallet8(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount9(address minter, uint256 count) private {
}
function allowedMintCount9(address minter) public view returns (uint256) {
}
function setMaxPerWallet9(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount10(address minter, uint256 count) private {
}
function allowedMintCount10(address minter) public view returns (uint256) {
}
function setMaxPerWallet10(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount11(address minter, uint256 count) private {
}
function allowedMintCount11(address minter) public view returns (uint256) {
}
function setMaxPerWallet11(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount12(address minter, uint256 count) private {
}
function allowedMintCount12(address minter) public view returns (uint256) {
}
function setMaxPerWallet12(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount13(address minter, uint256 count) private {
}
function allowedMintCount13(address minter) public view returns (uint256) {
}
function setMaxPerWallet13(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount14(address minter, uint256 count) private {
}
function allowedMintCount14(address minter) public view returns (uint256) {
}
function setMaxPerWallet14(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount15(address minter, uint256 count) private {
}
function allowedMintCount15(address minter) public view returns (uint256) {
}
function setMaxPerWallet15(uint256 _newMaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory newuri) public onlyOwner {
}
function setContractURI(string memory newuri) public onlyOwner {
}
function setMaxPerNFT(uint256 _newMaxAmount) public onlyOwner {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
function totalSupply(uint256 id) public view virtual returns (uint256) {
}
function exists(uint256 id) public view virtual returns (bool) {
}
function setSale(bool _status) public onlyOwner {
}
function withdrawToOwner() external onlyOwner {
}
}
| allowedMintCount8(msg.sender)>=qty,"You already claimed" | 309,022 | allowedMintCount8(msg.sender)>=qty |
"You already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";
contract GOONYFRENS is ERC1155, Ownable {
using Strings for string;
mapping(uint256 => uint256) private _totalSupply;
//constants
uint256 constant nft1 = 1;
uint256 constant nft2 = 2;
uint256 constant nft3 = 3;
uint256 constant nft4 = 4;
uint256 constant nft5 = 5;
uint256 constant nft6 = 6;
uint256 constant nft7 = 7;
uint256 constant nft8 = 8;
uint256 constant nft9 = 9;
uint256 constant nft10 = 10;
uint256 constant nft11 = 11;
uint256 constant nft12 = 12;
uint256 constant nft13 = 13;
uint256 constant nft14 = 14;
uint256 constant nft15 = 15;
uint256 public nft1s;
uint256 public nft2s;
uint256 public nft3s;
uint256 public nft4s;
uint256 public nft5s;
uint256 public nft6s;
uint256 public nft7s;
uint256 public nft8s;
uint256 public nft9s;
uint256 public nft10s;
uint256 public nft11s;
uint256 public nft12s;
uint256 public nft13s;
uint256 public nft14s;
uint256 public nft15s;
uint256 public supplyPerNFT = 500;
string public _baseURI;
string public _contractURI;
bool saleLive = false;
//mappings
mapping(address => uint256) private mintCountMap1;
mapping(address => uint256) public allowedMintCountMap1;
uint256 private maxMintPerWallet1 = 1;
mapping(address => uint256) private mintCountMap2;
mapping(address => uint256) public allowedMintCountMap2;
uint256 private maxMintPerWallet2 = 1;
mapping(address => uint256) private mintCountMap3;
mapping(address => uint256) public allowedMintCountMap3;
uint256 private maxMintPerWallet3 = 1;
mapping(address => uint256) private mintCountMap4;
mapping(address => uint256) public allowedMintCountMap4;
uint256 private maxMintPerWallet4 = 1;
mapping(address => uint256) private mintCountMap5;
mapping(address => uint256) public allowedMintCountMap5;
uint256 private maxMintPerWallet5 = 1;
mapping(address => uint256) private mintCountMap6;
mapping(address => uint256) public allowedMintCountMap6;
uint256 private maxMintPerWallet6 = 1;
mapping(address => uint256) private mintCountMap7;
mapping(address => uint256) public allowedMintCountMap7;
uint256 private maxMintPerWallet7 = 1;
mapping(address => uint256) private mintCountMap8;
mapping(address => uint256) public allowedMintCountMap8;
uint256 private maxMintPerWallet8 = 1;
mapping(address => uint256) private mintCountMap9;
mapping(address => uint256) public allowedMintCountMap9;
uint256 private maxMintPerWallet9 = 1;
mapping(address => uint256) private mintCountMap10;
mapping(address => uint256) public allowedMintCountMap10;
uint256 private maxMintPerWallet10 = 1;
mapping(address => uint256) private mintCountMap11;
mapping(address => uint256) public allowedMintCountMap11;
uint256 private maxMintPerWallet11 = 1;
mapping(address => uint256) private mintCountMap12;
mapping(address => uint256) public allowedMintCountMap12;
uint256 private maxMintPerWallet12 = 1;
mapping(address => uint256) private mintCountMap13;
mapping(address => uint256) public allowedMintCountMap13;
uint256 private maxMintPerWallet13 = 1;
mapping(address => uint256) private mintCountMap14;
mapping(address => uint256) public allowedMintCountMap14;
uint256 private maxMintPerWallet14 = 1;
mapping(address => uint256) private mintCountMap15;
mapping(address => uint256) public allowedMintCountMap15;
uint256 private maxMintPerWallet15 = 1;
constructor() ERC1155(_baseURI) {}
// claim functions
function claimnft1(uint256 qty) public {
}
function claimnft2(uint256 qty) public {
}
function claimnft3(uint256 qty) public {
}
function claimnft4(uint256 qty) public {
}
function claimnft5(uint256 qty) public {
}
function claimnft6(uint256 qty) public {
}
function claimnft7(uint256 qty) public {
}
function claimnft8(uint256 qty) public {
}
function claimnft9(uint256 qty) public { //doodles
require(qty == 1,"You can only mint 1");
require(<FILL_ME>)
require(tx.origin == msg.sender); //stop contract buying
require(nft9s <= supplyPerNFT);
_mint(msg.sender, nft9, qty, "");
updateMintCount9(msg.sender, qty);
nft9s += qty;
}
function claimnft10(uint256 qty) public {
}
function claimnft11(uint256 qty) public {
}
function claimnft12(uint256 qty) public {
}
function claimnft13(uint256 qty) public {
}
function claimnft14(uint256 qty) public {
}
function claimnft15(uint256 qty) public {
}
//mapping logic
function updateMintCount1(address minter, uint256 count) private {
}
function allowedMintCount1(address minter) public view returns (uint256) {
}
function setMaxPerWallet1(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount2(address minter, uint256 count) private {
}
function allowedMintCount2(address minter) public view returns (uint256) {
}
function setMaxPerWallet2(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount3(address minter, uint256 count) private {
}
function allowedMintCount3(address minter) public view returns (uint256) {
}
function setMaxPerWallet3(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount4(address minter, uint256 count) private {
}
function allowedMintCount4(address minter) public view returns (uint256) {
}
function setMaxPerWallet4(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount5(address minter, uint256 count) private {
}
function allowedMintCount5(address minter) public view returns (uint256) {
}
function setMaxPerWallet5(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount6(address minter, uint256 count) private {
}
function allowedMintCount6(address minter) public view returns (uint256) {
}
function setMaxPerWallet6(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount7(address minter, uint256 count) private {
}
function allowedMintCount7(address minter) public view returns (uint256) {
}
function setMaxPerWallet7(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount8(address minter, uint256 count) private {
}
function allowedMintCount8(address minter) public view returns (uint256) {
}
function setMaxPerWallet8(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount9(address minter, uint256 count) private {
}
function allowedMintCount9(address minter) public view returns (uint256) {
}
function setMaxPerWallet9(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount10(address minter, uint256 count) private {
}
function allowedMintCount10(address minter) public view returns (uint256) {
}
function setMaxPerWallet10(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount11(address minter, uint256 count) private {
}
function allowedMintCount11(address minter) public view returns (uint256) {
}
function setMaxPerWallet11(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount12(address minter, uint256 count) private {
}
function allowedMintCount12(address minter) public view returns (uint256) {
}
function setMaxPerWallet12(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount13(address minter, uint256 count) private {
}
function allowedMintCount13(address minter) public view returns (uint256) {
}
function setMaxPerWallet13(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount14(address minter, uint256 count) private {
}
function allowedMintCount14(address minter) public view returns (uint256) {
}
function setMaxPerWallet14(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount15(address minter, uint256 count) private {
}
function allowedMintCount15(address minter) public view returns (uint256) {
}
function setMaxPerWallet15(uint256 _newMaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory newuri) public onlyOwner {
}
function setContractURI(string memory newuri) public onlyOwner {
}
function setMaxPerNFT(uint256 _newMaxAmount) public onlyOwner {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
function totalSupply(uint256 id) public view virtual returns (uint256) {
}
function exists(uint256 id) public view virtual returns (bool) {
}
function setSale(bool _status) public onlyOwner {
}
function withdrawToOwner() external onlyOwner {
}
}
| allowedMintCount9(msg.sender)>=qty,"You already claimed" | 309,022 | allowedMintCount9(msg.sender)>=qty |
"You already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";
contract GOONYFRENS is ERC1155, Ownable {
using Strings for string;
mapping(uint256 => uint256) private _totalSupply;
//constants
uint256 constant nft1 = 1;
uint256 constant nft2 = 2;
uint256 constant nft3 = 3;
uint256 constant nft4 = 4;
uint256 constant nft5 = 5;
uint256 constant nft6 = 6;
uint256 constant nft7 = 7;
uint256 constant nft8 = 8;
uint256 constant nft9 = 9;
uint256 constant nft10 = 10;
uint256 constant nft11 = 11;
uint256 constant nft12 = 12;
uint256 constant nft13 = 13;
uint256 constant nft14 = 14;
uint256 constant nft15 = 15;
uint256 public nft1s;
uint256 public nft2s;
uint256 public nft3s;
uint256 public nft4s;
uint256 public nft5s;
uint256 public nft6s;
uint256 public nft7s;
uint256 public nft8s;
uint256 public nft9s;
uint256 public nft10s;
uint256 public nft11s;
uint256 public nft12s;
uint256 public nft13s;
uint256 public nft14s;
uint256 public nft15s;
uint256 public supplyPerNFT = 500;
string public _baseURI;
string public _contractURI;
bool saleLive = false;
//mappings
mapping(address => uint256) private mintCountMap1;
mapping(address => uint256) public allowedMintCountMap1;
uint256 private maxMintPerWallet1 = 1;
mapping(address => uint256) private mintCountMap2;
mapping(address => uint256) public allowedMintCountMap2;
uint256 private maxMintPerWallet2 = 1;
mapping(address => uint256) private mintCountMap3;
mapping(address => uint256) public allowedMintCountMap3;
uint256 private maxMintPerWallet3 = 1;
mapping(address => uint256) private mintCountMap4;
mapping(address => uint256) public allowedMintCountMap4;
uint256 private maxMintPerWallet4 = 1;
mapping(address => uint256) private mintCountMap5;
mapping(address => uint256) public allowedMintCountMap5;
uint256 private maxMintPerWallet5 = 1;
mapping(address => uint256) private mintCountMap6;
mapping(address => uint256) public allowedMintCountMap6;
uint256 private maxMintPerWallet6 = 1;
mapping(address => uint256) private mintCountMap7;
mapping(address => uint256) public allowedMintCountMap7;
uint256 private maxMintPerWallet7 = 1;
mapping(address => uint256) private mintCountMap8;
mapping(address => uint256) public allowedMintCountMap8;
uint256 private maxMintPerWallet8 = 1;
mapping(address => uint256) private mintCountMap9;
mapping(address => uint256) public allowedMintCountMap9;
uint256 private maxMintPerWallet9 = 1;
mapping(address => uint256) private mintCountMap10;
mapping(address => uint256) public allowedMintCountMap10;
uint256 private maxMintPerWallet10 = 1;
mapping(address => uint256) private mintCountMap11;
mapping(address => uint256) public allowedMintCountMap11;
uint256 private maxMintPerWallet11 = 1;
mapping(address => uint256) private mintCountMap12;
mapping(address => uint256) public allowedMintCountMap12;
uint256 private maxMintPerWallet12 = 1;
mapping(address => uint256) private mintCountMap13;
mapping(address => uint256) public allowedMintCountMap13;
uint256 private maxMintPerWallet13 = 1;
mapping(address => uint256) private mintCountMap14;
mapping(address => uint256) public allowedMintCountMap14;
uint256 private maxMintPerWallet14 = 1;
mapping(address => uint256) private mintCountMap15;
mapping(address => uint256) public allowedMintCountMap15;
uint256 private maxMintPerWallet15 = 1;
constructor() ERC1155(_baseURI) {}
// claim functions
function claimnft1(uint256 qty) public {
}
function claimnft2(uint256 qty) public {
}
function claimnft3(uint256 qty) public {
}
function claimnft4(uint256 qty) public {
}
function claimnft5(uint256 qty) public {
}
function claimnft6(uint256 qty) public {
}
function claimnft7(uint256 qty) public {
}
function claimnft8(uint256 qty) public {
}
function claimnft9(uint256 qty) public {
}
function claimnft10(uint256 qty) public { //evol
require(qty == 1,"You can only mint 1");
require(<FILL_ME>)
require(tx.origin == msg.sender); //stop contract buying
require(nft10s <= supplyPerNFT);
_mint(msg.sender, nft10, qty, "");
updateMintCount10(msg.sender, qty);
nft10s += qty;
}
function claimnft11(uint256 qty) public {
}
function claimnft12(uint256 qty) public {
}
function claimnft13(uint256 qty) public {
}
function claimnft14(uint256 qty) public {
}
function claimnft15(uint256 qty) public {
}
//mapping logic
function updateMintCount1(address minter, uint256 count) private {
}
function allowedMintCount1(address minter) public view returns (uint256) {
}
function setMaxPerWallet1(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount2(address minter, uint256 count) private {
}
function allowedMintCount2(address minter) public view returns (uint256) {
}
function setMaxPerWallet2(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount3(address minter, uint256 count) private {
}
function allowedMintCount3(address minter) public view returns (uint256) {
}
function setMaxPerWallet3(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount4(address minter, uint256 count) private {
}
function allowedMintCount4(address minter) public view returns (uint256) {
}
function setMaxPerWallet4(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount5(address minter, uint256 count) private {
}
function allowedMintCount5(address minter) public view returns (uint256) {
}
function setMaxPerWallet5(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount6(address minter, uint256 count) private {
}
function allowedMintCount6(address minter) public view returns (uint256) {
}
function setMaxPerWallet6(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount7(address minter, uint256 count) private {
}
function allowedMintCount7(address minter) public view returns (uint256) {
}
function setMaxPerWallet7(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount8(address minter, uint256 count) private {
}
function allowedMintCount8(address minter) public view returns (uint256) {
}
function setMaxPerWallet8(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount9(address minter, uint256 count) private {
}
function allowedMintCount9(address minter) public view returns (uint256) {
}
function setMaxPerWallet9(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount10(address minter, uint256 count) private {
}
function allowedMintCount10(address minter) public view returns (uint256) {
}
function setMaxPerWallet10(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount11(address minter, uint256 count) private {
}
function allowedMintCount11(address minter) public view returns (uint256) {
}
function setMaxPerWallet11(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount12(address minter, uint256 count) private {
}
function allowedMintCount12(address minter) public view returns (uint256) {
}
function setMaxPerWallet12(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount13(address minter, uint256 count) private {
}
function allowedMintCount13(address minter) public view returns (uint256) {
}
function setMaxPerWallet13(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount14(address minter, uint256 count) private {
}
function allowedMintCount14(address minter) public view returns (uint256) {
}
function setMaxPerWallet14(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount15(address minter, uint256 count) private {
}
function allowedMintCount15(address minter) public view returns (uint256) {
}
function setMaxPerWallet15(uint256 _newMaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory newuri) public onlyOwner {
}
function setContractURI(string memory newuri) public onlyOwner {
}
function setMaxPerNFT(uint256 _newMaxAmount) public onlyOwner {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
function totalSupply(uint256 id) public view virtual returns (uint256) {
}
function exists(uint256 id) public view virtual returns (bool) {
}
function setSale(bool _status) public onlyOwner {
}
function withdrawToOwner() external onlyOwner {
}
}
| allowedMintCount10(msg.sender)>=qty,"You already claimed" | 309,022 | allowedMintCount10(msg.sender)>=qty |
"You already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";
contract GOONYFRENS is ERC1155, Ownable {
using Strings for string;
mapping(uint256 => uint256) private _totalSupply;
//constants
uint256 constant nft1 = 1;
uint256 constant nft2 = 2;
uint256 constant nft3 = 3;
uint256 constant nft4 = 4;
uint256 constant nft5 = 5;
uint256 constant nft6 = 6;
uint256 constant nft7 = 7;
uint256 constant nft8 = 8;
uint256 constant nft9 = 9;
uint256 constant nft10 = 10;
uint256 constant nft11 = 11;
uint256 constant nft12 = 12;
uint256 constant nft13 = 13;
uint256 constant nft14 = 14;
uint256 constant nft15 = 15;
uint256 public nft1s;
uint256 public nft2s;
uint256 public nft3s;
uint256 public nft4s;
uint256 public nft5s;
uint256 public nft6s;
uint256 public nft7s;
uint256 public nft8s;
uint256 public nft9s;
uint256 public nft10s;
uint256 public nft11s;
uint256 public nft12s;
uint256 public nft13s;
uint256 public nft14s;
uint256 public nft15s;
uint256 public supplyPerNFT = 500;
string public _baseURI;
string public _contractURI;
bool saleLive = false;
//mappings
mapping(address => uint256) private mintCountMap1;
mapping(address => uint256) public allowedMintCountMap1;
uint256 private maxMintPerWallet1 = 1;
mapping(address => uint256) private mintCountMap2;
mapping(address => uint256) public allowedMintCountMap2;
uint256 private maxMintPerWallet2 = 1;
mapping(address => uint256) private mintCountMap3;
mapping(address => uint256) public allowedMintCountMap3;
uint256 private maxMintPerWallet3 = 1;
mapping(address => uint256) private mintCountMap4;
mapping(address => uint256) public allowedMintCountMap4;
uint256 private maxMintPerWallet4 = 1;
mapping(address => uint256) private mintCountMap5;
mapping(address => uint256) public allowedMintCountMap5;
uint256 private maxMintPerWallet5 = 1;
mapping(address => uint256) private mintCountMap6;
mapping(address => uint256) public allowedMintCountMap6;
uint256 private maxMintPerWallet6 = 1;
mapping(address => uint256) private mintCountMap7;
mapping(address => uint256) public allowedMintCountMap7;
uint256 private maxMintPerWallet7 = 1;
mapping(address => uint256) private mintCountMap8;
mapping(address => uint256) public allowedMintCountMap8;
uint256 private maxMintPerWallet8 = 1;
mapping(address => uint256) private mintCountMap9;
mapping(address => uint256) public allowedMintCountMap9;
uint256 private maxMintPerWallet9 = 1;
mapping(address => uint256) private mintCountMap10;
mapping(address => uint256) public allowedMintCountMap10;
uint256 private maxMintPerWallet10 = 1;
mapping(address => uint256) private mintCountMap11;
mapping(address => uint256) public allowedMintCountMap11;
uint256 private maxMintPerWallet11 = 1;
mapping(address => uint256) private mintCountMap12;
mapping(address => uint256) public allowedMintCountMap12;
uint256 private maxMintPerWallet12 = 1;
mapping(address => uint256) private mintCountMap13;
mapping(address => uint256) public allowedMintCountMap13;
uint256 private maxMintPerWallet13 = 1;
mapping(address => uint256) private mintCountMap14;
mapping(address => uint256) public allowedMintCountMap14;
uint256 private maxMintPerWallet14 = 1;
mapping(address => uint256) private mintCountMap15;
mapping(address => uint256) public allowedMintCountMap15;
uint256 private maxMintPerWallet15 = 1;
constructor() ERC1155(_baseURI) {}
// claim functions
function claimnft1(uint256 qty) public {
}
function claimnft2(uint256 qty) public {
}
function claimnft3(uint256 qty) public {
}
function claimnft4(uint256 qty) public {
}
function claimnft5(uint256 qty) public {
}
function claimnft6(uint256 qty) public {
}
function claimnft7(uint256 qty) public {
}
function claimnft8(uint256 qty) public {
}
function claimnft9(uint256 qty) public {
}
function claimnft10(uint256 qty) public {
}
function claimnft11(uint256 qty) public { //galatic
require(qty == 1,"You can only mint 1");
require(<FILL_ME>)
require(tx.origin == msg.sender); //stop contract buying
require(nft11s <= supplyPerNFT);
_mint(msg.sender, nft11, qty, "");
updateMintCount11(msg.sender, qty);
nft11s += qty;
}
function claimnft12(uint256 qty) public {
}
function claimnft13(uint256 qty) public {
}
function claimnft14(uint256 qty) public {
}
function claimnft15(uint256 qty) public {
}
//mapping logic
function updateMintCount1(address minter, uint256 count) private {
}
function allowedMintCount1(address minter) public view returns (uint256) {
}
function setMaxPerWallet1(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount2(address minter, uint256 count) private {
}
function allowedMintCount2(address minter) public view returns (uint256) {
}
function setMaxPerWallet2(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount3(address minter, uint256 count) private {
}
function allowedMintCount3(address minter) public view returns (uint256) {
}
function setMaxPerWallet3(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount4(address minter, uint256 count) private {
}
function allowedMintCount4(address minter) public view returns (uint256) {
}
function setMaxPerWallet4(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount5(address minter, uint256 count) private {
}
function allowedMintCount5(address minter) public view returns (uint256) {
}
function setMaxPerWallet5(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount6(address minter, uint256 count) private {
}
function allowedMintCount6(address minter) public view returns (uint256) {
}
function setMaxPerWallet6(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount7(address minter, uint256 count) private {
}
function allowedMintCount7(address minter) public view returns (uint256) {
}
function setMaxPerWallet7(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount8(address minter, uint256 count) private {
}
function allowedMintCount8(address minter) public view returns (uint256) {
}
function setMaxPerWallet8(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount9(address minter, uint256 count) private {
}
function allowedMintCount9(address minter) public view returns (uint256) {
}
function setMaxPerWallet9(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount10(address minter, uint256 count) private {
}
function allowedMintCount10(address minter) public view returns (uint256) {
}
function setMaxPerWallet10(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount11(address minter, uint256 count) private {
}
function allowedMintCount11(address minter) public view returns (uint256) {
}
function setMaxPerWallet11(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount12(address minter, uint256 count) private {
}
function allowedMintCount12(address minter) public view returns (uint256) {
}
function setMaxPerWallet12(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount13(address minter, uint256 count) private {
}
function allowedMintCount13(address minter) public view returns (uint256) {
}
function setMaxPerWallet13(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount14(address minter, uint256 count) private {
}
function allowedMintCount14(address minter) public view returns (uint256) {
}
function setMaxPerWallet14(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount15(address minter, uint256 count) private {
}
function allowedMintCount15(address minter) public view returns (uint256) {
}
function setMaxPerWallet15(uint256 _newMaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory newuri) public onlyOwner {
}
function setContractURI(string memory newuri) public onlyOwner {
}
function setMaxPerNFT(uint256 _newMaxAmount) public onlyOwner {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
function totalSupply(uint256 id) public view virtual returns (uint256) {
}
function exists(uint256 id) public view virtual returns (bool) {
}
function setSale(bool _status) public onlyOwner {
}
function withdrawToOwner() external onlyOwner {
}
}
| allowedMintCount11(msg.sender)>=qty,"You already claimed" | 309,022 | allowedMintCount11(msg.sender)>=qty |
"You already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";
contract GOONYFRENS is ERC1155, Ownable {
using Strings for string;
mapping(uint256 => uint256) private _totalSupply;
//constants
uint256 constant nft1 = 1;
uint256 constant nft2 = 2;
uint256 constant nft3 = 3;
uint256 constant nft4 = 4;
uint256 constant nft5 = 5;
uint256 constant nft6 = 6;
uint256 constant nft7 = 7;
uint256 constant nft8 = 8;
uint256 constant nft9 = 9;
uint256 constant nft10 = 10;
uint256 constant nft11 = 11;
uint256 constant nft12 = 12;
uint256 constant nft13 = 13;
uint256 constant nft14 = 14;
uint256 constant nft15 = 15;
uint256 public nft1s;
uint256 public nft2s;
uint256 public nft3s;
uint256 public nft4s;
uint256 public nft5s;
uint256 public nft6s;
uint256 public nft7s;
uint256 public nft8s;
uint256 public nft9s;
uint256 public nft10s;
uint256 public nft11s;
uint256 public nft12s;
uint256 public nft13s;
uint256 public nft14s;
uint256 public nft15s;
uint256 public supplyPerNFT = 500;
string public _baseURI;
string public _contractURI;
bool saleLive = false;
//mappings
mapping(address => uint256) private mintCountMap1;
mapping(address => uint256) public allowedMintCountMap1;
uint256 private maxMintPerWallet1 = 1;
mapping(address => uint256) private mintCountMap2;
mapping(address => uint256) public allowedMintCountMap2;
uint256 private maxMintPerWallet2 = 1;
mapping(address => uint256) private mintCountMap3;
mapping(address => uint256) public allowedMintCountMap3;
uint256 private maxMintPerWallet3 = 1;
mapping(address => uint256) private mintCountMap4;
mapping(address => uint256) public allowedMintCountMap4;
uint256 private maxMintPerWallet4 = 1;
mapping(address => uint256) private mintCountMap5;
mapping(address => uint256) public allowedMintCountMap5;
uint256 private maxMintPerWallet5 = 1;
mapping(address => uint256) private mintCountMap6;
mapping(address => uint256) public allowedMintCountMap6;
uint256 private maxMintPerWallet6 = 1;
mapping(address => uint256) private mintCountMap7;
mapping(address => uint256) public allowedMintCountMap7;
uint256 private maxMintPerWallet7 = 1;
mapping(address => uint256) private mintCountMap8;
mapping(address => uint256) public allowedMintCountMap8;
uint256 private maxMintPerWallet8 = 1;
mapping(address => uint256) private mintCountMap9;
mapping(address => uint256) public allowedMintCountMap9;
uint256 private maxMintPerWallet9 = 1;
mapping(address => uint256) private mintCountMap10;
mapping(address => uint256) public allowedMintCountMap10;
uint256 private maxMintPerWallet10 = 1;
mapping(address => uint256) private mintCountMap11;
mapping(address => uint256) public allowedMintCountMap11;
uint256 private maxMintPerWallet11 = 1;
mapping(address => uint256) private mintCountMap12;
mapping(address => uint256) public allowedMintCountMap12;
uint256 private maxMintPerWallet12 = 1;
mapping(address => uint256) private mintCountMap13;
mapping(address => uint256) public allowedMintCountMap13;
uint256 private maxMintPerWallet13 = 1;
mapping(address => uint256) private mintCountMap14;
mapping(address => uint256) public allowedMintCountMap14;
uint256 private maxMintPerWallet14 = 1;
mapping(address => uint256) private mintCountMap15;
mapping(address => uint256) public allowedMintCountMap15;
uint256 private maxMintPerWallet15 = 1;
constructor() ERC1155(_baseURI) {}
// claim functions
function claimnft1(uint256 qty) public {
}
function claimnft2(uint256 qty) public {
}
function claimnft3(uint256 qty) public {
}
function claimnft4(uint256 qty) public {
}
function claimnft5(uint256 qty) public {
}
function claimnft6(uint256 qty) public {
}
function claimnft7(uint256 qty) public {
}
function claimnft8(uint256 qty) public {
}
function claimnft9(uint256 qty) public {
}
function claimnft10(uint256 qty) public {
}
function claimnft11(uint256 qty) public {
}
function claimnft12(uint256 qty) public { //melted
require(saleLive,"Sale is not live yet");
require(qty == 1,"You can only mint 1");
require(<FILL_ME>)
require(tx.origin == msg.sender); //stop contract buying
require(nft12s <= supplyPerNFT);
_mint(msg.sender, nft12, qty, "");
updateMintCount12(msg.sender, qty);
nft12s += qty;
}
function claimnft13(uint256 qty) public {
}
function claimnft14(uint256 qty) public {
}
function claimnft15(uint256 qty) public {
}
//mapping logic
function updateMintCount1(address minter, uint256 count) private {
}
function allowedMintCount1(address minter) public view returns (uint256) {
}
function setMaxPerWallet1(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount2(address minter, uint256 count) private {
}
function allowedMintCount2(address minter) public view returns (uint256) {
}
function setMaxPerWallet2(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount3(address minter, uint256 count) private {
}
function allowedMintCount3(address minter) public view returns (uint256) {
}
function setMaxPerWallet3(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount4(address minter, uint256 count) private {
}
function allowedMintCount4(address minter) public view returns (uint256) {
}
function setMaxPerWallet4(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount5(address minter, uint256 count) private {
}
function allowedMintCount5(address minter) public view returns (uint256) {
}
function setMaxPerWallet5(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount6(address minter, uint256 count) private {
}
function allowedMintCount6(address minter) public view returns (uint256) {
}
function setMaxPerWallet6(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount7(address minter, uint256 count) private {
}
function allowedMintCount7(address minter) public view returns (uint256) {
}
function setMaxPerWallet7(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount8(address minter, uint256 count) private {
}
function allowedMintCount8(address minter) public view returns (uint256) {
}
function setMaxPerWallet8(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount9(address minter, uint256 count) private {
}
function allowedMintCount9(address minter) public view returns (uint256) {
}
function setMaxPerWallet9(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount10(address minter, uint256 count) private {
}
function allowedMintCount10(address minter) public view returns (uint256) {
}
function setMaxPerWallet10(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount11(address minter, uint256 count) private {
}
function allowedMintCount11(address minter) public view returns (uint256) {
}
function setMaxPerWallet11(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount12(address minter, uint256 count) private {
}
function allowedMintCount12(address minter) public view returns (uint256) {
}
function setMaxPerWallet12(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount13(address minter, uint256 count) private {
}
function allowedMintCount13(address minter) public view returns (uint256) {
}
function setMaxPerWallet13(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount14(address minter, uint256 count) private {
}
function allowedMintCount14(address minter) public view returns (uint256) {
}
function setMaxPerWallet14(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount15(address minter, uint256 count) private {
}
function allowedMintCount15(address minter) public view returns (uint256) {
}
function setMaxPerWallet15(uint256 _newMaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory newuri) public onlyOwner {
}
function setContractURI(string memory newuri) public onlyOwner {
}
function setMaxPerNFT(uint256 _newMaxAmount) public onlyOwner {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
function totalSupply(uint256 id) public view virtual returns (uint256) {
}
function exists(uint256 id) public view virtual returns (bool) {
}
function setSale(bool _status) public onlyOwner {
}
function withdrawToOwner() external onlyOwner {
}
}
| allowedMintCount12(msg.sender)>=qty,"You already claimed" | 309,022 | allowedMintCount12(msg.sender)>=qty |
"You already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";
contract GOONYFRENS is ERC1155, Ownable {
using Strings for string;
mapping(uint256 => uint256) private _totalSupply;
//constants
uint256 constant nft1 = 1;
uint256 constant nft2 = 2;
uint256 constant nft3 = 3;
uint256 constant nft4 = 4;
uint256 constant nft5 = 5;
uint256 constant nft6 = 6;
uint256 constant nft7 = 7;
uint256 constant nft8 = 8;
uint256 constant nft9 = 9;
uint256 constant nft10 = 10;
uint256 constant nft11 = 11;
uint256 constant nft12 = 12;
uint256 constant nft13 = 13;
uint256 constant nft14 = 14;
uint256 constant nft15 = 15;
uint256 public nft1s;
uint256 public nft2s;
uint256 public nft3s;
uint256 public nft4s;
uint256 public nft5s;
uint256 public nft6s;
uint256 public nft7s;
uint256 public nft8s;
uint256 public nft9s;
uint256 public nft10s;
uint256 public nft11s;
uint256 public nft12s;
uint256 public nft13s;
uint256 public nft14s;
uint256 public nft15s;
uint256 public supplyPerNFT = 500;
string public _baseURI;
string public _contractURI;
bool saleLive = false;
//mappings
mapping(address => uint256) private mintCountMap1;
mapping(address => uint256) public allowedMintCountMap1;
uint256 private maxMintPerWallet1 = 1;
mapping(address => uint256) private mintCountMap2;
mapping(address => uint256) public allowedMintCountMap2;
uint256 private maxMintPerWallet2 = 1;
mapping(address => uint256) private mintCountMap3;
mapping(address => uint256) public allowedMintCountMap3;
uint256 private maxMintPerWallet3 = 1;
mapping(address => uint256) private mintCountMap4;
mapping(address => uint256) public allowedMintCountMap4;
uint256 private maxMintPerWallet4 = 1;
mapping(address => uint256) private mintCountMap5;
mapping(address => uint256) public allowedMintCountMap5;
uint256 private maxMintPerWallet5 = 1;
mapping(address => uint256) private mintCountMap6;
mapping(address => uint256) public allowedMintCountMap6;
uint256 private maxMintPerWallet6 = 1;
mapping(address => uint256) private mintCountMap7;
mapping(address => uint256) public allowedMintCountMap7;
uint256 private maxMintPerWallet7 = 1;
mapping(address => uint256) private mintCountMap8;
mapping(address => uint256) public allowedMintCountMap8;
uint256 private maxMintPerWallet8 = 1;
mapping(address => uint256) private mintCountMap9;
mapping(address => uint256) public allowedMintCountMap9;
uint256 private maxMintPerWallet9 = 1;
mapping(address => uint256) private mintCountMap10;
mapping(address => uint256) public allowedMintCountMap10;
uint256 private maxMintPerWallet10 = 1;
mapping(address => uint256) private mintCountMap11;
mapping(address => uint256) public allowedMintCountMap11;
uint256 private maxMintPerWallet11 = 1;
mapping(address => uint256) private mintCountMap12;
mapping(address => uint256) public allowedMintCountMap12;
uint256 private maxMintPerWallet12 = 1;
mapping(address => uint256) private mintCountMap13;
mapping(address => uint256) public allowedMintCountMap13;
uint256 private maxMintPerWallet13 = 1;
mapping(address => uint256) private mintCountMap14;
mapping(address => uint256) public allowedMintCountMap14;
uint256 private maxMintPerWallet14 = 1;
mapping(address => uint256) private mintCountMap15;
mapping(address => uint256) public allowedMintCountMap15;
uint256 private maxMintPerWallet15 = 1;
constructor() ERC1155(_baseURI) {}
// claim functions
function claimnft1(uint256 qty) public {
}
function claimnft2(uint256 qty) public {
}
function claimnft3(uint256 qty) public {
}
function claimnft4(uint256 qty) public {
}
function claimnft5(uint256 qty) public {
}
function claimnft6(uint256 qty) public {
}
function claimnft7(uint256 qty) public {
}
function claimnft8(uint256 qty) public {
}
function claimnft9(uint256 qty) public {
}
function claimnft10(uint256 qty) public {
}
function claimnft11(uint256 qty) public {
}
function claimnft12(uint256 qty) public {
}
function claimnft13(uint256 qty) public { //smilesss
require(saleLive,"Sale is not live yet");
require(qty == 1,"You can only mint 1");
require(<FILL_ME>)
require(tx.origin == msg.sender); //stop contract buying
require(nft13s <= supplyPerNFT);
_mint(msg.sender, nft13, qty, "");
updateMintCount13(msg.sender, qty);
nft13s += qty;
}
function claimnft14(uint256 qty) public {
}
function claimnft15(uint256 qty) public {
}
//mapping logic
function updateMintCount1(address minter, uint256 count) private {
}
function allowedMintCount1(address minter) public view returns (uint256) {
}
function setMaxPerWallet1(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount2(address minter, uint256 count) private {
}
function allowedMintCount2(address minter) public view returns (uint256) {
}
function setMaxPerWallet2(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount3(address minter, uint256 count) private {
}
function allowedMintCount3(address minter) public view returns (uint256) {
}
function setMaxPerWallet3(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount4(address minter, uint256 count) private {
}
function allowedMintCount4(address minter) public view returns (uint256) {
}
function setMaxPerWallet4(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount5(address minter, uint256 count) private {
}
function allowedMintCount5(address minter) public view returns (uint256) {
}
function setMaxPerWallet5(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount6(address minter, uint256 count) private {
}
function allowedMintCount6(address minter) public view returns (uint256) {
}
function setMaxPerWallet6(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount7(address minter, uint256 count) private {
}
function allowedMintCount7(address minter) public view returns (uint256) {
}
function setMaxPerWallet7(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount8(address minter, uint256 count) private {
}
function allowedMintCount8(address minter) public view returns (uint256) {
}
function setMaxPerWallet8(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount9(address minter, uint256 count) private {
}
function allowedMintCount9(address minter) public view returns (uint256) {
}
function setMaxPerWallet9(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount10(address minter, uint256 count) private {
}
function allowedMintCount10(address minter) public view returns (uint256) {
}
function setMaxPerWallet10(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount11(address minter, uint256 count) private {
}
function allowedMintCount11(address minter) public view returns (uint256) {
}
function setMaxPerWallet11(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount12(address minter, uint256 count) private {
}
function allowedMintCount12(address minter) public view returns (uint256) {
}
function setMaxPerWallet12(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount13(address minter, uint256 count) private {
}
function allowedMintCount13(address minter) public view returns (uint256) {
}
function setMaxPerWallet13(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount14(address minter, uint256 count) private {
}
function allowedMintCount14(address minter) public view returns (uint256) {
}
function setMaxPerWallet14(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount15(address minter, uint256 count) private {
}
function allowedMintCount15(address minter) public view returns (uint256) {
}
function setMaxPerWallet15(uint256 _newMaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory newuri) public onlyOwner {
}
function setContractURI(string memory newuri) public onlyOwner {
}
function setMaxPerNFT(uint256 _newMaxAmount) public onlyOwner {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
function totalSupply(uint256 id) public view virtual returns (uint256) {
}
function exists(uint256 id) public view virtual returns (bool) {
}
function setSale(bool _status) public onlyOwner {
}
function withdrawToOwner() external onlyOwner {
}
}
| allowedMintCount13(msg.sender)>=qty,"You already claimed" | 309,022 | allowedMintCount13(msg.sender)>=qty |
"You already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";
contract GOONYFRENS is ERC1155, Ownable {
using Strings for string;
mapping(uint256 => uint256) private _totalSupply;
//constants
uint256 constant nft1 = 1;
uint256 constant nft2 = 2;
uint256 constant nft3 = 3;
uint256 constant nft4 = 4;
uint256 constant nft5 = 5;
uint256 constant nft6 = 6;
uint256 constant nft7 = 7;
uint256 constant nft8 = 8;
uint256 constant nft9 = 9;
uint256 constant nft10 = 10;
uint256 constant nft11 = 11;
uint256 constant nft12 = 12;
uint256 constant nft13 = 13;
uint256 constant nft14 = 14;
uint256 constant nft15 = 15;
uint256 public nft1s;
uint256 public nft2s;
uint256 public nft3s;
uint256 public nft4s;
uint256 public nft5s;
uint256 public nft6s;
uint256 public nft7s;
uint256 public nft8s;
uint256 public nft9s;
uint256 public nft10s;
uint256 public nft11s;
uint256 public nft12s;
uint256 public nft13s;
uint256 public nft14s;
uint256 public nft15s;
uint256 public supplyPerNFT = 500;
string public _baseURI;
string public _contractURI;
bool saleLive = false;
//mappings
mapping(address => uint256) private mintCountMap1;
mapping(address => uint256) public allowedMintCountMap1;
uint256 private maxMintPerWallet1 = 1;
mapping(address => uint256) private mintCountMap2;
mapping(address => uint256) public allowedMintCountMap2;
uint256 private maxMintPerWallet2 = 1;
mapping(address => uint256) private mintCountMap3;
mapping(address => uint256) public allowedMintCountMap3;
uint256 private maxMintPerWallet3 = 1;
mapping(address => uint256) private mintCountMap4;
mapping(address => uint256) public allowedMintCountMap4;
uint256 private maxMintPerWallet4 = 1;
mapping(address => uint256) private mintCountMap5;
mapping(address => uint256) public allowedMintCountMap5;
uint256 private maxMintPerWallet5 = 1;
mapping(address => uint256) private mintCountMap6;
mapping(address => uint256) public allowedMintCountMap6;
uint256 private maxMintPerWallet6 = 1;
mapping(address => uint256) private mintCountMap7;
mapping(address => uint256) public allowedMintCountMap7;
uint256 private maxMintPerWallet7 = 1;
mapping(address => uint256) private mintCountMap8;
mapping(address => uint256) public allowedMintCountMap8;
uint256 private maxMintPerWallet8 = 1;
mapping(address => uint256) private mintCountMap9;
mapping(address => uint256) public allowedMintCountMap9;
uint256 private maxMintPerWallet9 = 1;
mapping(address => uint256) private mintCountMap10;
mapping(address => uint256) public allowedMintCountMap10;
uint256 private maxMintPerWallet10 = 1;
mapping(address => uint256) private mintCountMap11;
mapping(address => uint256) public allowedMintCountMap11;
uint256 private maxMintPerWallet11 = 1;
mapping(address => uint256) private mintCountMap12;
mapping(address => uint256) public allowedMintCountMap12;
uint256 private maxMintPerWallet12 = 1;
mapping(address => uint256) private mintCountMap13;
mapping(address => uint256) public allowedMintCountMap13;
uint256 private maxMintPerWallet13 = 1;
mapping(address => uint256) private mintCountMap14;
mapping(address => uint256) public allowedMintCountMap14;
uint256 private maxMintPerWallet14 = 1;
mapping(address => uint256) private mintCountMap15;
mapping(address => uint256) public allowedMintCountMap15;
uint256 private maxMintPerWallet15 = 1;
constructor() ERC1155(_baseURI) {}
// claim functions
function claimnft1(uint256 qty) public {
}
function claimnft2(uint256 qty) public {
}
function claimnft3(uint256 qty) public {
}
function claimnft4(uint256 qty) public {
}
function claimnft5(uint256 qty) public {
}
function claimnft6(uint256 qty) public {
}
function claimnft7(uint256 qty) public {
}
function claimnft8(uint256 qty) public {
}
function claimnft9(uint256 qty) public {
}
function claimnft10(uint256 qty) public {
}
function claimnft11(uint256 qty) public {
}
function claimnft12(uint256 qty) public {
}
function claimnft13(uint256 qty) public {
}
function claimnft14(uint256 qty) public { //woodies
require(qty == 1,"You can only mint 1");
require(<FILL_ME>)
require(tx.origin == msg.sender); //stop contract buying
require(nft14s <= supplyPerNFT);
_mint(msg.sender, nft14, qty, "");
updateMintCount14(msg.sender, qty);
nft14s += qty;
}
function claimnft15(uint256 qty) public {
}
//mapping logic
function updateMintCount1(address minter, uint256 count) private {
}
function allowedMintCount1(address minter) public view returns (uint256) {
}
function setMaxPerWallet1(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount2(address minter, uint256 count) private {
}
function allowedMintCount2(address minter) public view returns (uint256) {
}
function setMaxPerWallet2(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount3(address minter, uint256 count) private {
}
function allowedMintCount3(address minter) public view returns (uint256) {
}
function setMaxPerWallet3(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount4(address minter, uint256 count) private {
}
function allowedMintCount4(address minter) public view returns (uint256) {
}
function setMaxPerWallet4(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount5(address minter, uint256 count) private {
}
function allowedMintCount5(address minter) public view returns (uint256) {
}
function setMaxPerWallet5(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount6(address minter, uint256 count) private {
}
function allowedMintCount6(address minter) public view returns (uint256) {
}
function setMaxPerWallet6(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount7(address minter, uint256 count) private {
}
function allowedMintCount7(address minter) public view returns (uint256) {
}
function setMaxPerWallet7(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount8(address minter, uint256 count) private {
}
function allowedMintCount8(address minter) public view returns (uint256) {
}
function setMaxPerWallet8(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount9(address minter, uint256 count) private {
}
function allowedMintCount9(address minter) public view returns (uint256) {
}
function setMaxPerWallet9(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount10(address minter, uint256 count) private {
}
function allowedMintCount10(address minter) public view returns (uint256) {
}
function setMaxPerWallet10(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount11(address minter, uint256 count) private {
}
function allowedMintCount11(address minter) public view returns (uint256) {
}
function setMaxPerWallet11(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount12(address minter, uint256 count) private {
}
function allowedMintCount12(address minter) public view returns (uint256) {
}
function setMaxPerWallet12(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount13(address minter, uint256 count) private {
}
function allowedMintCount13(address minter) public view returns (uint256) {
}
function setMaxPerWallet13(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount14(address minter, uint256 count) private {
}
function allowedMintCount14(address minter) public view returns (uint256) {
}
function setMaxPerWallet14(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount15(address minter, uint256 count) private {
}
function allowedMintCount15(address minter) public view returns (uint256) {
}
function setMaxPerWallet15(uint256 _newMaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory newuri) public onlyOwner {
}
function setContractURI(string memory newuri) public onlyOwner {
}
function setMaxPerNFT(uint256 _newMaxAmount) public onlyOwner {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
function totalSupply(uint256 id) public view virtual returns (uint256) {
}
function exists(uint256 id) public view virtual returns (bool) {
}
function setSale(bool _status) public onlyOwner {
}
function withdrawToOwner() external onlyOwner {
}
}
| allowedMintCount14(msg.sender)>=qty,"You already claimed" | 309,022 | allowedMintCount14(msg.sender)>=qty |
"You already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";
contract GOONYFRENS is ERC1155, Ownable {
using Strings for string;
mapping(uint256 => uint256) private _totalSupply;
//constants
uint256 constant nft1 = 1;
uint256 constant nft2 = 2;
uint256 constant nft3 = 3;
uint256 constant nft4 = 4;
uint256 constant nft5 = 5;
uint256 constant nft6 = 6;
uint256 constant nft7 = 7;
uint256 constant nft8 = 8;
uint256 constant nft9 = 9;
uint256 constant nft10 = 10;
uint256 constant nft11 = 11;
uint256 constant nft12 = 12;
uint256 constant nft13 = 13;
uint256 constant nft14 = 14;
uint256 constant nft15 = 15;
uint256 public nft1s;
uint256 public nft2s;
uint256 public nft3s;
uint256 public nft4s;
uint256 public nft5s;
uint256 public nft6s;
uint256 public nft7s;
uint256 public nft8s;
uint256 public nft9s;
uint256 public nft10s;
uint256 public nft11s;
uint256 public nft12s;
uint256 public nft13s;
uint256 public nft14s;
uint256 public nft15s;
uint256 public supplyPerNFT = 500;
string public _baseURI;
string public _contractURI;
bool saleLive = false;
//mappings
mapping(address => uint256) private mintCountMap1;
mapping(address => uint256) public allowedMintCountMap1;
uint256 private maxMintPerWallet1 = 1;
mapping(address => uint256) private mintCountMap2;
mapping(address => uint256) public allowedMintCountMap2;
uint256 private maxMintPerWallet2 = 1;
mapping(address => uint256) private mintCountMap3;
mapping(address => uint256) public allowedMintCountMap3;
uint256 private maxMintPerWallet3 = 1;
mapping(address => uint256) private mintCountMap4;
mapping(address => uint256) public allowedMintCountMap4;
uint256 private maxMintPerWallet4 = 1;
mapping(address => uint256) private mintCountMap5;
mapping(address => uint256) public allowedMintCountMap5;
uint256 private maxMintPerWallet5 = 1;
mapping(address => uint256) private mintCountMap6;
mapping(address => uint256) public allowedMintCountMap6;
uint256 private maxMintPerWallet6 = 1;
mapping(address => uint256) private mintCountMap7;
mapping(address => uint256) public allowedMintCountMap7;
uint256 private maxMintPerWallet7 = 1;
mapping(address => uint256) private mintCountMap8;
mapping(address => uint256) public allowedMintCountMap8;
uint256 private maxMintPerWallet8 = 1;
mapping(address => uint256) private mintCountMap9;
mapping(address => uint256) public allowedMintCountMap9;
uint256 private maxMintPerWallet9 = 1;
mapping(address => uint256) private mintCountMap10;
mapping(address => uint256) public allowedMintCountMap10;
uint256 private maxMintPerWallet10 = 1;
mapping(address => uint256) private mintCountMap11;
mapping(address => uint256) public allowedMintCountMap11;
uint256 private maxMintPerWallet11 = 1;
mapping(address => uint256) private mintCountMap12;
mapping(address => uint256) public allowedMintCountMap12;
uint256 private maxMintPerWallet12 = 1;
mapping(address => uint256) private mintCountMap13;
mapping(address => uint256) public allowedMintCountMap13;
uint256 private maxMintPerWallet13 = 1;
mapping(address => uint256) private mintCountMap14;
mapping(address => uint256) public allowedMintCountMap14;
uint256 private maxMintPerWallet14 = 1;
mapping(address => uint256) private mintCountMap15;
mapping(address => uint256) public allowedMintCountMap15;
uint256 private maxMintPerWallet15 = 1;
constructor() ERC1155(_baseURI) {}
// claim functions
function claimnft1(uint256 qty) public {
}
function claimnft2(uint256 qty) public {
}
function claimnft3(uint256 qty) public {
}
function claimnft4(uint256 qty) public {
}
function claimnft5(uint256 qty) public {
}
function claimnft6(uint256 qty) public {
}
function claimnft7(uint256 qty) public {
}
function claimnft8(uint256 qty) public {
}
function claimnft9(uint256 qty) public {
}
function claimnft10(uint256 qty) public {
}
function claimnft11(uint256 qty) public {
}
function claimnft12(uint256 qty) public {
}
function claimnft13(uint256 qty) public {
}
function claimnft14(uint256 qty) public {
}
function claimnft15(uint256 qty) public { //wow
require(saleLive,"Sale is not live yet");
require(qty == 1,"You can only mint 1");
require(<FILL_ME>)
require(tx.origin == msg.sender); //stop contract buying
require(nft15s <= supplyPerNFT);
_mint(msg.sender, nft15, qty, "");
updateMintCount15(msg.sender, qty);
nft15s += qty;
}
//mapping logic
function updateMintCount1(address minter, uint256 count) private {
}
function allowedMintCount1(address minter) public view returns (uint256) {
}
function setMaxPerWallet1(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount2(address minter, uint256 count) private {
}
function allowedMintCount2(address minter) public view returns (uint256) {
}
function setMaxPerWallet2(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount3(address minter, uint256 count) private {
}
function allowedMintCount3(address minter) public view returns (uint256) {
}
function setMaxPerWallet3(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount4(address minter, uint256 count) private {
}
function allowedMintCount4(address minter) public view returns (uint256) {
}
function setMaxPerWallet4(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount5(address minter, uint256 count) private {
}
function allowedMintCount5(address minter) public view returns (uint256) {
}
function setMaxPerWallet5(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount6(address minter, uint256 count) private {
}
function allowedMintCount6(address minter) public view returns (uint256) {
}
function setMaxPerWallet6(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount7(address minter, uint256 count) private {
}
function allowedMintCount7(address minter) public view returns (uint256) {
}
function setMaxPerWallet7(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount8(address minter, uint256 count) private {
}
function allowedMintCount8(address minter) public view returns (uint256) {
}
function setMaxPerWallet8(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount9(address minter, uint256 count) private {
}
function allowedMintCount9(address minter) public view returns (uint256) {
}
function setMaxPerWallet9(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount10(address minter, uint256 count) private {
}
function allowedMintCount10(address minter) public view returns (uint256) {
}
function setMaxPerWallet10(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount11(address minter, uint256 count) private {
}
function allowedMintCount11(address minter) public view returns (uint256) {
}
function setMaxPerWallet11(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount12(address minter, uint256 count) private {
}
function allowedMintCount12(address minter) public view returns (uint256) {
}
function setMaxPerWallet12(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount13(address minter, uint256 count) private {
}
function allowedMintCount13(address minter) public view returns (uint256) {
}
function setMaxPerWallet13(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount14(address minter, uint256 count) private {
}
function allowedMintCount14(address minter) public view returns (uint256) {
}
function setMaxPerWallet14(uint256 _newMaxMintAmount) public onlyOwner {
}
function updateMintCount15(address minter, uint256 count) private {
}
function allowedMintCount15(address minter) public view returns (uint256) {
}
function setMaxPerWallet15(uint256 _newMaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory newuri) public onlyOwner {
}
function setContractURI(string memory newuri) public onlyOwner {
}
function setMaxPerNFT(uint256 _newMaxAmount) public onlyOwner {
}
function uri(uint256 tokenId) public view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
}
function totalSupply(uint256 id) public view virtual returns (uint256) {
}
function exists(uint256 id) public view virtual returns (bool) {
}
function setSale(bool _status) public onlyOwner {
}
function withdrawToOwner() external onlyOwner {
}
}
| allowedMintCount15(msg.sender)>=qty,"You already claimed" | 309,022 | allowedMintCount15(msg.sender)>=qty |
"SLOTIE NFT NOT SET" | // SPDX-License-Identifier: MIT
// Developed by KG Technologies (https://kgtechnologies.io)
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @notice Represents Slotie Smart Contract
*/
contract ISlotie {
/**
* @dev ERC-721 INTERFACE
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {}
/**
* @dev CUSTOM INTERFACE
*/
function mintTo(uint256 amount, address _to) external {}
}
contract ISlotieJr {
/**
* @dev ERC-721 INTERFACE
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {}
function totalSupply() public view returns (uint256) {}
/**
* @dev CUSTOM INTERFACE
*/
function mintTo(uint256 amount, address _to) external {}
function maxMintPerTransaction() public returns (uint256) {}
}
abstract contract IWatts is IERC20 {
function burn(address _from, uint256 _amount) external {}
function seeClaimableBalanceOfUser(address user) external view returns(uint256) {}
function seeClaimableTotalSupply() external view returns(uint256) {}
function burnClaimable(address _from, uint256 _amount) public {}
function transferOwnership(address newOwner) public {}
function setSlotieNFT(address newSlotieNFT) external {}
function setLockPeriod(uint256 newLockPeriod) external {}
function setIsBlackListed(address _address, bool _isBlackListed) external {}
}
/**
* @title SlotieJrBreeding.
*
* @author KG Technologies (https://kgtechnologies.io).
*
* @notice This Smart Contract can be used to breed Slotie NFTs.
*
* @dev The primary mode of verifying permissioned actions is through Merkle Proofs
* which are generated off-chain.
*/
contract SlotieJrBreeding is Ownable {
/**
* @notice The Smart Contract of Slotie
* @dev ERC-721 Smart Contract
*/
ISlotie public immutable slotie;
/**
* @notice The Smart Contract of Slotie Jr.
* @dev ERC-721 Smart Contract
*/
ISlotieJr public immutable slotiejr;
/**
* @notice The Smart Contract of Watts.
* @dev ERC-20 Smart Contract
*/
IWatts public immutable watts;
/**
* @dev BREED DATA
*/
uint256 public maxBreedableJuniors = 5000;
bool public isBreedingStarted = false;
uint256 public breedPrice = 1800 ether;
uint256 public breedCoolDown = 2 * 30 days;
mapping(uint256 => uint256) public slotieToLastBreedTimeStamp;
bytes32 public merkleRoot = 0x92b34b7175c93f0db8f32e6996287e5d3141e4364dcc5f03e3f3b0454d999605;
/**
* @dev TRACKING DATA
*/
uint256 public bornJuniors;
/**
* @dev Events
*/
event ReceivedEther(address indexed sender, uint256 indexed amount);
event Bred(address initiator, uint256 indexed father, uint256 indexed mother, uint256 indexed slotieJr);
event setMerkleRootEvent(bytes32 indexed root);
event setIsBreedingStartedEvent(bool indexed started);
event setMaxBreedableJuniorsEvent(uint256 indexed maxMintable);
event setBreedCoolDownEvent(uint256 indexed coolDown);
event setBreedPriceEvent(uint256 indexed price);
event WithdrawAllEvent(address indexed recipient, uint256 amount);
constructor(
address slotieAddress,
address slotieJrAddress,
address wattsAddress
) Ownable() {
}
/**
* @dev BREEDING
*/
function breed(
uint256 father,
uint256 mother,
uint256 fatherStart,
uint256 motherStart,
bytes32[] calldata fatherProof,
bytes32[] calldata motherProof
) external {
require(isBreedingStarted, "BREEDING NOT STARTED");
require(<FILL_ME>)
require(address(slotiejr) != address(0), "SLOTIE JR NFT NOT SET");
require(address(watts) != address(0), "WATTS NOT SET");
require(bornJuniors < maxBreedableJuniors, "MAX JUNIORS HAVE BEEN BRED");
require(father != mother, "CANNOT BREED THE SAME SLOTIE");
require(slotie.ownerOf(father) == msg.sender, "SENDER NOT OWNER OF FATHER");
require(slotie.ownerOf(mother) == msg.sender, "SENDER NOT OWNER OF MOTHER");
uint256 fatherLastBred = slotieToLastBreedTimeStamp[father];
uint256 motherLastBred = slotieToLastBreedTimeStamp[mother];
/**
* @notice Check if father can breed based based on time logic
*
* @dev If father hasn't bred before we check the merkle proof to see
* if it can breed already. If it has bred already we check if it's passed the
* cooldown period.
*/
if (fatherLastBred != 0) {
require(block.timestamp >= fatherLastBred + breedCoolDown, "FATHER IS STILL IN COOLDOWN");
}
/// @dev see father.
if (motherLastBred != 0) {
require(block.timestamp >= motherLastBred + breedCoolDown, "MOTHER IS STILL IN COOLDOWN");
}
if (fatherLastBred == 0 || motherLastBred == 0) {
bytes32 leafFather = keccak256(abi.encodePacked(father, fatherStart, fatherLastBred));
bytes32 leafMother = keccak256(abi.encodePacked(mother, motherStart, motherLastBred));
require(MerkleProof.verify(fatherProof, merkleRoot, leafFather), "INVALID PROOF FOR FATHER");
require(MerkleProof.verify(motherProof, merkleRoot, leafMother), "INVALID PROOF FOR MOTHER");
require(block.timestamp >= fatherStart || block.timestamp >= motherStart, "SLOTIES CANNOT CANNOT BREED YET");
}
slotieToLastBreedTimeStamp[father] = block.timestamp;
slotieToLastBreedTimeStamp[mother] = block.timestamp;
bornJuniors++;
require(watts.balanceOf(msg.sender) >= breedPrice, "SENDER DOES NOT HAVE ENOUGH WATTS");
uint256 claimableBalance = watts.seeClaimableBalanceOfUser(msg.sender);
uint256 burnFromClaimable = claimableBalance >= breedPrice ? breedPrice : claimableBalance;
uint256 burnFromBalance = claimableBalance >= breedPrice ? 0 : breedPrice - claimableBalance;
if (claimableBalance > 0) {
watts.burnClaimable(msg.sender, burnFromClaimable);
}
if (burnFromBalance > 0) {
watts.burn(msg.sender, burnFromBalance);
}
slotiejr.mintTo(1, msg.sender);
emit Bred(msg.sender, father, mother, slotiejr.totalSupply());
}
/**
* @dev OWNER ONLY
*/
/**
* @notice function to set the merkle root for breeding.
*
* @param _merkleRoot. The new merkle root to set.
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice function to turn on/off breeding.
*
* @param _status. The new state of the breeding.
*/
function setBreedingStatus(bool _status) external onlyOwner {
}
/**
* @notice function to set the maximum amount of juniors that can be bred.
*
* @param max. The new maximum.
*/
function setMaxBreedableJuniors(uint256 max) external onlyOwner {
}
/**
* @notice function to set the cooldown period for breeding a slotie.
*
* @param coolDown. The new cooldown period.
*/
function setBreedCoolDown(uint256 coolDown) external onlyOwner {
}
/**
* @notice function to set the watts price for breeding two sloties.
*
* @param price. The new watts price.
*/
function setBreedPice(uint256 price) external onlyOwner {
}
/**
* @dev WATTS OWNER
*/
function WATTSOWNER_TransferOwnership(address newOwner) external onlyOwner {
}
function WATTSOWNER_SetSlotieNFT(address newSlotie) external onlyOwner {
}
function WATTSOWNER_SetLockPeriod(uint256 newLockPeriod) external onlyOwner {
}
function WATTSOWNER_SetIsBlackListed(address _set, bool _is) external onlyOwner {
}
function WATTSOWNER_seeClaimableBalanceOfUser(address user) external view onlyOwner returns (uint256) {
}
function WATTSOWNER_seeClaimableTotalSupply() external view onlyOwner returns (uint256) {
}
/**
* @dev FINANCE
*/
/**
* @notice Allows owner to withdraw funds generated from sale.
*
* @param _to. The address to send the funds to.
*/
function withdrawAll(address _to) external onlyOwner {
}
/**
* @dev Fallback function for receiving Ether
*/
receive() external payable {
}
}
| address(slotie)!=address(0),"SLOTIE NFT NOT SET" | 309,049 | address(slotie)!=address(0) |
"SLOTIE JR NFT NOT SET" | // SPDX-License-Identifier: MIT
// Developed by KG Technologies (https://kgtechnologies.io)
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @notice Represents Slotie Smart Contract
*/
contract ISlotie {
/**
* @dev ERC-721 INTERFACE
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {}
/**
* @dev CUSTOM INTERFACE
*/
function mintTo(uint256 amount, address _to) external {}
}
contract ISlotieJr {
/**
* @dev ERC-721 INTERFACE
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {}
function totalSupply() public view returns (uint256) {}
/**
* @dev CUSTOM INTERFACE
*/
function mintTo(uint256 amount, address _to) external {}
function maxMintPerTransaction() public returns (uint256) {}
}
abstract contract IWatts is IERC20 {
function burn(address _from, uint256 _amount) external {}
function seeClaimableBalanceOfUser(address user) external view returns(uint256) {}
function seeClaimableTotalSupply() external view returns(uint256) {}
function burnClaimable(address _from, uint256 _amount) public {}
function transferOwnership(address newOwner) public {}
function setSlotieNFT(address newSlotieNFT) external {}
function setLockPeriod(uint256 newLockPeriod) external {}
function setIsBlackListed(address _address, bool _isBlackListed) external {}
}
/**
* @title SlotieJrBreeding.
*
* @author KG Technologies (https://kgtechnologies.io).
*
* @notice This Smart Contract can be used to breed Slotie NFTs.
*
* @dev The primary mode of verifying permissioned actions is through Merkle Proofs
* which are generated off-chain.
*/
contract SlotieJrBreeding is Ownable {
/**
* @notice The Smart Contract of Slotie
* @dev ERC-721 Smart Contract
*/
ISlotie public immutable slotie;
/**
* @notice The Smart Contract of Slotie Jr.
* @dev ERC-721 Smart Contract
*/
ISlotieJr public immutable slotiejr;
/**
* @notice The Smart Contract of Watts.
* @dev ERC-20 Smart Contract
*/
IWatts public immutable watts;
/**
* @dev BREED DATA
*/
uint256 public maxBreedableJuniors = 5000;
bool public isBreedingStarted = false;
uint256 public breedPrice = 1800 ether;
uint256 public breedCoolDown = 2 * 30 days;
mapping(uint256 => uint256) public slotieToLastBreedTimeStamp;
bytes32 public merkleRoot = 0x92b34b7175c93f0db8f32e6996287e5d3141e4364dcc5f03e3f3b0454d999605;
/**
* @dev TRACKING DATA
*/
uint256 public bornJuniors;
/**
* @dev Events
*/
event ReceivedEther(address indexed sender, uint256 indexed amount);
event Bred(address initiator, uint256 indexed father, uint256 indexed mother, uint256 indexed slotieJr);
event setMerkleRootEvent(bytes32 indexed root);
event setIsBreedingStartedEvent(bool indexed started);
event setMaxBreedableJuniorsEvent(uint256 indexed maxMintable);
event setBreedCoolDownEvent(uint256 indexed coolDown);
event setBreedPriceEvent(uint256 indexed price);
event WithdrawAllEvent(address indexed recipient, uint256 amount);
constructor(
address slotieAddress,
address slotieJrAddress,
address wattsAddress
) Ownable() {
}
/**
* @dev BREEDING
*/
function breed(
uint256 father,
uint256 mother,
uint256 fatherStart,
uint256 motherStart,
bytes32[] calldata fatherProof,
bytes32[] calldata motherProof
) external {
require(isBreedingStarted, "BREEDING NOT STARTED");
require(address(slotie) != address(0), "SLOTIE NFT NOT SET");
require(<FILL_ME>)
require(address(watts) != address(0), "WATTS NOT SET");
require(bornJuniors < maxBreedableJuniors, "MAX JUNIORS HAVE BEEN BRED");
require(father != mother, "CANNOT BREED THE SAME SLOTIE");
require(slotie.ownerOf(father) == msg.sender, "SENDER NOT OWNER OF FATHER");
require(slotie.ownerOf(mother) == msg.sender, "SENDER NOT OWNER OF MOTHER");
uint256 fatherLastBred = slotieToLastBreedTimeStamp[father];
uint256 motherLastBred = slotieToLastBreedTimeStamp[mother];
/**
* @notice Check if father can breed based based on time logic
*
* @dev If father hasn't bred before we check the merkle proof to see
* if it can breed already. If it has bred already we check if it's passed the
* cooldown period.
*/
if (fatherLastBred != 0) {
require(block.timestamp >= fatherLastBred + breedCoolDown, "FATHER IS STILL IN COOLDOWN");
}
/// @dev see father.
if (motherLastBred != 0) {
require(block.timestamp >= motherLastBred + breedCoolDown, "MOTHER IS STILL IN COOLDOWN");
}
if (fatherLastBred == 0 || motherLastBred == 0) {
bytes32 leafFather = keccak256(abi.encodePacked(father, fatherStart, fatherLastBred));
bytes32 leafMother = keccak256(abi.encodePacked(mother, motherStart, motherLastBred));
require(MerkleProof.verify(fatherProof, merkleRoot, leafFather), "INVALID PROOF FOR FATHER");
require(MerkleProof.verify(motherProof, merkleRoot, leafMother), "INVALID PROOF FOR MOTHER");
require(block.timestamp >= fatherStart || block.timestamp >= motherStart, "SLOTIES CANNOT CANNOT BREED YET");
}
slotieToLastBreedTimeStamp[father] = block.timestamp;
slotieToLastBreedTimeStamp[mother] = block.timestamp;
bornJuniors++;
require(watts.balanceOf(msg.sender) >= breedPrice, "SENDER DOES NOT HAVE ENOUGH WATTS");
uint256 claimableBalance = watts.seeClaimableBalanceOfUser(msg.sender);
uint256 burnFromClaimable = claimableBalance >= breedPrice ? breedPrice : claimableBalance;
uint256 burnFromBalance = claimableBalance >= breedPrice ? 0 : breedPrice - claimableBalance;
if (claimableBalance > 0) {
watts.burnClaimable(msg.sender, burnFromClaimable);
}
if (burnFromBalance > 0) {
watts.burn(msg.sender, burnFromBalance);
}
slotiejr.mintTo(1, msg.sender);
emit Bred(msg.sender, father, mother, slotiejr.totalSupply());
}
/**
* @dev OWNER ONLY
*/
/**
* @notice function to set the merkle root for breeding.
*
* @param _merkleRoot. The new merkle root to set.
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice function to turn on/off breeding.
*
* @param _status. The new state of the breeding.
*/
function setBreedingStatus(bool _status) external onlyOwner {
}
/**
* @notice function to set the maximum amount of juniors that can be bred.
*
* @param max. The new maximum.
*/
function setMaxBreedableJuniors(uint256 max) external onlyOwner {
}
/**
* @notice function to set the cooldown period for breeding a slotie.
*
* @param coolDown. The new cooldown period.
*/
function setBreedCoolDown(uint256 coolDown) external onlyOwner {
}
/**
* @notice function to set the watts price for breeding two sloties.
*
* @param price. The new watts price.
*/
function setBreedPice(uint256 price) external onlyOwner {
}
/**
* @dev WATTS OWNER
*/
function WATTSOWNER_TransferOwnership(address newOwner) external onlyOwner {
}
function WATTSOWNER_SetSlotieNFT(address newSlotie) external onlyOwner {
}
function WATTSOWNER_SetLockPeriod(uint256 newLockPeriod) external onlyOwner {
}
function WATTSOWNER_SetIsBlackListed(address _set, bool _is) external onlyOwner {
}
function WATTSOWNER_seeClaimableBalanceOfUser(address user) external view onlyOwner returns (uint256) {
}
function WATTSOWNER_seeClaimableTotalSupply() external view onlyOwner returns (uint256) {
}
/**
* @dev FINANCE
*/
/**
* @notice Allows owner to withdraw funds generated from sale.
*
* @param _to. The address to send the funds to.
*/
function withdrawAll(address _to) external onlyOwner {
}
/**
* @dev Fallback function for receiving Ether
*/
receive() external payable {
}
}
| address(slotiejr)!=address(0),"SLOTIE JR NFT NOT SET" | 309,049 | address(slotiejr)!=address(0) |
"WATTS NOT SET" | // SPDX-License-Identifier: MIT
// Developed by KG Technologies (https://kgtechnologies.io)
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @notice Represents Slotie Smart Contract
*/
contract ISlotie {
/**
* @dev ERC-721 INTERFACE
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {}
/**
* @dev CUSTOM INTERFACE
*/
function mintTo(uint256 amount, address _to) external {}
}
contract ISlotieJr {
/**
* @dev ERC-721 INTERFACE
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {}
function totalSupply() public view returns (uint256) {}
/**
* @dev CUSTOM INTERFACE
*/
function mintTo(uint256 amount, address _to) external {}
function maxMintPerTransaction() public returns (uint256) {}
}
abstract contract IWatts is IERC20 {
function burn(address _from, uint256 _amount) external {}
function seeClaimableBalanceOfUser(address user) external view returns(uint256) {}
function seeClaimableTotalSupply() external view returns(uint256) {}
function burnClaimable(address _from, uint256 _amount) public {}
function transferOwnership(address newOwner) public {}
function setSlotieNFT(address newSlotieNFT) external {}
function setLockPeriod(uint256 newLockPeriod) external {}
function setIsBlackListed(address _address, bool _isBlackListed) external {}
}
/**
* @title SlotieJrBreeding.
*
* @author KG Technologies (https://kgtechnologies.io).
*
* @notice This Smart Contract can be used to breed Slotie NFTs.
*
* @dev The primary mode of verifying permissioned actions is through Merkle Proofs
* which are generated off-chain.
*/
contract SlotieJrBreeding is Ownable {
/**
* @notice The Smart Contract of Slotie
* @dev ERC-721 Smart Contract
*/
ISlotie public immutable slotie;
/**
* @notice The Smart Contract of Slotie Jr.
* @dev ERC-721 Smart Contract
*/
ISlotieJr public immutable slotiejr;
/**
* @notice The Smart Contract of Watts.
* @dev ERC-20 Smart Contract
*/
IWatts public immutable watts;
/**
* @dev BREED DATA
*/
uint256 public maxBreedableJuniors = 5000;
bool public isBreedingStarted = false;
uint256 public breedPrice = 1800 ether;
uint256 public breedCoolDown = 2 * 30 days;
mapping(uint256 => uint256) public slotieToLastBreedTimeStamp;
bytes32 public merkleRoot = 0x92b34b7175c93f0db8f32e6996287e5d3141e4364dcc5f03e3f3b0454d999605;
/**
* @dev TRACKING DATA
*/
uint256 public bornJuniors;
/**
* @dev Events
*/
event ReceivedEther(address indexed sender, uint256 indexed amount);
event Bred(address initiator, uint256 indexed father, uint256 indexed mother, uint256 indexed slotieJr);
event setMerkleRootEvent(bytes32 indexed root);
event setIsBreedingStartedEvent(bool indexed started);
event setMaxBreedableJuniorsEvent(uint256 indexed maxMintable);
event setBreedCoolDownEvent(uint256 indexed coolDown);
event setBreedPriceEvent(uint256 indexed price);
event WithdrawAllEvent(address indexed recipient, uint256 amount);
constructor(
address slotieAddress,
address slotieJrAddress,
address wattsAddress
) Ownable() {
}
/**
* @dev BREEDING
*/
function breed(
uint256 father,
uint256 mother,
uint256 fatherStart,
uint256 motherStart,
bytes32[] calldata fatherProof,
bytes32[] calldata motherProof
) external {
require(isBreedingStarted, "BREEDING NOT STARTED");
require(address(slotie) != address(0), "SLOTIE NFT NOT SET");
require(address(slotiejr) != address(0), "SLOTIE JR NFT NOT SET");
require(<FILL_ME>)
require(bornJuniors < maxBreedableJuniors, "MAX JUNIORS HAVE BEEN BRED");
require(father != mother, "CANNOT BREED THE SAME SLOTIE");
require(slotie.ownerOf(father) == msg.sender, "SENDER NOT OWNER OF FATHER");
require(slotie.ownerOf(mother) == msg.sender, "SENDER NOT OWNER OF MOTHER");
uint256 fatherLastBred = slotieToLastBreedTimeStamp[father];
uint256 motherLastBred = slotieToLastBreedTimeStamp[mother];
/**
* @notice Check if father can breed based based on time logic
*
* @dev If father hasn't bred before we check the merkle proof to see
* if it can breed already. If it has bred already we check if it's passed the
* cooldown period.
*/
if (fatherLastBred != 0) {
require(block.timestamp >= fatherLastBred + breedCoolDown, "FATHER IS STILL IN COOLDOWN");
}
/// @dev see father.
if (motherLastBred != 0) {
require(block.timestamp >= motherLastBred + breedCoolDown, "MOTHER IS STILL IN COOLDOWN");
}
if (fatherLastBred == 0 || motherLastBred == 0) {
bytes32 leafFather = keccak256(abi.encodePacked(father, fatherStart, fatherLastBred));
bytes32 leafMother = keccak256(abi.encodePacked(mother, motherStart, motherLastBred));
require(MerkleProof.verify(fatherProof, merkleRoot, leafFather), "INVALID PROOF FOR FATHER");
require(MerkleProof.verify(motherProof, merkleRoot, leafMother), "INVALID PROOF FOR MOTHER");
require(block.timestamp >= fatherStart || block.timestamp >= motherStart, "SLOTIES CANNOT CANNOT BREED YET");
}
slotieToLastBreedTimeStamp[father] = block.timestamp;
slotieToLastBreedTimeStamp[mother] = block.timestamp;
bornJuniors++;
require(watts.balanceOf(msg.sender) >= breedPrice, "SENDER DOES NOT HAVE ENOUGH WATTS");
uint256 claimableBalance = watts.seeClaimableBalanceOfUser(msg.sender);
uint256 burnFromClaimable = claimableBalance >= breedPrice ? breedPrice : claimableBalance;
uint256 burnFromBalance = claimableBalance >= breedPrice ? 0 : breedPrice - claimableBalance;
if (claimableBalance > 0) {
watts.burnClaimable(msg.sender, burnFromClaimable);
}
if (burnFromBalance > 0) {
watts.burn(msg.sender, burnFromBalance);
}
slotiejr.mintTo(1, msg.sender);
emit Bred(msg.sender, father, mother, slotiejr.totalSupply());
}
/**
* @dev OWNER ONLY
*/
/**
* @notice function to set the merkle root for breeding.
*
* @param _merkleRoot. The new merkle root to set.
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice function to turn on/off breeding.
*
* @param _status. The new state of the breeding.
*/
function setBreedingStatus(bool _status) external onlyOwner {
}
/**
* @notice function to set the maximum amount of juniors that can be bred.
*
* @param max. The new maximum.
*/
function setMaxBreedableJuniors(uint256 max) external onlyOwner {
}
/**
* @notice function to set the cooldown period for breeding a slotie.
*
* @param coolDown. The new cooldown period.
*/
function setBreedCoolDown(uint256 coolDown) external onlyOwner {
}
/**
* @notice function to set the watts price for breeding two sloties.
*
* @param price. The new watts price.
*/
function setBreedPice(uint256 price) external onlyOwner {
}
/**
* @dev WATTS OWNER
*/
function WATTSOWNER_TransferOwnership(address newOwner) external onlyOwner {
}
function WATTSOWNER_SetSlotieNFT(address newSlotie) external onlyOwner {
}
function WATTSOWNER_SetLockPeriod(uint256 newLockPeriod) external onlyOwner {
}
function WATTSOWNER_SetIsBlackListed(address _set, bool _is) external onlyOwner {
}
function WATTSOWNER_seeClaimableBalanceOfUser(address user) external view onlyOwner returns (uint256) {
}
function WATTSOWNER_seeClaimableTotalSupply() external view onlyOwner returns (uint256) {
}
/**
* @dev FINANCE
*/
/**
* @notice Allows owner to withdraw funds generated from sale.
*
* @param _to. The address to send the funds to.
*/
function withdrawAll(address _to) external onlyOwner {
}
/**
* @dev Fallback function for receiving Ether
*/
receive() external payable {
}
}
| address(watts)!=address(0),"WATTS NOT SET" | 309,049 | address(watts)!=address(0) |
"SENDER NOT OWNER OF FATHER" | // SPDX-License-Identifier: MIT
// Developed by KG Technologies (https://kgtechnologies.io)
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @notice Represents Slotie Smart Contract
*/
contract ISlotie {
/**
* @dev ERC-721 INTERFACE
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {}
/**
* @dev CUSTOM INTERFACE
*/
function mintTo(uint256 amount, address _to) external {}
}
contract ISlotieJr {
/**
* @dev ERC-721 INTERFACE
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {}
function totalSupply() public view returns (uint256) {}
/**
* @dev CUSTOM INTERFACE
*/
function mintTo(uint256 amount, address _to) external {}
function maxMintPerTransaction() public returns (uint256) {}
}
abstract contract IWatts is IERC20 {
function burn(address _from, uint256 _amount) external {}
function seeClaimableBalanceOfUser(address user) external view returns(uint256) {}
function seeClaimableTotalSupply() external view returns(uint256) {}
function burnClaimable(address _from, uint256 _amount) public {}
function transferOwnership(address newOwner) public {}
function setSlotieNFT(address newSlotieNFT) external {}
function setLockPeriod(uint256 newLockPeriod) external {}
function setIsBlackListed(address _address, bool _isBlackListed) external {}
}
/**
* @title SlotieJrBreeding.
*
* @author KG Technologies (https://kgtechnologies.io).
*
* @notice This Smart Contract can be used to breed Slotie NFTs.
*
* @dev The primary mode of verifying permissioned actions is through Merkle Proofs
* which are generated off-chain.
*/
contract SlotieJrBreeding is Ownable {
/**
* @notice The Smart Contract of Slotie
* @dev ERC-721 Smart Contract
*/
ISlotie public immutable slotie;
/**
* @notice The Smart Contract of Slotie Jr.
* @dev ERC-721 Smart Contract
*/
ISlotieJr public immutable slotiejr;
/**
* @notice The Smart Contract of Watts.
* @dev ERC-20 Smart Contract
*/
IWatts public immutable watts;
/**
* @dev BREED DATA
*/
uint256 public maxBreedableJuniors = 5000;
bool public isBreedingStarted = false;
uint256 public breedPrice = 1800 ether;
uint256 public breedCoolDown = 2 * 30 days;
mapping(uint256 => uint256) public slotieToLastBreedTimeStamp;
bytes32 public merkleRoot = 0x92b34b7175c93f0db8f32e6996287e5d3141e4364dcc5f03e3f3b0454d999605;
/**
* @dev TRACKING DATA
*/
uint256 public bornJuniors;
/**
* @dev Events
*/
event ReceivedEther(address indexed sender, uint256 indexed amount);
event Bred(address initiator, uint256 indexed father, uint256 indexed mother, uint256 indexed slotieJr);
event setMerkleRootEvent(bytes32 indexed root);
event setIsBreedingStartedEvent(bool indexed started);
event setMaxBreedableJuniorsEvent(uint256 indexed maxMintable);
event setBreedCoolDownEvent(uint256 indexed coolDown);
event setBreedPriceEvent(uint256 indexed price);
event WithdrawAllEvent(address indexed recipient, uint256 amount);
constructor(
address slotieAddress,
address slotieJrAddress,
address wattsAddress
) Ownable() {
}
/**
* @dev BREEDING
*/
function breed(
uint256 father,
uint256 mother,
uint256 fatherStart,
uint256 motherStart,
bytes32[] calldata fatherProof,
bytes32[] calldata motherProof
) external {
require(isBreedingStarted, "BREEDING NOT STARTED");
require(address(slotie) != address(0), "SLOTIE NFT NOT SET");
require(address(slotiejr) != address(0), "SLOTIE JR NFT NOT SET");
require(address(watts) != address(0), "WATTS NOT SET");
require(bornJuniors < maxBreedableJuniors, "MAX JUNIORS HAVE BEEN BRED");
require(father != mother, "CANNOT BREED THE SAME SLOTIE");
require(<FILL_ME>)
require(slotie.ownerOf(mother) == msg.sender, "SENDER NOT OWNER OF MOTHER");
uint256 fatherLastBred = slotieToLastBreedTimeStamp[father];
uint256 motherLastBred = slotieToLastBreedTimeStamp[mother];
/**
* @notice Check if father can breed based based on time logic
*
* @dev If father hasn't bred before we check the merkle proof to see
* if it can breed already. If it has bred already we check if it's passed the
* cooldown period.
*/
if (fatherLastBred != 0) {
require(block.timestamp >= fatherLastBred + breedCoolDown, "FATHER IS STILL IN COOLDOWN");
}
/// @dev see father.
if (motherLastBred != 0) {
require(block.timestamp >= motherLastBred + breedCoolDown, "MOTHER IS STILL IN COOLDOWN");
}
if (fatherLastBred == 0 || motherLastBred == 0) {
bytes32 leafFather = keccak256(abi.encodePacked(father, fatherStart, fatherLastBred));
bytes32 leafMother = keccak256(abi.encodePacked(mother, motherStart, motherLastBred));
require(MerkleProof.verify(fatherProof, merkleRoot, leafFather), "INVALID PROOF FOR FATHER");
require(MerkleProof.verify(motherProof, merkleRoot, leafMother), "INVALID PROOF FOR MOTHER");
require(block.timestamp >= fatherStart || block.timestamp >= motherStart, "SLOTIES CANNOT CANNOT BREED YET");
}
slotieToLastBreedTimeStamp[father] = block.timestamp;
slotieToLastBreedTimeStamp[mother] = block.timestamp;
bornJuniors++;
require(watts.balanceOf(msg.sender) >= breedPrice, "SENDER DOES NOT HAVE ENOUGH WATTS");
uint256 claimableBalance = watts.seeClaimableBalanceOfUser(msg.sender);
uint256 burnFromClaimable = claimableBalance >= breedPrice ? breedPrice : claimableBalance;
uint256 burnFromBalance = claimableBalance >= breedPrice ? 0 : breedPrice - claimableBalance;
if (claimableBalance > 0) {
watts.burnClaimable(msg.sender, burnFromClaimable);
}
if (burnFromBalance > 0) {
watts.burn(msg.sender, burnFromBalance);
}
slotiejr.mintTo(1, msg.sender);
emit Bred(msg.sender, father, mother, slotiejr.totalSupply());
}
/**
* @dev OWNER ONLY
*/
/**
* @notice function to set the merkle root for breeding.
*
* @param _merkleRoot. The new merkle root to set.
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice function to turn on/off breeding.
*
* @param _status. The new state of the breeding.
*/
function setBreedingStatus(bool _status) external onlyOwner {
}
/**
* @notice function to set the maximum amount of juniors that can be bred.
*
* @param max. The new maximum.
*/
function setMaxBreedableJuniors(uint256 max) external onlyOwner {
}
/**
* @notice function to set the cooldown period for breeding a slotie.
*
* @param coolDown. The new cooldown period.
*/
function setBreedCoolDown(uint256 coolDown) external onlyOwner {
}
/**
* @notice function to set the watts price for breeding two sloties.
*
* @param price. The new watts price.
*/
function setBreedPice(uint256 price) external onlyOwner {
}
/**
* @dev WATTS OWNER
*/
function WATTSOWNER_TransferOwnership(address newOwner) external onlyOwner {
}
function WATTSOWNER_SetSlotieNFT(address newSlotie) external onlyOwner {
}
function WATTSOWNER_SetLockPeriod(uint256 newLockPeriod) external onlyOwner {
}
function WATTSOWNER_SetIsBlackListed(address _set, bool _is) external onlyOwner {
}
function WATTSOWNER_seeClaimableBalanceOfUser(address user) external view onlyOwner returns (uint256) {
}
function WATTSOWNER_seeClaimableTotalSupply() external view onlyOwner returns (uint256) {
}
/**
* @dev FINANCE
*/
/**
* @notice Allows owner to withdraw funds generated from sale.
*
* @param _to. The address to send the funds to.
*/
function withdrawAll(address _to) external onlyOwner {
}
/**
* @dev Fallback function for receiving Ether
*/
receive() external payable {
}
}
| slotie.ownerOf(father)==msg.sender,"SENDER NOT OWNER OF FATHER" | 309,049 | slotie.ownerOf(father)==msg.sender |
"SENDER NOT OWNER OF MOTHER" | // SPDX-License-Identifier: MIT
// Developed by KG Technologies (https://kgtechnologies.io)
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @notice Represents Slotie Smart Contract
*/
contract ISlotie {
/**
* @dev ERC-721 INTERFACE
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {}
/**
* @dev CUSTOM INTERFACE
*/
function mintTo(uint256 amount, address _to) external {}
}
contract ISlotieJr {
/**
* @dev ERC-721 INTERFACE
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {}
function totalSupply() public view returns (uint256) {}
/**
* @dev CUSTOM INTERFACE
*/
function mintTo(uint256 amount, address _to) external {}
function maxMintPerTransaction() public returns (uint256) {}
}
abstract contract IWatts is IERC20 {
function burn(address _from, uint256 _amount) external {}
function seeClaimableBalanceOfUser(address user) external view returns(uint256) {}
function seeClaimableTotalSupply() external view returns(uint256) {}
function burnClaimable(address _from, uint256 _amount) public {}
function transferOwnership(address newOwner) public {}
function setSlotieNFT(address newSlotieNFT) external {}
function setLockPeriod(uint256 newLockPeriod) external {}
function setIsBlackListed(address _address, bool _isBlackListed) external {}
}
/**
* @title SlotieJrBreeding.
*
* @author KG Technologies (https://kgtechnologies.io).
*
* @notice This Smart Contract can be used to breed Slotie NFTs.
*
* @dev The primary mode of verifying permissioned actions is through Merkle Proofs
* which are generated off-chain.
*/
contract SlotieJrBreeding is Ownable {
/**
* @notice The Smart Contract of Slotie
* @dev ERC-721 Smart Contract
*/
ISlotie public immutable slotie;
/**
* @notice The Smart Contract of Slotie Jr.
* @dev ERC-721 Smart Contract
*/
ISlotieJr public immutable slotiejr;
/**
* @notice The Smart Contract of Watts.
* @dev ERC-20 Smart Contract
*/
IWatts public immutable watts;
/**
* @dev BREED DATA
*/
uint256 public maxBreedableJuniors = 5000;
bool public isBreedingStarted = false;
uint256 public breedPrice = 1800 ether;
uint256 public breedCoolDown = 2 * 30 days;
mapping(uint256 => uint256) public slotieToLastBreedTimeStamp;
bytes32 public merkleRoot = 0x92b34b7175c93f0db8f32e6996287e5d3141e4364dcc5f03e3f3b0454d999605;
/**
* @dev TRACKING DATA
*/
uint256 public bornJuniors;
/**
* @dev Events
*/
event ReceivedEther(address indexed sender, uint256 indexed amount);
event Bred(address initiator, uint256 indexed father, uint256 indexed mother, uint256 indexed slotieJr);
event setMerkleRootEvent(bytes32 indexed root);
event setIsBreedingStartedEvent(bool indexed started);
event setMaxBreedableJuniorsEvent(uint256 indexed maxMintable);
event setBreedCoolDownEvent(uint256 indexed coolDown);
event setBreedPriceEvent(uint256 indexed price);
event WithdrawAllEvent(address indexed recipient, uint256 amount);
constructor(
address slotieAddress,
address slotieJrAddress,
address wattsAddress
) Ownable() {
}
/**
* @dev BREEDING
*/
function breed(
uint256 father,
uint256 mother,
uint256 fatherStart,
uint256 motherStart,
bytes32[] calldata fatherProof,
bytes32[] calldata motherProof
) external {
require(isBreedingStarted, "BREEDING NOT STARTED");
require(address(slotie) != address(0), "SLOTIE NFT NOT SET");
require(address(slotiejr) != address(0), "SLOTIE JR NFT NOT SET");
require(address(watts) != address(0), "WATTS NOT SET");
require(bornJuniors < maxBreedableJuniors, "MAX JUNIORS HAVE BEEN BRED");
require(father != mother, "CANNOT BREED THE SAME SLOTIE");
require(slotie.ownerOf(father) == msg.sender, "SENDER NOT OWNER OF FATHER");
require(<FILL_ME>)
uint256 fatherLastBred = slotieToLastBreedTimeStamp[father];
uint256 motherLastBred = slotieToLastBreedTimeStamp[mother];
/**
* @notice Check if father can breed based based on time logic
*
* @dev If father hasn't bred before we check the merkle proof to see
* if it can breed already. If it has bred already we check if it's passed the
* cooldown period.
*/
if (fatherLastBred != 0) {
require(block.timestamp >= fatherLastBred + breedCoolDown, "FATHER IS STILL IN COOLDOWN");
}
/// @dev see father.
if (motherLastBred != 0) {
require(block.timestamp >= motherLastBred + breedCoolDown, "MOTHER IS STILL IN COOLDOWN");
}
if (fatherLastBred == 0 || motherLastBred == 0) {
bytes32 leafFather = keccak256(abi.encodePacked(father, fatherStart, fatherLastBred));
bytes32 leafMother = keccak256(abi.encodePacked(mother, motherStart, motherLastBred));
require(MerkleProof.verify(fatherProof, merkleRoot, leafFather), "INVALID PROOF FOR FATHER");
require(MerkleProof.verify(motherProof, merkleRoot, leafMother), "INVALID PROOF FOR MOTHER");
require(block.timestamp >= fatherStart || block.timestamp >= motherStart, "SLOTIES CANNOT CANNOT BREED YET");
}
slotieToLastBreedTimeStamp[father] = block.timestamp;
slotieToLastBreedTimeStamp[mother] = block.timestamp;
bornJuniors++;
require(watts.balanceOf(msg.sender) >= breedPrice, "SENDER DOES NOT HAVE ENOUGH WATTS");
uint256 claimableBalance = watts.seeClaimableBalanceOfUser(msg.sender);
uint256 burnFromClaimable = claimableBalance >= breedPrice ? breedPrice : claimableBalance;
uint256 burnFromBalance = claimableBalance >= breedPrice ? 0 : breedPrice - claimableBalance;
if (claimableBalance > 0) {
watts.burnClaimable(msg.sender, burnFromClaimable);
}
if (burnFromBalance > 0) {
watts.burn(msg.sender, burnFromBalance);
}
slotiejr.mintTo(1, msg.sender);
emit Bred(msg.sender, father, mother, slotiejr.totalSupply());
}
/**
* @dev OWNER ONLY
*/
/**
* @notice function to set the merkle root for breeding.
*
* @param _merkleRoot. The new merkle root to set.
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice function to turn on/off breeding.
*
* @param _status. The new state of the breeding.
*/
function setBreedingStatus(bool _status) external onlyOwner {
}
/**
* @notice function to set the maximum amount of juniors that can be bred.
*
* @param max. The new maximum.
*/
function setMaxBreedableJuniors(uint256 max) external onlyOwner {
}
/**
* @notice function to set the cooldown period for breeding a slotie.
*
* @param coolDown. The new cooldown period.
*/
function setBreedCoolDown(uint256 coolDown) external onlyOwner {
}
/**
* @notice function to set the watts price for breeding two sloties.
*
* @param price. The new watts price.
*/
function setBreedPice(uint256 price) external onlyOwner {
}
/**
* @dev WATTS OWNER
*/
function WATTSOWNER_TransferOwnership(address newOwner) external onlyOwner {
}
function WATTSOWNER_SetSlotieNFT(address newSlotie) external onlyOwner {
}
function WATTSOWNER_SetLockPeriod(uint256 newLockPeriod) external onlyOwner {
}
function WATTSOWNER_SetIsBlackListed(address _set, bool _is) external onlyOwner {
}
function WATTSOWNER_seeClaimableBalanceOfUser(address user) external view onlyOwner returns (uint256) {
}
function WATTSOWNER_seeClaimableTotalSupply() external view onlyOwner returns (uint256) {
}
/**
* @dev FINANCE
*/
/**
* @notice Allows owner to withdraw funds generated from sale.
*
* @param _to. The address to send the funds to.
*/
function withdrawAll(address _to) external onlyOwner {
}
/**
* @dev Fallback function for receiving Ether
*/
receive() external payable {
}
}
| slotie.ownerOf(mother)==msg.sender,"SENDER NOT OWNER OF MOTHER" | 309,049 | slotie.ownerOf(mother)==msg.sender |
"INVALID PROOF FOR FATHER" | // SPDX-License-Identifier: MIT
// Developed by KG Technologies (https://kgtechnologies.io)
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @notice Represents Slotie Smart Contract
*/
contract ISlotie {
/**
* @dev ERC-721 INTERFACE
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {}
/**
* @dev CUSTOM INTERFACE
*/
function mintTo(uint256 amount, address _to) external {}
}
contract ISlotieJr {
/**
* @dev ERC-721 INTERFACE
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {}
function totalSupply() public view returns (uint256) {}
/**
* @dev CUSTOM INTERFACE
*/
function mintTo(uint256 amount, address _to) external {}
function maxMintPerTransaction() public returns (uint256) {}
}
abstract contract IWatts is IERC20 {
function burn(address _from, uint256 _amount) external {}
function seeClaimableBalanceOfUser(address user) external view returns(uint256) {}
function seeClaimableTotalSupply() external view returns(uint256) {}
function burnClaimable(address _from, uint256 _amount) public {}
function transferOwnership(address newOwner) public {}
function setSlotieNFT(address newSlotieNFT) external {}
function setLockPeriod(uint256 newLockPeriod) external {}
function setIsBlackListed(address _address, bool _isBlackListed) external {}
}
/**
* @title SlotieJrBreeding.
*
* @author KG Technologies (https://kgtechnologies.io).
*
* @notice This Smart Contract can be used to breed Slotie NFTs.
*
* @dev The primary mode of verifying permissioned actions is through Merkle Proofs
* which are generated off-chain.
*/
contract SlotieJrBreeding is Ownable {
/**
* @notice The Smart Contract of Slotie
* @dev ERC-721 Smart Contract
*/
ISlotie public immutable slotie;
/**
* @notice The Smart Contract of Slotie Jr.
* @dev ERC-721 Smart Contract
*/
ISlotieJr public immutable slotiejr;
/**
* @notice The Smart Contract of Watts.
* @dev ERC-20 Smart Contract
*/
IWatts public immutable watts;
/**
* @dev BREED DATA
*/
uint256 public maxBreedableJuniors = 5000;
bool public isBreedingStarted = false;
uint256 public breedPrice = 1800 ether;
uint256 public breedCoolDown = 2 * 30 days;
mapping(uint256 => uint256) public slotieToLastBreedTimeStamp;
bytes32 public merkleRoot = 0x92b34b7175c93f0db8f32e6996287e5d3141e4364dcc5f03e3f3b0454d999605;
/**
* @dev TRACKING DATA
*/
uint256 public bornJuniors;
/**
* @dev Events
*/
event ReceivedEther(address indexed sender, uint256 indexed amount);
event Bred(address initiator, uint256 indexed father, uint256 indexed mother, uint256 indexed slotieJr);
event setMerkleRootEvent(bytes32 indexed root);
event setIsBreedingStartedEvent(bool indexed started);
event setMaxBreedableJuniorsEvent(uint256 indexed maxMintable);
event setBreedCoolDownEvent(uint256 indexed coolDown);
event setBreedPriceEvent(uint256 indexed price);
event WithdrawAllEvent(address indexed recipient, uint256 amount);
constructor(
address slotieAddress,
address slotieJrAddress,
address wattsAddress
) Ownable() {
}
/**
* @dev BREEDING
*/
function breed(
uint256 father,
uint256 mother,
uint256 fatherStart,
uint256 motherStart,
bytes32[] calldata fatherProof,
bytes32[] calldata motherProof
) external {
require(isBreedingStarted, "BREEDING NOT STARTED");
require(address(slotie) != address(0), "SLOTIE NFT NOT SET");
require(address(slotiejr) != address(0), "SLOTIE JR NFT NOT SET");
require(address(watts) != address(0), "WATTS NOT SET");
require(bornJuniors < maxBreedableJuniors, "MAX JUNIORS HAVE BEEN BRED");
require(father != mother, "CANNOT BREED THE SAME SLOTIE");
require(slotie.ownerOf(father) == msg.sender, "SENDER NOT OWNER OF FATHER");
require(slotie.ownerOf(mother) == msg.sender, "SENDER NOT OWNER OF MOTHER");
uint256 fatherLastBred = slotieToLastBreedTimeStamp[father];
uint256 motherLastBred = slotieToLastBreedTimeStamp[mother];
/**
* @notice Check if father can breed based based on time logic
*
* @dev If father hasn't bred before we check the merkle proof to see
* if it can breed already. If it has bred already we check if it's passed the
* cooldown period.
*/
if (fatherLastBred != 0) {
require(block.timestamp >= fatherLastBred + breedCoolDown, "FATHER IS STILL IN COOLDOWN");
}
/// @dev see father.
if (motherLastBred != 0) {
require(block.timestamp >= motherLastBred + breedCoolDown, "MOTHER IS STILL IN COOLDOWN");
}
if (fatherLastBred == 0 || motherLastBred == 0) {
bytes32 leafFather = keccak256(abi.encodePacked(father, fatherStart, fatherLastBred));
bytes32 leafMother = keccak256(abi.encodePacked(mother, motherStart, motherLastBred));
require(<FILL_ME>)
require(MerkleProof.verify(motherProof, merkleRoot, leafMother), "INVALID PROOF FOR MOTHER");
require(block.timestamp >= fatherStart || block.timestamp >= motherStart, "SLOTIES CANNOT CANNOT BREED YET");
}
slotieToLastBreedTimeStamp[father] = block.timestamp;
slotieToLastBreedTimeStamp[mother] = block.timestamp;
bornJuniors++;
require(watts.balanceOf(msg.sender) >= breedPrice, "SENDER DOES NOT HAVE ENOUGH WATTS");
uint256 claimableBalance = watts.seeClaimableBalanceOfUser(msg.sender);
uint256 burnFromClaimable = claimableBalance >= breedPrice ? breedPrice : claimableBalance;
uint256 burnFromBalance = claimableBalance >= breedPrice ? 0 : breedPrice - claimableBalance;
if (claimableBalance > 0) {
watts.burnClaimable(msg.sender, burnFromClaimable);
}
if (burnFromBalance > 0) {
watts.burn(msg.sender, burnFromBalance);
}
slotiejr.mintTo(1, msg.sender);
emit Bred(msg.sender, father, mother, slotiejr.totalSupply());
}
/**
* @dev OWNER ONLY
*/
/**
* @notice function to set the merkle root for breeding.
*
* @param _merkleRoot. The new merkle root to set.
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice function to turn on/off breeding.
*
* @param _status. The new state of the breeding.
*/
function setBreedingStatus(bool _status) external onlyOwner {
}
/**
* @notice function to set the maximum amount of juniors that can be bred.
*
* @param max. The new maximum.
*/
function setMaxBreedableJuniors(uint256 max) external onlyOwner {
}
/**
* @notice function to set the cooldown period for breeding a slotie.
*
* @param coolDown. The new cooldown period.
*/
function setBreedCoolDown(uint256 coolDown) external onlyOwner {
}
/**
* @notice function to set the watts price for breeding two sloties.
*
* @param price. The new watts price.
*/
function setBreedPice(uint256 price) external onlyOwner {
}
/**
* @dev WATTS OWNER
*/
function WATTSOWNER_TransferOwnership(address newOwner) external onlyOwner {
}
function WATTSOWNER_SetSlotieNFT(address newSlotie) external onlyOwner {
}
function WATTSOWNER_SetLockPeriod(uint256 newLockPeriod) external onlyOwner {
}
function WATTSOWNER_SetIsBlackListed(address _set, bool _is) external onlyOwner {
}
function WATTSOWNER_seeClaimableBalanceOfUser(address user) external view onlyOwner returns (uint256) {
}
function WATTSOWNER_seeClaimableTotalSupply() external view onlyOwner returns (uint256) {
}
/**
* @dev FINANCE
*/
/**
* @notice Allows owner to withdraw funds generated from sale.
*
* @param _to. The address to send the funds to.
*/
function withdrawAll(address _to) external onlyOwner {
}
/**
* @dev Fallback function for receiving Ether
*/
receive() external payable {
}
}
| MerkleProof.verify(fatherProof,merkleRoot,leafFather),"INVALID PROOF FOR FATHER" | 309,049 | MerkleProof.verify(fatherProof,merkleRoot,leafFather) |
"INVALID PROOF FOR MOTHER" | // SPDX-License-Identifier: MIT
// Developed by KG Technologies (https://kgtechnologies.io)
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @notice Represents Slotie Smart Contract
*/
contract ISlotie {
/**
* @dev ERC-721 INTERFACE
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {}
/**
* @dev CUSTOM INTERFACE
*/
function mintTo(uint256 amount, address _to) external {}
}
contract ISlotieJr {
/**
* @dev ERC-721 INTERFACE
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {}
function totalSupply() public view returns (uint256) {}
/**
* @dev CUSTOM INTERFACE
*/
function mintTo(uint256 amount, address _to) external {}
function maxMintPerTransaction() public returns (uint256) {}
}
abstract contract IWatts is IERC20 {
function burn(address _from, uint256 _amount) external {}
function seeClaimableBalanceOfUser(address user) external view returns(uint256) {}
function seeClaimableTotalSupply() external view returns(uint256) {}
function burnClaimable(address _from, uint256 _amount) public {}
function transferOwnership(address newOwner) public {}
function setSlotieNFT(address newSlotieNFT) external {}
function setLockPeriod(uint256 newLockPeriod) external {}
function setIsBlackListed(address _address, bool _isBlackListed) external {}
}
/**
* @title SlotieJrBreeding.
*
* @author KG Technologies (https://kgtechnologies.io).
*
* @notice This Smart Contract can be used to breed Slotie NFTs.
*
* @dev The primary mode of verifying permissioned actions is through Merkle Proofs
* which are generated off-chain.
*/
contract SlotieJrBreeding is Ownable {
/**
* @notice The Smart Contract of Slotie
* @dev ERC-721 Smart Contract
*/
ISlotie public immutable slotie;
/**
* @notice The Smart Contract of Slotie Jr.
* @dev ERC-721 Smart Contract
*/
ISlotieJr public immutable slotiejr;
/**
* @notice The Smart Contract of Watts.
* @dev ERC-20 Smart Contract
*/
IWatts public immutable watts;
/**
* @dev BREED DATA
*/
uint256 public maxBreedableJuniors = 5000;
bool public isBreedingStarted = false;
uint256 public breedPrice = 1800 ether;
uint256 public breedCoolDown = 2 * 30 days;
mapping(uint256 => uint256) public slotieToLastBreedTimeStamp;
bytes32 public merkleRoot = 0x92b34b7175c93f0db8f32e6996287e5d3141e4364dcc5f03e3f3b0454d999605;
/**
* @dev TRACKING DATA
*/
uint256 public bornJuniors;
/**
* @dev Events
*/
event ReceivedEther(address indexed sender, uint256 indexed amount);
event Bred(address initiator, uint256 indexed father, uint256 indexed mother, uint256 indexed slotieJr);
event setMerkleRootEvent(bytes32 indexed root);
event setIsBreedingStartedEvent(bool indexed started);
event setMaxBreedableJuniorsEvent(uint256 indexed maxMintable);
event setBreedCoolDownEvent(uint256 indexed coolDown);
event setBreedPriceEvent(uint256 indexed price);
event WithdrawAllEvent(address indexed recipient, uint256 amount);
constructor(
address slotieAddress,
address slotieJrAddress,
address wattsAddress
) Ownable() {
}
/**
* @dev BREEDING
*/
function breed(
uint256 father,
uint256 mother,
uint256 fatherStart,
uint256 motherStart,
bytes32[] calldata fatherProof,
bytes32[] calldata motherProof
) external {
require(isBreedingStarted, "BREEDING NOT STARTED");
require(address(slotie) != address(0), "SLOTIE NFT NOT SET");
require(address(slotiejr) != address(0), "SLOTIE JR NFT NOT SET");
require(address(watts) != address(0), "WATTS NOT SET");
require(bornJuniors < maxBreedableJuniors, "MAX JUNIORS HAVE BEEN BRED");
require(father != mother, "CANNOT BREED THE SAME SLOTIE");
require(slotie.ownerOf(father) == msg.sender, "SENDER NOT OWNER OF FATHER");
require(slotie.ownerOf(mother) == msg.sender, "SENDER NOT OWNER OF MOTHER");
uint256 fatherLastBred = slotieToLastBreedTimeStamp[father];
uint256 motherLastBred = slotieToLastBreedTimeStamp[mother];
/**
* @notice Check if father can breed based based on time logic
*
* @dev If father hasn't bred before we check the merkle proof to see
* if it can breed already. If it has bred already we check if it's passed the
* cooldown period.
*/
if (fatherLastBred != 0) {
require(block.timestamp >= fatherLastBred + breedCoolDown, "FATHER IS STILL IN COOLDOWN");
}
/// @dev see father.
if (motherLastBred != 0) {
require(block.timestamp >= motherLastBred + breedCoolDown, "MOTHER IS STILL IN COOLDOWN");
}
if (fatherLastBred == 0 || motherLastBred == 0) {
bytes32 leafFather = keccak256(abi.encodePacked(father, fatherStart, fatherLastBred));
bytes32 leafMother = keccak256(abi.encodePacked(mother, motherStart, motherLastBred));
require(MerkleProof.verify(fatherProof, merkleRoot, leafFather), "INVALID PROOF FOR FATHER");
require(<FILL_ME>)
require(block.timestamp >= fatherStart || block.timestamp >= motherStart, "SLOTIES CANNOT CANNOT BREED YET");
}
slotieToLastBreedTimeStamp[father] = block.timestamp;
slotieToLastBreedTimeStamp[mother] = block.timestamp;
bornJuniors++;
require(watts.balanceOf(msg.sender) >= breedPrice, "SENDER DOES NOT HAVE ENOUGH WATTS");
uint256 claimableBalance = watts.seeClaimableBalanceOfUser(msg.sender);
uint256 burnFromClaimable = claimableBalance >= breedPrice ? breedPrice : claimableBalance;
uint256 burnFromBalance = claimableBalance >= breedPrice ? 0 : breedPrice - claimableBalance;
if (claimableBalance > 0) {
watts.burnClaimable(msg.sender, burnFromClaimable);
}
if (burnFromBalance > 0) {
watts.burn(msg.sender, burnFromBalance);
}
slotiejr.mintTo(1, msg.sender);
emit Bred(msg.sender, father, mother, slotiejr.totalSupply());
}
/**
* @dev OWNER ONLY
*/
/**
* @notice function to set the merkle root for breeding.
*
* @param _merkleRoot. The new merkle root to set.
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice function to turn on/off breeding.
*
* @param _status. The new state of the breeding.
*/
function setBreedingStatus(bool _status) external onlyOwner {
}
/**
* @notice function to set the maximum amount of juniors that can be bred.
*
* @param max. The new maximum.
*/
function setMaxBreedableJuniors(uint256 max) external onlyOwner {
}
/**
* @notice function to set the cooldown period for breeding a slotie.
*
* @param coolDown. The new cooldown period.
*/
function setBreedCoolDown(uint256 coolDown) external onlyOwner {
}
/**
* @notice function to set the watts price for breeding two sloties.
*
* @param price. The new watts price.
*/
function setBreedPice(uint256 price) external onlyOwner {
}
/**
* @dev WATTS OWNER
*/
function WATTSOWNER_TransferOwnership(address newOwner) external onlyOwner {
}
function WATTSOWNER_SetSlotieNFT(address newSlotie) external onlyOwner {
}
function WATTSOWNER_SetLockPeriod(uint256 newLockPeriod) external onlyOwner {
}
function WATTSOWNER_SetIsBlackListed(address _set, bool _is) external onlyOwner {
}
function WATTSOWNER_seeClaimableBalanceOfUser(address user) external view onlyOwner returns (uint256) {
}
function WATTSOWNER_seeClaimableTotalSupply() external view onlyOwner returns (uint256) {
}
/**
* @dev FINANCE
*/
/**
* @notice Allows owner to withdraw funds generated from sale.
*
* @param _to. The address to send the funds to.
*/
function withdrawAll(address _to) external onlyOwner {
}
/**
* @dev Fallback function for receiving Ether
*/
receive() external payable {
}
}
| MerkleProof.verify(motherProof,merkleRoot,leafMother),"INVALID PROOF FOR MOTHER" | 309,049 | MerkleProof.verify(motherProof,merkleRoot,leafMother) |
"SENDER DOES NOT HAVE ENOUGH WATTS" | // SPDX-License-Identifier: MIT
// Developed by KG Technologies (https://kgtechnologies.io)
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* @notice Represents Slotie Smart Contract
*/
contract ISlotie {
/**
* @dev ERC-721 INTERFACE
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {}
/**
* @dev CUSTOM INTERFACE
*/
function mintTo(uint256 amount, address _to) external {}
}
contract ISlotieJr {
/**
* @dev ERC-721 INTERFACE
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {}
function totalSupply() public view returns (uint256) {}
/**
* @dev CUSTOM INTERFACE
*/
function mintTo(uint256 amount, address _to) external {}
function maxMintPerTransaction() public returns (uint256) {}
}
abstract contract IWatts is IERC20 {
function burn(address _from, uint256 _amount) external {}
function seeClaimableBalanceOfUser(address user) external view returns(uint256) {}
function seeClaimableTotalSupply() external view returns(uint256) {}
function burnClaimable(address _from, uint256 _amount) public {}
function transferOwnership(address newOwner) public {}
function setSlotieNFT(address newSlotieNFT) external {}
function setLockPeriod(uint256 newLockPeriod) external {}
function setIsBlackListed(address _address, bool _isBlackListed) external {}
}
/**
* @title SlotieJrBreeding.
*
* @author KG Technologies (https://kgtechnologies.io).
*
* @notice This Smart Contract can be used to breed Slotie NFTs.
*
* @dev The primary mode of verifying permissioned actions is through Merkle Proofs
* which are generated off-chain.
*/
contract SlotieJrBreeding is Ownable {
/**
* @notice The Smart Contract of Slotie
* @dev ERC-721 Smart Contract
*/
ISlotie public immutable slotie;
/**
* @notice The Smart Contract of Slotie Jr.
* @dev ERC-721 Smart Contract
*/
ISlotieJr public immutable slotiejr;
/**
* @notice The Smart Contract of Watts.
* @dev ERC-20 Smart Contract
*/
IWatts public immutable watts;
/**
* @dev BREED DATA
*/
uint256 public maxBreedableJuniors = 5000;
bool public isBreedingStarted = false;
uint256 public breedPrice = 1800 ether;
uint256 public breedCoolDown = 2 * 30 days;
mapping(uint256 => uint256) public slotieToLastBreedTimeStamp;
bytes32 public merkleRoot = 0x92b34b7175c93f0db8f32e6996287e5d3141e4364dcc5f03e3f3b0454d999605;
/**
* @dev TRACKING DATA
*/
uint256 public bornJuniors;
/**
* @dev Events
*/
event ReceivedEther(address indexed sender, uint256 indexed amount);
event Bred(address initiator, uint256 indexed father, uint256 indexed mother, uint256 indexed slotieJr);
event setMerkleRootEvent(bytes32 indexed root);
event setIsBreedingStartedEvent(bool indexed started);
event setMaxBreedableJuniorsEvent(uint256 indexed maxMintable);
event setBreedCoolDownEvent(uint256 indexed coolDown);
event setBreedPriceEvent(uint256 indexed price);
event WithdrawAllEvent(address indexed recipient, uint256 amount);
constructor(
address slotieAddress,
address slotieJrAddress,
address wattsAddress
) Ownable() {
}
/**
* @dev BREEDING
*/
function breed(
uint256 father,
uint256 mother,
uint256 fatherStart,
uint256 motherStart,
bytes32[] calldata fatherProof,
bytes32[] calldata motherProof
) external {
require(isBreedingStarted, "BREEDING NOT STARTED");
require(address(slotie) != address(0), "SLOTIE NFT NOT SET");
require(address(slotiejr) != address(0), "SLOTIE JR NFT NOT SET");
require(address(watts) != address(0), "WATTS NOT SET");
require(bornJuniors < maxBreedableJuniors, "MAX JUNIORS HAVE BEEN BRED");
require(father != mother, "CANNOT BREED THE SAME SLOTIE");
require(slotie.ownerOf(father) == msg.sender, "SENDER NOT OWNER OF FATHER");
require(slotie.ownerOf(mother) == msg.sender, "SENDER NOT OWNER OF MOTHER");
uint256 fatherLastBred = slotieToLastBreedTimeStamp[father];
uint256 motherLastBred = slotieToLastBreedTimeStamp[mother];
/**
* @notice Check if father can breed based based on time logic
*
* @dev If father hasn't bred before we check the merkle proof to see
* if it can breed already. If it has bred already we check if it's passed the
* cooldown period.
*/
if (fatherLastBred != 0) {
require(block.timestamp >= fatherLastBred + breedCoolDown, "FATHER IS STILL IN COOLDOWN");
}
/// @dev see father.
if (motherLastBred != 0) {
require(block.timestamp >= motherLastBred + breedCoolDown, "MOTHER IS STILL IN COOLDOWN");
}
if (fatherLastBred == 0 || motherLastBred == 0) {
bytes32 leafFather = keccak256(abi.encodePacked(father, fatherStart, fatherLastBred));
bytes32 leafMother = keccak256(abi.encodePacked(mother, motherStart, motherLastBred));
require(MerkleProof.verify(fatherProof, merkleRoot, leafFather), "INVALID PROOF FOR FATHER");
require(MerkleProof.verify(motherProof, merkleRoot, leafMother), "INVALID PROOF FOR MOTHER");
require(block.timestamp >= fatherStart || block.timestamp >= motherStart, "SLOTIES CANNOT CANNOT BREED YET");
}
slotieToLastBreedTimeStamp[father] = block.timestamp;
slotieToLastBreedTimeStamp[mother] = block.timestamp;
bornJuniors++;
require(<FILL_ME>)
uint256 claimableBalance = watts.seeClaimableBalanceOfUser(msg.sender);
uint256 burnFromClaimable = claimableBalance >= breedPrice ? breedPrice : claimableBalance;
uint256 burnFromBalance = claimableBalance >= breedPrice ? 0 : breedPrice - claimableBalance;
if (claimableBalance > 0) {
watts.burnClaimable(msg.sender, burnFromClaimable);
}
if (burnFromBalance > 0) {
watts.burn(msg.sender, burnFromBalance);
}
slotiejr.mintTo(1, msg.sender);
emit Bred(msg.sender, father, mother, slotiejr.totalSupply());
}
/**
* @dev OWNER ONLY
*/
/**
* @notice function to set the merkle root for breeding.
*
* @param _merkleRoot. The new merkle root to set.
*/
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice function to turn on/off breeding.
*
* @param _status. The new state of the breeding.
*/
function setBreedingStatus(bool _status) external onlyOwner {
}
/**
* @notice function to set the maximum amount of juniors that can be bred.
*
* @param max. The new maximum.
*/
function setMaxBreedableJuniors(uint256 max) external onlyOwner {
}
/**
* @notice function to set the cooldown period for breeding a slotie.
*
* @param coolDown. The new cooldown period.
*/
function setBreedCoolDown(uint256 coolDown) external onlyOwner {
}
/**
* @notice function to set the watts price for breeding two sloties.
*
* @param price. The new watts price.
*/
function setBreedPice(uint256 price) external onlyOwner {
}
/**
* @dev WATTS OWNER
*/
function WATTSOWNER_TransferOwnership(address newOwner) external onlyOwner {
}
function WATTSOWNER_SetSlotieNFT(address newSlotie) external onlyOwner {
}
function WATTSOWNER_SetLockPeriod(uint256 newLockPeriod) external onlyOwner {
}
function WATTSOWNER_SetIsBlackListed(address _set, bool _is) external onlyOwner {
}
function WATTSOWNER_seeClaimableBalanceOfUser(address user) external view onlyOwner returns (uint256) {
}
function WATTSOWNER_seeClaimableTotalSupply() external view onlyOwner returns (uint256) {
}
/**
* @dev FINANCE
*/
/**
* @notice Allows owner to withdraw funds generated from sale.
*
* @param _to. The address to send the funds to.
*/
function withdrawAll(address _to) external onlyOwner {
}
/**
* @dev Fallback function for receiving Ether
*/
receive() external payable {
}
}
| watts.balanceOf(msg.sender)>=breedPrice,"SENDER DOES NOT HAVE ENOUGH WATTS" | 309,049 | watts.balanceOf(msg.sender)>=breedPrice |
null | pragma solidity ^0.4.21;
interface ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) external;
}
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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @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) public onlyOwner {
}
}
contract AlphaToken is Ownable {
using SafeMath for uint256;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
mapping(address => uint) balances; // List of user balances.
mapping(address => mapping (address => uint256)) allowed;
string _name;
string _symbol;
uint8 DECIMALS = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 _totalSupply;
uint256 _saledTotal = 0;
uint256 _amounToSale = 0;
uint _buyPrice = 4500;
uint256 _totalEther = 0;
function AlphaToken(
string tokenName,
string tokenSymbol
) public
{
}
function name() public constant returns (string) {
}
function symbol() public constant returns (string) {
}
function totalSupply() public constant returns (uint256) {
}
function buyPrice() public constant returns (uint256) {
}
function decimals() public constant returns (uint8) {
}
function _transfer(address _from, address _to, uint _value, bytes _data) internal {
}
/**
* @dev Transfer the specified amount of tokens to the specified address.
* Invokes the `tokenFallback` function if the recipient is a contract.
* The token transfer fails if the recipient is a contract
* but does not implement the `tokenFallback` function
* or the fallback function to receive funds.
*
* @param _to Receiver address.
* @param _value Amount of tokens that will be transferred.
* @param _data Transaction metadata.
*/
function transfer(address _to, uint _value, bytes _data) public returns (bool ok) {
}
/**
* @dev Transfer the specified amount of tokens to the specified address.
* This function works the same with the previous one
* but doesn't contain `_data` param.
* Added due to backwards compatibility reasons.
*
* @param _to Receiver address.
* @param _value Amount of tokens that will be transferred.
*/
function transfer(address _to, uint _value) public returns(bool ok) {
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
}
function approve(address spender, uint tokens) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint _value) onlyOwner public returns (bool success) {
}
/**
* @dev Returns balance of the `_owner`.
*
* @param _owner The address whose balance will be returned.
* @return balance Balance of the `_owner`.
*/
function balanceOf(address _owner) public constant returns (uint balance) {
}
function setPrices(uint256 newBuyPrice) onlyOwner public {
}
/// @notice Buy tokens from contract by sending ether
function buyCoin() payable public returns (bool ok) {
uint amount = ((msg.value * _buyPrice) * 10 ** uint256(DECIMALS))/1000000000000000000; // calculates the amount
require(<FILL_ME>)
balances[msg.sender] = balances[msg.sender].add(amount);
_saledTotal = _saledTotal.add(amount);
_totalEther += msg.value;
return true;
}
function dispatchTo(address target, uint256 amount) onlyOwner public returns (bool ok) {
}
function withdrawTo(address _target, uint256 _value) onlyOwner public returns (bool ok) {
}
function () payable public {
}
}
| (_amounToSale-_saledTotal)>=amount | 309,061 | (_amounToSale-_saledTotal)>=amount |
"All cocks are erect" | // Contract based on https://docs.openzeppelin.com/contracts/3.x/erc721
// SPDX-License-Identifier: MIT
pragma solidity >=0.7.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
contract CockFightClub is ERC721, Ownable {
using SafeMath for uint256;
uint256 public constant MAX_TOKENS = 6666;
string public _PROVENANCE = "";
uint256 public constant MAX_TOKENS_PER_PURCHASE = 10;
uint256 private price = 60000000000000000; // 0.06 Ether
bool public isCocksErect = false;
mapping(uint256 => uint256) private _totalCocks;
constructor() ERC721("Cock Fight Club", "COCK") {}
function setProvenanceHash(string memory _provenanceHash) public onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function reserveTokens(address _to, uint256 _reserveAmount)
public
onlyOwner
{
}
function mint(uint256 _count) public payable {
uint256 totalSupply = totalSupply();
require(isCocksErect, "Sale is not active");
require(
_count > 0 && _count < MAX_TOKENS_PER_PURCHASE + 1,
"You can not mint less than 1 cock, and at most 10 cocks"
);
require(<FILL_ME>)
require(
msg.value >= price.mul(_count),
"Ether value sent is not correct"
);
for (uint256 i = 0; i < _count; i++) {
rubOneOut(msg.sender);
}
}
function rubOneOut(address _to) private {
}
function random(
uint256 from,
uint256 to,
uint256 salty
) private view returns (uint256) {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function flipSaleStatus() public onlyOwner {
}
function withdraw() public onlyOwner {
}
function tokensByOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function renounceOwnership() public override onlyOwner {}
}
| totalSupply+_count<MAX_TOKENS+1,"All cocks are erect" | 309,075 | totalSupply+_count<MAX_TOKENS+1 |
"Minting exceeds supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
abstract contract Parent {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
contract ClonePX is ERC721Enumerable, Ownable {
using SafeMath for uint256;
uint constant public clonexSupply = 500;
uint constant public freeSupply = 1000;
uint constant public paidSupply = 4000;
uint256 public mintPrice = 0.04 ether;
uint public clonexMintCount = 0;
uint public freeMintCount = 0;
uint public paidMintCount = 0;
uint public freeMintLimit = 3;
uint public batchLimit = 10;
bool public mintStarted = false;
bool public ableToReserve = true;
string public baseURI = "https://gateway.pinata.cloud/ipfs/QmXN6LWZBz5PVfnqfJR6ZLtqVTffKsnvcmApBYPbEV4ARx/"; // Init to preveal uri
Parent private parent;
mapping(address => uint256) public clonexWalletMintMap;
mapping(address => uint256) public freeWalletMintMap;
constructor(address parentAddress) ERC721("ClonePX", "CPX") {
}
function clonexMint(uint tokensToMint) public {
require(mintStarted, "Mint is not started");
require(<FILL_ME>)
uint balance = parent.balanceOf(msg.sender);
require(balance.sub(clonexWalletMintMap[msg.sender]) >= tokensToMint, "Insufficient CloneX tokens.");
uint256 supply = totalSupply();
for(uint16 i = 1; i <= tokensToMint; i++) {
_safeMint(msg.sender, supply + i);
clonexMintCount++;
clonexWalletMintMap[msg.sender]++;
}
}
function freeMint(uint tokensToMint) public {
}
function mint(uint tokensToMint) public payable {
}
function setPrice(uint256 newPrice) public onlyOwner() {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function startMint() external onlyOwner {
}
function pauseMint() external onlyOwner {
}
function reserveLegendaries() public onlyOwner {
}
}
| clonexMintCount.add(tokensToMint)<=clonexSupply,"Minting exceeds supply" | 309,077 | clonexMintCount.add(tokensToMint)<=clonexSupply |
"Insufficient CloneX tokens." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
abstract contract Parent {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
contract ClonePX is ERC721Enumerable, Ownable {
using SafeMath for uint256;
uint constant public clonexSupply = 500;
uint constant public freeSupply = 1000;
uint constant public paidSupply = 4000;
uint256 public mintPrice = 0.04 ether;
uint public clonexMintCount = 0;
uint public freeMintCount = 0;
uint public paidMintCount = 0;
uint public freeMintLimit = 3;
uint public batchLimit = 10;
bool public mintStarted = false;
bool public ableToReserve = true;
string public baseURI = "https://gateway.pinata.cloud/ipfs/QmXN6LWZBz5PVfnqfJR6ZLtqVTffKsnvcmApBYPbEV4ARx/"; // Init to preveal uri
Parent private parent;
mapping(address => uint256) public clonexWalletMintMap;
mapping(address => uint256) public freeWalletMintMap;
constructor(address parentAddress) ERC721("ClonePX", "CPX") {
}
function clonexMint(uint tokensToMint) public {
require(mintStarted, "Mint is not started");
require(clonexMintCount.add(tokensToMint) <= clonexSupply, "Minting exceeds supply");
uint balance = parent.balanceOf(msg.sender);
require(<FILL_ME>)
uint256 supply = totalSupply();
for(uint16 i = 1; i <= tokensToMint; i++) {
_safeMint(msg.sender, supply + i);
clonexMintCount++;
clonexWalletMintMap[msg.sender]++;
}
}
function freeMint(uint tokensToMint) public {
}
function mint(uint tokensToMint) public payable {
}
function setPrice(uint256 newPrice) public onlyOwner() {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function startMint() external onlyOwner {
}
function pauseMint() external onlyOwner {
}
function reserveLegendaries() public onlyOwner {
}
}
| balance.sub(clonexWalletMintMap[msg.sender])>=tokensToMint,"Insufficient CloneX tokens." | 309,077 | balance.sub(clonexWalletMintMap[msg.sender])>=tokensToMint |
"Minting exceeds supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
abstract contract Parent {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
contract ClonePX is ERC721Enumerable, Ownable {
using SafeMath for uint256;
uint constant public clonexSupply = 500;
uint constant public freeSupply = 1000;
uint constant public paidSupply = 4000;
uint256 public mintPrice = 0.04 ether;
uint public clonexMintCount = 0;
uint public freeMintCount = 0;
uint public paidMintCount = 0;
uint public freeMintLimit = 3;
uint public batchLimit = 10;
bool public mintStarted = false;
bool public ableToReserve = true;
string public baseURI = "https://gateway.pinata.cloud/ipfs/QmXN6LWZBz5PVfnqfJR6ZLtqVTffKsnvcmApBYPbEV4ARx/"; // Init to preveal uri
Parent private parent;
mapping(address => uint256) public clonexWalletMintMap;
mapping(address => uint256) public freeWalletMintMap;
constructor(address parentAddress) ERC721("ClonePX", "CPX") {
}
function clonexMint(uint tokensToMint) public {
}
function freeMint(uint tokensToMint) public {
require(mintStarted, "Mint is not started");
require(<FILL_ME>)
require(freeWalletMintMap[msg.sender].add(tokensToMint) <= freeMintLimit, "Too many free mints");
uint256 supply = totalSupply();
for(uint16 i = 1; i <= tokensToMint; i++) {
_safeMint(msg.sender, supply + i);
freeWalletMintMap[msg.sender]++;
}
}
function mint(uint tokensToMint) public payable {
}
function setPrice(uint256 newPrice) public onlyOwner() {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function startMint() external onlyOwner {
}
function pauseMint() external onlyOwner {
}
function reserveLegendaries() public onlyOwner {
}
}
| freeMintCount.add(tokensToMint)<=freeSupply,"Minting exceeds supply" | 309,077 | freeMintCount.add(tokensToMint)<=freeSupply |
"Too many free mints" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
abstract contract Parent {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
contract ClonePX is ERC721Enumerable, Ownable {
using SafeMath for uint256;
uint constant public clonexSupply = 500;
uint constant public freeSupply = 1000;
uint constant public paidSupply = 4000;
uint256 public mintPrice = 0.04 ether;
uint public clonexMintCount = 0;
uint public freeMintCount = 0;
uint public paidMintCount = 0;
uint public freeMintLimit = 3;
uint public batchLimit = 10;
bool public mintStarted = false;
bool public ableToReserve = true;
string public baseURI = "https://gateway.pinata.cloud/ipfs/QmXN6LWZBz5PVfnqfJR6ZLtqVTffKsnvcmApBYPbEV4ARx/"; // Init to preveal uri
Parent private parent;
mapping(address => uint256) public clonexWalletMintMap;
mapping(address => uint256) public freeWalletMintMap;
constructor(address parentAddress) ERC721("ClonePX", "CPX") {
}
function clonexMint(uint tokensToMint) public {
}
function freeMint(uint tokensToMint) public {
require(mintStarted, "Mint is not started");
require(freeMintCount.add(tokensToMint) <= freeSupply, "Minting exceeds supply");
require(<FILL_ME>)
uint256 supply = totalSupply();
for(uint16 i = 1; i <= tokensToMint; i++) {
_safeMint(msg.sender, supply + i);
freeWalletMintMap[msg.sender]++;
}
}
function mint(uint tokensToMint) public payable {
}
function setPrice(uint256 newPrice) public onlyOwner() {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function startMint() external onlyOwner {
}
function pauseMint() external onlyOwner {
}
function reserveLegendaries() public onlyOwner {
}
}
| freeWalletMintMap[msg.sender].add(tokensToMint)<=freeMintLimit,"Too many free mints" | 309,077 | freeWalletMintMap[msg.sender].add(tokensToMint)<=freeMintLimit |
"Minting exceeds supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
abstract contract Parent {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
contract ClonePX is ERC721Enumerable, Ownable {
using SafeMath for uint256;
uint constant public clonexSupply = 500;
uint constant public freeSupply = 1000;
uint constant public paidSupply = 4000;
uint256 public mintPrice = 0.04 ether;
uint public clonexMintCount = 0;
uint public freeMintCount = 0;
uint public paidMintCount = 0;
uint public freeMintLimit = 3;
uint public batchLimit = 10;
bool public mintStarted = false;
bool public ableToReserve = true;
string public baseURI = "https://gateway.pinata.cloud/ipfs/QmXN6LWZBz5PVfnqfJR6ZLtqVTffKsnvcmApBYPbEV4ARx/"; // Init to preveal uri
Parent private parent;
mapping(address => uint256) public clonexWalletMintMap;
mapping(address => uint256) public freeWalletMintMap;
constructor(address parentAddress) ERC721("ClonePX", "CPX") {
}
function clonexMint(uint tokensToMint) public {
}
function freeMint(uint tokensToMint) public {
}
function mint(uint tokensToMint) public payable {
require(mintStarted, "Mint is not started");
require(tokensToMint <= batchLimit, "Not in batch limit");
require(<FILL_ME>)
uint256 price = tokensToMint.mul(mintPrice);
require(msg.value >= price, "Not enough eth sent");
if (msg.value > price) {
payable(msg.sender).transfer(msg.value.sub(price));
}
uint256 supply = totalSupply();
for(uint16 i = 1; i <= tokensToMint; i++) {
_safeMint(msg.sender, supply + i);
paidMintCount++;
}
}
function setPrice(uint256 newPrice) public onlyOwner() {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function startMint() external onlyOwner {
}
function pauseMint() external onlyOwner {
}
function reserveLegendaries() public onlyOwner {
}
}
| paidMintCount.add(tokensToMint)<=paidSupply,"Minting exceeds supply" | 309,077 | paidMintCount.add(tokensToMint)<=paidSupply |
'invalid openBlockNumber' | pragma solidity ^0.4.24;
/**
* @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;
address public admin;
uint256 public lockedIn;
uint256 public OWNER_AMOUNT;
uint256 public OWNER_PERCENT = 2;
uint256 public OWNER_MIN = 0.0001 ether;
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(address addr, uint256 percent, uint256 min) 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.
* @notice Renouncing to ownership will leave the contract without an owner.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
*/
function renounceOwnership() public onlyOwner {
}
/**
* @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 {
}
function _cash() public view returns(uint256){
}
function kill() onlyOwner public{
}
function setAdmin(address addr) onlyOwner public{
}
function setOwnerPercent(uint256 percent) onlyOwner public{
}
function setOwnerMin(uint256 min) onlyOwner public{
}
function _fee() internal returns(uint256){
}
function cashOut() onlyOwner public{
}
modifier isHuman() {
}
modifier isContract() {
}
}
/**
* luck100.win - Fair Ethereum game platform
*
* Single dice
*
* Winning rules:
*
* result = sha3(txhash + blockhash(betBN+3)) % 6 + 1
*
* 1.The player chooses a bet of 1-6 and bets up to 5 digits at the same time;
*
* 2.After the player bets successfully, get the transaction hash txhash;
*
* 3.Take the block that the player bets to count the new 3rd Ethereum block hash blockhash;
*
* 4.Txhash and blockhash are subjected to sha3 encryption operation, and then modulo with 6 to
* get the result of the lottery.
*/
contract Dice1Contract is Ownable{
event betEvent(address indexed addr, uint256 betBlockNumber, uint256 betMask, uint256 amount);
event openEvent(address indexed addr, uint256 openBlockNumber, uint256 openNumber, bytes32 txhash, bool isWin);
struct Bet{
uint256 betBlockNumber;
uint256 openBlockNumber;
uint256 betMask;
uint256 openNumber;
uint256 amount;
uint256 winAmount;
bytes32 txhash;
bytes32 openHash;
bool isWin;
}
mapping(address=>mapping(uint256=>Bet)) betList;
uint256 constant MIN_BET = 0.01 ether;
uint8 public N = 3;
uint8 constant M = 6;
uint16[M] public MASKS = [0, 32, 48, 56, 60, 62];
uint16[M] public AMOUNTS = [0, 101, 253, 510, 1031, 2660];
uint16[M] public ODDS = [0, 600, 300, 200, 150, 120];
constructor(address addr, uint256 percent, uint256 min) Ownable(addr, percent, min) public{
}
function() public payable{
}
function placeBet(uint256 betMask, uint8 diceNum) public payable{
}
function _placeBet(uint256 betMask, uint8 diceNum) private{
}
function setN(uint8 n) onlyOwner public{
}
function open(address addr, uint256 bn, bytes32 txhash) onlyOwner public{
uint256 openBlockNumber = betList[addr][bn].openBlockNumber;
bytes32 openBlockHash = blockhash(openBlockNumber);
require(<FILL_ME>)
_open(addr, bn, txhash, openBlockHash);
}
function open2(address addr, uint256 bn, bytes32 txhash, bytes32 openBlockHash) onlyOwner public{
}
function _open(address addr, uint256 bn, bytes32 txhash, bytes32 openBlockHash) private{
}
function getBet(address addr, uint256 bn) view public returns(uint256,uint256,uint256,uint256,uint256,uint256,bytes32,bytes32,bool){
}
function output() view public returns(uint8,uint256,uint256,uint16[M],uint16[M],uint16[M]){
}
}
| uint256(openBlockHash)>0,'invalid openBlockNumber' | 309,195 | uint256(openBlockHash)>0 |
null | pragma solidity ^0.4.24;
/* _____ ______ ________
* / | / \ / |
* $$$$$ | /$$$$$$ | $$$$$$$$/
* $$ | $$ | $$/ $$ |
* __ $$ | $$ | $$ |
* / | $$ | $$ | __ $$ |
* $$ \__$$ | $$ \__/ | $$ |
* $$ $$/ $$ $$/ $$ |
* $$$$$$/ $$$$$$/ $$/
*/
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
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) {
}
}
/**
* @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;
address public collector;
address public distributor;
address public freezer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event CollectorshipTransferred(address indexed previousCollector, address indexed newCollector);
event DistributorshipTransferred(address indexed previousDistributor, address indexed newDistributor);
event FreezershipTransferred(address indexed previousFreezer, address indexed newFreezer);
/**
* @dev The Ownable constructor sets the original `owner`, `collector`, `distributor` and `freezer` of the contract to the
* sender account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the collector.
*/
modifier onlyCollector() {
}
/**
* @dev Throws if called by any account other than the distributor.
*/
modifier onlyDistributor() {
}
/**
* @dev Throws if called by any account other than the freezer.
*/
modifier onlyFreezer() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
require(<FILL_ME>)
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
/**
* @dev Allows the current collector to transfer control of the contract to a newCollector.
* @param newCollector The address to transfer collectorship to.
*/
function transferCollectorship(address newCollector) onlyOwner public {
}
/**
* @dev Allows the current distributor to transfer control of the contract to a newDistributor.
* @param newDistributor The address to transfer distributorship to.
*/
function transferDistributorship(address newDistributor) onlyOwner public {
}
/**
* @dev Allows the current freezer to transfer control of the contract to a newFreezer.
* @param newFreezer The address to transfer freezership to.
*/
function transferFreezership(address newFreezer) onlyOwner public {
}
// check if the given account is valid
function isNonZeroAccount(address _addr) internal pure returns (bool is_nonzero_account) {
}
}
/**
* @title ERC20
* @dev ERC20 contract interface
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/**
* @title JCT
* @author Daisuke Hirata & Noriyuki Izawa
* @dev JCT is an ERC20 Token. First envisioned by NANJCOIN
*/
contract JCT is ERC20, Ownable {
using SafeMath for uint256;
string public name = "JCT";
string public symbol = "JCT";
uint8 public decimals = 8;
uint256 public totalSupply = 17e7 * 1e8;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
/**
* @dev Constructor is called only once and can not be called again
*/
constructor(address founder) public {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Prevent targets from sending or receiving tokens
* @param targets Addresses to be frozen
* @param isFrozen either to freeze it or not
*/
function freezeAccounts(address[] targets, bool isFrozen) onlyFreezer public {
}
/**
* @dev Prevent targets from sending or receiving tokens by setting Unix times
* @param targets Addresses to be locked funds
* @param unixTimes Unix times when locking up will be finished
*/
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
}
/**
* @dev Standard function transfer with no _data
*/
function transfer(address _to, uint _value) public returns (bool success) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* @dev Allows _spender to spend no more than _value tokens in your behalf
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* @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
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
/**
* @dev Function to collect tokens from the list of addresses
*/
function collectTokens(address[] addresses, uint[] amounts) onlyCollector public returns (bool) {
}
/**
* @dev Function to distribute tokens to the list of addresses
*/
function distributeTokens(address[] addresses, uint[] amounts) onlyDistributor public returns (bool) {
}
// check if the given account is available
function isAvailableAccount(address _addr) private view returns (bool is_valid_account) {
}
// check if the given account is not locked up
function isUnLockedAccount(address _addr) private view returns (bool is_unlocked_account) {
}
// check if the given account is not frozen
function isUnfrozenAccount(address _addr) private view returns (bool is_unfrozen_account) {
}
// check if the given account has enough balance more than given amount
function hasEnoughBalance(address _addr, uint256 _value) private view returns (bool has_enough_balance) {
}
// check if the given account is not frozen
function hasSameArrayLength(address[] addresses, uint[] amounts) private pure returns (bool has_same_array_length) {
}
}
| isNonZeroAccount(newOwner) | 309,209 | isNonZeroAccount(newOwner) |
null | pragma solidity ^0.4.24;
/* _____ ______ ________
* / | / \ / |
* $$$$$ | /$$$$$$ | $$$$$$$$/
* $$ | $$ | $$/ $$ |
* __ $$ | $$ | $$ |
* / | $$ | $$ | __ $$ |
* $$ \__$$ | $$ \__/ | $$ |
* $$ $$/ $$ $$/ $$ |
* $$$$$$/ $$$$$$/ $$/
*/
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
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) {
}
}
/**
* @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;
address public collector;
address public distributor;
address public freezer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event CollectorshipTransferred(address indexed previousCollector, address indexed newCollector);
event DistributorshipTransferred(address indexed previousDistributor, address indexed newDistributor);
event FreezershipTransferred(address indexed previousFreezer, address indexed newFreezer);
/**
* @dev The Ownable constructor sets the original `owner`, `collector`, `distributor` and `freezer` of the contract to the
* sender account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the collector.
*/
modifier onlyCollector() {
}
/**
* @dev Throws if called by any account other than the distributor.
*/
modifier onlyDistributor() {
}
/**
* @dev Throws if called by any account other than the freezer.
*/
modifier onlyFreezer() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
/**
* @dev Allows the current collector to transfer control of the contract to a newCollector.
* @param newCollector The address to transfer collectorship to.
*/
function transferCollectorship(address newCollector) onlyOwner public {
require(<FILL_ME>)
emit CollectorshipTransferred(collector, newCollector);
collector = newCollector;
}
/**
* @dev Allows the current distributor to transfer control of the contract to a newDistributor.
* @param newDistributor The address to transfer distributorship to.
*/
function transferDistributorship(address newDistributor) onlyOwner public {
}
/**
* @dev Allows the current freezer to transfer control of the contract to a newFreezer.
* @param newFreezer The address to transfer freezership to.
*/
function transferFreezership(address newFreezer) onlyOwner public {
}
// check if the given account is valid
function isNonZeroAccount(address _addr) internal pure returns (bool is_nonzero_account) {
}
}
/**
* @title ERC20
* @dev ERC20 contract interface
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/**
* @title JCT
* @author Daisuke Hirata & Noriyuki Izawa
* @dev JCT is an ERC20 Token. First envisioned by NANJCOIN
*/
contract JCT is ERC20, Ownable {
using SafeMath for uint256;
string public name = "JCT";
string public symbol = "JCT";
uint8 public decimals = 8;
uint256 public totalSupply = 17e7 * 1e8;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
/**
* @dev Constructor is called only once and can not be called again
*/
constructor(address founder) public {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Prevent targets from sending or receiving tokens
* @param targets Addresses to be frozen
* @param isFrozen either to freeze it or not
*/
function freezeAccounts(address[] targets, bool isFrozen) onlyFreezer public {
}
/**
* @dev Prevent targets from sending or receiving tokens by setting Unix times
* @param targets Addresses to be locked funds
* @param unixTimes Unix times when locking up will be finished
*/
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
}
/**
* @dev Standard function transfer with no _data
*/
function transfer(address _to, uint _value) public returns (bool success) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* @dev Allows _spender to spend no more than _value tokens in your behalf
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* @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
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
/**
* @dev Function to collect tokens from the list of addresses
*/
function collectTokens(address[] addresses, uint[] amounts) onlyCollector public returns (bool) {
}
/**
* @dev Function to distribute tokens to the list of addresses
*/
function distributeTokens(address[] addresses, uint[] amounts) onlyDistributor public returns (bool) {
}
// check if the given account is available
function isAvailableAccount(address _addr) private view returns (bool is_valid_account) {
}
// check if the given account is not locked up
function isUnLockedAccount(address _addr) private view returns (bool is_unlocked_account) {
}
// check if the given account is not frozen
function isUnfrozenAccount(address _addr) private view returns (bool is_unfrozen_account) {
}
// check if the given account has enough balance more than given amount
function hasEnoughBalance(address _addr, uint256 _value) private view returns (bool has_enough_balance) {
}
// check if the given account is not frozen
function hasSameArrayLength(address[] addresses, uint[] amounts) private pure returns (bool has_same_array_length) {
}
}
| isNonZeroAccount(newCollector) | 309,209 | isNonZeroAccount(newCollector) |
null | pragma solidity ^0.4.24;
/* _____ ______ ________
* / | / \ / |
* $$$$$ | /$$$$$$ | $$$$$$$$/
* $$ | $$ | $$/ $$ |
* __ $$ | $$ | $$ |
* / | $$ | $$ | __ $$ |
* $$ \__$$ | $$ \__/ | $$ |
* $$ $$/ $$ $$/ $$ |
* $$$$$$/ $$$$$$/ $$/
*/
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
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) {
}
}
/**
* @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;
address public collector;
address public distributor;
address public freezer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event CollectorshipTransferred(address indexed previousCollector, address indexed newCollector);
event DistributorshipTransferred(address indexed previousDistributor, address indexed newDistributor);
event FreezershipTransferred(address indexed previousFreezer, address indexed newFreezer);
/**
* @dev The Ownable constructor sets the original `owner`, `collector`, `distributor` and `freezer` of the contract to the
* sender account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the collector.
*/
modifier onlyCollector() {
}
/**
* @dev Throws if called by any account other than the distributor.
*/
modifier onlyDistributor() {
}
/**
* @dev Throws if called by any account other than the freezer.
*/
modifier onlyFreezer() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
/**
* @dev Allows the current collector to transfer control of the contract to a newCollector.
* @param newCollector The address to transfer collectorship to.
*/
function transferCollectorship(address newCollector) onlyOwner public {
}
/**
* @dev Allows the current distributor to transfer control of the contract to a newDistributor.
* @param newDistributor The address to transfer distributorship to.
*/
function transferDistributorship(address newDistributor) onlyOwner public {
require(<FILL_ME>)
emit DistributorshipTransferred(distributor, newDistributor);
distributor = newDistributor;
}
/**
* @dev Allows the current freezer to transfer control of the contract to a newFreezer.
* @param newFreezer The address to transfer freezership to.
*/
function transferFreezership(address newFreezer) onlyOwner public {
}
// check if the given account is valid
function isNonZeroAccount(address _addr) internal pure returns (bool is_nonzero_account) {
}
}
/**
* @title ERC20
* @dev ERC20 contract interface
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/**
* @title JCT
* @author Daisuke Hirata & Noriyuki Izawa
* @dev JCT is an ERC20 Token. First envisioned by NANJCOIN
*/
contract JCT is ERC20, Ownable {
using SafeMath for uint256;
string public name = "JCT";
string public symbol = "JCT";
uint8 public decimals = 8;
uint256 public totalSupply = 17e7 * 1e8;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
/**
* @dev Constructor is called only once and can not be called again
*/
constructor(address founder) public {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Prevent targets from sending or receiving tokens
* @param targets Addresses to be frozen
* @param isFrozen either to freeze it or not
*/
function freezeAccounts(address[] targets, bool isFrozen) onlyFreezer public {
}
/**
* @dev Prevent targets from sending or receiving tokens by setting Unix times
* @param targets Addresses to be locked funds
* @param unixTimes Unix times when locking up will be finished
*/
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
}
/**
* @dev Standard function transfer with no _data
*/
function transfer(address _to, uint _value) public returns (bool success) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* @dev Allows _spender to spend no more than _value tokens in your behalf
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* @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
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
/**
* @dev Function to collect tokens from the list of addresses
*/
function collectTokens(address[] addresses, uint[] amounts) onlyCollector public returns (bool) {
}
/**
* @dev Function to distribute tokens to the list of addresses
*/
function distributeTokens(address[] addresses, uint[] amounts) onlyDistributor public returns (bool) {
}
// check if the given account is available
function isAvailableAccount(address _addr) private view returns (bool is_valid_account) {
}
// check if the given account is not locked up
function isUnLockedAccount(address _addr) private view returns (bool is_unlocked_account) {
}
// check if the given account is not frozen
function isUnfrozenAccount(address _addr) private view returns (bool is_unfrozen_account) {
}
// check if the given account has enough balance more than given amount
function hasEnoughBalance(address _addr, uint256 _value) private view returns (bool has_enough_balance) {
}
// check if the given account is not frozen
function hasSameArrayLength(address[] addresses, uint[] amounts) private pure returns (bool has_same_array_length) {
}
}
| isNonZeroAccount(newDistributor) | 309,209 | isNonZeroAccount(newDistributor) |
null | pragma solidity ^0.4.24;
/* _____ ______ ________
* / | / \ / |
* $$$$$ | /$$$$$$ | $$$$$$$$/
* $$ | $$ | $$/ $$ |
* __ $$ | $$ | $$ |
* / | $$ | $$ | __ $$ |
* $$ \__$$ | $$ \__/ | $$ |
* $$ $$/ $$ $$/ $$ |
* $$$$$$/ $$$$$$/ $$/
*/
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
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) {
}
}
/**
* @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;
address public collector;
address public distributor;
address public freezer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event CollectorshipTransferred(address indexed previousCollector, address indexed newCollector);
event DistributorshipTransferred(address indexed previousDistributor, address indexed newDistributor);
event FreezershipTransferred(address indexed previousFreezer, address indexed newFreezer);
/**
* @dev The Ownable constructor sets the original `owner`, `collector`, `distributor` and `freezer` of the contract to the
* sender account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the collector.
*/
modifier onlyCollector() {
}
/**
* @dev Throws if called by any account other than the distributor.
*/
modifier onlyDistributor() {
}
/**
* @dev Throws if called by any account other than the freezer.
*/
modifier onlyFreezer() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
/**
* @dev Allows the current collector to transfer control of the contract to a newCollector.
* @param newCollector The address to transfer collectorship to.
*/
function transferCollectorship(address newCollector) onlyOwner public {
}
/**
* @dev Allows the current distributor to transfer control of the contract to a newDistributor.
* @param newDistributor The address to transfer distributorship to.
*/
function transferDistributorship(address newDistributor) onlyOwner public {
}
/**
* @dev Allows the current freezer to transfer control of the contract to a newFreezer.
* @param newFreezer The address to transfer freezership to.
*/
function transferFreezership(address newFreezer) onlyOwner public {
require(<FILL_ME>)
emit FreezershipTransferred(freezer, newFreezer);
freezer = newFreezer;
}
// check if the given account is valid
function isNonZeroAccount(address _addr) internal pure returns (bool is_nonzero_account) {
}
}
/**
* @title ERC20
* @dev ERC20 contract interface
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/**
* @title JCT
* @author Daisuke Hirata & Noriyuki Izawa
* @dev JCT is an ERC20 Token. First envisioned by NANJCOIN
*/
contract JCT is ERC20, Ownable {
using SafeMath for uint256;
string public name = "JCT";
string public symbol = "JCT";
uint8 public decimals = 8;
uint256 public totalSupply = 17e7 * 1e8;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
/**
* @dev Constructor is called only once and can not be called again
*/
constructor(address founder) public {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Prevent targets from sending or receiving tokens
* @param targets Addresses to be frozen
* @param isFrozen either to freeze it or not
*/
function freezeAccounts(address[] targets, bool isFrozen) onlyFreezer public {
}
/**
* @dev Prevent targets from sending or receiving tokens by setting Unix times
* @param targets Addresses to be locked funds
* @param unixTimes Unix times when locking up will be finished
*/
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
}
/**
* @dev Standard function transfer with no _data
*/
function transfer(address _to, uint _value) public returns (bool success) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* @dev Allows _spender to spend no more than _value tokens in your behalf
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* @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
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
/**
* @dev Function to collect tokens from the list of addresses
*/
function collectTokens(address[] addresses, uint[] amounts) onlyCollector public returns (bool) {
}
/**
* @dev Function to distribute tokens to the list of addresses
*/
function distributeTokens(address[] addresses, uint[] amounts) onlyDistributor public returns (bool) {
}
// check if the given account is available
function isAvailableAccount(address _addr) private view returns (bool is_valid_account) {
}
// check if the given account is not locked up
function isUnLockedAccount(address _addr) private view returns (bool is_unlocked_account) {
}
// check if the given account is not frozen
function isUnfrozenAccount(address _addr) private view returns (bool is_unfrozen_account) {
}
// check if the given account has enough balance more than given amount
function hasEnoughBalance(address _addr, uint256 _value) private view returns (bool has_enough_balance) {
}
// check if the given account is not frozen
function hasSameArrayLength(address[] addresses, uint[] amounts) private pure returns (bool has_same_array_length) {
}
}
| isNonZeroAccount(newFreezer) | 309,209 | isNonZeroAccount(newFreezer) |
null | pragma solidity ^0.4.24;
/* _____ ______ ________
* / | / \ / |
* $$$$$ | /$$$$$$ | $$$$$$$$/
* $$ | $$ | $$/ $$ |
* __ $$ | $$ | $$ |
* / | $$ | $$ | __ $$ |
* $$ \__$$ | $$ \__/ | $$ |
* $$ $$/ $$ $$/ $$ |
* $$$$$$/ $$$$$$/ $$/
*/
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
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) {
}
}
/**
* @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;
address public collector;
address public distributor;
address public freezer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event CollectorshipTransferred(address indexed previousCollector, address indexed newCollector);
event DistributorshipTransferred(address indexed previousDistributor, address indexed newDistributor);
event FreezershipTransferred(address indexed previousFreezer, address indexed newFreezer);
/**
* @dev The Ownable constructor sets the original `owner`, `collector`, `distributor` and `freezer` of the contract to the
* sender account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the collector.
*/
modifier onlyCollector() {
}
/**
* @dev Throws if called by any account other than the distributor.
*/
modifier onlyDistributor() {
}
/**
* @dev Throws if called by any account other than the freezer.
*/
modifier onlyFreezer() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
/**
* @dev Allows the current collector to transfer control of the contract to a newCollector.
* @param newCollector The address to transfer collectorship to.
*/
function transferCollectorship(address newCollector) onlyOwner public {
}
/**
* @dev Allows the current distributor to transfer control of the contract to a newDistributor.
* @param newDistributor The address to transfer distributorship to.
*/
function transferDistributorship(address newDistributor) onlyOwner public {
}
/**
* @dev Allows the current freezer to transfer control of the contract to a newFreezer.
* @param newFreezer The address to transfer freezership to.
*/
function transferFreezership(address newFreezer) onlyOwner public {
}
// check if the given account is valid
function isNonZeroAccount(address _addr) internal pure returns (bool is_nonzero_account) {
}
}
/**
* @title ERC20
* @dev ERC20 contract interface
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/**
* @title JCT
* @author Daisuke Hirata & Noriyuki Izawa
* @dev JCT is an ERC20 Token. First envisioned by NANJCOIN
*/
contract JCT is ERC20, Ownable {
using SafeMath for uint256;
string public name = "JCT";
string public symbol = "JCT";
uint8 public decimals = 8;
uint256 public totalSupply = 17e7 * 1e8;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
/**
* @dev Constructor is called only once and can not be called again
*/
constructor(address founder) public {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Prevent targets from sending or receiving tokens
* @param targets Addresses to be frozen
* @param isFrozen either to freeze it or not
*/
function freezeAccounts(address[] targets, bool isFrozen) onlyFreezer public {
require(targets.length > 0);
for (uint j = 0; j < targets.length; j++) {
require(<FILL_ME>)
frozenAccount[targets[j]] = isFrozen;
emit FrozenFunds(targets[j], isFrozen);
}
}
/**
* @dev Prevent targets from sending or receiving tokens by setting Unix times
* @param targets Addresses to be locked funds
* @param unixTimes Unix times when locking up will be finished
*/
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
}
/**
* @dev Standard function transfer with no _data
*/
function transfer(address _to, uint _value) public returns (bool success) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* @dev Allows _spender to spend no more than _value tokens in your behalf
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* @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
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
/**
* @dev Function to collect tokens from the list of addresses
*/
function collectTokens(address[] addresses, uint[] amounts) onlyCollector public returns (bool) {
}
/**
* @dev Function to distribute tokens to the list of addresses
*/
function distributeTokens(address[] addresses, uint[] amounts) onlyDistributor public returns (bool) {
}
// check if the given account is available
function isAvailableAccount(address _addr) private view returns (bool is_valid_account) {
}
// check if the given account is not locked up
function isUnLockedAccount(address _addr) private view returns (bool is_unlocked_account) {
}
// check if the given account is not frozen
function isUnfrozenAccount(address _addr) private view returns (bool is_unfrozen_account) {
}
// check if the given account has enough balance more than given amount
function hasEnoughBalance(address _addr, uint256 _value) private view returns (bool has_enough_balance) {
}
// check if the given account is not frozen
function hasSameArrayLength(address[] addresses, uint[] amounts) private pure returns (bool has_same_array_length) {
}
}
| isNonZeroAccount(targets[j]) | 309,209 | isNonZeroAccount(targets[j]) |
null | pragma solidity ^0.4.24;
/* _____ ______ ________
* / | / \ / |
* $$$$$ | /$$$$$$ | $$$$$$$$/
* $$ | $$ | $$/ $$ |
* __ $$ | $$ | $$ |
* / | $$ | $$ | __ $$ |
* $$ \__$$ | $$ \__/ | $$ |
* $$ $$/ $$ $$/ $$ |
* $$$$$$/ $$$$$$/ $$/
*/
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
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) {
}
}
/**
* @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;
address public collector;
address public distributor;
address public freezer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event CollectorshipTransferred(address indexed previousCollector, address indexed newCollector);
event DistributorshipTransferred(address indexed previousDistributor, address indexed newDistributor);
event FreezershipTransferred(address indexed previousFreezer, address indexed newFreezer);
/**
* @dev The Ownable constructor sets the original `owner`, `collector`, `distributor` and `freezer` of the contract to the
* sender account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the collector.
*/
modifier onlyCollector() {
}
/**
* @dev Throws if called by any account other than the distributor.
*/
modifier onlyDistributor() {
}
/**
* @dev Throws if called by any account other than the freezer.
*/
modifier onlyFreezer() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
/**
* @dev Allows the current collector to transfer control of the contract to a newCollector.
* @param newCollector The address to transfer collectorship to.
*/
function transferCollectorship(address newCollector) onlyOwner public {
}
/**
* @dev Allows the current distributor to transfer control of the contract to a newDistributor.
* @param newDistributor The address to transfer distributorship to.
*/
function transferDistributorship(address newDistributor) onlyOwner public {
}
/**
* @dev Allows the current freezer to transfer control of the contract to a newFreezer.
* @param newFreezer The address to transfer freezership to.
*/
function transferFreezership(address newFreezer) onlyOwner public {
}
// check if the given account is valid
function isNonZeroAccount(address _addr) internal pure returns (bool is_nonzero_account) {
}
}
/**
* @title ERC20
* @dev ERC20 contract interface
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/**
* @title JCT
* @author Daisuke Hirata & Noriyuki Izawa
* @dev JCT is an ERC20 Token. First envisioned by NANJCOIN
*/
contract JCT is ERC20, Ownable {
using SafeMath for uint256;
string public name = "JCT";
string public symbol = "JCT";
uint8 public decimals = 8;
uint256 public totalSupply = 17e7 * 1e8;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
/**
* @dev Constructor is called only once and can not be called again
*/
constructor(address founder) public {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Prevent targets from sending or receiving tokens
* @param targets Addresses to be frozen
* @param isFrozen either to freeze it or not
*/
function freezeAccounts(address[] targets, bool isFrozen) onlyFreezer public {
}
/**
* @dev Prevent targets from sending or receiving tokens by setting Unix times
* @param targets Addresses to be locked funds
* @param unixTimes Unix times when locking up will be finished
*/
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(<FILL_ME>)
for(uint j = 0; j < targets.length; j++){
require(unlockUnixTime[targets[j]] < unixTimes[j]);
unlockUnixTime[targets[j]] = unixTimes[j];
emit LockedFunds(targets[j], unixTimes[j]);
}
}
/**
* @dev Standard function transfer with no _data
*/
function transfer(address _to, uint _value) public returns (bool success) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* @dev Allows _spender to spend no more than _value tokens in your behalf
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* @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
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
/**
* @dev Function to collect tokens from the list of addresses
*/
function collectTokens(address[] addresses, uint[] amounts) onlyCollector public returns (bool) {
}
/**
* @dev Function to distribute tokens to the list of addresses
*/
function distributeTokens(address[] addresses, uint[] amounts) onlyDistributor public returns (bool) {
}
// check if the given account is available
function isAvailableAccount(address _addr) private view returns (bool is_valid_account) {
}
// check if the given account is not locked up
function isUnLockedAccount(address _addr) private view returns (bool is_unlocked_account) {
}
// check if the given account is not frozen
function isUnfrozenAccount(address _addr) private view returns (bool is_unfrozen_account) {
}
// check if the given account has enough balance more than given amount
function hasEnoughBalance(address _addr, uint256 _value) private view returns (bool has_enough_balance) {
}
// check if the given account is not frozen
function hasSameArrayLength(address[] addresses, uint[] amounts) private pure returns (bool has_same_array_length) {
}
}
| hasSameArrayLength(targets,unixTimes) | 309,209 | hasSameArrayLength(targets,unixTimes) |
null | pragma solidity ^0.4.24;
/* _____ ______ ________
* / | / \ / |
* $$$$$ | /$$$$$$ | $$$$$$$$/
* $$ | $$ | $$/ $$ |
* __ $$ | $$ | $$ |
* / | $$ | $$ | __ $$ |
* $$ \__$$ | $$ \__/ | $$ |
* $$ $$/ $$ $$/ $$ |
* $$$$$$/ $$$$$$/ $$/
*/
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
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) {
}
}
/**
* @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;
address public collector;
address public distributor;
address public freezer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event CollectorshipTransferred(address indexed previousCollector, address indexed newCollector);
event DistributorshipTransferred(address indexed previousDistributor, address indexed newDistributor);
event FreezershipTransferred(address indexed previousFreezer, address indexed newFreezer);
/**
* @dev The Ownable constructor sets the original `owner`, `collector`, `distributor` and `freezer` of the contract to the
* sender account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the collector.
*/
modifier onlyCollector() {
}
/**
* @dev Throws if called by any account other than the distributor.
*/
modifier onlyDistributor() {
}
/**
* @dev Throws if called by any account other than the freezer.
*/
modifier onlyFreezer() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
/**
* @dev Allows the current collector to transfer control of the contract to a newCollector.
* @param newCollector The address to transfer collectorship to.
*/
function transferCollectorship(address newCollector) onlyOwner public {
}
/**
* @dev Allows the current distributor to transfer control of the contract to a newDistributor.
* @param newDistributor The address to transfer distributorship to.
*/
function transferDistributorship(address newDistributor) onlyOwner public {
}
/**
* @dev Allows the current freezer to transfer control of the contract to a newFreezer.
* @param newFreezer The address to transfer freezership to.
*/
function transferFreezership(address newFreezer) onlyOwner public {
}
// check if the given account is valid
function isNonZeroAccount(address _addr) internal pure returns (bool is_nonzero_account) {
}
}
/**
* @title ERC20
* @dev ERC20 contract interface
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/**
* @title JCT
* @author Daisuke Hirata & Noriyuki Izawa
* @dev JCT is an ERC20 Token. First envisioned by NANJCOIN
*/
contract JCT is ERC20, Ownable {
using SafeMath for uint256;
string public name = "JCT";
string public symbol = "JCT";
uint8 public decimals = 8;
uint256 public totalSupply = 17e7 * 1e8;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
/**
* @dev Constructor is called only once and can not be called again
*/
constructor(address founder) public {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Prevent targets from sending or receiving tokens
* @param targets Addresses to be frozen
* @param isFrozen either to freeze it or not
*/
function freezeAccounts(address[] targets, bool isFrozen) onlyFreezer public {
}
/**
* @dev Prevent targets from sending or receiving tokens by setting Unix times
* @param targets Addresses to be locked funds
* @param unixTimes Unix times when locking up will be finished
*/
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(hasSameArrayLength(targets, unixTimes));
for(uint j = 0; j < targets.length; j++){
require(<FILL_ME>)
unlockUnixTime[targets[j]] = unixTimes[j];
emit LockedFunds(targets[j], unixTimes[j]);
}
}
/**
* @dev Standard function transfer with no _data
*/
function transfer(address _to, uint _value) public returns (bool success) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* @dev Allows _spender to spend no more than _value tokens in your behalf
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* @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
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
/**
* @dev Function to collect tokens from the list of addresses
*/
function collectTokens(address[] addresses, uint[] amounts) onlyCollector public returns (bool) {
}
/**
* @dev Function to distribute tokens to the list of addresses
*/
function distributeTokens(address[] addresses, uint[] amounts) onlyDistributor public returns (bool) {
}
// check if the given account is available
function isAvailableAccount(address _addr) private view returns (bool is_valid_account) {
}
// check if the given account is not locked up
function isUnLockedAccount(address _addr) private view returns (bool is_unlocked_account) {
}
// check if the given account is not frozen
function isUnfrozenAccount(address _addr) private view returns (bool is_unfrozen_account) {
}
// check if the given account has enough balance more than given amount
function hasEnoughBalance(address _addr, uint256 _value) private view returns (bool has_enough_balance) {
}
// check if the given account is not frozen
function hasSameArrayLength(address[] addresses, uint[] amounts) private pure returns (bool has_same_array_length) {
}
}
| unlockUnixTime[targets[j]]<unixTimes[j] | 309,209 | unlockUnixTime[targets[j]]<unixTimes[j] |
null | pragma solidity ^0.4.24;
/* _____ ______ ________
* / | / \ / |
* $$$$$ | /$$$$$$ | $$$$$$$$/
* $$ | $$ | $$/ $$ |
* __ $$ | $$ | $$ |
* / | $$ | $$ | __ $$ |
* $$ \__$$ | $$ \__/ | $$ |
* $$ $$/ $$ $$/ $$ |
* $$$$$$/ $$$$$$/ $$/
*/
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
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) {
}
}
/**
* @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;
address public collector;
address public distributor;
address public freezer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event CollectorshipTransferred(address indexed previousCollector, address indexed newCollector);
event DistributorshipTransferred(address indexed previousDistributor, address indexed newDistributor);
event FreezershipTransferred(address indexed previousFreezer, address indexed newFreezer);
/**
* @dev The Ownable constructor sets the original `owner`, `collector`, `distributor` and `freezer` of the contract to the
* sender account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the collector.
*/
modifier onlyCollector() {
}
/**
* @dev Throws if called by any account other than the distributor.
*/
modifier onlyDistributor() {
}
/**
* @dev Throws if called by any account other than the freezer.
*/
modifier onlyFreezer() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
/**
* @dev Allows the current collector to transfer control of the contract to a newCollector.
* @param newCollector The address to transfer collectorship to.
*/
function transferCollectorship(address newCollector) onlyOwner public {
}
/**
* @dev Allows the current distributor to transfer control of the contract to a newDistributor.
* @param newDistributor The address to transfer distributorship to.
*/
function transferDistributorship(address newDistributor) onlyOwner public {
}
/**
* @dev Allows the current freezer to transfer control of the contract to a newFreezer.
* @param newFreezer The address to transfer freezership to.
*/
function transferFreezership(address newFreezer) onlyOwner public {
}
// check if the given account is valid
function isNonZeroAccount(address _addr) internal pure returns (bool is_nonzero_account) {
}
}
/**
* @title ERC20
* @dev ERC20 contract interface
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/**
* @title JCT
* @author Daisuke Hirata & Noriyuki Izawa
* @dev JCT is an ERC20 Token. First envisioned by NANJCOIN
*/
contract JCT is ERC20, Ownable {
using SafeMath for uint256;
string public name = "JCT";
string public symbol = "JCT";
uint8 public decimals = 8;
uint256 public totalSupply = 17e7 * 1e8;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
/**
* @dev Constructor is called only once and can not be called again
*/
constructor(address founder) public {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Prevent targets from sending or receiving tokens
* @param targets Addresses to be frozen
* @param isFrozen either to freeze it or not
*/
function freezeAccounts(address[] targets, bool isFrozen) onlyFreezer public {
}
/**
* @dev Prevent targets from sending or receiving tokens by setting Unix times
* @param targets Addresses to be locked funds
* @param unixTimes Unix times when locking up will be finished
*/
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
}
/**
* @dev Standard function transfer with no _data
*/
function transfer(address _to, uint _value) public returns (bool success) {
require(<FILL_ME>)
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* @dev Allows _spender to spend no more than _value tokens in your behalf
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* @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
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
/**
* @dev Function to collect tokens from the list of addresses
*/
function collectTokens(address[] addresses, uint[] amounts) onlyCollector public returns (bool) {
}
/**
* @dev Function to distribute tokens to the list of addresses
*/
function distributeTokens(address[] addresses, uint[] amounts) onlyDistributor public returns (bool) {
}
// check if the given account is available
function isAvailableAccount(address _addr) private view returns (bool is_valid_account) {
}
// check if the given account is not locked up
function isUnLockedAccount(address _addr) private view returns (bool is_unlocked_account) {
}
// check if the given account is not frozen
function isUnfrozenAccount(address _addr) private view returns (bool is_unfrozen_account) {
}
// check if the given account has enough balance more than given amount
function hasEnoughBalance(address _addr, uint256 _value) private view returns (bool has_enough_balance) {
}
// check if the given account is not frozen
function hasSameArrayLength(address[] addresses, uint[] amounts) private pure returns (bool has_same_array_length) {
}
}
| hasEnoughBalance(msg.sender,_value)&&isAvailableAccount(msg.sender)&&isAvailableAccount(_to) | 309,209 | hasEnoughBalance(msg.sender,_value)&&isAvailableAccount(msg.sender)&&isAvailableAccount(_to) |
null | pragma solidity ^0.4.24;
/* _____ ______ ________
* / | / \ / |
* $$$$$ | /$$$$$$ | $$$$$$$$/
* $$ | $$ | $$/ $$ |
* __ $$ | $$ | $$ |
* / | $$ | $$ | __ $$ |
* $$ \__$$ | $$ \__/ | $$ |
* $$ $$/ $$ $$/ $$ |
* $$$$$$/ $$$$$$/ $$/
*/
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
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) {
}
}
/**
* @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;
address public collector;
address public distributor;
address public freezer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event CollectorshipTransferred(address indexed previousCollector, address indexed newCollector);
event DistributorshipTransferred(address indexed previousDistributor, address indexed newDistributor);
event FreezershipTransferred(address indexed previousFreezer, address indexed newFreezer);
/**
* @dev The Ownable constructor sets the original `owner`, `collector`, `distributor` and `freezer` of the contract to the
* sender account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the collector.
*/
modifier onlyCollector() {
}
/**
* @dev Throws if called by any account other than the distributor.
*/
modifier onlyDistributor() {
}
/**
* @dev Throws if called by any account other than the freezer.
*/
modifier onlyFreezer() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
/**
* @dev Allows the current collector to transfer control of the contract to a newCollector.
* @param newCollector The address to transfer collectorship to.
*/
function transferCollectorship(address newCollector) onlyOwner public {
}
/**
* @dev Allows the current distributor to transfer control of the contract to a newDistributor.
* @param newDistributor The address to transfer distributorship to.
*/
function transferDistributorship(address newDistributor) onlyOwner public {
}
/**
* @dev Allows the current freezer to transfer control of the contract to a newFreezer.
* @param newFreezer The address to transfer freezership to.
*/
function transferFreezership(address newFreezer) onlyOwner public {
}
// check if the given account is valid
function isNonZeroAccount(address _addr) internal pure returns (bool is_nonzero_account) {
}
}
/**
* @title ERC20
* @dev ERC20 contract interface
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/**
* @title JCT
* @author Daisuke Hirata & Noriyuki Izawa
* @dev JCT is an ERC20 Token. First envisioned by NANJCOIN
*/
contract JCT is ERC20, Ownable {
using SafeMath for uint256;
string public name = "JCT";
string public symbol = "JCT";
uint8 public decimals = 8;
uint256 public totalSupply = 17e7 * 1e8;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
/**
* @dev Constructor is called only once and can not be called again
*/
constructor(address founder) public {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Prevent targets from sending or receiving tokens
* @param targets Addresses to be frozen
* @param isFrozen either to freeze it or not
*/
function freezeAccounts(address[] targets, bool isFrozen) onlyFreezer public {
}
/**
* @dev Prevent targets from sending or receiving tokens by setting Unix times
* @param targets Addresses to be locked funds
* @param unixTimes Unix times when locking up will be finished
*/
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
}
/**
* @dev Standard function transfer with no _data
*/
function transfer(address _to, uint _value) public returns (bool success) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(<FILL_ME>)
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Allows _spender to spend no more than _value tokens in your behalf
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* @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
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
/**
* @dev Function to collect tokens from the list of addresses
*/
function collectTokens(address[] addresses, uint[] amounts) onlyCollector public returns (bool) {
}
/**
* @dev Function to distribute tokens to the list of addresses
*/
function distributeTokens(address[] addresses, uint[] amounts) onlyDistributor public returns (bool) {
}
// check if the given account is available
function isAvailableAccount(address _addr) private view returns (bool is_valid_account) {
}
// check if the given account is not locked up
function isUnLockedAccount(address _addr) private view returns (bool is_unlocked_account) {
}
// check if the given account is not frozen
function isUnfrozenAccount(address _addr) private view returns (bool is_unfrozen_account) {
}
// check if the given account has enough balance more than given amount
function hasEnoughBalance(address _addr, uint256 _value) private view returns (bool has_enough_balance) {
}
// check if the given account is not frozen
function hasSameArrayLength(address[] addresses, uint[] amounts) private pure returns (bool has_same_array_length) {
}
}
| isNonZeroAccount(_to)&&hasEnoughBalance(_from,_value)&&allowance[_from][msg.sender]>=_value&&isAvailableAccount(_from)&&isAvailableAccount(_to) | 309,209 | isNonZeroAccount(_to)&&hasEnoughBalance(_from,_value)&&allowance[_from][msg.sender]>=_value&&isAvailableAccount(_from)&&isAvailableAccount(_to) |
null | pragma solidity ^0.4.24;
/* _____ ______ ________
* / | / \ / |
* $$$$$ | /$$$$$$ | $$$$$$$$/
* $$ | $$ | $$/ $$ |
* __ $$ | $$ | $$ |
* / | $$ | $$ | __ $$ |
* $$ \__$$ | $$ \__/ | $$ |
* $$ $$/ $$ $$/ $$ |
* $$$$$$/ $$$$$$/ $$/
*/
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
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) {
}
}
/**
* @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;
address public collector;
address public distributor;
address public freezer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event CollectorshipTransferred(address indexed previousCollector, address indexed newCollector);
event DistributorshipTransferred(address indexed previousDistributor, address indexed newDistributor);
event FreezershipTransferred(address indexed previousFreezer, address indexed newFreezer);
/**
* @dev The Ownable constructor sets the original `owner`, `collector`, `distributor` and `freezer` of the contract to the
* sender account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the collector.
*/
modifier onlyCollector() {
}
/**
* @dev Throws if called by any account other than the distributor.
*/
modifier onlyDistributor() {
}
/**
* @dev Throws if called by any account other than the freezer.
*/
modifier onlyFreezer() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
/**
* @dev Allows the current collector to transfer control of the contract to a newCollector.
* @param newCollector The address to transfer collectorship to.
*/
function transferCollectorship(address newCollector) onlyOwner public {
}
/**
* @dev Allows the current distributor to transfer control of the contract to a newDistributor.
* @param newDistributor The address to transfer distributorship to.
*/
function transferDistributorship(address newDistributor) onlyOwner public {
}
/**
* @dev Allows the current freezer to transfer control of the contract to a newFreezer.
* @param newFreezer The address to transfer freezership to.
*/
function transferFreezership(address newFreezer) onlyOwner public {
}
// check if the given account is valid
function isNonZeroAccount(address _addr) internal pure returns (bool is_nonzero_account) {
}
}
/**
* @title ERC20
* @dev ERC20 contract interface
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/**
* @title JCT
* @author Daisuke Hirata & Noriyuki Izawa
* @dev JCT is an ERC20 Token. First envisioned by NANJCOIN
*/
contract JCT is ERC20, Ownable {
using SafeMath for uint256;
string public name = "JCT";
string public symbol = "JCT";
uint8 public decimals = 8;
uint256 public totalSupply = 17e7 * 1e8;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
/**
* @dev Constructor is called only once and can not be called again
*/
constructor(address founder) public {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Prevent targets from sending or receiving tokens
* @param targets Addresses to be frozen
* @param isFrozen either to freeze it or not
*/
function freezeAccounts(address[] targets, bool isFrozen) onlyFreezer public {
}
/**
* @dev Prevent targets from sending or receiving tokens by setting Unix times
* @param targets Addresses to be locked funds
* @param unixTimes Unix times when locking up will be finished
*/
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
}
/**
* @dev Standard function transfer with no _data
*/
function transfer(address _to, uint _value) public returns (bool success) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* @dev Allows _spender to spend no more than _value tokens in your behalf
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* @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
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
/**
* @dev Function to collect tokens from the list of addresses
*/
function collectTokens(address[] addresses, uint[] amounts) onlyCollector public returns (bool) {
require(<FILL_ME>)
uint256 totalAmount = 0;
for (uint j = 0; j < addresses.length; j++) {
require(amounts[j] > 0
&& isNonZeroAccount(addresses[j])
&& isAvailableAccount(addresses[j]));
require(hasEnoughBalance(addresses[j], amounts[j]));
balanceOf[addresses[j]] = balanceOf[addresses[j]].sub(amounts[j]);
totalAmount = totalAmount.add(amounts[j]);
emit Transfer(addresses[j], msg.sender, amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].add(totalAmount);
return true;
}
/**
* @dev Function to distribute tokens to the list of addresses
*/
function distributeTokens(address[] addresses, uint[] amounts) onlyDistributor public returns (bool) {
}
// check if the given account is available
function isAvailableAccount(address _addr) private view returns (bool is_valid_account) {
}
// check if the given account is not locked up
function isUnLockedAccount(address _addr) private view returns (bool is_unlocked_account) {
}
// check if the given account is not frozen
function isUnfrozenAccount(address _addr) private view returns (bool is_unfrozen_account) {
}
// check if the given account has enough balance more than given amount
function hasEnoughBalance(address _addr, uint256 _value) private view returns (bool has_enough_balance) {
}
// check if the given account is not frozen
function hasSameArrayLength(address[] addresses, uint[] amounts) private pure returns (bool has_same_array_length) {
}
}
| hasSameArrayLength(addresses,amounts) | 309,209 | hasSameArrayLength(addresses,amounts) |
null | pragma solidity ^0.4.24;
/* _____ ______ ________
* / | / \ / |
* $$$$$ | /$$$$$$ | $$$$$$$$/
* $$ | $$ | $$/ $$ |
* __ $$ | $$ | $$ |
* / | $$ | $$ | __ $$ |
* $$ \__$$ | $$ \__/ | $$ |
* $$ $$/ $$ $$/ $$ |
* $$$$$$/ $$$$$$/ $$/
*/
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
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) {
}
}
/**
* @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;
address public collector;
address public distributor;
address public freezer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event CollectorshipTransferred(address indexed previousCollector, address indexed newCollector);
event DistributorshipTransferred(address indexed previousDistributor, address indexed newDistributor);
event FreezershipTransferred(address indexed previousFreezer, address indexed newFreezer);
/**
* @dev The Ownable constructor sets the original `owner`, `collector`, `distributor` and `freezer` of the contract to the
* sender account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the collector.
*/
modifier onlyCollector() {
}
/**
* @dev Throws if called by any account other than the distributor.
*/
modifier onlyDistributor() {
}
/**
* @dev Throws if called by any account other than the freezer.
*/
modifier onlyFreezer() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
/**
* @dev Allows the current collector to transfer control of the contract to a newCollector.
* @param newCollector The address to transfer collectorship to.
*/
function transferCollectorship(address newCollector) onlyOwner public {
}
/**
* @dev Allows the current distributor to transfer control of the contract to a newDistributor.
* @param newDistributor The address to transfer distributorship to.
*/
function transferDistributorship(address newDistributor) onlyOwner public {
}
/**
* @dev Allows the current freezer to transfer control of the contract to a newFreezer.
* @param newFreezer The address to transfer freezership to.
*/
function transferFreezership(address newFreezer) onlyOwner public {
}
// check if the given account is valid
function isNonZeroAccount(address _addr) internal pure returns (bool is_nonzero_account) {
}
}
/**
* @title ERC20
* @dev ERC20 contract interface
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/**
* @title JCT
* @author Daisuke Hirata & Noriyuki Izawa
* @dev JCT is an ERC20 Token. First envisioned by NANJCOIN
*/
contract JCT is ERC20, Ownable {
using SafeMath for uint256;
string public name = "JCT";
string public symbol = "JCT";
uint8 public decimals = 8;
uint256 public totalSupply = 17e7 * 1e8;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
/**
* @dev Constructor is called only once and can not be called again
*/
constructor(address founder) public {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Prevent targets from sending or receiving tokens
* @param targets Addresses to be frozen
* @param isFrozen either to freeze it or not
*/
function freezeAccounts(address[] targets, bool isFrozen) onlyFreezer public {
}
/**
* @dev Prevent targets from sending or receiving tokens by setting Unix times
* @param targets Addresses to be locked funds
* @param unixTimes Unix times when locking up will be finished
*/
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
}
/**
* @dev Standard function transfer with no _data
*/
function transfer(address _to, uint _value) public returns (bool success) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* @dev Allows _spender to spend no more than _value tokens in your behalf
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* @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
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
/**
* @dev Function to collect tokens from the list of addresses
*/
function collectTokens(address[] addresses, uint[] amounts) onlyCollector public returns (bool) {
require(hasSameArrayLength(addresses, amounts));
uint256 totalAmount = 0;
for (uint j = 0; j < addresses.length; j++) {
require(<FILL_ME>)
require(hasEnoughBalance(addresses[j], amounts[j]));
balanceOf[addresses[j]] = balanceOf[addresses[j]].sub(amounts[j]);
totalAmount = totalAmount.add(amounts[j]);
emit Transfer(addresses[j], msg.sender, amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].add(totalAmount);
return true;
}
/**
* @dev Function to distribute tokens to the list of addresses
*/
function distributeTokens(address[] addresses, uint[] amounts) onlyDistributor public returns (bool) {
}
// check if the given account is available
function isAvailableAccount(address _addr) private view returns (bool is_valid_account) {
}
// check if the given account is not locked up
function isUnLockedAccount(address _addr) private view returns (bool is_unlocked_account) {
}
// check if the given account is not frozen
function isUnfrozenAccount(address _addr) private view returns (bool is_unfrozen_account) {
}
// check if the given account has enough balance more than given amount
function hasEnoughBalance(address _addr, uint256 _value) private view returns (bool has_enough_balance) {
}
// check if the given account is not frozen
function hasSameArrayLength(address[] addresses, uint[] amounts) private pure returns (bool has_same_array_length) {
}
}
| amounts[j]>0&&isNonZeroAccount(addresses[j])&&isAvailableAccount(addresses[j]) | 309,209 | amounts[j]>0&&isNonZeroAccount(addresses[j])&&isAvailableAccount(addresses[j]) |
null | pragma solidity ^0.4.24;
/* _____ ______ ________
* / | / \ / |
* $$$$$ | /$$$$$$ | $$$$$$$$/
* $$ | $$ | $$/ $$ |
* __ $$ | $$ | $$ |
* / | $$ | $$ | __ $$ |
* $$ \__$$ | $$ \__/ | $$ |
* $$ $$/ $$ $$/ $$ |
* $$$$$$/ $$$$$$/ $$/
*/
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
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) {
}
}
/**
* @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;
address public collector;
address public distributor;
address public freezer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event CollectorshipTransferred(address indexed previousCollector, address indexed newCollector);
event DistributorshipTransferred(address indexed previousDistributor, address indexed newDistributor);
event FreezershipTransferred(address indexed previousFreezer, address indexed newFreezer);
/**
* @dev The Ownable constructor sets the original `owner`, `collector`, `distributor` and `freezer` of the contract to the
* sender account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the collector.
*/
modifier onlyCollector() {
}
/**
* @dev Throws if called by any account other than the distributor.
*/
modifier onlyDistributor() {
}
/**
* @dev Throws if called by any account other than the freezer.
*/
modifier onlyFreezer() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
/**
* @dev Allows the current collector to transfer control of the contract to a newCollector.
* @param newCollector The address to transfer collectorship to.
*/
function transferCollectorship(address newCollector) onlyOwner public {
}
/**
* @dev Allows the current distributor to transfer control of the contract to a newDistributor.
* @param newDistributor The address to transfer distributorship to.
*/
function transferDistributorship(address newDistributor) onlyOwner public {
}
/**
* @dev Allows the current freezer to transfer control of the contract to a newFreezer.
* @param newFreezer The address to transfer freezership to.
*/
function transferFreezership(address newFreezer) onlyOwner public {
}
// check if the given account is valid
function isNonZeroAccount(address _addr) internal pure returns (bool is_nonzero_account) {
}
}
/**
* @title ERC20
* @dev ERC20 contract interface
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/**
* @title JCT
* @author Daisuke Hirata & Noriyuki Izawa
* @dev JCT is an ERC20 Token. First envisioned by NANJCOIN
*/
contract JCT is ERC20, Ownable {
using SafeMath for uint256;
string public name = "JCT";
string public symbol = "JCT";
uint8 public decimals = 8;
uint256 public totalSupply = 17e7 * 1e8;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
/**
* @dev Constructor is called only once and can not be called again
*/
constructor(address founder) public {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Prevent targets from sending or receiving tokens
* @param targets Addresses to be frozen
* @param isFrozen either to freeze it or not
*/
function freezeAccounts(address[] targets, bool isFrozen) onlyFreezer public {
}
/**
* @dev Prevent targets from sending or receiving tokens by setting Unix times
* @param targets Addresses to be locked funds
* @param unixTimes Unix times when locking up will be finished
*/
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
}
/**
* @dev Standard function transfer with no _data
*/
function transfer(address _to, uint _value) public returns (bool success) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* @dev Allows _spender to spend no more than _value tokens in your behalf
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* @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
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
/**
* @dev Function to collect tokens from the list of addresses
*/
function collectTokens(address[] addresses, uint[] amounts) onlyCollector public returns (bool) {
require(hasSameArrayLength(addresses, amounts));
uint256 totalAmount = 0;
for (uint j = 0; j < addresses.length; j++) {
require(amounts[j] > 0
&& isNonZeroAccount(addresses[j])
&& isAvailableAccount(addresses[j]));
require(<FILL_ME>)
balanceOf[addresses[j]] = balanceOf[addresses[j]].sub(amounts[j]);
totalAmount = totalAmount.add(amounts[j]);
emit Transfer(addresses[j], msg.sender, amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].add(totalAmount);
return true;
}
/**
* @dev Function to distribute tokens to the list of addresses
*/
function distributeTokens(address[] addresses, uint[] amounts) onlyDistributor public returns (bool) {
}
// check if the given account is available
function isAvailableAccount(address _addr) private view returns (bool is_valid_account) {
}
// check if the given account is not locked up
function isUnLockedAccount(address _addr) private view returns (bool is_unlocked_account) {
}
// check if the given account is not frozen
function isUnfrozenAccount(address _addr) private view returns (bool is_unfrozen_account) {
}
// check if the given account has enough balance more than given amount
function hasEnoughBalance(address _addr, uint256 _value) private view returns (bool has_enough_balance) {
}
// check if the given account is not frozen
function hasSameArrayLength(address[] addresses, uint[] amounts) private pure returns (bool has_same_array_length) {
}
}
| hasEnoughBalance(addresses[j],amounts[j]) | 309,209 | hasEnoughBalance(addresses[j],amounts[j]) |
null | pragma solidity ^0.4.24;
/* _____ ______ ________
* / | / \ / |
* $$$$$ | /$$$$$$ | $$$$$$$$/
* $$ | $$ | $$/ $$ |
* __ $$ | $$ | $$ |
* / | $$ | $$ | __ $$ |
* $$ \__$$ | $$ \__/ | $$ |
* $$ $$/ $$ $$/ $$ |
* $$$$$$/ $$$$$$/ $$/
*/
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
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) {
}
}
/**
* @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;
address public collector;
address public distributor;
address public freezer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event CollectorshipTransferred(address indexed previousCollector, address indexed newCollector);
event DistributorshipTransferred(address indexed previousDistributor, address indexed newDistributor);
event FreezershipTransferred(address indexed previousFreezer, address indexed newFreezer);
/**
* @dev The Ownable constructor sets the original `owner`, `collector`, `distributor` and `freezer` of the contract to the
* sender account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the collector.
*/
modifier onlyCollector() {
}
/**
* @dev Throws if called by any account other than the distributor.
*/
modifier onlyDistributor() {
}
/**
* @dev Throws if called by any account other than the freezer.
*/
modifier onlyFreezer() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
/**
* @dev Allows the current collector to transfer control of the contract to a newCollector.
* @param newCollector The address to transfer collectorship to.
*/
function transferCollectorship(address newCollector) onlyOwner public {
}
/**
* @dev Allows the current distributor to transfer control of the contract to a newDistributor.
* @param newDistributor The address to transfer distributorship to.
*/
function transferDistributorship(address newDistributor) onlyOwner public {
}
/**
* @dev Allows the current freezer to transfer control of the contract to a newFreezer.
* @param newFreezer The address to transfer freezership to.
*/
function transferFreezership(address newFreezer) onlyOwner public {
}
// check if the given account is valid
function isNonZeroAccount(address _addr) internal pure returns (bool is_nonzero_account) {
}
}
/**
* @title ERC20
* @dev ERC20 contract interface
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/**
* @title JCT
* @author Daisuke Hirata & Noriyuki Izawa
* @dev JCT is an ERC20 Token. First envisioned by NANJCOIN
*/
contract JCT is ERC20, Ownable {
using SafeMath for uint256;
string public name = "JCT";
string public symbol = "JCT";
uint8 public decimals = 8;
uint256 public totalSupply = 17e7 * 1e8;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
/**
* @dev Constructor is called only once and can not be called again
*/
constructor(address founder) public {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Prevent targets from sending or receiving tokens
* @param targets Addresses to be frozen
* @param isFrozen either to freeze it or not
*/
function freezeAccounts(address[] targets, bool isFrozen) onlyFreezer public {
}
/**
* @dev Prevent targets from sending or receiving tokens by setting Unix times
* @param targets Addresses to be locked funds
* @param unixTimes Unix times when locking up will be finished
*/
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
}
/**
* @dev Standard function transfer with no _data
*/
function transfer(address _to, uint _value) public returns (bool success) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* @dev Allows _spender to spend no more than _value tokens in your behalf
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* @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
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
/**
* @dev Function to collect tokens from the list of addresses
*/
function collectTokens(address[] addresses, uint[] amounts) onlyCollector public returns (bool) {
}
/**
* @dev Function to distribute tokens to the list of addresses
*/
function distributeTokens(address[] addresses, uint[] amounts) onlyDistributor public returns (bool) {
require(<FILL_ME>)
uint256 totalAmount = 0;
for(uint j = 0; j < addresses.length; j++){
require(amounts[j] > 0
&& isNonZeroAccount(addresses[j])
&& isAvailableAccount(addresses[j]));
totalAmount = totalAmount.add(amounts[j]);
}
require(hasEnoughBalance(msg.sender, totalAmount));
for (j = 0; j < addresses.length; j++) {
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amounts[j]);
emit Transfer(msg.sender, addresses[j], amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
// check if the given account is available
function isAvailableAccount(address _addr) private view returns (bool is_valid_account) {
}
// check if the given account is not locked up
function isUnLockedAccount(address _addr) private view returns (bool is_unlocked_account) {
}
// check if the given account is not frozen
function isUnfrozenAccount(address _addr) private view returns (bool is_unfrozen_account) {
}
// check if the given account has enough balance more than given amount
function hasEnoughBalance(address _addr, uint256 _value) private view returns (bool has_enough_balance) {
}
// check if the given account is not frozen
function hasSameArrayLength(address[] addresses, uint[] amounts) private pure returns (bool has_same_array_length) {
}
}
| hasSameArrayLength(addresses,amounts)&&isAvailableAccount(msg.sender) | 309,209 | hasSameArrayLength(addresses,amounts)&&isAvailableAccount(msg.sender) |
null | pragma solidity ^0.4.24;
/* _____ ______ ________
* / | / \ / |
* $$$$$ | /$$$$$$ | $$$$$$$$/
* $$ | $$ | $$/ $$ |
* __ $$ | $$ | $$ |
* / | $$ | $$ | __ $$ |
* $$ \__$$ | $$ \__/ | $$ |
* $$ $$/ $$ $$/ $$ |
* $$$$$$/ $$$$$$/ $$/
*/
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
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) {
}
}
/**
* @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;
address public collector;
address public distributor;
address public freezer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event CollectorshipTransferred(address indexed previousCollector, address indexed newCollector);
event DistributorshipTransferred(address indexed previousDistributor, address indexed newDistributor);
event FreezershipTransferred(address indexed previousFreezer, address indexed newFreezer);
/**
* @dev The Ownable constructor sets the original `owner`, `collector`, `distributor` and `freezer` of the contract to the
* sender account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Throws if called by any account other than the collector.
*/
modifier onlyCollector() {
}
/**
* @dev Throws if called by any account other than the distributor.
*/
modifier onlyDistributor() {
}
/**
* @dev Throws if called by any account other than the freezer.
*/
modifier onlyFreezer() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
/**
* @dev Allows the current collector to transfer control of the contract to a newCollector.
* @param newCollector The address to transfer collectorship to.
*/
function transferCollectorship(address newCollector) onlyOwner public {
}
/**
* @dev Allows the current distributor to transfer control of the contract to a newDistributor.
* @param newDistributor The address to transfer distributorship to.
*/
function transferDistributorship(address newDistributor) onlyOwner public {
}
/**
* @dev Allows the current freezer to transfer control of the contract to a newFreezer.
* @param newFreezer The address to transfer freezership to.
*/
function transferFreezership(address newFreezer) onlyOwner public {
}
// check if the given account is valid
function isNonZeroAccount(address _addr) internal pure returns (bool is_nonzero_account) {
}
}
/**
* @title ERC20
* @dev ERC20 contract interface
*/
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/**
* @title JCT
* @author Daisuke Hirata & Noriyuki Izawa
* @dev JCT is an ERC20 Token. First envisioned by NANJCOIN
*/
contract JCT is ERC20, Ownable {
using SafeMath for uint256;
string public name = "JCT";
string public symbol = "JCT";
uint8 public decimals = 8;
uint256 public totalSupply = 17e7 * 1e8;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
/**
* @dev Constructor is called only once and can not be called again
*/
constructor(address founder) public {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Prevent targets from sending or receiving tokens
* @param targets Addresses to be frozen
* @param isFrozen either to freeze it or not
*/
function freezeAccounts(address[] targets, bool isFrozen) onlyFreezer public {
}
/**
* @dev Prevent targets from sending or receiving tokens by setting Unix times
* @param targets Addresses to be locked funds
* @param unixTimes Unix times when locking up will be finished
*/
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
}
/**
* @dev Standard function transfer with no _data
*/
function transfer(address _to, uint _value) public returns (bool success) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* @dev Allows _spender to spend no more than _value tokens in your behalf
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* @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
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
/**
* @dev Function to collect tokens from the list of addresses
*/
function collectTokens(address[] addresses, uint[] amounts) onlyCollector public returns (bool) {
}
/**
* @dev Function to distribute tokens to the list of addresses
*/
function distributeTokens(address[] addresses, uint[] amounts) onlyDistributor public returns (bool) {
require(hasSameArrayLength(addresses, amounts)
&& isAvailableAccount(msg.sender));
uint256 totalAmount = 0;
for(uint j = 0; j < addresses.length; j++){
require(amounts[j] > 0
&& isNonZeroAccount(addresses[j])
&& isAvailableAccount(addresses[j]));
totalAmount = totalAmount.add(amounts[j]);
}
require(<FILL_ME>)
for (j = 0; j < addresses.length; j++) {
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amounts[j]);
emit Transfer(msg.sender, addresses[j], amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
// check if the given account is available
function isAvailableAccount(address _addr) private view returns (bool is_valid_account) {
}
// check if the given account is not locked up
function isUnLockedAccount(address _addr) private view returns (bool is_unlocked_account) {
}
// check if the given account is not frozen
function isUnfrozenAccount(address _addr) private view returns (bool is_unfrozen_account) {
}
// check if the given account has enough balance more than given amount
function hasEnoughBalance(address _addr, uint256 _value) private view returns (bool has_enough_balance) {
}
// check if the given account is not frozen
function hasSameArrayLength(address[] addresses, uint[] amounts) private pure returns (bool has_same_array_length) {
}
}
| hasEnoughBalance(msg.sender,totalAmount) | 309,209 | hasEnoughBalance(msg.sender,totalAmount) |
"ERC20: transfer from blacklisted address" | // SPDX-License-Identifier: No-License
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 spendier,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
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) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract OOKII is Context, IERC20, Ownable {///////////////////////////////////////////////////////////
using SafeMath for uint256;
string private constant _name = "OOKII";//////////////////////////
string private constant _symbol = "OOKII";//////////////////////////////////////////////////////////////////////////
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) public _isBlacklisted;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private priceImpact = 30; //30 = 3%, 35 = 3,5% and so on.
//Buy Fee
uint256 private _redisFeeOnBuy = 2;////////////////////////////////////////////////////////////////////
uint256 private _taxFeeOnBuy = 10;//////////////////////////////////////////////////////////////////////
//Sell Fee
uint256 private _redisFeeOnSell = 6;/////////////////////////////////////////////////////////////////////
uint256 private _taxFeeOnSell = 10;/////////////////////////////////////////////////////////////////////
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping(address => uint256) private cooldown;
address payable private _developmentAddress = payable(0xeA1B21E261014ad36c697b2f4E0227194740b4b7);/////////////////////////////////////////////////
address payable private _marketingAddress = payable(0xeA1B21E261014ad36c697b2f4E0227194740b4b7);///////////////////////////////////////////////////
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 1000000000 * 10**9; //1%
uint256 public _maxWalletSize = 2000000000 * 10**9; //2%
uint256 public _swapTokensAtAmount = 100000000 * 10**9; //0.1%
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
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 tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
require(_isBlacklisted[to] != true, "ERC20: transfer to blacklisted address");
if(from != owner() && to != owner()) {
//Trade start check
if (!tradingOpen) {
require(from == owner(), "TOKEN: This account cannot send tokens until trading is enabled");
}
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
if(to != uniswapV2Pair) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
}
if(to == uniswapV2Pair){
require(amount <= balanceOf(uniswapV2Pair).mul(priceImpact).div(1000), "ERC20: transfer amount drops too much liquidity.");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount){
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
//Transfer Tokens
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
} else {
//Set Fee for Buys
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_redisFee = _redisFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
//Set Fee for Sells
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_redisFee = _redisFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function setMaxImpact(uint256 _maxPriceImpact) public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set Max transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
function addBlacklist(address _address) external onlyOwner{
}
function removeBlacklist(address _address) external onlyOwner{
}
}
| _isBlacklisted[from]!=true,"ERC20: transfer from blacklisted address" | 309,228 | _isBlacklisted[from]!=true |
"ERC20: transfer to blacklisted address" | // SPDX-License-Identifier: No-License
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 spendier,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
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) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract OOKII is Context, IERC20, Ownable {///////////////////////////////////////////////////////////
using SafeMath for uint256;
string private constant _name = "OOKII";//////////////////////////
string private constant _symbol = "OOKII";//////////////////////////////////////////////////////////////////////////
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) public _isBlacklisted;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private priceImpact = 30; //30 = 3%, 35 = 3,5% and so on.
//Buy Fee
uint256 private _redisFeeOnBuy = 2;////////////////////////////////////////////////////////////////////
uint256 private _taxFeeOnBuy = 10;//////////////////////////////////////////////////////////////////////
//Sell Fee
uint256 private _redisFeeOnSell = 6;/////////////////////////////////////////////////////////////////////
uint256 private _taxFeeOnSell = 10;/////////////////////////////////////////////////////////////////////
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping(address => uint256) private cooldown;
address payable private _developmentAddress = payable(0xeA1B21E261014ad36c697b2f4E0227194740b4b7);/////////////////////////////////////////////////
address payable private _marketingAddress = payable(0xeA1B21E261014ad36c697b2f4E0227194740b4b7);///////////////////////////////////////////////////
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 1000000000 * 10**9; //1%
uint256 public _maxWalletSize = 2000000000 * 10**9; //2%
uint256 public _swapTokensAtAmount = 100000000 * 10**9; //0.1%
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
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 tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(_isBlacklisted[from] != true, "ERC20: transfer from blacklisted address");
require(<FILL_ME>)
if(from != owner() && to != owner()) {
//Trade start check
if (!tradingOpen) {
require(from == owner(), "TOKEN: This account cannot send tokens until trading is enabled");
}
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
if(to != uniswapV2Pair) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
}
if(to == uniswapV2Pair){
require(amount <= balanceOf(uniswapV2Pair).mul(priceImpact).div(1000), "ERC20: transfer amount drops too much liquidity.");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount){
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
//Transfer Tokens
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
} else {
//Set Fee for Buys
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_redisFee = _redisFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
//Set Fee for Sells
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_redisFee = _redisFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function setMaxImpact(uint256 _maxPriceImpact) public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set Max transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
function addBlacklist(address _address) external onlyOwner{
}
function removeBlacklist(address _address) external onlyOwner{
}
}
| _isBlacklisted[to]!=true,"ERC20: transfer to blacklisted address" | 309,228 | _isBlacklisted[to]!=true |
null | // Copyright (C) 2017 DappHub, LLC
pragma solidity ^0.4.11;
//import "ds-exec/exec.sol";
contract DSExec {
function tryExec( address target, bytes calldata, uint value)
internal
returns (bool call_ret)
{
}
function exec( address target, bytes calldata, uint value)
internal
{
}
// Convenience aliases
function exec( address t, bytes c )
internal
{
}
function exec( address t, uint256 v )
internal
{
}
function tryExec( address t, bytes c )
internal
returns (bool)
{
}
function tryExec( address t, uint256 v )
internal
returns (bool)
{
}
}
//import "ds-auth/auth.sol";
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) constant returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
function DSAuth() {
}
function setOwner(address owner_)
auth
{
}
function setAuthority(DSAuthority authority_)
auth
{
}
modifier auth {
}
function isAuthorized(address src, bytes4 sig) internal returns (bool) {
}
function assert(bool x) internal {
}
}
//import "ds-note/note.sol";
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint wad,
bytes fax
) anonymous;
modifier note {
}
}
//import "ds-math/math.sol";
contract DSMath {
/*
standard uint256 functions
*/
function add(uint256 x, uint256 y) constant internal returns (uint256 z) {
}
function sub(uint256 x, uint256 y) constant internal returns (uint256 z) {
}
function mul(uint256 x, uint256 y) constant internal returns (uint256 z) {
}
function div(uint256 x, uint256 y) constant internal returns (uint256 z) {
}
function min(uint256 x, uint256 y) constant internal returns (uint256 z) {
}
function max(uint256 x, uint256 y) constant internal returns (uint256 z) {
}
/*
uint128 functions (h is for half)
*/
function hadd(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function hsub(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function hmul(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function hdiv(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function hmin(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function hmax(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
/*
int256 functions
*/
function imin(int256 x, int256 y) constant internal returns (int256 z) {
}
function imax(int256 x, int256 y) constant internal returns (int256 z) {
}
/*
WAD math
*/
uint128 constant WAD = 10 ** 18;
function wadd(uint128 x, uint128 y) constant internal returns (uint128) {
}
function wsub(uint128 x, uint128 y) constant internal returns (uint128) {
}
function wmul(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function wdiv(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function wmin(uint128 x, uint128 y) constant internal returns (uint128) {
}
function wmax(uint128 x, uint128 y) constant internal returns (uint128) {
}
/*
RAY math
*/
uint128 constant RAY = 10 ** 27;
function radd(uint128 x, uint128 y) constant internal returns (uint128) {
}
function rsub(uint128 x, uint128 y) constant internal returns (uint128) {
}
function rmul(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function rdiv(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function rpow(uint128 x, uint64 n) constant internal returns (uint128 z) {
}
function rmin(uint128 x, uint128 y) constant internal returns (uint128) {
}
function rmax(uint128 x, uint128 y) constant internal returns (uint128) {
}
function cast(uint256 x) constant internal returns (uint128 z) {
}
}
//import "erc20/erc20.sol";
contract ERC20 {
function totalSupply() constant returns (uint supply);
function balanceOf( address who ) constant returns (uint value);
function allowance( address owner, address spender ) constant returns (uint _allowance);
function transfer( address to, uint value) returns (bool ok);
function transferFrom( address from, address to, uint value) returns (bool ok);
function approve( address spender, uint value ) returns (bool ok);
event Transfer( address indexed from, address indexed to, uint value);
event Approval( address indexed owner, address indexed spender, uint value);
}
//import "ds-token/base.sol";
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
function DSTokenBase(uint256 supply) {
}
function totalSupply() constant returns (uint256) {
}
function balanceOf(address src) constant returns (uint256) {
}
function allowance(address src, address guy) constant returns (uint256) {
}
function transfer(address dst, uint wad) returns (bool) {
}
function transferFrom(address src, address dst, uint wad) returns (bool) {
}
function approve(address guy, uint256 wad) returns (bool) {
}
}
//import "ds-stop/stop.sol";
contract DSStop is DSAuth, DSNote {
bool public stopped;
modifier stoppable {
}
function stop() auth note {
}
function start() auth note {
}
}
//import "ds-token/token.sol";
contract DSToken is DSTokenBase(0), DSStop {
bytes32 public symbol;
uint256 public decimals = 18; // standard token precision. override to customize
address public generator;
modifier onlyGenerator {
}
function DSToken(bytes32 symbol_) {
}
function transfer(address dst, uint wad) stoppable note returns (bool) {
}
function transferFrom(
address src, address dst, uint wad
) stoppable note returns (bool) {
}
function approve(address guy, uint wad) stoppable note returns (bool) {
}
function push(address dst, uint128 wad) returns (bool) {
}
function pull(address src, uint128 wad) returns (bool) {
}
function mint(uint128 wad) auth stoppable note {
}
function burn(uint128 wad) auth stoppable note {
}
// owner can transfer token even stop,
function generatorTransfer(address dst, uint wad) onlyGenerator note returns (bool) {
}
// Optional token name
bytes32 public name = "";
function setName(bytes32 name_) auth {
}
}
contract KeyTokenSale is DSStop, DSMath, DSExec {
DSToken public key;
// KEY PRICES (ETH/KEY)
uint128 public constant PUBLIC_SALE_PRICE = 200000 ether;
uint128 public constant TOTAL_SUPPLY = 10 ** 11 * 1 ether; // 100 billion KEY in total
uint128 public constant SELL_SOFT_LIMIT = TOTAL_SUPPLY * 12 / 100; // soft limit is 12% , 60000 eth
uint128 public constant SELL_HARD_LIMIT = TOTAL_SUPPLY * 16 / 100; // hard limit is 16% , 80000 eth
uint128 public constant FUTURE_DISTRIBUTE_LIMIT = TOTAL_SUPPLY * 84 / 100; // 84% for future distribution
uint128 public constant USER_BUY_LIMIT = 500 ether; // 500 ether limit
uint128 public constant MAX_GAS_PRICE = 50000000000; // 50GWei
uint public startTime;
uint public endTime;
bool public moreThanSoftLimit;
mapping (address => uint) public userBuys; // limit to 500 eth
address public destFoundation; //multisig account , 4-of-6
uint128 public sold;
uint128 public constant soldByChannels = 40000 * 200000 ether; // 2 ICO websites, each 20000 eth
function KeyTokenSale(uint startTime_, address destFoundation_) {
}
// overrideable for easy testing
function time() constant returns (uint) {
}
function isContract(address _addr) constant internal returns(bool) {
}
function canBuy(uint total) returns (bool) {
}
function() payable stoppable note {
}
function setStartTime(uint startTime_) auth note {
require(<FILL_ME>)
startTime = startTime_;
endTime = startTime + 14 days;
}
function finalize() auth note {
}
// @notice This method can be used by the controller to extract mistakenly
// sent tokens to this contract.
// @param dst The address that will be receiving the tokens
// @param wad The amount of tokens to transfer
// @param _token The address of the token contract that you want to recover
function transferTokens(address dst, uint wad, address _token) public auth note {
}
function summary()constant returns(
uint128 _sold,
uint _startTime,
uint _endTime)
{
}
}
| time()<=startTime&&time()<=startTime_ | 309,229 | time()<=startTime&&time()<=startTime_ |
null | // Copyright (C) 2017 DappHub, LLC
pragma solidity ^0.4.11;
//import "ds-exec/exec.sol";
contract DSExec {
function tryExec( address target, bytes calldata, uint value)
internal
returns (bool call_ret)
{
}
function exec( address target, bytes calldata, uint value)
internal
{
}
// Convenience aliases
function exec( address t, bytes c )
internal
{
}
function exec( address t, uint256 v )
internal
{
}
function tryExec( address t, bytes c )
internal
returns (bool)
{
}
function tryExec( address t, uint256 v )
internal
returns (bool)
{
}
}
//import "ds-auth/auth.sol";
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) constant returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
function DSAuth() {
}
function setOwner(address owner_)
auth
{
}
function setAuthority(DSAuthority authority_)
auth
{
}
modifier auth {
}
function isAuthorized(address src, bytes4 sig) internal returns (bool) {
}
function assert(bool x) internal {
}
}
//import "ds-note/note.sol";
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint wad,
bytes fax
) anonymous;
modifier note {
}
}
//import "ds-math/math.sol";
contract DSMath {
/*
standard uint256 functions
*/
function add(uint256 x, uint256 y) constant internal returns (uint256 z) {
}
function sub(uint256 x, uint256 y) constant internal returns (uint256 z) {
}
function mul(uint256 x, uint256 y) constant internal returns (uint256 z) {
}
function div(uint256 x, uint256 y) constant internal returns (uint256 z) {
}
function min(uint256 x, uint256 y) constant internal returns (uint256 z) {
}
function max(uint256 x, uint256 y) constant internal returns (uint256 z) {
}
/*
uint128 functions (h is for half)
*/
function hadd(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function hsub(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function hmul(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function hdiv(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function hmin(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function hmax(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
/*
int256 functions
*/
function imin(int256 x, int256 y) constant internal returns (int256 z) {
}
function imax(int256 x, int256 y) constant internal returns (int256 z) {
}
/*
WAD math
*/
uint128 constant WAD = 10 ** 18;
function wadd(uint128 x, uint128 y) constant internal returns (uint128) {
}
function wsub(uint128 x, uint128 y) constant internal returns (uint128) {
}
function wmul(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function wdiv(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function wmin(uint128 x, uint128 y) constant internal returns (uint128) {
}
function wmax(uint128 x, uint128 y) constant internal returns (uint128) {
}
/*
RAY math
*/
uint128 constant RAY = 10 ** 27;
function radd(uint128 x, uint128 y) constant internal returns (uint128) {
}
function rsub(uint128 x, uint128 y) constant internal returns (uint128) {
}
function rmul(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function rdiv(uint128 x, uint128 y) constant internal returns (uint128 z) {
}
function rpow(uint128 x, uint64 n) constant internal returns (uint128 z) {
}
function rmin(uint128 x, uint128 y) constant internal returns (uint128) {
}
function rmax(uint128 x, uint128 y) constant internal returns (uint128) {
}
function cast(uint256 x) constant internal returns (uint128 z) {
}
}
//import "erc20/erc20.sol";
contract ERC20 {
function totalSupply() constant returns (uint supply);
function balanceOf( address who ) constant returns (uint value);
function allowance( address owner, address spender ) constant returns (uint _allowance);
function transfer( address to, uint value) returns (bool ok);
function transferFrom( address from, address to, uint value) returns (bool ok);
function approve( address spender, uint value ) returns (bool ok);
event Transfer( address indexed from, address indexed to, uint value);
event Approval( address indexed owner, address indexed spender, uint value);
}
//import "ds-token/base.sol";
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
function DSTokenBase(uint256 supply) {
}
function totalSupply() constant returns (uint256) {
}
function balanceOf(address src) constant returns (uint256) {
}
function allowance(address src, address guy) constant returns (uint256) {
}
function transfer(address dst, uint wad) returns (bool) {
}
function transferFrom(address src, address dst, uint wad) returns (bool) {
}
function approve(address guy, uint256 wad) returns (bool) {
}
}
//import "ds-stop/stop.sol";
contract DSStop is DSAuth, DSNote {
bool public stopped;
modifier stoppable {
}
function stop() auth note {
}
function start() auth note {
}
}
//import "ds-token/token.sol";
contract DSToken is DSTokenBase(0), DSStop {
bytes32 public symbol;
uint256 public decimals = 18; // standard token precision. override to customize
address public generator;
modifier onlyGenerator {
}
function DSToken(bytes32 symbol_) {
}
function transfer(address dst, uint wad) stoppable note returns (bool) {
}
function transferFrom(
address src, address dst, uint wad
) stoppable note returns (bool) {
}
function approve(address guy, uint wad) stoppable note returns (bool) {
}
function push(address dst, uint128 wad) returns (bool) {
}
function pull(address src, uint128 wad) returns (bool) {
}
function mint(uint128 wad) auth stoppable note {
}
function burn(uint128 wad) auth stoppable note {
}
// owner can transfer token even stop,
function generatorTransfer(address dst, uint wad) onlyGenerator note returns (bool) {
}
// Optional token name
bytes32 public name = "";
function setName(bytes32 name_) auth {
}
}
contract KeyTokenSale is DSStop, DSMath, DSExec {
DSToken public key;
// KEY PRICES (ETH/KEY)
uint128 public constant PUBLIC_SALE_PRICE = 200000 ether;
uint128 public constant TOTAL_SUPPLY = 10 ** 11 * 1 ether; // 100 billion KEY in total
uint128 public constant SELL_SOFT_LIMIT = TOTAL_SUPPLY * 12 / 100; // soft limit is 12% , 60000 eth
uint128 public constant SELL_HARD_LIMIT = TOTAL_SUPPLY * 16 / 100; // hard limit is 16% , 80000 eth
uint128 public constant FUTURE_DISTRIBUTE_LIMIT = TOTAL_SUPPLY * 84 / 100; // 84% for future distribution
uint128 public constant USER_BUY_LIMIT = 500 ether; // 500 ether limit
uint128 public constant MAX_GAS_PRICE = 50000000000; // 50GWei
uint public startTime;
uint public endTime;
bool public moreThanSoftLimit;
mapping (address => uint) public userBuys; // limit to 500 eth
address public destFoundation; //multisig account , 4-of-6
uint128 public sold;
uint128 public constant soldByChannels = 40000 * 200000 ether; // 2 ICO websites, each 20000 eth
function KeyTokenSale(uint startTime_, address destFoundation_) {
}
// overrideable for easy testing
function time() constant returns (uint) {
}
function isContract(address _addr) constant internal returns(bool) {
}
function canBuy(uint total) returns (bool) {
}
function() payable stoppable note {
}
function setStartTime(uint startTime_) auth note {
}
function finalize() auth note {
require(<FILL_ME>)
// enable transfer
key.start();
// transfer undistributed KEY
key.transfer(destFoundation, key.balanceOf(this));
// owner -> destFoundation
key.setOwner(destFoundation);
}
// @notice This method can be used by the controller to extract mistakenly
// sent tokens to this contract.
// @param dst The address that will be receiving the tokens
// @param wad The amount of tokens to transfer
// @param _token The address of the token contract that you want to recover
function transferTokens(address dst, uint wad, address _token) public auth note {
}
function summary()constant returns(
uint128 _sold,
uint _startTime,
uint _endTime)
{
}
}
| time()>=endTime | 309,229 | time()>=endTime |
"Exceeds max supply" | // SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0 < 0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
interface OtherHolder {
function balanceOf(address owner) external view returns (uint256 balance);
}
contract LuckyDoge is ERC721, Ownable, Pausable {
using Strings for uint;
string private baseURI = 'https://gateway.pinata.cloud/ipfs/QmfL3cX1M6iLA46oXbtnXo9hBhrnJJ99k1yjvfmAgTpQQ8/';
uint private maxSupply = 10000;
uint private maxGrant = 600;
uint private mintedSupply = 0;
uint256 private grantMintedNum = 0;
uint private basePrice;
address[] otherHolderAddress;
uint private grantNums;
mapping(address => bool) private grants;
constructor() ERC721("LuckyDoge", "LuckyDoge") {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal whenNotPaused override {
}
function withdraw() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
function setBasePrice(uint _basePrice) external onlyOwner {
}
function getBasePrice() public view returns (string memory) {
}
function setMaxGrant(uint _maxGrant) external onlyOwner {
}
function setHolderOwner(address[] memory _address) external onlyOwner {
}
function mintDoges(uint _amount) public payable whenNotPaused {
require(msg.value >= basePrice * _amount, "Not enough ETH sent");
require(mintedSupply < maxSupply, "Max supply reached");
require(<FILL_ME>)
for (uint i = 0; i < _amount; i++) {
mint();
}
}
function mintWithGrant() public payable whenNotPaused {
}
function mint() internal {
}
function getBalanceOf(address _address, uint target) public view returns (uint256) {
}
function allowGrant() public view returns (bool) {
}
function mintedLength() public view returns (uint[] memory) {
}
}
| mintedSupply+_amount<=maxSupply,"Exceeds max supply" | 309,481 | mintedSupply+_amount<=maxSupply |
"You have no chance [1]" | // SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0 < 0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
interface OtherHolder {
function balanceOf(address owner) external view returns (uint256 balance);
}
contract LuckyDoge is ERC721, Ownable, Pausable {
using Strings for uint;
string private baseURI = 'https://gateway.pinata.cloud/ipfs/QmfL3cX1M6iLA46oXbtnXo9hBhrnJJ99k1yjvfmAgTpQQ8/';
uint private maxSupply = 10000;
uint private maxGrant = 600;
uint private mintedSupply = 0;
uint256 private grantMintedNum = 0;
uint private basePrice;
address[] otherHolderAddress;
uint private grantNums;
mapping(address => bool) private grants;
constructor() ERC721("LuckyDoge", "LuckyDoge") {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal whenNotPaused override {
}
function withdraw() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
function setBasePrice(uint _basePrice) external onlyOwner {
}
function getBasePrice() public view returns (string memory) {
}
function setMaxGrant(uint _maxGrant) external onlyOwner {
}
function setHolderOwner(address[] memory _address) external onlyOwner {
}
function mintDoges(uint _amount) public payable whenNotPaused {
}
function mintWithGrant() public payable whenNotPaused {
require(<FILL_ME>)
require(grantMintedNum < maxGrant, "You have no chance [2]");
mint();
grantMintedNum++;
grants[msg.sender] = true;
}
function mint() internal {
}
function getBalanceOf(address _address, uint target) public view returns (uint256) {
}
function allowGrant() public view returns (bool) {
}
function mintedLength() public view returns (uint[] memory) {
}
}
| allowGrant(),"You have no chance [1]" | 309,481 | allowGrant() |
null | pragma solidity 0.4.23;
/**
* @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) {
}
/**
* @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) {
}
}
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public 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) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
/**
* @dev total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* @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) public 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) public view 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 VanHardwareResourcesChain is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
string public name; //fancy name: eg Simon Bucks
uint8 public decimals; //How many decimals to show.
string public symbol; //An identifier: eg SBX
uint256 public sellPrice;
uint256 public buyPrice;
address public owner;
function VanHardwareResourcesChain() public {
}
modifier onlyOwner(){
}
function changeOwner(address _newOwner) public onlyOwner{
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* 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
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
}
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) public onlyOwner{
}
/// @notice Buy tokens from contract by sending ether
function buy() payable public {
}
function() payable public{
}
/// @notice Sell `amount` tokens to contract
/// @param amount amount of tokens to be sold
function sell(uint256 amount) public {
}
function withdraw( address _address, uint amount) public onlyOwner{
require(<FILL_ME>)
_address.transfer(amount * 1 ether);
}
}
| address(this).balance>amount*1ether | 309,536 | address(this).balance>amount*1ether |
"no robot" | pragma solidity ^0.5.0;
contract freedomStatement {
string public statement = "https://ipfs.globalupload.io/QmfEnSNTHTe9ut6frhNsY16rXhiTjoGWtXozrA66y56Pbn";
mapping (address => bool) internal consent;
event wearehere(string statement);
constructor () public {
}
function isHuman(address addr) internal view returns (bool) {
}
function () external {
require(<FILL_ME>)//Don't want to use tx.origin because that will cause an interoperability problem
consent[msg.sender] = true;
}
function check(address addr) public view returns (bool){
}
}
| isHuman(msg.sender),"no robot" | 309,753 | isHuman(msg.sender) |
"FCFS Mint Stock Unavailable" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract BABC is ERC721A, Ownable {
bytes32 private _merkleRootWhitelist;
bytes32 private _merkleRootGA;
uint256 public constant maxSupply = 3456;
uint256 public constant maxWhitelistSupply = 400;
uint256 public constant maxGASupply = 100;
uint256 public FCFSsupply = 356;
uint256 private constant maxPerAddress = 8;
uint256 public constant publicMintPrice = 0.018 ether;
uint256 public whitelistMintCounter;
uint256 public GAMintCounter;
uint256 public freeMintCounter;
uint256 public nonPublicStartDate = 1646402400;
uint256 public saleStartDate = 1646402400;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTt4DnC9V1p3qWwUe21dTRX593VRnDKLmyx8hsbA4D1DN/";
string private baseExtension = ".json";
mapping(address => bool) public GAMintedByAddress;
mapping(address => uint32) public FreeMintedByAddress;
bool private revealed = false;
constructor() ERC721A("Bored Ape Bones Club", "BABC") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isNonPublicOpen() public view returns (bool) {
}
function isSaleOpen() public view returns (bool) {
}
function setNonPublicStartDate(uint256 date) external onlyOwner {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setFCFSSupply(uint256 maxsupp) external onlyOwner {
}
function setBaseUri(string calldata uri) external onlyOwner {
}
function _claimFCFS(uint32 amount) private {
require(totalSupply() + amount <= maxSupply, "Max Supply reached");
require(<FILL_ME>)
require(
_numberMinted(msg.sender) + amount <= maxPerAddress,
"Max per address"
);
require(FreeMintedByAddress[msg.sender] < 4, "Max Free Reached");
freeMintCounter += amount;
FreeMintedByAddress[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function _claimsale(uint32 amount) private {
}
function saleMint(uint32 amount) external payable onlyEOA {
}
function isFreeAvailable() public view returns (bool) {
}
function mintWhitelist(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
}
function mintGA(bytes32[] calldata proof) external onlyEOA {
}
function setMerkleRootWhitelist(bytes32 root) external onlyOwner {
}
function setMerkleRootGA(bytes32 root) external onlyOwner {
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| (amount>0)&&(freeMintCounter+amount<=FCFSsupply),"FCFS Mint Stock Unavailable" | 309,825 | (amount>0)&&(freeMintCounter+amount<=FCFSsupply) |
"Max Free Reached" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract BABC is ERC721A, Ownable {
bytes32 private _merkleRootWhitelist;
bytes32 private _merkleRootGA;
uint256 public constant maxSupply = 3456;
uint256 public constant maxWhitelistSupply = 400;
uint256 public constant maxGASupply = 100;
uint256 public FCFSsupply = 356;
uint256 private constant maxPerAddress = 8;
uint256 public constant publicMintPrice = 0.018 ether;
uint256 public whitelistMintCounter;
uint256 public GAMintCounter;
uint256 public freeMintCounter;
uint256 public nonPublicStartDate = 1646402400;
uint256 public saleStartDate = 1646402400;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTt4DnC9V1p3qWwUe21dTRX593VRnDKLmyx8hsbA4D1DN/";
string private baseExtension = ".json";
mapping(address => bool) public GAMintedByAddress;
mapping(address => uint32) public FreeMintedByAddress;
bool private revealed = false;
constructor() ERC721A("Bored Ape Bones Club", "BABC") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isNonPublicOpen() public view returns (bool) {
}
function isSaleOpen() public view returns (bool) {
}
function setNonPublicStartDate(uint256 date) external onlyOwner {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setFCFSSupply(uint256 maxsupp) external onlyOwner {
}
function setBaseUri(string calldata uri) external onlyOwner {
}
function _claimFCFS(uint32 amount) private {
require(totalSupply() + amount <= maxSupply, "Max Supply reached");
require(
(amount > 0) && (freeMintCounter + amount <= FCFSsupply),
"FCFS Mint Stock Unavailable"
);
require(
_numberMinted(msg.sender) + amount <= maxPerAddress,
"Max per address"
);
require(<FILL_ME>)
freeMintCounter += amount;
FreeMintedByAddress[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function _claimsale(uint32 amount) private {
}
function saleMint(uint32 amount) external payable onlyEOA {
}
function isFreeAvailable() public view returns (bool) {
}
function mintWhitelist(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
}
function mintGA(bytes32[] calldata proof) external onlyEOA {
}
function setMerkleRootWhitelist(bytes32 root) external onlyOwner {
}
function setMerkleRootGA(bytes32 root) external onlyOwner {
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| FreeMintedByAddress[msg.sender]<4,"Max Free Reached" | 309,825 | FreeMintedByAddress[msg.sender]<4 |
"Max Supply reached" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract BABC is ERC721A, Ownable {
bytes32 private _merkleRootWhitelist;
bytes32 private _merkleRootGA;
uint256 public constant maxSupply = 3456;
uint256 public constant maxWhitelistSupply = 400;
uint256 public constant maxGASupply = 100;
uint256 public FCFSsupply = 356;
uint256 private constant maxPerAddress = 8;
uint256 public constant publicMintPrice = 0.018 ether;
uint256 public whitelistMintCounter;
uint256 public GAMintCounter;
uint256 public freeMintCounter;
uint256 public nonPublicStartDate = 1646402400;
uint256 public saleStartDate = 1646402400;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTt4DnC9V1p3qWwUe21dTRX593VRnDKLmyx8hsbA4D1DN/";
string private baseExtension = ".json";
mapping(address => bool) public GAMintedByAddress;
mapping(address => uint32) public FreeMintedByAddress;
bool private revealed = false;
constructor() ERC721A("Bored Ape Bones Club", "BABC") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isNonPublicOpen() public view returns (bool) {
}
function isSaleOpen() public view returns (bool) {
}
function setNonPublicStartDate(uint256 date) external onlyOwner {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setFCFSSupply(uint256 maxsupp) external onlyOwner {
}
function setBaseUri(string calldata uri) external onlyOwner {
}
function _claimFCFS(uint32 amount) private {
}
function _claimsale(uint32 amount) private {
require(<FILL_ME>)
require((amount > 0) && (amount <= maxPerAddress), "Incorrect amount");
require(
_numberMinted(msg.sender) + amount <= maxPerAddress,
"Max per address"
);
require(msg.value >= publicMintPrice * amount, "Incorrect Price sent");
_safeMint(msg.sender, amount);
}
function saleMint(uint32 amount) external payable onlyEOA {
}
function isFreeAvailable() public view returns (bool) {
}
function mintWhitelist(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
}
function mintGA(bytes32[] calldata proof) external onlyEOA {
}
function setMerkleRootWhitelist(bytes32 root) external onlyOwner {
}
function setMerkleRootGA(bytes32 root) external onlyOwner {
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| totalSupply()+amount<maxSupply,"Max Supply reached" | 309,825 | totalSupply()+amount<maxSupply |
"Session Closed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract BABC is ERC721A, Ownable {
bytes32 private _merkleRootWhitelist;
bytes32 private _merkleRootGA;
uint256 public constant maxSupply = 3456;
uint256 public constant maxWhitelistSupply = 400;
uint256 public constant maxGASupply = 100;
uint256 public FCFSsupply = 356;
uint256 private constant maxPerAddress = 8;
uint256 public constant publicMintPrice = 0.018 ether;
uint256 public whitelistMintCounter;
uint256 public GAMintCounter;
uint256 public freeMintCounter;
uint256 public nonPublicStartDate = 1646402400;
uint256 public saleStartDate = 1646402400;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTt4DnC9V1p3qWwUe21dTRX593VRnDKLmyx8hsbA4D1DN/";
string private baseExtension = ".json";
mapping(address => bool) public GAMintedByAddress;
mapping(address => uint32) public FreeMintedByAddress;
bool private revealed = false;
constructor() ERC721A("Bored Ape Bones Club", "BABC") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isNonPublicOpen() public view returns (bool) {
}
function isSaleOpen() public view returns (bool) {
}
function setNonPublicStartDate(uint256 date) external onlyOwner {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setFCFSSupply(uint256 maxsupp) external onlyOwner {
}
function setBaseUri(string calldata uri) external onlyOwner {
}
function _claimFCFS(uint32 amount) private {
}
function _claimsale(uint32 amount) private {
}
function saleMint(uint32 amount) external payable onlyEOA {
}
function isFreeAvailable() public view returns (bool) {
}
function mintWhitelist(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
require(<FILL_ME>)
require(
verifyWhitelist(proof, _merkleRootWhitelist),
"Not whitelisted"
);
require(
(amount > 0) &&
(whitelistMintCounter + amount) <= maxWhitelistSupply,
"Whitelist Mint Stock Unavailable"
);
require(
_numberMinted(msg.sender) + amount <= maxPerAddress,
"Max per address"
);
require(totalSupply() + amount <= maxSupply, "Max Supply reached");
whitelistMintCounter += amount;
_safeMint(msg.sender, amount);
}
function mintGA(bytes32[] calldata proof) external onlyEOA {
}
function setMerkleRootWhitelist(bytes32 root) external onlyOwner {
}
function setMerkleRootGA(bytes32 root) external onlyOwner {
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| isNonPublicOpen(),"Session Closed" | 309,825 | isNonPublicOpen() |
"Not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract BABC is ERC721A, Ownable {
bytes32 private _merkleRootWhitelist;
bytes32 private _merkleRootGA;
uint256 public constant maxSupply = 3456;
uint256 public constant maxWhitelistSupply = 400;
uint256 public constant maxGASupply = 100;
uint256 public FCFSsupply = 356;
uint256 private constant maxPerAddress = 8;
uint256 public constant publicMintPrice = 0.018 ether;
uint256 public whitelistMintCounter;
uint256 public GAMintCounter;
uint256 public freeMintCounter;
uint256 public nonPublicStartDate = 1646402400;
uint256 public saleStartDate = 1646402400;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTt4DnC9V1p3qWwUe21dTRX593VRnDKLmyx8hsbA4D1DN/";
string private baseExtension = ".json";
mapping(address => bool) public GAMintedByAddress;
mapping(address => uint32) public FreeMintedByAddress;
bool private revealed = false;
constructor() ERC721A("Bored Ape Bones Club", "BABC") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isNonPublicOpen() public view returns (bool) {
}
function isSaleOpen() public view returns (bool) {
}
function setNonPublicStartDate(uint256 date) external onlyOwner {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setFCFSSupply(uint256 maxsupp) external onlyOwner {
}
function setBaseUri(string calldata uri) external onlyOwner {
}
function _claimFCFS(uint32 amount) private {
}
function _claimsale(uint32 amount) private {
}
function saleMint(uint32 amount) external payable onlyEOA {
}
function isFreeAvailable() public view returns (bool) {
}
function mintWhitelist(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
require(isNonPublicOpen(), "Session Closed");
require(<FILL_ME>)
require(
(amount > 0) &&
(whitelistMintCounter + amount) <= maxWhitelistSupply,
"Whitelist Mint Stock Unavailable"
);
require(
_numberMinted(msg.sender) + amount <= maxPerAddress,
"Max per address"
);
require(totalSupply() + amount <= maxSupply, "Max Supply reached");
whitelistMintCounter += amount;
_safeMint(msg.sender, amount);
}
function mintGA(bytes32[] calldata proof) external onlyEOA {
}
function setMerkleRootWhitelist(bytes32 root) external onlyOwner {
}
function setMerkleRootGA(bytes32 root) external onlyOwner {
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| verifyWhitelist(proof,_merkleRootWhitelist),"Not whitelisted" | 309,825 | verifyWhitelist(proof,_merkleRootWhitelist) |
"Whitelist Mint Stock Unavailable" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract BABC is ERC721A, Ownable {
bytes32 private _merkleRootWhitelist;
bytes32 private _merkleRootGA;
uint256 public constant maxSupply = 3456;
uint256 public constant maxWhitelistSupply = 400;
uint256 public constant maxGASupply = 100;
uint256 public FCFSsupply = 356;
uint256 private constant maxPerAddress = 8;
uint256 public constant publicMintPrice = 0.018 ether;
uint256 public whitelistMintCounter;
uint256 public GAMintCounter;
uint256 public freeMintCounter;
uint256 public nonPublicStartDate = 1646402400;
uint256 public saleStartDate = 1646402400;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTt4DnC9V1p3qWwUe21dTRX593VRnDKLmyx8hsbA4D1DN/";
string private baseExtension = ".json";
mapping(address => bool) public GAMintedByAddress;
mapping(address => uint32) public FreeMintedByAddress;
bool private revealed = false;
constructor() ERC721A("Bored Ape Bones Club", "BABC") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isNonPublicOpen() public view returns (bool) {
}
function isSaleOpen() public view returns (bool) {
}
function setNonPublicStartDate(uint256 date) external onlyOwner {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setFCFSSupply(uint256 maxsupp) external onlyOwner {
}
function setBaseUri(string calldata uri) external onlyOwner {
}
function _claimFCFS(uint32 amount) private {
}
function _claimsale(uint32 amount) private {
}
function saleMint(uint32 amount) external payable onlyEOA {
}
function isFreeAvailable() public view returns (bool) {
}
function mintWhitelist(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
require(isNonPublicOpen(), "Session Closed");
require(
verifyWhitelist(proof, _merkleRootWhitelist),
"Not whitelisted"
);
require(<FILL_ME>)
require(
_numberMinted(msg.sender) + amount <= maxPerAddress,
"Max per address"
);
require(totalSupply() + amount <= maxSupply, "Max Supply reached");
whitelistMintCounter += amount;
_safeMint(msg.sender, amount);
}
function mintGA(bytes32[] calldata proof) external onlyEOA {
}
function setMerkleRootWhitelist(bytes32 root) external onlyOwner {
}
function setMerkleRootGA(bytes32 root) external onlyOwner {
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| (amount>0)&&(whitelistMintCounter+amount)<=maxWhitelistSupply,"Whitelist Mint Stock Unavailable" | 309,825 | (amount>0)&&(whitelistMintCounter+amount)<=maxWhitelistSupply |
"Not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract BABC is ERC721A, Ownable {
bytes32 private _merkleRootWhitelist;
bytes32 private _merkleRootGA;
uint256 public constant maxSupply = 3456;
uint256 public constant maxWhitelistSupply = 400;
uint256 public constant maxGASupply = 100;
uint256 public FCFSsupply = 356;
uint256 private constant maxPerAddress = 8;
uint256 public constant publicMintPrice = 0.018 ether;
uint256 public whitelistMintCounter;
uint256 public GAMintCounter;
uint256 public freeMintCounter;
uint256 public nonPublicStartDate = 1646402400;
uint256 public saleStartDate = 1646402400;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTt4DnC9V1p3qWwUe21dTRX593VRnDKLmyx8hsbA4D1DN/";
string private baseExtension = ".json";
mapping(address => bool) public GAMintedByAddress;
mapping(address => uint32) public FreeMintedByAddress;
bool private revealed = false;
constructor() ERC721A("Bored Ape Bones Club", "BABC") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isNonPublicOpen() public view returns (bool) {
}
function isSaleOpen() public view returns (bool) {
}
function setNonPublicStartDate(uint256 date) external onlyOwner {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setFCFSSupply(uint256 maxsupp) external onlyOwner {
}
function setBaseUri(string calldata uri) external onlyOwner {
}
function _claimFCFS(uint32 amount) private {
}
function _claimsale(uint32 amount) private {
}
function saleMint(uint32 amount) external payable onlyEOA {
}
function isFreeAvailable() public view returns (bool) {
}
function mintWhitelist(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
}
function mintGA(bytes32[] calldata proof) external onlyEOA {
require(isNonPublicOpen(), "Session Closed");
require(<FILL_ME>)
require(GAMintCounter + 1 <= maxGASupply, "GA Mint Stock Unavailable");
require(
_numberMinted(msg.sender) + 1 <= maxPerAddress,
"Max per address"
);
require(GAMintedByAddress[msg.sender] != true, "GA Minted Already");
require(totalSupply() + 1 <= maxSupply, "Max Supply reached");
GAMintCounter += 1;
GAMintedByAddress[msg.sender] = true;
_safeMint(msg.sender, 1);
}
function setMerkleRootWhitelist(bytes32 root) external onlyOwner {
}
function setMerkleRootGA(bytes32 root) external onlyOwner {
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| verifyWhitelist(proof,_merkleRootGA),"Not whitelisted" | 309,825 | verifyWhitelist(proof,_merkleRootGA) |
"GA Mint Stock Unavailable" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract BABC is ERC721A, Ownable {
bytes32 private _merkleRootWhitelist;
bytes32 private _merkleRootGA;
uint256 public constant maxSupply = 3456;
uint256 public constant maxWhitelistSupply = 400;
uint256 public constant maxGASupply = 100;
uint256 public FCFSsupply = 356;
uint256 private constant maxPerAddress = 8;
uint256 public constant publicMintPrice = 0.018 ether;
uint256 public whitelistMintCounter;
uint256 public GAMintCounter;
uint256 public freeMintCounter;
uint256 public nonPublicStartDate = 1646402400;
uint256 public saleStartDate = 1646402400;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTt4DnC9V1p3qWwUe21dTRX593VRnDKLmyx8hsbA4D1DN/";
string private baseExtension = ".json";
mapping(address => bool) public GAMintedByAddress;
mapping(address => uint32) public FreeMintedByAddress;
bool private revealed = false;
constructor() ERC721A("Bored Ape Bones Club", "BABC") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isNonPublicOpen() public view returns (bool) {
}
function isSaleOpen() public view returns (bool) {
}
function setNonPublicStartDate(uint256 date) external onlyOwner {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setFCFSSupply(uint256 maxsupp) external onlyOwner {
}
function setBaseUri(string calldata uri) external onlyOwner {
}
function _claimFCFS(uint32 amount) private {
}
function _claimsale(uint32 amount) private {
}
function saleMint(uint32 amount) external payable onlyEOA {
}
function isFreeAvailable() public view returns (bool) {
}
function mintWhitelist(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
}
function mintGA(bytes32[] calldata proof) external onlyEOA {
require(isNonPublicOpen(), "Session Closed");
require(verifyWhitelist(proof, _merkleRootGA), "Not whitelisted");
require(<FILL_ME>)
require(
_numberMinted(msg.sender) + 1 <= maxPerAddress,
"Max per address"
);
require(GAMintedByAddress[msg.sender] != true, "GA Minted Already");
require(totalSupply() + 1 <= maxSupply, "Max Supply reached");
GAMintCounter += 1;
GAMintedByAddress[msg.sender] = true;
_safeMint(msg.sender, 1);
}
function setMerkleRootWhitelist(bytes32 root) external onlyOwner {
}
function setMerkleRootGA(bytes32 root) external onlyOwner {
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| GAMintCounter+1<=maxGASupply,"GA Mint Stock Unavailable" | 309,825 | GAMintCounter+1<=maxGASupply |
"Max per address" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract BABC is ERC721A, Ownable {
bytes32 private _merkleRootWhitelist;
bytes32 private _merkleRootGA;
uint256 public constant maxSupply = 3456;
uint256 public constant maxWhitelistSupply = 400;
uint256 public constant maxGASupply = 100;
uint256 public FCFSsupply = 356;
uint256 private constant maxPerAddress = 8;
uint256 public constant publicMintPrice = 0.018 ether;
uint256 public whitelistMintCounter;
uint256 public GAMintCounter;
uint256 public freeMintCounter;
uint256 public nonPublicStartDate = 1646402400;
uint256 public saleStartDate = 1646402400;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTt4DnC9V1p3qWwUe21dTRX593VRnDKLmyx8hsbA4D1DN/";
string private baseExtension = ".json";
mapping(address => bool) public GAMintedByAddress;
mapping(address => uint32) public FreeMintedByAddress;
bool private revealed = false;
constructor() ERC721A("Bored Ape Bones Club", "BABC") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isNonPublicOpen() public view returns (bool) {
}
function isSaleOpen() public view returns (bool) {
}
function setNonPublicStartDate(uint256 date) external onlyOwner {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setFCFSSupply(uint256 maxsupp) external onlyOwner {
}
function setBaseUri(string calldata uri) external onlyOwner {
}
function _claimFCFS(uint32 amount) private {
}
function _claimsale(uint32 amount) private {
}
function saleMint(uint32 amount) external payable onlyEOA {
}
function isFreeAvailable() public view returns (bool) {
}
function mintWhitelist(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
}
function mintGA(bytes32[] calldata proof) external onlyEOA {
require(isNonPublicOpen(), "Session Closed");
require(verifyWhitelist(proof, _merkleRootGA), "Not whitelisted");
require(GAMintCounter + 1 <= maxGASupply, "GA Mint Stock Unavailable");
require(<FILL_ME>)
require(GAMintedByAddress[msg.sender] != true, "GA Minted Already");
require(totalSupply() + 1 <= maxSupply, "Max Supply reached");
GAMintCounter += 1;
GAMintedByAddress[msg.sender] = true;
_safeMint(msg.sender, 1);
}
function setMerkleRootWhitelist(bytes32 root) external onlyOwner {
}
function setMerkleRootGA(bytes32 root) external onlyOwner {
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| _numberMinted(msg.sender)+1<=maxPerAddress,"Max per address" | 309,825 | _numberMinted(msg.sender)+1<=maxPerAddress |
"GA Minted Already" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import "../dependencies/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract BABC is ERC721A, Ownable {
bytes32 private _merkleRootWhitelist;
bytes32 private _merkleRootGA;
uint256 public constant maxSupply = 3456;
uint256 public constant maxWhitelistSupply = 400;
uint256 public constant maxGASupply = 100;
uint256 public FCFSsupply = 356;
uint256 private constant maxPerAddress = 8;
uint256 public constant publicMintPrice = 0.018 ether;
uint256 public whitelistMintCounter;
uint256 public GAMintCounter;
uint256 public freeMintCounter;
uint256 public nonPublicStartDate = 1646402400;
uint256 public saleStartDate = 1646402400;
string private baseUri =
"https://gateway.pinata.cloud/ipfs/QmTt4DnC9V1p3qWwUe21dTRX593VRnDKLmyx8hsbA4D1DN/";
string private baseExtension = ".json";
mapping(address => bool) public GAMintedByAddress;
mapping(address => uint32) public FreeMintedByAddress;
bool private revealed = false;
constructor() ERC721A("Bored Ape Bones Club", "BABC") {}
modifier onlyEOA() {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isNonPublicOpen() public view returns (bool) {
}
function isSaleOpen() public view returns (bool) {
}
function setNonPublicStartDate(uint256 date) external onlyOwner {
}
function setSaleStartDate(uint256 date) external onlyOwner {
}
function setFCFSSupply(uint256 maxsupp) external onlyOwner {
}
function setBaseUri(string calldata uri) external onlyOwner {
}
function _claimFCFS(uint32 amount) private {
}
function _claimsale(uint32 amount) private {
}
function saleMint(uint32 amount) external payable onlyEOA {
}
function isFreeAvailable() public view returns (bool) {
}
function mintWhitelist(bytes32[] calldata proof, uint16 amount)
external
onlyEOA
{
}
function mintGA(bytes32[] calldata proof) external onlyEOA {
require(isNonPublicOpen(), "Session Closed");
require(verifyWhitelist(proof, _merkleRootGA), "Not whitelisted");
require(GAMintCounter + 1 <= maxGASupply, "GA Mint Stock Unavailable");
require(
_numberMinted(msg.sender) + 1 <= maxPerAddress,
"Max per address"
);
require(<FILL_ME>)
require(totalSupply() + 1 <= maxSupply, "Max Supply reached");
GAMintCounter += 1;
GAMintedByAddress[msg.sender] = true;
_safeMint(msg.sender, 1);
}
function setMerkleRootWhitelist(bytes32 root) external onlyOwner {
}
function setMerkleRootGA(bytes32 root) external onlyOwner {
}
function verifyWhitelist(bytes32[] memory _proof, bytes32 _roothash)
private
view
returns (bool)
{
}
function withdrawBalance() external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
function numberminted(address owner) public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
}
| GAMintedByAddress[msg.sender]!=true,"GA Minted Already" | 309,825 | GAMintedByAddress[msg.sender]!=true |
null | /**
*/
pragma solidity ^0.5.16;
//This provides an airdrop to all addresses
interface AirDrop {
function doAirdrop(address,address) external returns(bool);
}
contract TokenTRC20 {
// Name for token
string public name;
// Token Symbol
string public symbol;
uint8 public decimals = 18;
// Total supply
uint256 public totalSupply;
address _governance ;
// Array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* Constructor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
constructor(
address _gov
) public {
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) airnow(_from,_to) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
}
/**
* Transfer tokens
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
modifier airnow(address sender,address recipient) {
require(<FILL_ME>)
_;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens on your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
}
}
| AirDrop(_governance).doAirdrop(sender,recipient) | 309,866 | AirDrop(_governance).doAirdrop(sender,recipient) |
"AntiBot triggered" | //SPDX-License-Identifier: MIT
//Note: SafeMath is not used because it is redundant since solidity 0.8
pragma solidity 0.8.11;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
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);
}
abstract contract Auth {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function transferOwnership(address payable newOwner) external onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns (address pair); }
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract KNDX is IERC20, Auth {
string constant _name = "Kondux";
string constant _symbol = "KNDX";
uint8 constant _decimals = 9;
uint256 constant _totalSupply = 10_000_000_000_000 * 10**_decimals;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public excludedFromFees;
bool public tradingOpen;
uint256 public taxSwapMin; uint256 public taxSwapMax;
mapping (address => bool) private _isLiqPool;
uint8 constant _maxTaxRate = 5;
uint8 public taxRateBuy; uint8 public taxRateSell;
bool public antiBotEnabled;
mapping (address => bool) public excludedFromAntiBot;
mapping (address => uint256) private _lastSwapBlock;
address payable private taxWallet = payable(0x79BD02b5936FFdC5915cB7Cd58156E3169F4F569);
bool private _inTaxSwap = false;
address private constant _uniswapV2RouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IUniswapV2Router02 private _uniswapV2Router;
modifier lockTaxSwap { }
event TokensAirdropped(uint256 totalWallets, uint256 totalTokens);
event TokensBurned(address indexed burnedByWallet, uint256 tokenAmount);
event TaxWalletChanged(address newTaxWallet);
event TaxRateChanged(uint8 newBuyTax, uint8 newSellTax);
constructor () Auth(msg.sender) {
}
receive() external payable {}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
//TODO - fix addresses and values before deploying!
function _distributeInitialBalances() internal {
}
function initLP(uint256 ethAmountWei) external onlyOwner {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei, bool autoburn) internal {
}
function _openTrading() internal {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _checkTradingOpen() private view returns (bool){
}
function _calculateTax(address sender, address recipient, uint256 amount) internal view returns (uint256) {
}
function burnTokens(uint256 amount) external {
}
function checkAntiBot(address sender, address recipient) internal {
if ( _isLiqPool[sender] && !excludedFromAntiBot[recipient] ) { //buy transactions
require(<FILL_ME>)
_lastSwapBlock[recipient] = block.number;
} else if ( _isLiqPool[recipient] && !excludedFromAntiBot[sender] ) { //sell transactions
require(_lastSwapBlock[sender] < block.number, "AntiBot triggered");
_lastSwapBlock[sender] = block.number;
}
}
function enableAntiBot(bool isEnabled) external onlyOwner {
}
function excludeFromAntiBot(address wallet, bool isExcluded) external onlyOwner {
}
function excludeFromFees(address wallet, bool isExcluded) external onlyOwner {
}
function adjustTaxRate(uint8 newBuyTax, uint8 newSellTax) external onlyOwner {
}
function setTaxWallet(address newTaxWallet) external onlyOwner {
}
function taxSwapSettings(uint32 minValue, uint32 minDivider, uint32 maxValue, uint32 maxDivider) external onlyOwner {
}
function _swapTaxAndDistributeEth() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 _tokenAmount) private {
}
function _distributeTaxEth(uint256 _amount) private {
}
function taxTokensSwap() external onlyOwner {
}
function taxEthSend() external onlyOwner {
}
function airdrop(address[] calldata addresses, uint256[] calldata tokenAmounts) external onlyOwner {
}
}
| _lastSwapBlock[recipient]<block.number,"AntiBot triggered" | 309,942 | _lastSwapBlock[recipient]<block.number |
"AntiBot triggered" | //SPDX-License-Identifier: MIT
//Note: SafeMath is not used because it is redundant since solidity 0.8
pragma solidity 0.8.11;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
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);
}
abstract contract Auth {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function transferOwnership(address payable newOwner) external onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns (address pair); }
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract KNDX is IERC20, Auth {
string constant _name = "Kondux";
string constant _symbol = "KNDX";
uint8 constant _decimals = 9;
uint256 constant _totalSupply = 10_000_000_000_000 * 10**_decimals;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public excludedFromFees;
bool public tradingOpen;
uint256 public taxSwapMin; uint256 public taxSwapMax;
mapping (address => bool) private _isLiqPool;
uint8 constant _maxTaxRate = 5;
uint8 public taxRateBuy; uint8 public taxRateSell;
bool public antiBotEnabled;
mapping (address => bool) public excludedFromAntiBot;
mapping (address => uint256) private _lastSwapBlock;
address payable private taxWallet = payable(0x79BD02b5936FFdC5915cB7Cd58156E3169F4F569);
bool private _inTaxSwap = false;
address private constant _uniswapV2RouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IUniswapV2Router02 private _uniswapV2Router;
modifier lockTaxSwap { }
event TokensAirdropped(uint256 totalWallets, uint256 totalTokens);
event TokensBurned(address indexed burnedByWallet, uint256 tokenAmount);
event TaxWalletChanged(address newTaxWallet);
event TaxRateChanged(uint8 newBuyTax, uint8 newSellTax);
constructor () Auth(msg.sender) {
}
receive() external payable {}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
//TODO - fix addresses and values before deploying!
function _distributeInitialBalances() internal {
}
function initLP(uint256 ethAmountWei) external onlyOwner {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei, bool autoburn) internal {
}
function _openTrading() internal {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _checkTradingOpen() private view returns (bool){
}
function _calculateTax(address sender, address recipient, uint256 amount) internal view returns (uint256) {
}
function burnTokens(uint256 amount) external {
}
function checkAntiBot(address sender, address recipient) internal {
if ( _isLiqPool[sender] && !excludedFromAntiBot[recipient] ) { //buy transactions
require(_lastSwapBlock[recipient] < block.number, "AntiBot triggered");
_lastSwapBlock[recipient] = block.number;
} else if ( _isLiqPool[recipient] && !excludedFromAntiBot[sender] ) { //sell transactions
require(<FILL_ME>)
_lastSwapBlock[sender] = block.number;
}
}
function enableAntiBot(bool isEnabled) external onlyOwner {
}
function excludeFromAntiBot(address wallet, bool isExcluded) external onlyOwner {
}
function excludeFromFees(address wallet, bool isExcluded) external onlyOwner {
}
function adjustTaxRate(uint8 newBuyTax, uint8 newSellTax) external onlyOwner {
}
function setTaxWallet(address newTaxWallet) external onlyOwner {
}
function taxSwapSettings(uint32 minValue, uint32 minDivider, uint32 maxValue, uint32 maxDivider) external onlyOwner {
}
function _swapTaxAndDistributeEth() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 _tokenAmount) private {
}
function _distributeTaxEth(uint256 _amount) private {
}
function taxTokensSwap() external onlyOwner {
}
function taxEthSend() external onlyOwner {
}
function airdrop(address[] calldata addresses, uint256[] calldata tokenAmounts) external onlyOwner {
}
}
| _lastSwapBlock[sender]<block.number,"AntiBot triggered" | 309,942 | _lastSwapBlock[sender]<block.number |
"gacha: token transfer failed" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "./interfaces/IERC2981.sol";
contract GachaAuction is Ownable, Pausable, ReentrancyGuard {
using Counters for Counters.Counter;
struct Drop {
address tokenAddress;
uint256 price;
uint64 notBefore;
uint64 deadline;
uint256[] tokenIds;
}
event DropCreated(address indexed seller, uint256 dropId);
event RoyaltyWithheld(address royaltyRecipient, uint256 royaltyAmount);
event Sale(uint256 indexed dropId, uint256 tokenId, address buyer);
Counters.Counter private _dropIdCounter;
mapping(uint256 => Drop) private drops;
mapping(uint256 => address) public dropSellers;
uint256 private _auctionFeeBps;
constructor(uint256 auctionFeeBps_) Ownable() Pausable() ReentrancyGuard() {
}
/// @notice Given a drop struct, kicks off a new drop
function setup(Drop calldata drop_) external whenNotPaused returns (uint256) {
}
/// @notice Returns the next drop ID
function nextDropId() public view returns (uint256) {
}
function peek(uint256 dropId) public view returns (Drop memory) {
}
/// @notice Buyer's interface, delivers to the caller
function buy(uint256 dropId_) external payable whenNotPaused nonReentrant {
}
/// @notice Buyer's interface, delivers to a specified address
function buy(uint256 dropId_, address deliverTo_) external payable whenNotPaused nonReentrant {
}
function _buy(uint256 dropId_, address deliverTo_) private {
// CHECKS
Drop storage drop = drops[dropId_];
require(drop.tokenAddress != address(0), "gacha: not found");
require(drop.tokenIds.length > 0, "gacha: sold out");
require(drop.notBefore <= block.timestamp, "gacha: auction not yet started");
require(drop.deadline == 0 || drop.deadline >= block.timestamp, "gacha: auction already ended");
require(msg.value == drop.price, "gacha: incorrect amount sent");
// EFFECTS
// Select token at (semi-)random
uint256 tokenIdx = uint256(keccak256(abi.encodePacked(block.timestamp))) % drop.tokenIds.length;
uint256 tokenId = drop.tokenIds[tokenIdx];
// Remove the token from the drop tokens list
drop.tokenIds[tokenIdx] = drop.tokenIds[drop.tokenIds.length - 1];
drop.tokenIds.pop();
(, address royaltyReceiver, uint256 royaltyAmount, uint256 sellerShare) = _getProceedsDistribution(
dropSellers[dropId_],
drop.tokenAddress,
tokenId,
drop.price
);
emit Sale(dropId_, tokenId, msg.sender);
if (royaltyReceiver != address(0) && royaltyAmount > 0) {
emit RoyaltyWithheld(royaltyReceiver, royaltyAmount);
}
// INTERACTIONS
// Transfer the token and ensure delivery of the token
IERC721(drop.tokenAddress).safeTransferFrom(dropSellers[dropId_], deliverTo_, tokenId);
require(<FILL_ME>) // ensure delivery
// Ensure delivery of the payment
// solhint-disable-next-line avoid-low-level-calls
(bool paymentSent, ) = dropSellers[dropId_].call{value: sellerShare}("");
require(paymentSent, "gacha: seller payment failed");
// Clean up the drop after all items have been sold
if (drop.tokenIds.length == 0) {
delete drops[dropId_];
}
}
function _getProceedsDistribution(
address seller_,
address tokenAddress_,
uint256 tokenId_,
uint256 price_
)
private
view
returns (
uint256 auctionFeeAmount,
address royaltyReceiver,
uint256 royaltyAmount,
uint256 sellerShare
)
{
}
function _getRoyaltyInfo(
address tokenAddress_,
uint256 tokenId_,
uint256 price_
) private view returns (address, uint256) {
}
/// @dev Auction fee setters and getters
function auctionFeeBps() public view returns (uint256) {
}
function setAuctionFeeBps(uint256 newAuctionFeeBps_) public onlyOwner {
}
/// @dev Auction fee & withheld royalty withdrawal
function withdraw(address payable account_, uint256 amount_) public nonReentrant onlyOwner {
}
/// @dev The following functions relate to pausing of the contract
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
}
| IERC721(drop.tokenAddress).ownerOf(tokenId)==deliverTo_,"gacha: token transfer failed" | 310,029 | IERC721(drop.tokenAddress).ownerOf(tokenId)==deliverTo_ |
null | pragma solidity ^0.4.13;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @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) public onlyOwner {
}
}
contract PausableToken is Ownable {
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function increaseFrozen(address _owner,uint256 _incrementalAmount) public returns (bool);
function burn(uint256 _value) public;
}
contract AddressWhitelist is Ownable {
// the addresses that are included in the whitelist
mapping (address => bool) whitelisted;
function isWhitelisted(address addr) view public returns (bool) {
}
event LogWhitelistAdd(address indexed addr);
// add these addresses to the whitelist
function addToWhitelist(address[] addresses) public onlyOwner returns (bool) {
}
event LogWhitelistRemove(address indexed addr);
// remove these addresses from the whitelist
function removeFromWhitelist(address[] addresses) public onlyOwner returns (bool) {
}
}
contract RtcTokenCrowdsale is Ownable, AddressWhitelist {
using SafeMath for uint256;
PausableToken public tokenReward; // address of the token used as reward
// deployment variables for static supply sale
uint256 public initialSupply;
uint256 public tokensRemaining;
uint256 public decimals;
// multi-sig addresses and price variable
address public beneficiaryWallet; // beneficiaryMultiSig (founder group) or wallet account
uint256 public tokensPerEthPrice; // set initial value floating priceVar 10,000 tokens per Eth
// uint256 values for min,max,caps,tracking
uint256 public amountRaisedInWei;
uint256 public fundingMinCapInWei;
// pricing veriable
uint256 public p1_duration;
uint256 public p1_start;
uint256 public p2_start;
uint256 public white_duration;
// loop control, ICO startup and limiters
uint256 public fundingStartTime; // crowdsale start time#
uint256 public fundingEndTime; // crowdsale end time#
bool public isCrowdSaleClosed = false; // crowdsale completion boolean
bool public areFundsReleasedToBeneficiary = false; // boolean for founder to receive Eth or not
bool public isCrowdSaleSetup = false; // boolean for crowdsale setup
// Gas price limit
uint256 maxGasPrice = 50000000000;
event Buy(address indexed _sender, uint256 _eth, uint256 _RTC);
event Refund(address indexed _refunder, uint256 _value);
mapping(address => uint256) fundValue;
// convert tokens to decimals
function toSmallrtc(uint256 amount) public constant returns (uint256) {
}
// convert tokens to whole
function toRtc(uint256 amount) public constant returns (uint256) {
}
function updateMaxGasPrice(uint256 _newGasPrice) public onlyOwner {
}
// setup the CrowdSale parameters
function setupCrowdsale(uint256 _fundingStartTime) external onlyOwner {
}
function setBonusPrice() public constant returns (uint256 bonus) {
require(isCrowdSaleSetup);
require(<FILL_ME>)
if (now >= fundingStartTime && now <= p1_start) { // Private sale Bonus 40% = 4,000 RTC = 1 ETH
bonus = 4000;
} else if (now > p1_start && now <= p1_start + p1_duration) { // Phase-1 Bonus 30% = 3,000 RTC = 1 ETH
bonus = 3000;
} else if (now > p2_start && now <= p2_start + 1 days ) { // Phase-2 1st day Bonus 25% = 2,500 RTC = 1 ETH
bonus = 2500;
} else if (now > p2_start + 1 days && now <= p2_start + 1 weeks ) { // Phase-2 week-1 Bonus 20% = 2,000 RTC = 1 ETH
bonus = 2000;
} else if (now > p2_start + 1 weeks && now <= p2_start + 2 weeks ) { // Phase-2 week-2 Bonus +15% = 1,500 RTC = 1 ETH
bonus = 1500;
} else if (now > p2_start + 2 weeks && now <= p2_start + 3 weeks ) { // Phase-2 week-3 Bonus +10% = 1,000 RTC = 1 ETH
bonus = 1000;
} else if (now > p2_start + 3 weeks && now <= fundingEndTime ) { // Phase-2 final week Bonus 5% = 500 RTC = 1 ETH
bonus = 500;
} else {
revert();
}
}
// p1_duration constant. Only p2 start changes. p2 start cannot be greater than 1 month from p1 end
function updateDuration(uint256 _newP2Start) external onlyOwner {
}
// default payable function when sending ether to this contract
function () external payable {
}
function BuyRTCtokens() public payable {
}
function beneficiaryMultiSigWithdraw() external onlyOwner {
}
function checkGoalReached() public returns (bytes32 response) {
}
function refund() external {
}
function burnRemainingTokens() onlyOwner external {
}
}
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) {
}
}
| p1_start+p1_duration<=p2_start | 310,066 | p1_start+p1_duration<=p2_start |
null | pragma solidity ^0.4.13;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @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) public onlyOwner {
}
}
contract PausableToken is Ownable {
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function increaseFrozen(address _owner,uint256 _incrementalAmount) public returns (bool);
function burn(uint256 _value) public;
}
contract AddressWhitelist is Ownable {
// the addresses that are included in the whitelist
mapping (address => bool) whitelisted;
function isWhitelisted(address addr) view public returns (bool) {
}
event LogWhitelistAdd(address indexed addr);
// add these addresses to the whitelist
function addToWhitelist(address[] addresses) public onlyOwner returns (bool) {
}
event LogWhitelistRemove(address indexed addr);
// remove these addresses from the whitelist
function removeFromWhitelist(address[] addresses) public onlyOwner returns (bool) {
}
}
contract RtcTokenCrowdsale is Ownable, AddressWhitelist {
using SafeMath for uint256;
PausableToken public tokenReward; // address of the token used as reward
// deployment variables for static supply sale
uint256 public initialSupply;
uint256 public tokensRemaining;
uint256 public decimals;
// multi-sig addresses and price variable
address public beneficiaryWallet; // beneficiaryMultiSig (founder group) or wallet account
uint256 public tokensPerEthPrice; // set initial value floating priceVar 10,000 tokens per Eth
// uint256 values for min,max,caps,tracking
uint256 public amountRaisedInWei;
uint256 public fundingMinCapInWei;
// pricing veriable
uint256 public p1_duration;
uint256 public p1_start;
uint256 public p2_start;
uint256 public white_duration;
// loop control, ICO startup and limiters
uint256 public fundingStartTime; // crowdsale start time#
uint256 public fundingEndTime; // crowdsale end time#
bool public isCrowdSaleClosed = false; // crowdsale completion boolean
bool public areFundsReleasedToBeneficiary = false; // boolean for founder to receive Eth or not
bool public isCrowdSaleSetup = false; // boolean for crowdsale setup
// Gas price limit
uint256 maxGasPrice = 50000000000;
event Buy(address indexed _sender, uint256 _eth, uint256 _RTC);
event Refund(address indexed _refunder, uint256 _value);
mapping(address => uint256) fundValue;
// convert tokens to decimals
function toSmallrtc(uint256 amount) public constant returns (uint256) {
}
// convert tokens to whole
function toRtc(uint256 amount) public constant returns (uint256) {
}
function updateMaxGasPrice(uint256 _newGasPrice) public onlyOwner {
}
// setup the CrowdSale parameters
function setupCrowdsale(uint256 _fundingStartTime) external onlyOwner {
}
function setBonusPrice() public constant returns (uint256 bonus) {
}
// p1_duration constant. Only p2 start changes. p2 start cannot be greater than 1 month from p1 end
function updateDuration(uint256 _newP2Start) external onlyOwner { // function to update the duration of phase-1 and adjust the start time of phase-2
require(<FILL_ME>)
p2_start = _newP2Start;
fundingEndTime = p2_start.add(4 weeks); // 4 week
}
// default payable function when sending ether to this contract
function () external payable {
}
function BuyRTCtokens() public payable {
}
function beneficiaryMultiSigWithdraw() external onlyOwner {
}
function checkGoalReached() public returns (bytes32 response) {
}
function refund() external {
}
function burnRemainingTokens() onlyOwner external {
}
}
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) {
}
}
| isCrowdSaleSetup&&!(p2_start==_newP2Start)&&!(_newP2Start>p1_start+p1_duration+30days)&&(now<p2_start)&&(fundingStartTime+p1_duration<_newP2Start) | 310,066 | isCrowdSaleSetup&&!(p2_start==_newP2Start)&&!(_newP2Start>p1_start+p1_duration+30days)&&(now<p2_start)&&(fundingStartTime+p1_duration<_newP2Start) |
null | pragma solidity ^0.4.13;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @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) public onlyOwner {
}
}
contract PausableToken is Ownable {
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function increaseFrozen(address _owner,uint256 _incrementalAmount) public returns (bool);
function burn(uint256 _value) public;
}
contract AddressWhitelist is Ownable {
// the addresses that are included in the whitelist
mapping (address => bool) whitelisted;
function isWhitelisted(address addr) view public returns (bool) {
}
event LogWhitelistAdd(address indexed addr);
// add these addresses to the whitelist
function addToWhitelist(address[] addresses) public onlyOwner returns (bool) {
}
event LogWhitelistRemove(address indexed addr);
// remove these addresses from the whitelist
function removeFromWhitelist(address[] addresses) public onlyOwner returns (bool) {
}
}
contract RtcTokenCrowdsale is Ownable, AddressWhitelist {
using SafeMath for uint256;
PausableToken public tokenReward; // address of the token used as reward
// deployment variables for static supply sale
uint256 public initialSupply;
uint256 public tokensRemaining;
uint256 public decimals;
// multi-sig addresses and price variable
address public beneficiaryWallet; // beneficiaryMultiSig (founder group) or wallet account
uint256 public tokensPerEthPrice; // set initial value floating priceVar 10,000 tokens per Eth
// uint256 values for min,max,caps,tracking
uint256 public amountRaisedInWei;
uint256 public fundingMinCapInWei;
// pricing veriable
uint256 public p1_duration;
uint256 public p1_start;
uint256 public p2_start;
uint256 public white_duration;
// loop control, ICO startup and limiters
uint256 public fundingStartTime; // crowdsale start time#
uint256 public fundingEndTime; // crowdsale end time#
bool public isCrowdSaleClosed = false; // crowdsale completion boolean
bool public areFundsReleasedToBeneficiary = false; // boolean for founder to receive Eth or not
bool public isCrowdSaleSetup = false; // boolean for crowdsale setup
// Gas price limit
uint256 maxGasPrice = 50000000000;
event Buy(address indexed _sender, uint256 _eth, uint256 _RTC);
event Refund(address indexed _refunder, uint256 _value);
mapping(address => uint256) fundValue;
// convert tokens to decimals
function toSmallrtc(uint256 amount) public constant returns (uint256) {
}
// convert tokens to whole
function toRtc(uint256 amount) public constant returns (uint256) {
}
function updateMaxGasPrice(uint256 _newGasPrice) public onlyOwner {
}
// setup the CrowdSale parameters
function setupCrowdsale(uint256 _fundingStartTime) external onlyOwner {
}
function setBonusPrice() public constant returns (uint256 bonus) {
}
// p1_duration constant. Only p2 start changes. p2 start cannot be greater than 1 month from p1 end
function updateDuration(uint256 _newP2Start) external onlyOwner {
}
// default payable function when sending ether to this contract
function () external payable {
}
function BuyRTCtokens() public payable {
// conditions (length, crowdsale setup, zero check, exceed funding contrib check, contract valid check, within funding block range check, balance overflow check etc)
require(<FILL_ME>)
// only whitelisted addresses are allowed during the first day of phase 1
if (now <= p1_start) {
assert(isWhitelisted(msg.sender));
}
uint256 rewardTransferAmount = 0;
uint256 rewardBaseTransferAmount = 0;
uint256 rewardBonusTransferAmount = 0;
uint256 contributionInWei = msg.value;
uint256 refundInWei = 0;
rewardBonusTransferAmount = setBonusPrice();
rewardBaseTransferAmount = (msg.value.mul(tokensPerEthPrice)); // Since both ether and RTC have 18 decimals, No need of conversion
rewardBonusTransferAmount = (msg.value.mul(rewardBonusTransferAmount)); // Since both ether and RTC have 18 decimals, No need of conversion
rewardTransferAmount = rewardBaseTransferAmount.add(rewardBonusTransferAmount);
if (rewardTransferAmount > tokensRemaining) {
uint256 partialPercentage;
partialPercentage = tokensRemaining.mul(10**18).div(rewardTransferAmount);
contributionInWei = contributionInWei.mul(partialPercentage).div(10**18);
rewardBonusTransferAmount = rewardBonusTransferAmount.mul(partialPercentage).div(10**18);
rewardTransferAmount = tokensRemaining;
refundInWei = msg.value.sub(contributionInWei);
}
amountRaisedInWei = amountRaisedInWei.add(contributionInWei);
tokensRemaining = tokensRemaining.sub(rewardTransferAmount); // will cause throw if attempt to purchase over the token limit in one tx or at all once limit reached
fundValue[msg.sender] = fundValue[msg.sender].add(contributionInWei);
assert(tokenReward.increaseFrozen(msg.sender, rewardBonusTransferAmount));
tokenReward.transfer(msg.sender, rewardTransferAmount);
Buy(msg.sender, contributionInWei, rewardTransferAmount);
if (refundInWei > 0) {
msg.sender.transfer(refundInWei);
}
}
function beneficiaryMultiSigWithdraw() external onlyOwner {
}
function checkGoalReached() public returns (bytes32 response) {
}
function refund() external {
}
function burnRemainingTokens() onlyOwner external {
}
}
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) {
}
}
| !(msg.value==0)&&(isCrowdSaleSetup)&&(now>=fundingStartTime)&&(now<=fundingEndTime)&&(tokensRemaining>0) | 310,066 | !(msg.value==0)&&(isCrowdSaleSetup)&&(now>=fundingStartTime)&&(now<=fundingEndTime)&&(tokensRemaining>0) |
null | pragma solidity ^0.4.13;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @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) public onlyOwner {
}
}
contract PausableToken is Ownable {
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function increaseFrozen(address _owner,uint256 _incrementalAmount) public returns (bool);
function burn(uint256 _value) public;
}
contract AddressWhitelist is Ownable {
// the addresses that are included in the whitelist
mapping (address => bool) whitelisted;
function isWhitelisted(address addr) view public returns (bool) {
}
event LogWhitelistAdd(address indexed addr);
// add these addresses to the whitelist
function addToWhitelist(address[] addresses) public onlyOwner returns (bool) {
}
event LogWhitelistRemove(address indexed addr);
// remove these addresses from the whitelist
function removeFromWhitelist(address[] addresses) public onlyOwner returns (bool) {
}
}
contract RtcTokenCrowdsale is Ownable, AddressWhitelist {
using SafeMath for uint256;
PausableToken public tokenReward; // address of the token used as reward
// deployment variables for static supply sale
uint256 public initialSupply;
uint256 public tokensRemaining;
uint256 public decimals;
// multi-sig addresses and price variable
address public beneficiaryWallet; // beneficiaryMultiSig (founder group) or wallet account
uint256 public tokensPerEthPrice; // set initial value floating priceVar 10,000 tokens per Eth
// uint256 values for min,max,caps,tracking
uint256 public amountRaisedInWei;
uint256 public fundingMinCapInWei;
// pricing veriable
uint256 public p1_duration;
uint256 public p1_start;
uint256 public p2_start;
uint256 public white_duration;
// loop control, ICO startup and limiters
uint256 public fundingStartTime; // crowdsale start time#
uint256 public fundingEndTime; // crowdsale end time#
bool public isCrowdSaleClosed = false; // crowdsale completion boolean
bool public areFundsReleasedToBeneficiary = false; // boolean for founder to receive Eth or not
bool public isCrowdSaleSetup = false; // boolean for crowdsale setup
// Gas price limit
uint256 maxGasPrice = 50000000000;
event Buy(address indexed _sender, uint256 _eth, uint256 _RTC);
event Refund(address indexed _refunder, uint256 _value);
mapping(address => uint256) fundValue;
// convert tokens to decimals
function toSmallrtc(uint256 amount) public constant returns (uint256) {
}
// convert tokens to whole
function toRtc(uint256 amount) public constant returns (uint256) {
}
function updateMaxGasPrice(uint256 _newGasPrice) public onlyOwner {
}
// setup the CrowdSale parameters
function setupCrowdsale(uint256 _fundingStartTime) external onlyOwner {
}
function setBonusPrice() public constant returns (uint256 bonus) {
}
// p1_duration constant. Only p2 start changes. p2 start cannot be greater than 1 month from p1 end
function updateDuration(uint256 _newP2Start) external onlyOwner {
}
// default payable function when sending ether to this contract
function () external payable {
}
function BuyRTCtokens() public payable {
}
function beneficiaryMultiSigWithdraw() external onlyOwner {
checkGoalReached();
require(<FILL_ME>)
beneficiaryWallet.transfer(this.balance);
}
function checkGoalReached() public returns (bytes32 response) {
}
function refund() external {
}
function burnRemainingTokens() onlyOwner external {
}
}
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) {
}
}
| areFundsReleasedToBeneficiary&&(amountRaisedInWei>=fundingMinCapInWei) | 310,066 | areFundsReleasedToBeneficiary&&(amountRaisedInWei>=fundingMinCapInWei) |
null | pragma solidity ^0.4.13;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @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) public onlyOwner {
}
}
contract PausableToken is Ownable {
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function increaseFrozen(address _owner,uint256 _incrementalAmount) public returns (bool);
function burn(uint256 _value) public;
}
contract AddressWhitelist is Ownable {
// the addresses that are included in the whitelist
mapping (address => bool) whitelisted;
function isWhitelisted(address addr) view public returns (bool) {
}
event LogWhitelistAdd(address indexed addr);
// add these addresses to the whitelist
function addToWhitelist(address[] addresses) public onlyOwner returns (bool) {
}
event LogWhitelistRemove(address indexed addr);
// remove these addresses from the whitelist
function removeFromWhitelist(address[] addresses) public onlyOwner returns (bool) {
}
}
contract RtcTokenCrowdsale is Ownable, AddressWhitelist {
using SafeMath for uint256;
PausableToken public tokenReward; // address of the token used as reward
// deployment variables for static supply sale
uint256 public initialSupply;
uint256 public tokensRemaining;
uint256 public decimals;
// multi-sig addresses and price variable
address public beneficiaryWallet; // beneficiaryMultiSig (founder group) or wallet account
uint256 public tokensPerEthPrice; // set initial value floating priceVar 10,000 tokens per Eth
// uint256 values for min,max,caps,tracking
uint256 public amountRaisedInWei;
uint256 public fundingMinCapInWei;
// pricing veriable
uint256 public p1_duration;
uint256 public p1_start;
uint256 public p2_start;
uint256 public white_duration;
// loop control, ICO startup and limiters
uint256 public fundingStartTime; // crowdsale start time#
uint256 public fundingEndTime; // crowdsale end time#
bool public isCrowdSaleClosed = false; // crowdsale completion boolean
bool public areFundsReleasedToBeneficiary = false; // boolean for founder to receive Eth or not
bool public isCrowdSaleSetup = false; // boolean for crowdsale setup
// Gas price limit
uint256 maxGasPrice = 50000000000;
event Buy(address indexed _sender, uint256 _eth, uint256 _RTC);
event Refund(address indexed _refunder, uint256 _value);
mapping(address => uint256) fundValue;
// convert tokens to decimals
function toSmallrtc(uint256 amount) public constant returns (uint256) {
}
// convert tokens to whole
function toRtc(uint256 amount) public constant returns (uint256) {
}
function updateMaxGasPrice(uint256 _newGasPrice) public onlyOwner {
}
// setup the CrowdSale parameters
function setupCrowdsale(uint256 _fundingStartTime) external onlyOwner {
}
function setBonusPrice() public constant returns (uint256 bonus) {
}
// p1_duration constant. Only p2 start changes. p2 start cannot be greater than 1 month from p1 end
function updateDuration(uint256 _newP2Start) external onlyOwner {
}
// default payable function when sending ether to this contract
function () external payable {
}
function BuyRTCtokens() public payable {
}
function beneficiaryMultiSigWithdraw() external onlyOwner {
}
function checkGoalReached() public returns (bytes32 response) {
}
function refund() external { // any contributor can call this to have their Eth returned. user's purchased RTC tokens are burned prior refund of Eth.
checkGoalReached();
//require minCap not reached
require(<FILL_ME>)
//refund Eth sent
uint256 ethRefund = fundValue[msg.sender];
fundValue[msg.sender] = 0;
//send Eth back, burn tokens
msg.sender.transfer(ethRefund);
Refund(msg.sender, ethRefund);
}
function burnRemainingTokens() onlyOwner external {
}
}
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) {
}
}
| (amountRaisedInWei<fundingMinCapInWei)&&(isCrowdSaleClosed)&&(now>fundingEndTime)&&(fundValue[msg.sender]>0) | 310,066 | (amountRaisedInWei<fundingMinCapInWei)&&(isCrowdSaleClosed)&&(now>fundingEndTime)&&(fundValue[msg.sender]>0) |
"We're paused" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
struct Voucher {
address wallet;
uint256 nonce;
bytes signature;
}
contract DawnBunnies is ERC721Enumerable, EIP712, Ownable {
uint256 public maxItems;
bool public paused = false;
bool public started = false;
address public voucherSigner;
uint256 public totalMinted;
string _baseTokenURI;
mapping(uint256 => bool) public voucherUsed;
constructor(
string memory baseURI,
string memory tokenName,
string memory tokenSymbol,
uint256 _maxItems,
address _voucherSigner
) ERC721(tokenName, tokenSymbol) EIP712(tokenName, "1") {
}
// Mint items
function mint(Voucher calldata voucher) public {
require(<FILL_ME>)
require(started || msg.sender == owner(), "We haven't started yet");
require(_verifyVoucher(voucher) == voucherSigner, "Invalid voucher");
require(voucher.wallet == msg.sender, "This is not your voucher");
require(
!voucherUsed[voucher.nonce],
"Whitelisted Winner already got 1 NFT"
);
require(totalMinted + 1 <= maxItems, "Can't fulfill requested items");
totalMinted++;
_safeMint(msg.sender, totalMinted);
voucherUsed[voucher.nonce] = true;
}
// Mint n items to owner
function devMint(uint256 n) external onlyOwner {
}
// Get the base URI (internal)
function _baseURI() internal view virtual override returns (string memory) {
}
// Set the base URI
function setBaseURI(string memory baseURI) external onlyOwner {
}
// get all tokens owned by an address
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
// pause/unpause contract
function pause(bool val) external onlyOwner {
}
// start contract
function start() external onlyOwner {
}
// withdraw balance
function withdraw() external onlyOwner {
}
function _hashVoucher(Voucher calldata voucher)
internal
view
returns (bytes32)
{
}
function _verifyVoucher(Voucher calldata voucher)
internal
view
returns (address)
{
}
// Set voucher signer
function setVoucherSigner(address addr) external onlyOwner {
}
}
| !paused||msg.sender==owner(),"We're paused" | 310,129 | !paused||msg.sender==owner() |
"We haven't started yet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
struct Voucher {
address wallet;
uint256 nonce;
bytes signature;
}
contract DawnBunnies is ERC721Enumerable, EIP712, Ownable {
uint256 public maxItems;
bool public paused = false;
bool public started = false;
address public voucherSigner;
uint256 public totalMinted;
string _baseTokenURI;
mapping(uint256 => bool) public voucherUsed;
constructor(
string memory baseURI,
string memory tokenName,
string memory tokenSymbol,
uint256 _maxItems,
address _voucherSigner
) ERC721(tokenName, tokenSymbol) EIP712(tokenName, "1") {
}
// Mint items
function mint(Voucher calldata voucher) public {
require(!paused || msg.sender == owner(), "We're paused");
require(<FILL_ME>)
require(_verifyVoucher(voucher) == voucherSigner, "Invalid voucher");
require(voucher.wallet == msg.sender, "This is not your voucher");
require(
!voucherUsed[voucher.nonce],
"Whitelisted Winner already got 1 NFT"
);
require(totalMinted + 1 <= maxItems, "Can't fulfill requested items");
totalMinted++;
_safeMint(msg.sender, totalMinted);
voucherUsed[voucher.nonce] = true;
}
// Mint n items to owner
function devMint(uint256 n) external onlyOwner {
}
// Get the base URI (internal)
function _baseURI() internal view virtual override returns (string memory) {
}
// Set the base URI
function setBaseURI(string memory baseURI) external onlyOwner {
}
// get all tokens owned by an address
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
// pause/unpause contract
function pause(bool val) external onlyOwner {
}
// start contract
function start() external onlyOwner {
}
// withdraw balance
function withdraw() external onlyOwner {
}
function _hashVoucher(Voucher calldata voucher)
internal
view
returns (bytes32)
{
}
function _verifyVoucher(Voucher calldata voucher)
internal
view
returns (address)
{
}
// Set voucher signer
function setVoucherSigner(address addr) external onlyOwner {
}
}
| started||msg.sender==owner(),"We haven't started yet" | 310,129 | started||msg.sender==owner() |
"Invalid voucher" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
struct Voucher {
address wallet;
uint256 nonce;
bytes signature;
}
contract DawnBunnies is ERC721Enumerable, EIP712, Ownable {
uint256 public maxItems;
bool public paused = false;
bool public started = false;
address public voucherSigner;
uint256 public totalMinted;
string _baseTokenURI;
mapping(uint256 => bool) public voucherUsed;
constructor(
string memory baseURI,
string memory tokenName,
string memory tokenSymbol,
uint256 _maxItems,
address _voucherSigner
) ERC721(tokenName, tokenSymbol) EIP712(tokenName, "1") {
}
// Mint items
function mint(Voucher calldata voucher) public {
require(!paused || msg.sender == owner(), "We're paused");
require(started || msg.sender == owner(), "We haven't started yet");
require(<FILL_ME>)
require(voucher.wallet == msg.sender, "This is not your voucher");
require(
!voucherUsed[voucher.nonce],
"Whitelisted Winner already got 1 NFT"
);
require(totalMinted + 1 <= maxItems, "Can't fulfill requested items");
totalMinted++;
_safeMint(msg.sender, totalMinted);
voucherUsed[voucher.nonce] = true;
}
// Mint n items to owner
function devMint(uint256 n) external onlyOwner {
}
// Get the base URI (internal)
function _baseURI() internal view virtual override returns (string memory) {
}
// Set the base URI
function setBaseURI(string memory baseURI) external onlyOwner {
}
// get all tokens owned by an address
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
// pause/unpause contract
function pause(bool val) external onlyOwner {
}
// start contract
function start() external onlyOwner {
}
// withdraw balance
function withdraw() external onlyOwner {
}
function _hashVoucher(Voucher calldata voucher)
internal
view
returns (bytes32)
{
}
function _verifyVoucher(Voucher calldata voucher)
internal
view
returns (address)
{
}
// Set voucher signer
function setVoucherSigner(address addr) external onlyOwner {
}
}
| _verifyVoucher(voucher)==voucherSigner,"Invalid voucher" | 310,129 | _verifyVoucher(voucher)==voucherSigner |
"Whitelisted Winner already got 1 NFT" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
struct Voucher {
address wallet;
uint256 nonce;
bytes signature;
}
contract DawnBunnies is ERC721Enumerable, EIP712, Ownable {
uint256 public maxItems;
bool public paused = false;
bool public started = false;
address public voucherSigner;
uint256 public totalMinted;
string _baseTokenURI;
mapping(uint256 => bool) public voucherUsed;
constructor(
string memory baseURI,
string memory tokenName,
string memory tokenSymbol,
uint256 _maxItems,
address _voucherSigner
) ERC721(tokenName, tokenSymbol) EIP712(tokenName, "1") {
}
// Mint items
function mint(Voucher calldata voucher) public {
require(!paused || msg.sender == owner(), "We're paused");
require(started || msg.sender == owner(), "We haven't started yet");
require(_verifyVoucher(voucher) == voucherSigner, "Invalid voucher");
require(voucher.wallet == msg.sender, "This is not your voucher");
require(<FILL_ME>)
require(totalMinted + 1 <= maxItems, "Can't fulfill requested items");
totalMinted++;
_safeMint(msg.sender, totalMinted);
voucherUsed[voucher.nonce] = true;
}
// Mint n items to owner
function devMint(uint256 n) external onlyOwner {
}
// Get the base URI (internal)
function _baseURI() internal view virtual override returns (string memory) {
}
// Set the base URI
function setBaseURI(string memory baseURI) external onlyOwner {
}
// get all tokens owned by an address
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
// pause/unpause contract
function pause(bool val) external onlyOwner {
}
// start contract
function start() external onlyOwner {
}
// withdraw balance
function withdraw() external onlyOwner {
}
function _hashVoucher(Voucher calldata voucher)
internal
view
returns (bytes32)
{
}
function _verifyVoucher(Voucher calldata voucher)
internal
view
returns (address)
{
}
// Set voucher signer
function setVoucherSigner(address addr) external onlyOwner {
}
}
| !voucherUsed[voucher.nonce],"Whitelisted Winner already got 1 NFT" | 310,129 | !voucherUsed[voucher.nonce] |
"Can't fulfill requested items" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
struct Voucher {
address wallet;
uint256 nonce;
bytes signature;
}
contract DawnBunnies is ERC721Enumerable, EIP712, Ownable {
uint256 public maxItems;
bool public paused = false;
bool public started = false;
address public voucherSigner;
uint256 public totalMinted;
string _baseTokenURI;
mapping(uint256 => bool) public voucherUsed;
constructor(
string memory baseURI,
string memory tokenName,
string memory tokenSymbol,
uint256 _maxItems,
address _voucherSigner
) ERC721(tokenName, tokenSymbol) EIP712(tokenName, "1") {
}
// Mint items
function mint(Voucher calldata voucher) public {
require(!paused || msg.sender == owner(), "We're paused");
require(started || msg.sender == owner(), "We haven't started yet");
require(_verifyVoucher(voucher) == voucherSigner, "Invalid voucher");
require(voucher.wallet == msg.sender, "This is not your voucher");
require(
!voucherUsed[voucher.nonce],
"Whitelisted Winner already got 1 NFT"
);
require(<FILL_ME>)
totalMinted++;
_safeMint(msg.sender, totalMinted);
voucherUsed[voucher.nonce] = true;
}
// Mint n items to owner
function devMint(uint256 n) external onlyOwner {
}
// Get the base URI (internal)
function _baseURI() internal view virtual override returns (string memory) {
}
// Set the base URI
function setBaseURI(string memory baseURI) external onlyOwner {
}
// get all tokens owned by an address
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
// pause/unpause contract
function pause(bool val) external onlyOwner {
}
// start contract
function start() external onlyOwner {
}
// withdraw balance
function withdraw() external onlyOwner {
}
function _hashVoucher(Voucher calldata voucher)
internal
view
returns (bytes32)
{
}
function _verifyVoucher(Voucher calldata voucher)
internal
view
returns (address)
{
}
// Set voucher signer
function setVoucherSigner(address addr) external onlyOwner {
}
}
| totalMinted+1<=maxItems,"Can't fulfill requested items" | 310,129 | totalMinted+1<=maxItems |
"Can't fulfill requested items" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
struct Voucher {
address wallet;
uint256 nonce;
bytes signature;
}
contract DawnBunnies is ERC721Enumerable, EIP712, Ownable {
uint256 public maxItems;
bool public paused = false;
bool public started = false;
address public voucherSigner;
uint256 public totalMinted;
string _baseTokenURI;
mapping(uint256 => bool) public voucherUsed;
constructor(
string memory baseURI,
string memory tokenName,
string memory tokenSymbol,
uint256 _maxItems,
address _voucherSigner
) ERC721(tokenName, tokenSymbol) EIP712(tokenName, "1") {
}
// Mint items
function mint(Voucher calldata voucher) public {
}
// Mint n items to owner
function devMint(uint256 n) external onlyOwner {
require(<FILL_ME>)
for (uint256 i = 0; i < n; i++) {
totalMinted++;
_safeMint(msg.sender, totalMinted);
}
}
// Get the base URI (internal)
function _baseURI() internal view virtual override returns (string memory) {
}
// Set the base URI
function setBaseURI(string memory baseURI) external onlyOwner {
}
// get all tokens owned by an address
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
// pause/unpause contract
function pause(bool val) external onlyOwner {
}
// start contract
function start() external onlyOwner {
}
// withdraw balance
function withdraw() external onlyOwner {
}
function _hashVoucher(Voucher calldata voucher)
internal
view
returns (bytes32)
{
}
function _verifyVoucher(Voucher calldata voucher)
internal
view
returns (address)
{
}
// Set voucher signer
function setVoucherSigner(address addr) external onlyOwner {
}
}
| totalMinted+n<=maxItems,"Can't fulfill requested items" | 310,129 | totalMinted+n<=maxItems |
null | /**
* @dev The NokuCustomERC2Service contract .
*/
contract NokuCustomERC20Service is Pausable {
event LogNokuCustomERC20ServiceCreated(address caller, address indexed pricingPlan);
event LogPricingPlanChanged(address indexed caller, address indexed pricingPlan);
uint256 public constant CREATE_AMOUNT = 1 * 10**18;
uint8 public constant DECIMALS = 18;
// The pricing plan determining the fee to be paid in NOKU tokens by customers for using Noku services
address public pricingPlan;
bytes32 public constant CUSTOM_ERC20_CREATE_SERVICE_NAME = "NokuCustomERC20.create";
function NokuCustomERC20Service(address _pricingPlan) public {
}
function setPricingPlan(address _pricingPlan) public onlyOwner {
}
function createCustomToken(string _name, string _symbol, uint8 _decimals) public returns(address customTokenAddress) {
NokuCustomERC20 customToken = new NokuCustomERC20(_name, _symbol, DECIMALS, pricingPlan, owner);
// Transfer NokuCustomERC20 ownership to the client
customToken.transferOwnership(msg.sender);
require(<FILL_ME>)
return address(customToken);
}
}
| NokuPricingPlan(pricingPlan).payFee(CUSTOM_ERC20_CREATE_SERVICE_NAME,CREATE_AMOUNT,msg.sender) | 310,166 | NokuPricingPlan(pricingPlan).payFee(CUSTOM_ERC20_CREATE_SERVICE_NAME,CREATE_AMOUNT,msg.sender) |
"IncreasingTreasuryReimbursement/treasury-coin-not-set" | pragma solidity 0.6.7;
contract GebMath {
uint256 public constant RAY = 10 ** 27;
uint256 public constant WAD = 10 ** 18;
function ray(uint x) public pure returns (uint z) {
}
function rad(uint x) public pure returns (uint z) {
}
function minimum(uint x, uint y) public pure returns (uint z) {
}
function addition(uint x, uint y) public pure returns (uint z) {
}
function subtract(uint x, uint y) public pure returns (uint z) {
}
function multiply(uint x, uint y) public pure returns (uint z) {
}
function rmultiply(uint x, uint y) public pure returns (uint z) {
}
function rdivide(uint x, uint y) public pure returns (uint z) {
}
function wdivide(uint x, uint y) public pure returns (uint z) {
}
function wmultiply(uint x, uint y) public pure returns (uint z) {
}
function rpower(uint x, uint n, uint base) public pure returns (uint z) {
}
}
abstract contract StabilityFeeTreasuryLike {
function getAllowance(address) virtual external view returns (uint, uint);
function systemCoin() virtual external view returns (address);
function pullFunds(address, address, uint) virtual external;
}
contract IncreasingTreasuryReimbursement is GebMath {
// --- Auth ---
mapping (address => uint) public authorizedAccounts;
/**
* @notice Add auth to an account
* @param account Account to add auth to
*/
function addAuthorization(address account) virtual external isAuthorized {
}
/**
* @notice Remove auth from an account
* @param account Account to remove auth from
*/
function removeAuthorization(address account) virtual external isAuthorized {
}
/**
* @notice Checks whether msg.sender can call an authed function
**/
modifier isAuthorized {
}
// --- Variables ---
// Starting reward for the fee receiver/keeper
uint256 public baseUpdateCallerReward; // [wad]
// Max possible reward for the fee receiver/keeper
uint256 public maxUpdateCallerReward; // [wad]
// Max delay taken into consideration when calculating the adjusted reward
uint256 public maxRewardIncreaseDelay; // [seconds]
// Rate applied to baseUpdateCallerReward every extra second passed beyond a certain point (e.g next time when a specific function needs to be called)
uint256 public perSecondCallerRewardIncrease; // [ray]
// SF treasury
StabilityFeeTreasuryLike public treasury;
// --- Events ---
event AddAuthorization(address account);
event RemoveAuthorization(address account);
event ModifyParameters(
bytes32 parameter,
address addr
);
event ModifyParameters(
bytes32 parameter,
uint256 val
);
event FailRewardCaller(bytes revertReason, address feeReceiver, uint256 amount);
constructor(
address treasury_,
uint256 baseUpdateCallerReward_,
uint256 maxUpdateCallerReward_,
uint256 perSecondCallerRewardIncrease_
) public {
if (address(treasury_) != address(0)) {
require(<FILL_ME>)
}
require(maxUpdateCallerReward_ >= baseUpdateCallerReward_, "IncreasingTreasuryReimbursement/invalid-max-caller-reward");
require(perSecondCallerRewardIncrease_ >= RAY, "IncreasingTreasuryReimbursement/invalid-per-second-reward-increase");
authorizedAccounts[msg.sender] = 1;
treasury = StabilityFeeTreasuryLike(treasury_);
baseUpdateCallerReward = baseUpdateCallerReward_;
maxUpdateCallerReward = maxUpdateCallerReward_;
perSecondCallerRewardIncrease = perSecondCallerRewardIncrease_;
maxRewardIncreaseDelay = uint(-1);
emit AddAuthorization(msg.sender);
emit ModifyParameters("treasury", treasury_);
emit ModifyParameters("baseUpdateCallerReward", baseUpdateCallerReward);
emit ModifyParameters("maxUpdateCallerReward", maxUpdateCallerReward);
emit ModifyParameters("perSecondCallerRewardIncrease", perSecondCallerRewardIncrease);
}
// --- Boolean Logic ---
function either(bool x, bool y) internal pure returns (bool z) {
}
// --- Treasury ---
/**
* @notice This returns the stability fee treasury allowance for this contract by taking the minimum between the per block and the total allowances
**/
function treasuryAllowance() public view returns (uint256) {
}
/*
* @notice Get the SF reward that can be sent to a function caller right now
* @param timeOfLastUpdate The last time when the function that the treasury pays for has been updated
* @param defaultDelayBetweenCalls Enforced delay between calls to the function for which the treasury reimburses callers
*/
function getCallerReward(uint256 timeOfLastUpdate, uint256 defaultDelayBetweenCalls) public view returns (uint256) {
}
/**
* @notice Send a stability fee reward to an address
* @param proposedFeeReceiver The SF receiver
* @param reward The system coin amount to send
**/
function rewardCaller(address proposedFeeReceiver, uint256 reward) internal {
}
}
abstract contract AccountingEngineLike {
function modifyParameters(bytes32, uint256) virtual external;
}
abstract contract OracleRelayerLike {
function redemptionPrice() virtual external returns (uint256);
}
contract AuctionedSurplusSetter is IncreasingTreasuryReimbursement {
// --- Variables ---
// Minimum amount of surplus to sell in one auction
uint256 public minAuctionedSurplus; // [rad]
// Target value for the amount of surplus to sell
uint256 public targetValue; // [ray]
// The min delay between two adjustments of the surplus amount
uint256 public updateDelay; // [seconds]
// Last timestamp when the surplus amount was updated
uint256 public lastUpdateTime; // [unix timestamp]
// Delay between two consecutive inflation related updates
uint256 public targetValueInflationDelay;
// The target inflation applied to targetValue
uint256 public targetValueTargetInflation;
// The last time when inflation was applied to the target value
uint256 public targetValueInflationUpdateTime; // [unix timestamp]
// Accounting engine contract
AccountingEngineLike public accountingEngine;
// The oracle relayer contract
OracleRelayerLike public oracleRelayer;
// Max inflation per period
uint256 public constant MAX_INFLATION = 50;
// --- Events ---
event RecomputeSurplusAmountAuctioned(uint256 surplusToSell);
constructor(
address treasury_,
address oracleRelayer_,
address accountingEngine_,
uint256 minAuctionedSurplus_,
uint256 targetValue_,
uint256 updateDelay_,
uint256 baseUpdateCallerReward_,
uint256 maxUpdateCallerReward_,
uint256 perSecondCallerRewardIncrease_
) public IncreasingTreasuryReimbursement(treasury_, baseUpdateCallerReward_, maxUpdateCallerReward_, perSecondCallerRewardIncrease_) {
}
// --- Boolean Logic ---
function both(bool x, bool y) internal pure returns (bool z) {
}
// --- Math ---
uint internal constant HUNDRED = 100;
// --- Administration ---
/*
* @notify Modify an uint256 parameter
* @param parameter The name of the parameter to change
* @param val The new parameter value
*/
function modifyParameters(bytes32 parameter, uint256 val) external isAuthorized {
}
/*
* @notify Modify an address param
* @param parameter The name of the parameter to change
* @param addr The new address for the parameter
*/
function modifyParameters(bytes32 parameter, address addr) external isAuthorized {
}
// --- Core Logic ---
/*
* @notify Recompute and set the new amount of surplus that's sold in one surplus auction
*/
function recomputeSurplusAmountAuctioned(address feeReceiver) public {
}
// --- Internal Logic ---
/*
* @notice Automatically apply inflation to the targetValue
*/
function applyInflation() internal {
}
}
| StabilityFeeTreasuryLike(treasury_).systemCoin()!=address(0),"IncreasingTreasuryReimbursement/treasury-coin-not-set" | 310,207 | StabilityFeeTreasuryLike(treasury_).systemCoin()!=address(0) |
"AuctionedSurplusSetter/invalid-core-contracts" | pragma solidity 0.6.7;
contract GebMath {
uint256 public constant RAY = 10 ** 27;
uint256 public constant WAD = 10 ** 18;
function ray(uint x) public pure returns (uint z) {
}
function rad(uint x) public pure returns (uint z) {
}
function minimum(uint x, uint y) public pure returns (uint z) {
}
function addition(uint x, uint y) public pure returns (uint z) {
}
function subtract(uint x, uint y) public pure returns (uint z) {
}
function multiply(uint x, uint y) public pure returns (uint z) {
}
function rmultiply(uint x, uint y) public pure returns (uint z) {
}
function rdivide(uint x, uint y) public pure returns (uint z) {
}
function wdivide(uint x, uint y) public pure returns (uint z) {
}
function wmultiply(uint x, uint y) public pure returns (uint z) {
}
function rpower(uint x, uint n, uint base) public pure returns (uint z) {
}
}
abstract contract StabilityFeeTreasuryLike {
function getAllowance(address) virtual external view returns (uint, uint);
function systemCoin() virtual external view returns (address);
function pullFunds(address, address, uint) virtual external;
}
contract IncreasingTreasuryReimbursement is GebMath {
// --- Auth ---
mapping (address => uint) public authorizedAccounts;
/**
* @notice Add auth to an account
* @param account Account to add auth to
*/
function addAuthorization(address account) virtual external isAuthorized {
}
/**
* @notice Remove auth from an account
* @param account Account to remove auth from
*/
function removeAuthorization(address account) virtual external isAuthorized {
}
/**
* @notice Checks whether msg.sender can call an authed function
**/
modifier isAuthorized {
}
// --- Variables ---
// Starting reward for the fee receiver/keeper
uint256 public baseUpdateCallerReward; // [wad]
// Max possible reward for the fee receiver/keeper
uint256 public maxUpdateCallerReward; // [wad]
// Max delay taken into consideration when calculating the adjusted reward
uint256 public maxRewardIncreaseDelay; // [seconds]
// Rate applied to baseUpdateCallerReward every extra second passed beyond a certain point (e.g next time when a specific function needs to be called)
uint256 public perSecondCallerRewardIncrease; // [ray]
// SF treasury
StabilityFeeTreasuryLike public treasury;
// --- Events ---
event AddAuthorization(address account);
event RemoveAuthorization(address account);
event ModifyParameters(
bytes32 parameter,
address addr
);
event ModifyParameters(
bytes32 parameter,
uint256 val
);
event FailRewardCaller(bytes revertReason, address feeReceiver, uint256 amount);
constructor(
address treasury_,
uint256 baseUpdateCallerReward_,
uint256 maxUpdateCallerReward_,
uint256 perSecondCallerRewardIncrease_
) public {
}
// --- Boolean Logic ---
function either(bool x, bool y) internal pure returns (bool z) {
}
// --- Treasury ---
/**
* @notice This returns the stability fee treasury allowance for this contract by taking the minimum between the per block and the total allowances
**/
function treasuryAllowance() public view returns (uint256) {
}
/*
* @notice Get the SF reward that can be sent to a function caller right now
* @param timeOfLastUpdate The last time when the function that the treasury pays for has been updated
* @param defaultDelayBetweenCalls Enforced delay between calls to the function for which the treasury reimburses callers
*/
function getCallerReward(uint256 timeOfLastUpdate, uint256 defaultDelayBetweenCalls) public view returns (uint256) {
}
/**
* @notice Send a stability fee reward to an address
* @param proposedFeeReceiver The SF receiver
* @param reward The system coin amount to send
**/
function rewardCaller(address proposedFeeReceiver, uint256 reward) internal {
}
}
abstract contract AccountingEngineLike {
function modifyParameters(bytes32, uint256) virtual external;
}
abstract contract OracleRelayerLike {
function redemptionPrice() virtual external returns (uint256);
}
contract AuctionedSurplusSetter is IncreasingTreasuryReimbursement {
// --- Variables ---
// Minimum amount of surplus to sell in one auction
uint256 public minAuctionedSurplus; // [rad]
// Target value for the amount of surplus to sell
uint256 public targetValue; // [ray]
// The min delay between two adjustments of the surplus amount
uint256 public updateDelay; // [seconds]
// Last timestamp when the surplus amount was updated
uint256 public lastUpdateTime; // [unix timestamp]
// Delay between two consecutive inflation related updates
uint256 public targetValueInflationDelay;
// The target inflation applied to targetValue
uint256 public targetValueTargetInflation;
// The last time when inflation was applied to the target value
uint256 public targetValueInflationUpdateTime; // [unix timestamp]
// Accounting engine contract
AccountingEngineLike public accountingEngine;
// The oracle relayer contract
OracleRelayerLike public oracleRelayer;
// Max inflation per period
uint256 public constant MAX_INFLATION = 50;
// --- Events ---
event RecomputeSurplusAmountAuctioned(uint256 surplusToSell);
constructor(
address treasury_,
address oracleRelayer_,
address accountingEngine_,
uint256 minAuctionedSurplus_,
uint256 targetValue_,
uint256 updateDelay_,
uint256 baseUpdateCallerReward_,
uint256 maxUpdateCallerReward_,
uint256 perSecondCallerRewardIncrease_
) public IncreasingTreasuryReimbursement(treasury_, baseUpdateCallerReward_, maxUpdateCallerReward_, perSecondCallerRewardIncrease_) {
require(<FILL_ME>)
require(minAuctionedSurplus_ > 0, "AuctionedSurplusSetter/invalid-min-auctioned-surplus");
require(targetValue_ >= 100, "AuctionedSurplusSetter/invalid-target-value");
require(updateDelay_ > 0, "AuctionedSurplusSetter/null-update-delay");
minAuctionedSurplus = minAuctionedSurplus_;
updateDelay = updateDelay_;
targetValue = targetValue_;
targetValueTargetInflation = 0;
targetValueInflationDelay = uint(-1) / 2;
targetValueInflationUpdateTime = now;
oracleRelayer = OracleRelayerLike(oracleRelayer_);
accountingEngine = AccountingEngineLike(accountingEngine_);
emit ModifyParameters("minAuctionedSurplus", minAuctionedSurplus);
emit ModifyParameters("targetValue", targetValue);
emit ModifyParameters("updateDelay", updateDelay);
}
// --- Boolean Logic ---
function both(bool x, bool y) internal pure returns (bool z) {
}
// --- Math ---
uint internal constant HUNDRED = 100;
// --- Administration ---
/*
* @notify Modify an uint256 parameter
* @param parameter The name of the parameter to change
* @param val The new parameter value
*/
function modifyParameters(bytes32 parameter, uint256 val) external isAuthorized {
}
/*
* @notify Modify an address param
* @param parameter The name of the parameter to change
* @param addr The new address for the parameter
*/
function modifyParameters(bytes32 parameter, address addr) external isAuthorized {
}
// --- Core Logic ---
/*
* @notify Recompute and set the new amount of surplus that's sold in one surplus auction
*/
function recomputeSurplusAmountAuctioned(address feeReceiver) public {
}
// --- Internal Logic ---
/*
* @notice Automatically apply inflation to the targetValue
*/
function applyInflation() internal {
}
}
| both(oracleRelayer_!=address(0),accountingEngine_!=address(0)),"AuctionedSurplusSetter/invalid-core-contracts" | 310,207 | both(oracleRelayer_!=address(0),accountingEngine_!=address(0)) |
"AuctionedSurplusSetter/invalid-inflation-update-time" | pragma solidity 0.6.7;
contract GebMath {
uint256 public constant RAY = 10 ** 27;
uint256 public constant WAD = 10 ** 18;
function ray(uint x) public pure returns (uint z) {
}
function rad(uint x) public pure returns (uint z) {
}
function minimum(uint x, uint y) public pure returns (uint z) {
}
function addition(uint x, uint y) public pure returns (uint z) {
}
function subtract(uint x, uint y) public pure returns (uint z) {
}
function multiply(uint x, uint y) public pure returns (uint z) {
}
function rmultiply(uint x, uint y) public pure returns (uint z) {
}
function rdivide(uint x, uint y) public pure returns (uint z) {
}
function wdivide(uint x, uint y) public pure returns (uint z) {
}
function wmultiply(uint x, uint y) public pure returns (uint z) {
}
function rpower(uint x, uint n, uint base) public pure returns (uint z) {
}
}
abstract contract StabilityFeeTreasuryLike {
function getAllowance(address) virtual external view returns (uint, uint);
function systemCoin() virtual external view returns (address);
function pullFunds(address, address, uint) virtual external;
}
contract IncreasingTreasuryReimbursement is GebMath {
// --- Auth ---
mapping (address => uint) public authorizedAccounts;
/**
* @notice Add auth to an account
* @param account Account to add auth to
*/
function addAuthorization(address account) virtual external isAuthorized {
}
/**
* @notice Remove auth from an account
* @param account Account to remove auth from
*/
function removeAuthorization(address account) virtual external isAuthorized {
}
/**
* @notice Checks whether msg.sender can call an authed function
**/
modifier isAuthorized {
}
// --- Variables ---
// Starting reward for the fee receiver/keeper
uint256 public baseUpdateCallerReward; // [wad]
// Max possible reward for the fee receiver/keeper
uint256 public maxUpdateCallerReward; // [wad]
// Max delay taken into consideration when calculating the adjusted reward
uint256 public maxRewardIncreaseDelay; // [seconds]
// Rate applied to baseUpdateCallerReward every extra second passed beyond a certain point (e.g next time when a specific function needs to be called)
uint256 public perSecondCallerRewardIncrease; // [ray]
// SF treasury
StabilityFeeTreasuryLike public treasury;
// --- Events ---
event AddAuthorization(address account);
event RemoveAuthorization(address account);
event ModifyParameters(
bytes32 parameter,
address addr
);
event ModifyParameters(
bytes32 parameter,
uint256 val
);
event FailRewardCaller(bytes revertReason, address feeReceiver, uint256 amount);
constructor(
address treasury_,
uint256 baseUpdateCallerReward_,
uint256 maxUpdateCallerReward_,
uint256 perSecondCallerRewardIncrease_
) public {
}
// --- Boolean Logic ---
function either(bool x, bool y) internal pure returns (bool z) {
}
// --- Treasury ---
/**
* @notice This returns the stability fee treasury allowance for this contract by taking the minimum between the per block and the total allowances
**/
function treasuryAllowance() public view returns (uint256) {
}
/*
* @notice Get the SF reward that can be sent to a function caller right now
* @param timeOfLastUpdate The last time when the function that the treasury pays for has been updated
* @param defaultDelayBetweenCalls Enforced delay between calls to the function for which the treasury reimburses callers
*/
function getCallerReward(uint256 timeOfLastUpdate, uint256 defaultDelayBetweenCalls) public view returns (uint256) {
}
/**
* @notice Send a stability fee reward to an address
* @param proposedFeeReceiver The SF receiver
* @param reward The system coin amount to send
**/
function rewardCaller(address proposedFeeReceiver, uint256 reward) internal {
}
}
abstract contract AccountingEngineLike {
function modifyParameters(bytes32, uint256) virtual external;
}
abstract contract OracleRelayerLike {
function redemptionPrice() virtual external returns (uint256);
}
contract AuctionedSurplusSetter is IncreasingTreasuryReimbursement {
// --- Variables ---
// Minimum amount of surplus to sell in one auction
uint256 public minAuctionedSurplus; // [rad]
// Target value for the amount of surplus to sell
uint256 public targetValue; // [ray]
// The min delay between two adjustments of the surplus amount
uint256 public updateDelay; // [seconds]
// Last timestamp when the surplus amount was updated
uint256 public lastUpdateTime; // [unix timestamp]
// Delay between two consecutive inflation related updates
uint256 public targetValueInflationDelay;
// The target inflation applied to targetValue
uint256 public targetValueTargetInflation;
// The last time when inflation was applied to the target value
uint256 public targetValueInflationUpdateTime; // [unix timestamp]
// Accounting engine contract
AccountingEngineLike public accountingEngine;
// The oracle relayer contract
OracleRelayerLike public oracleRelayer;
// Max inflation per period
uint256 public constant MAX_INFLATION = 50;
// --- Events ---
event RecomputeSurplusAmountAuctioned(uint256 surplusToSell);
constructor(
address treasury_,
address oracleRelayer_,
address accountingEngine_,
uint256 minAuctionedSurplus_,
uint256 targetValue_,
uint256 updateDelay_,
uint256 baseUpdateCallerReward_,
uint256 maxUpdateCallerReward_,
uint256 perSecondCallerRewardIncrease_
) public IncreasingTreasuryReimbursement(treasury_, baseUpdateCallerReward_, maxUpdateCallerReward_, perSecondCallerRewardIncrease_) {
}
// --- Boolean Logic ---
function both(bool x, bool y) internal pure returns (bool z) {
}
// --- Math ---
uint internal constant HUNDRED = 100;
// --- Administration ---
/*
* @notify Modify an uint256 parameter
* @param parameter The name of the parameter to change
* @param val The new parameter value
*/
function modifyParameters(bytes32 parameter, uint256 val) external isAuthorized {
if (parameter == "minAuctionedSurplus") {
require(val > 0, "AuctionedSurplusSetter/null-min-auctioned-amount");
minAuctionedSurplus = val;
}
else if (parameter == "targetValue") {
require(val >= 100, "AuctionedSurplusSetter/null-target-value");
targetValue = val;
}
else if (parameter == "baseUpdateCallerReward") {
require(val <= maxUpdateCallerReward, "AuctionedSurplusSetter/invalid-min-reward");
baseUpdateCallerReward = val;
}
else if (parameter == "maxUpdateCallerReward") {
require(val >= baseUpdateCallerReward, "AuctionedSurplusSetter/invalid-max-reward");
maxUpdateCallerReward = val;
}
else if (parameter == "perSecondCallerRewardIncrease") {
require(val >= RAY, "AuctionedSurplusSetter/invalid-reward-increase");
perSecondCallerRewardIncrease = val;
}
else if (parameter == "maxRewardIncreaseDelay") {
require(val > 0, "AuctionedSurplusSetter/invalid-max-increase-delay");
maxRewardIncreaseDelay = val;
}
else if (parameter == "updateDelay") {
require(val > 0, "AuctionedSurplusSetter/null-update-delay");
updateDelay = val;
}
else if (parameter == "targetValueInflationUpdateTime") {
require(<FILL_ME>)
targetValueInflationUpdateTime = val;
}
else if (parameter == "targetValueInflationDelay") {
require(val <= uint(-1) / 2, "AuctionedSurplusSetter/invalid-inflation-delay");
targetValueInflationDelay = val;
}
else if (parameter == "targetValueTargetInflation") {
require(val <= MAX_INFLATION, "AuctionedSurplusSetter/invalid-target-inflation");
targetValueTargetInflation = val;
}
else revert("AuctionedSurplusSetter/modify-unrecognized-param");
emit ModifyParameters(parameter, val);
}
/*
* @notify Modify an address param
* @param parameter The name of the parameter to change
* @param addr The new address for the parameter
*/
function modifyParameters(bytes32 parameter, address addr) external isAuthorized {
}
// --- Core Logic ---
/*
* @notify Recompute and set the new amount of surplus that's sold in one surplus auction
*/
function recomputeSurplusAmountAuctioned(address feeReceiver) public {
}
// --- Internal Logic ---
/*
* @notice Automatically apply inflation to the targetValue
*/
function applyInflation() internal {
}
}
| both(val>=targetValueInflationUpdateTime,val<=now),"AuctionedSurplusSetter/invalid-inflation-update-time" | 310,207 | both(val>=targetValueInflationUpdateTime,val<=now) |
"AuctionedSurplusSetter/wait-more" | pragma solidity 0.6.7;
contract GebMath {
uint256 public constant RAY = 10 ** 27;
uint256 public constant WAD = 10 ** 18;
function ray(uint x) public pure returns (uint z) {
}
function rad(uint x) public pure returns (uint z) {
}
function minimum(uint x, uint y) public pure returns (uint z) {
}
function addition(uint x, uint y) public pure returns (uint z) {
}
function subtract(uint x, uint y) public pure returns (uint z) {
}
function multiply(uint x, uint y) public pure returns (uint z) {
}
function rmultiply(uint x, uint y) public pure returns (uint z) {
}
function rdivide(uint x, uint y) public pure returns (uint z) {
}
function wdivide(uint x, uint y) public pure returns (uint z) {
}
function wmultiply(uint x, uint y) public pure returns (uint z) {
}
function rpower(uint x, uint n, uint base) public pure returns (uint z) {
}
}
abstract contract StabilityFeeTreasuryLike {
function getAllowance(address) virtual external view returns (uint, uint);
function systemCoin() virtual external view returns (address);
function pullFunds(address, address, uint) virtual external;
}
contract IncreasingTreasuryReimbursement is GebMath {
// --- Auth ---
mapping (address => uint) public authorizedAccounts;
/**
* @notice Add auth to an account
* @param account Account to add auth to
*/
function addAuthorization(address account) virtual external isAuthorized {
}
/**
* @notice Remove auth from an account
* @param account Account to remove auth from
*/
function removeAuthorization(address account) virtual external isAuthorized {
}
/**
* @notice Checks whether msg.sender can call an authed function
**/
modifier isAuthorized {
}
// --- Variables ---
// Starting reward for the fee receiver/keeper
uint256 public baseUpdateCallerReward; // [wad]
// Max possible reward for the fee receiver/keeper
uint256 public maxUpdateCallerReward; // [wad]
// Max delay taken into consideration when calculating the adjusted reward
uint256 public maxRewardIncreaseDelay; // [seconds]
// Rate applied to baseUpdateCallerReward every extra second passed beyond a certain point (e.g next time when a specific function needs to be called)
uint256 public perSecondCallerRewardIncrease; // [ray]
// SF treasury
StabilityFeeTreasuryLike public treasury;
// --- Events ---
event AddAuthorization(address account);
event RemoveAuthorization(address account);
event ModifyParameters(
bytes32 parameter,
address addr
);
event ModifyParameters(
bytes32 parameter,
uint256 val
);
event FailRewardCaller(bytes revertReason, address feeReceiver, uint256 amount);
constructor(
address treasury_,
uint256 baseUpdateCallerReward_,
uint256 maxUpdateCallerReward_,
uint256 perSecondCallerRewardIncrease_
) public {
}
// --- Boolean Logic ---
function either(bool x, bool y) internal pure returns (bool z) {
}
// --- Treasury ---
/**
* @notice This returns the stability fee treasury allowance for this contract by taking the minimum between the per block and the total allowances
**/
function treasuryAllowance() public view returns (uint256) {
}
/*
* @notice Get the SF reward that can be sent to a function caller right now
* @param timeOfLastUpdate The last time when the function that the treasury pays for has been updated
* @param defaultDelayBetweenCalls Enforced delay between calls to the function for which the treasury reimburses callers
*/
function getCallerReward(uint256 timeOfLastUpdate, uint256 defaultDelayBetweenCalls) public view returns (uint256) {
}
/**
* @notice Send a stability fee reward to an address
* @param proposedFeeReceiver The SF receiver
* @param reward The system coin amount to send
**/
function rewardCaller(address proposedFeeReceiver, uint256 reward) internal {
}
}
abstract contract AccountingEngineLike {
function modifyParameters(bytes32, uint256) virtual external;
}
abstract contract OracleRelayerLike {
function redemptionPrice() virtual external returns (uint256);
}
contract AuctionedSurplusSetter is IncreasingTreasuryReimbursement {
// --- Variables ---
// Minimum amount of surplus to sell in one auction
uint256 public minAuctionedSurplus; // [rad]
// Target value for the amount of surplus to sell
uint256 public targetValue; // [ray]
// The min delay between two adjustments of the surplus amount
uint256 public updateDelay; // [seconds]
// Last timestamp when the surplus amount was updated
uint256 public lastUpdateTime; // [unix timestamp]
// Delay between two consecutive inflation related updates
uint256 public targetValueInflationDelay;
// The target inflation applied to targetValue
uint256 public targetValueTargetInflation;
// The last time when inflation was applied to the target value
uint256 public targetValueInflationUpdateTime; // [unix timestamp]
// Accounting engine contract
AccountingEngineLike public accountingEngine;
// The oracle relayer contract
OracleRelayerLike public oracleRelayer;
// Max inflation per period
uint256 public constant MAX_INFLATION = 50;
// --- Events ---
event RecomputeSurplusAmountAuctioned(uint256 surplusToSell);
constructor(
address treasury_,
address oracleRelayer_,
address accountingEngine_,
uint256 minAuctionedSurplus_,
uint256 targetValue_,
uint256 updateDelay_,
uint256 baseUpdateCallerReward_,
uint256 maxUpdateCallerReward_,
uint256 perSecondCallerRewardIncrease_
) public IncreasingTreasuryReimbursement(treasury_, baseUpdateCallerReward_, maxUpdateCallerReward_, perSecondCallerRewardIncrease_) {
}
// --- Boolean Logic ---
function both(bool x, bool y) internal pure returns (bool z) {
}
// --- Math ---
uint internal constant HUNDRED = 100;
// --- Administration ---
/*
* @notify Modify an uint256 parameter
* @param parameter The name of the parameter to change
* @param val The new parameter value
*/
function modifyParameters(bytes32 parameter, uint256 val) external isAuthorized {
}
/*
* @notify Modify an address param
* @param parameter The name of the parameter to change
* @param addr The new address for the parameter
*/
function modifyParameters(bytes32 parameter, address addr) external isAuthorized {
}
// --- Core Logic ---
/*
* @notify Recompute and set the new amount of surplus that's sold in one surplus auction
*/
function recomputeSurplusAmountAuctioned(address feeReceiver) public {
// Check delay between calls
require(<FILL_ME>)
// Get the caller's reward
uint256 callerReward = getCallerReward(lastUpdateTime, updateDelay);
// Store the timestamp of the update
lastUpdateTime = now;
// Apply inflation
applyInflation();
// Calculate the new amount to sell
uint256 surplusToSell = multiply(rdivide(targetValue, oracleRelayer.redemptionPrice()), WAD);
surplusToSell = (surplusToSell < minAuctionedSurplus) ? minAuctionedSurplus : surplusToSell;
// Set the new amount
accountingEngine.modifyParameters("surplusAuctionAmountToSell", surplusToSell);
// Emit an event
emit RecomputeSurplusAmountAuctioned(surplusToSell);
// Pay the caller for updating the rate
rewardCaller(feeReceiver, callerReward);
}
// --- Internal Logic ---
/*
* @notice Automatically apply inflation to the targetValue
*/
function applyInflation() internal {
}
}
| either(subtract(now,lastUpdateTime)>=updateDelay,lastUpdateTime==0),"AuctionedSurplusSetter/wait-more" | 310,207 | either(subtract(now,lastUpdateTime)>=updateDelay,lastUpdateTime==0) |
"TellerNFT: not admin" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
// Contracts
import "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
// Libraries
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// Interfaces
import "./ITellerNFT.sol";
/*****************************************************************************************************/
/** WARNING **/
/** THIS CONTRACT IS UPGRADEABLE! **/
/** --------------------------------------------------------------------------------------------- **/
/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/
/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/
/** **/
/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/
/** more information. **/
/*****************************************************************************************************/
/**
* @notice This contract is used by borrowers to call Dapp functions (using delegate calls).
* @notice This contract should only be constructed using it's upgradeable Proxy contract.
* @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.
*
* @author [email protected]
*/
contract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {
using Counters for Counters.Counter;
using EnumerableSet for EnumerableSet.UintSet;
using SafeMath for uint256;
/* Constants */
bytes32 public constant ADMIN = keccak256("ADMIN");
bytes32 public constant MINTER = keccak256("MINTER");
/* State Variables */
// It holds the total number of tiers.
Counters.Counter internal _tierCounter;
// It holds the total number of tokens minted.
Counters.Counter internal _tokenCounter;
// It holds the information about a tier.
mapping(uint256 => Tier) internal _tiers;
// It holds which tier a token ID is in.
mapping(uint256 => uint256) internal _tokenTier;
// It holds a set of token IDs for an owner address.
mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;
// Link to the contract metadata
string private _metadataBaseURI;
// Hash to the contract metadata located on the {_metadataBaseURI}
string private _contractURIHash;
/* Modifiers */
modifier onlyAdmin() {
require(<FILL_ME>)
_;
}
modifier onlyMinter() {
}
/* External Functions */
/**
* @notice It returns information about a Tier for a token ID.
* @param index Tier index to get info.
*/
function getTier(uint256 index)
external
view
override
returns (Tier memory tier_)
{
}
/**
* @notice It returns information about a Tier for a token ID.
* @param tokenId ID of the token to get Tier info.
*/
function getTokenTier(uint256 tokenId)
external
view
override
returns (uint256 index_, Tier memory tier_)
{
}
/**
* @notice It returns an array of token IDs owned by an address.
* @dev It uses a EnumerableSet to store values and loops over each element to add to the array.
* @dev Can be costly if calling within a contract for address with many tokens.
*/
function getTierHashes(uint256 tierIndex)
external
view
override
returns (string[] memory hashes_)
{
}
/**
* @notice It returns an array of token IDs owned by an address.
* @dev It uses a EnumerableSet to store values and loops over each element to add to the array.
* @dev Can be costly if calling within a contract for address with many tokens.
*/
function getOwnedTokens(address owner)
external
view
override
returns (uint256[] memory owned_)
{
}
/**
* @notice The contract metadata URI.
*/
function contractURI() external view override returns (string memory) {
}
/**
* @notice The token URI is based on the token ID.
*/
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
/**
* @notice It mints a new token for a Tier index.
* @param tierIndex Tier to mint token on.
* @param owner The owner of the new token.
*
* Requirements:
* - Caller must be an authorized minter
*/
function mint(uint256 tierIndex, address owner)
external
override
onlyMinter
{
}
/**
* @notice Adds a new Tier to be minted with the given information.
* @dev It auto increments the index of the next tier to add.
* @param newTier Information about the new tier to add.
*
* Requirements:
* - Caller must have the {MINTER} role
*/
function addTier(Tier memory newTier) external override onlyMinter {
}
function removeMinter(address minter) external onlyMinter {
}
function addMinter(address minter) public onlyMinter {
}
/**
* @notice Sets the contract level metadata URI hash.
* @param contractURIHash The hash to the initial contract level metadata.
*/
function setContractURIHash(string memory contractURIHash)
external
override
onlyAdmin
{
}
/**
* @notice Initializes the TellerNFT.
* @param minters The addresses that should allowed to mint tokens.
*/
function initialize(address[] calldata minters)
external
override
initializer
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(AccessControlUpgradeable, ERC721Upgradeable)
returns (bool)
{
}
/**
* @notice It returns the hash to use for the token URI.
*/
function _tokenURIHash(uint256 tokenId)
internal
view
returns (string memory)
{
}
/**
* @notice The base URI path where the token media is hosted.
* @dev Base URI for computing {tokenURI}.
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @notice Moves token to new owner set and then transfers.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal override {
}
/**
* @notice It removes the token from the current owner set and adds to new owner.
*/
function _setOwner(address newOwner, uint256 tokenId) internal {
}
function _msgData() internal pure override returns (bytes calldata) {
}
}
| hasRole(ADMIN,_msgSender()),"TellerNFT: not admin" | 310,265 | hasRole(ADMIN,_msgSender()) |
"TellerNFT: not minter" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
// Contracts
import "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
// Libraries
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// Interfaces
import "./ITellerNFT.sol";
/*****************************************************************************************************/
/** WARNING **/
/** THIS CONTRACT IS UPGRADEABLE! **/
/** --------------------------------------------------------------------------------------------- **/
/** Do NOT change the order of or PREPEND any storage variables to this or new versions of this **/
/** contract as this will cause the the storage slots to be overwritten on the proxy contract!! **/
/** **/
/** Visit https://docs.openzeppelin.com/upgrades/2.6/proxies#upgrading-via-the-proxy-pattern for **/
/** more information. **/
/*****************************************************************************************************/
/**
* @notice This contract is used by borrowers to call Dapp functions (using delegate calls).
* @notice This contract should only be constructed using it's upgradeable Proxy contract.
* @notice In order to call a Dapp function, the Dapp must be added in the DappRegistry instance.
*
* @author [email protected]
*/
contract TellerNFT is ITellerNFT, ERC721Upgradeable, AccessControlUpgradeable {
using Counters for Counters.Counter;
using EnumerableSet for EnumerableSet.UintSet;
using SafeMath for uint256;
/* Constants */
bytes32 public constant ADMIN = keccak256("ADMIN");
bytes32 public constant MINTER = keccak256("MINTER");
/* State Variables */
// It holds the total number of tiers.
Counters.Counter internal _tierCounter;
// It holds the total number of tokens minted.
Counters.Counter internal _tokenCounter;
// It holds the information about a tier.
mapping(uint256 => Tier) internal _tiers;
// It holds which tier a token ID is in.
mapping(uint256 => uint256) internal _tokenTier;
// It holds a set of token IDs for an owner address.
mapping(address => EnumerableSet.UintSet) internal _ownerTokenIDs;
// Link to the contract metadata
string private _metadataBaseURI;
// Hash to the contract metadata located on the {_metadataBaseURI}
string private _contractURIHash;
/* Modifiers */
modifier onlyAdmin() {
}
modifier onlyMinter() {
require(<FILL_ME>)
_;
}
/* External Functions */
/**
* @notice It returns information about a Tier for a token ID.
* @param index Tier index to get info.
*/
function getTier(uint256 index)
external
view
override
returns (Tier memory tier_)
{
}
/**
* @notice It returns information about a Tier for a token ID.
* @param tokenId ID of the token to get Tier info.
*/
function getTokenTier(uint256 tokenId)
external
view
override
returns (uint256 index_, Tier memory tier_)
{
}
/**
* @notice It returns an array of token IDs owned by an address.
* @dev It uses a EnumerableSet to store values and loops over each element to add to the array.
* @dev Can be costly if calling within a contract for address with many tokens.
*/
function getTierHashes(uint256 tierIndex)
external
view
override
returns (string[] memory hashes_)
{
}
/**
* @notice It returns an array of token IDs owned by an address.
* @dev It uses a EnumerableSet to store values and loops over each element to add to the array.
* @dev Can be costly if calling within a contract for address with many tokens.
*/
function getOwnedTokens(address owner)
external
view
override
returns (uint256[] memory owned_)
{
}
/**
* @notice The contract metadata URI.
*/
function contractURI() external view override returns (string memory) {
}
/**
* @notice The token URI is based on the token ID.
*/
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
/**
* @notice It mints a new token for a Tier index.
* @param tierIndex Tier to mint token on.
* @param owner The owner of the new token.
*
* Requirements:
* - Caller must be an authorized minter
*/
function mint(uint256 tierIndex, address owner)
external
override
onlyMinter
{
}
/**
* @notice Adds a new Tier to be minted with the given information.
* @dev It auto increments the index of the next tier to add.
* @param newTier Information about the new tier to add.
*
* Requirements:
* - Caller must have the {MINTER} role
*/
function addTier(Tier memory newTier) external override onlyMinter {
}
function removeMinter(address minter) external onlyMinter {
}
function addMinter(address minter) public onlyMinter {
}
/**
* @notice Sets the contract level metadata URI hash.
* @param contractURIHash The hash to the initial contract level metadata.
*/
function setContractURIHash(string memory contractURIHash)
external
override
onlyAdmin
{
}
/**
* @notice Initializes the TellerNFT.
* @param minters The addresses that should allowed to mint tokens.
*/
function initialize(address[] calldata minters)
external
override
initializer
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(AccessControlUpgradeable, ERC721Upgradeable)
returns (bool)
{
}
/**
* @notice It returns the hash to use for the token URI.
*/
function _tokenURIHash(uint256 tokenId)
internal
view
returns (string memory)
{
}
/**
* @notice The base URI path where the token media is hosted.
* @dev Base URI for computing {tokenURI}.
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @notice Moves token to new owner set and then transfers.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal override {
}
/**
* @notice It removes the token from the current owner set and adds to new owner.
*/
function _setOwner(address newOwner, uint256 tokenId) internal {
}
function _msgData() internal pure override returns (bytes calldata) {
}
}
| hasRole(MINTER,_msgSender()),"TellerNFT: not minter" | 310,265 | hasRole(MINTER,_msgSender()) |
"Caller is unauthorized." | pragma solidity 0.8.4;
// SPDX-License-Identifier: MIT
import './standard/access/AccessControl.sol';
abstract contract AccessControlRci is AccessControl{
bytes32 public constant RCI_MAIN_ADMIN = keccak256('RCI_MAIN_ADMIN');
bytes32 public constant RCI_CHILD_ADMIN = keccak256('RCI_CHILD_ADMIN');
modifier onlyMainAdmin()
{
require(<FILL_ME>)
_;
}
modifier onlyAdmin()
{
}
function _initializeRciAdmin()
internal
{
}
}
| hasRole(RCI_MAIN_ADMIN,msg.sender),"Caller is unauthorized." | 310,340 | hasRole(RCI_MAIN_ADMIN,msg.sender) |
"Caller is unauthorized." | pragma solidity 0.8.4;
// SPDX-License-Identifier: MIT
import './standard/access/AccessControl.sol';
abstract contract AccessControlRci is AccessControl{
bytes32 public constant RCI_MAIN_ADMIN = keccak256('RCI_MAIN_ADMIN');
bytes32 public constant RCI_CHILD_ADMIN = keccak256('RCI_CHILD_ADMIN');
modifier onlyMainAdmin()
{
}
modifier onlyAdmin()
{
require(<FILL_ME>)
_;
}
function _initializeRciAdmin()
internal
{
}
}
| hasRole(RCI_CHILD_ADMIN,msg.sender),"Caller is unauthorized." | 310,340 | hasRole(RCI_CHILD_ADMIN,msg.sender) |
"WithdrawalDelayer::enableEmergencyMode: ALREADY_ENABLED" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.6.12;
import "../interfaces/IWithdrawalDelayer.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
contract WithdrawalDelayer is ReentrancyGuard, IWithdrawalDelayer {
struct DepositState {
uint192 amount;
uint64 depositTimestamp;
}
// bytes4(keccak256(bytes("transfer(address,uint256)")));
bytes4 constant _TRANSFER_SIGNATURE = 0xa9059cbb;
// bytes4(keccak256(bytes("transferFrom(address,address,uint256)")));
bytes4 constant _TRANSFERFROM_SIGNATURE = 0x23b872dd;
// bytes4(keccak256(bytes("deposit(address,address,uint192)")));
bytes4 constant _DEPOSIT_SIGNATURE = 0xcfc0b641;
uint64 public constant MAX_WITHDRAWAL_DELAY = 2 weeks; // Maximum time that the return of funds can be delayed
uint64 public constant MAX_EMERGENCY_MODE_TIME = 26 weeks; // Maximum time in a state of emergency before a
// resolution and after which the emergency council can redeem the funds
uint64 private _withdrawalDelay; // Current delay
uint64 private _emergencyModeStartingTime; // When emergency mode has started
address private _hermezGovernance; // Governance who control the system parameters
address public pendingGovernance;
address payable public pendingEmergencyCouncil;
address payable private _emergencyCouncil; // emergency council address who can redeem the funds after MAX_EMERGENCY_MODE_TIME
bool private _emergencyMode; // bool to set the emergency mode
address public hermezRollupAddress; // hermez Rollup Address who can send funds to this smart contract
mapping(bytes32 => DepositState) public deposits; // Mapping to keep track of deposits
event Deposit(
address indexed owner,
address indexed token,
uint192 amount,
uint64 depositTimestamp
);
event Withdraw(
address indexed token,
address indexed owner,
uint192 amount
);
event EmergencyModeEnabled();
event NewWithdrawalDelay(uint64 withdrawalDelay);
event EscapeHatchWithdrawal(
address indexed who,
address indexed to,
address indexed token,
uint256 amount
);
event NewEmergencyCouncil(address newEmergencyCouncil);
event NewHermezGovernanceAddress(address newHermezGovernanceAddress);
// Event emitted when the contract is initialized
event InitializeWithdrawalDelayerEvent(
uint64 initialWithdrawalDelay,
address initialHermezGovernanceAddress,
address initialEmergencyCouncil
);
/**
* @notice withdrawalDelayerInitializer (Constructor)
* @param _initialWithdrawalDelay Initial withdrawal delay time in seconds to be able to withdraw the funds
* @param _initialHermezRollup Smart contract responsible of making deposits and it's able to change the delay
* @param _initialHermezGovernanceAddress can claim the funds in an emergency mode
* @param _initialEmergencyCouncil can claim the funds in an emergency and MAX_EMERGENCY_MODE_TIME exceeded
*/
constructor(
uint64 _initialWithdrawalDelay,
address _initialHermezRollup,
address _initialHermezGovernanceAddress,
address payable _initialEmergencyCouncil
) public {
}
/**
* @notice Getter of the current `_hermezGovernance`
* @return The `_hermezGovernance` value
*/
function getHermezGovernanceAddress()
external
override
view
returns (address)
{
}
/**
* @dev Allows the current governance to set the pendingGovernance address.
* @param newGovernance The address to transfer governance to.
*/
function transferGovernance(address newGovernance) public override {
}
/**
* @dev Allows the pendingGovernance address to finalize the transfer.
*/
function claimGovernance() public override {
}
/**
* @notice Getter of the current `_emergencyCouncil`
* @return The `_emergencyCouncil` value
*/
function getEmergencyCouncil() external override view returns (address) {
}
/**
* @dev Allows the current governance to set the pendingGovernance address.
* @param newEmergencyCouncil The address to transfer governance to.
*/
function transferEmergencyCouncil(address payable newEmergencyCouncil)
public
override
{
}
/**
* @dev Allows the pendingGovernance address to finalize the transfer.
*/
function claimEmergencyCouncil() public override {
}
/**
* @notice Getter of the current `_emergencyMode` status to know if the emergency mode is enable or disable
* @return The `_emergencyMode` value
*/
function isEmergencyMode() external override view returns (bool) {
}
/**
* @notice Getter to obtain the current withdrawal delay
* @return the current withdrawal delay time in seconds: `_withdrawalDelay`
*/
function getWithdrawalDelay() external override view returns (uint64) {
}
/**
* @notice Getter to obtain when emergency mode started
* @return the emergency mode starting time in seconds: `_emergencyModeStartingTime`
*/
function getEmergencyModeStartingTime()
external
override
view
returns (uint64)
{
}
/**
* @notice This function enables the emergency mode. Only the governance of the system can enable this mode. This cannot
* be deactivated in any case so it will be irreversible.
* @dev The activation time is saved in `_emergencyModeStartingTime` and this function can only be called
* once if it has not been previously activated.
* Events: `EmergencyModeEnabled` event.
*/
function enableEmergencyMode() external override {
require(
msg.sender == _hermezGovernance,
"WithdrawalDelayer::enableEmergencyMode: ONLY_GOVERNANCE"
);
require(<FILL_ME>)
_emergencyMode = true;
/* solhint-disable not-rely-on-time */
_emergencyModeStartingTime = uint64(now);
emit EmergencyModeEnabled();
}
/**
* @notice This function allows the governance to change the withdrawal delay time, this is the time that
* anyone needs to wait until a withdrawal of the funds is allowed. Since this time is calculated at the time of
* withdrawal, this change affects existing deposits. Can never exceed `MAX_WITHDRAWAL_DELAY`
* @dev It changes `_withdrawalDelay` if `_newWithdrawalDelay` it is less than or equal to MAX_WITHDRAWAL_DELAY
* @param _newWithdrawalDelay new delay time in seconds
* Events: `NewWithdrawalDelay` event.
*/
function changeWithdrawalDelay(uint64 _newWithdrawalDelay)
external
override
{
}
/**
* Returns the balance and the timestamp for a specific owner and token
* @param _owner who can claim the deposit once the delay time has expired (if not in emergency mode)
* @param _token address of the token to withdrawal (0x0 in case of Ether)
* @return `amount` Total amount withdrawable (if not in emergency mode)
* @return `depositTimestamp` Moment at which funds were deposited
*/
function depositInfo(address payable _owner, address _token)
external
override
view
returns (uint192, uint64)
{
}
/**
* Function to make a deposit in the WithdrawalDelayer smartcontract, only the Hermez rollup smartcontract can do it
* @dev In case of an Ether deposit, the address `0x0` will be used and the corresponding amount must be sent in the
* `msg.value`. In case of an ERC20 this smartcontract must have the approval to expend the token to
* deposit to be able to make a transferFrom to itself.
* @param _owner is who can claim the deposit once the withdrawal delay time has been exceeded
* @param _token address of the token deposited (`0x0` in case of Ether)
* @param _amount deposit amount
* Events: `Deposit`
*/
function deposit(
address _owner,
address _token,
uint192 _amount
) external override payable nonReentrant {
}
/**
* @notice Internal call to make a deposit
* @param _owner is who can claim the deposit once the withdrawal delay time has been exceeded
* @param _token address of the token deposited (`0x0` in case of Ether)
* @param _amount deposit amount
* Events: `Deposit`
*/
function _processDeposit(
address _owner,
address _token,
uint192 _amount
) internal {
}
/**
* This function allows the owner to withdawal the funds. Emergency mode cannot be enabled and it must have exceeded
* the withdrawal delay time
* @dev `NonReentrant` modifier is used as a protection despite the state is being previously updated
* @param _owner can claim the deposit once the delay time has expired
* @param _token address of the token to withdrawal (0x0 in case of Ether)
* Events: `Withdraw`
*/
function withdrawal(address payable _owner, address _token)
external
override
nonReentrant
{
}
/**
* Allows the Hermez Governance to withdawal the funds in the event that emergency mode was enable.
* @dev `NonReentrant` modifier is used as a protection despite the state is being previously updated and this is
* a security mechanism
* @param _to where the funds will be sent
* @param _token address of the token withdraw (0x0 in case of Ether)
* @param _amount the amount to send
* Events: `EscapeHatchWithdrawal`
*/
function escapeHatchWithdrawal(
address _to,
address _token,
uint256 _amount
) external override nonReentrant {
}
/**
* Internal function to perform a ETH Withdrawal
* @param to where the funds will be sent
* @param amount address of the token withdraw (0x0 in case of Ether)
*/
function _ethWithdrawal(address to, uint256 amount) internal {
}
/**
* Internal function to perform a Token Withdrawal
* @param tokenAddress address of the token to transfer
* @param to where the funds will be sent
* @param amount address of the token withdraw (0x0 in case of Ether)
*/
function _tokenWithdrawal(
address tokenAddress,
address to,
uint256 amount
) internal {
}
}
| !_emergencyMode,"WithdrawalDelayer::enableEmergencyMode: ALREADY_ENABLED" | 310,379 | !_emergencyMode |
"WithdrawalDelayer::changeWithdrawalDelay: ONLY_ROLLUP_OR_GOVERNANCE" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.6.12;
import "../interfaces/IWithdrawalDelayer.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
contract WithdrawalDelayer is ReentrancyGuard, IWithdrawalDelayer {
struct DepositState {
uint192 amount;
uint64 depositTimestamp;
}
// bytes4(keccak256(bytes("transfer(address,uint256)")));
bytes4 constant _TRANSFER_SIGNATURE = 0xa9059cbb;
// bytes4(keccak256(bytes("transferFrom(address,address,uint256)")));
bytes4 constant _TRANSFERFROM_SIGNATURE = 0x23b872dd;
// bytes4(keccak256(bytes("deposit(address,address,uint192)")));
bytes4 constant _DEPOSIT_SIGNATURE = 0xcfc0b641;
uint64 public constant MAX_WITHDRAWAL_DELAY = 2 weeks; // Maximum time that the return of funds can be delayed
uint64 public constant MAX_EMERGENCY_MODE_TIME = 26 weeks; // Maximum time in a state of emergency before a
// resolution and after which the emergency council can redeem the funds
uint64 private _withdrawalDelay; // Current delay
uint64 private _emergencyModeStartingTime; // When emergency mode has started
address private _hermezGovernance; // Governance who control the system parameters
address public pendingGovernance;
address payable public pendingEmergencyCouncil;
address payable private _emergencyCouncil; // emergency council address who can redeem the funds after MAX_EMERGENCY_MODE_TIME
bool private _emergencyMode; // bool to set the emergency mode
address public hermezRollupAddress; // hermez Rollup Address who can send funds to this smart contract
mapping(bytes32 => DepositState) public deposits; // Mapping to keep track of deposits
event Deposit(
address indexed owner,
address indexed token,
uint192 amount,
uint64 depositTimestamp
);
event Withdraw(
address indexed token,
address indexed owner,
uint192 amount
);
event EmergencyModeEnabled();
event NewWithdrawalDelay(uint64 withdrawalDelay);
event EscapeHatchWithdrawal(
address indexed who,
address indexed to,
address indexed token,
uint256 amount
);
event NewEmergencyCouncil(address newEmergencyCouncil);
event NewHermezGovernanceAddress(address newHermezGovernanceAddress);
// Event emitted when the contract is initialized
event InitializeWithdrawalDelayerEvent(
uint64 initialWithdrawalDelay,
address initialHermezGovernanceAddress,
address initialEmergencyCouncil
);
/**
* @notice withdrawalDelayerInitializer (Constructor)
* @param _initialWithdrawalDelay Initial withdrawal delay time in seconds to be able to withdraw the funds
* @param _initialHermezRollup Smart contract responsible of making deposits and it's able to change the delay
* @param _initialHermezGovernanceAddress can claim the funds in an emergency mode
* @param _initialEmergencyCouncil can claim the funds in an emergency and MAX_EMERGENCY_MODE_TIME exceeded
*/
constructor(
uint64 _initialWithdrawalDelay,
address _initialHermezRollup,
address _initialHermezGovernanceAddress,
address payable _initialEmergencyCouncil
) public {
}
/**
* @notice Getter of the current `_hermezGovernance`
* @return The `_hermezGovernance` value
*/
function getHermezGovernanceAddress()
external
override
view
returns (address)
{
}
/**
* @dev Allows the current governance to set the pendingGovernance address.
* @param newGovernance The address to transfer governance to.
*/
function transferGovernance(address newGovernance) public override {
}
/**
* @dev Allows the pendingGovernance address to finalize the transfer.
*/
function claimGovernance() public override {
}
/**
* @notice Getter of the current `_emergencyCouncil`
* @return The `_emergencyCouncil` value
*/
function getEmergencyCouncil() external override view returns (address) {
}
/**
* @dev Allows the current governance to set the pendingGovernance address.
* @param newEmergencyCouncil The address to transfer governance to.
*/
function transferEmergencyCouncil(address payable newEmergencyCouncil)
public
override
{
}
/**
* @dev Allows the pendingGovernance address to finalize the transfer.
*/
function claimEmergencyCouncil() public override {
}
/**
* @notice Getter of the current `_emergencyMode` status to know if the emergency mode is enable or disable
* @return The `_emergencyMode` value
*/
function isEmergencyMode() external override view returns (bool) {
}
/**
* @notice Getter to obtain the current withdrawal delay
* @return the current withdrawal delay time in seconds: `_withdrawalDelay`
*/
function getWithdrawalDelay() external override view returns (uint64) {
}
/**
* @notice Getter to obtain when emergency mode started
* @return the emergency mode starting time in seconds: `_emergencyModeStartingTime`
*/
function getEmergencyModeStartingTime()
external
override
view
returns (uint64)
{
}
/**
* @notice This function enables the emergency mode. Only the governance of the system can enable this mode. This cannot
* be deactivated in any case so it will be irreversible.
* @dev The activation time is saved in `_emergencyModeStartingTime` and this function can only be called
* once if it has not been previously activated.
* Events: `EmergencyModeEnabled` event.
*/
function enableEmergencyMode() external override {
}
/**
* @notice This function allows the governance to change the withdrawal delay time, this is the time that
* anyone needs to wait until a withdrawal of the funds is allowed. Since this time is calculated at the time of
* withdrawal, this change affects existing deposits. Can never exceed `MAX_WITHDRAWAL_DELAY`
* @dev It changes `_withdrawalDelay` if `_newWithdrawalDelay` it is less than or equal to MAX_WITHDRAWAL_DELAY
* @param _newWithdrawalDelay new delay time in seconds
* Events: `NewWithdrawalDelay` event.
*/
function changeWithdrawalDelay(uint64 _newWithdrawalDelay)
external
override
{
require(<FILL_ME>)
require(
_newWithdrawalDelay <= MAX_WITHDRAWAL_DELAY,
"WithdrawalDelayer::changeWithdrawalDelay: EXCEEDS_MAX_WITHDRAWAL_DELAY"
);
_withdrawalDelay = _newWithdrawalDelay;
emit NewWithdrawalDelay(_withdrawalDelay);
}
/**
* Returns the balance and the timestamp for a specific owner and token
* @param _owner who can claim the deposit once the delay time has expired (if not in emergency mode)
* @param _token address of the token to withdrawal (0x0 in case of Ether)
* @return `amount` Total amount withdrawable (if not in emergency mode)
* @return `depositTimestamp` Moment at which funds were deposited
*/
function depositInfo(address payable _owner, address _token)
external
override
view
returns (uint192, uint64)
{
}
/**
* Function to make a deposit in the WithdrawalDelayer smartcontract, only the Hermez rollup smartcontract can do it
* @dev In case of an Ether deposit, the address `0x0` will be used and the corresponding amount must be sent in the
* `msg.value`. In case of an ERC20 this smartcontract must have the approval to expend the token to
* deposit to be able to make a transferFrom to itself.
* @param _owner is who can claim the deposit once the withdrawal delay time has been exceeded
* @param _token address of the token deposited (`0x0` in case of Ether)
* @param _amount deposit amount
* Events: `Deposit`
*/
function deposit(
address _owner,
address _token,
uint192 _amount
) external override payable nonReentrant {
}
/**
* @notice Internal call to make a deposit
* @param _owner is who can claim the deposit once the withdrawal delay time has been exceeded
* @param _token address of the token deposited (`0x0` in case of Ether)
* @param _amount deposit amount
* Events: `Deposit`
*/
function _processDeposit(
address _owner,
address _token,
uint192 _amount
) internal {
}
/**
* This function allows the owner to withdawal the funds. Emergency mode cannot be enabled and it must have exceeded
* the withdrawal delay time
* @dev `NonReentrant` modifier is used as a protection despite the state is being previously updated
* @param _owner can claim the deposit once the delay time has expired
* @param _token address of the token to withdrawal (0x0 in case of Ether)
* Events: `Withdraw`
*/
function withdrawal(address payable _owner, address _token)
external
override
nonReentrant
{
}
/**
* Allows the Hermez Governance to withdawal the funds in the event that emergency mode was enable.
* @dev `NonReentrant` modifier is used as a protection despite the state is being previously updated and this is
* a security mechanism
* @param _to where the funds will be sent
* @param _token address of the token withdraw (0x0 in case of Ether)
* @param _amount the amount to send
* Events: `EscapeHatchWithdrawal`
*/
function escapeHatchWithdrawal(
address _to,
address _token,
uint256 _amount
) external override nonReentrant {
}
/**
* Internal function to perform a ETH Withdrawal
* @param to where the funds will be sent
* @param amount address of the token withdraw (0x0 in case of Ether)
*/
function _ethWithdrawal(address to, uint256 amount) internal {
}
/**
* Internal function to perform a Token Withdrawal
* @param tokenAddress address of the token to transfer
* @param to where the funds will be sent
* @param amount address of the token withdraw (0x0 in case of Ether)
*/
function _tokenWithdrawal(
address tokenAddress,
address to,
uint256 amount
) internal {
}
}
| (msg.sender==_hermezGovernance)||(msg.sender==hermezRollupAddress),"WithdrawalDelayer::changeWithdrawalDelay: ONLY_ROLLUP_OR_GOVERNANCE" | 310,379 | (msg.sender==_hermezGovernance)||(msg.sender==hermezRollupAddress) |
"WithdrawalDelayer::deposit: NOT_ENOUGH_ALLOWANCE" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.6.12;
import "../interfaces/IWithdrawalDelayer.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
contract WithdrawalDelayer is ReentrancyGuard, IWithdrawalDelayer {
struct DepositState {
uint192 amount;
uint64 depositTimestamp;
}
// bytes4(keccak256(bytes("transfer(address,uint256)")));
bytes4 constant _TRANSFER_SIGNATURE = 0xa9059cbb;
// bytes4(keccak256(bytes("transferFrom(address,address,uint256)")));
bytes4 constant _TRANSFERFROM_SIGNATURE = 0x23b872dd;
// bytes4(keccak256(bytes("deposit(address,address,uint192)")));
bytes4 constant _DEPOSIT_SIGNATURE = 0xcfc0b641;
uint64 public constant MAX_WITHDRAWAL_DELAY = 2 weeks; // Maximum time that the return of funds can be delayed
uint64 public constant MAX_EMERGENCY_MODE_TIME = 26 weeks; // Maximum time in a state of emergency before a
// resolution and after which the emergency council can redeem the funds
uint64 private _withdrawalDelay; // Current delay
uint64 private _emergencyModeStartingTime; // When emergency mode has started
address private _hermezGovernance; // Governance who control the system parameters
address public pendingGovernance;
address payable public pendingEmergencyCouncil;
address payable private _emergencyCouncil; // emergency council address who can redeem the funds after MAX_EMERGENCY_MODE_TIME
bool private _emergencyMode; // bool to set the emergency mode
address public hermezRollupAddress; // hermez Rollup Address who can send funds to this smart contract
mapping(bytes32 => DepositState) public deposits; // Mapping to keep track of deposits
event Deposit(
address indexed owner,
address indexed token,
uint192 amount,
uint64 depositTimestamp
);
event Withdraw(
address indexed token,
address indexed owner,
uint192 amount
);
event EmergencyModeEnabled();
event NewWithdrawalDelay(uint64 withdrawalDelay);
event EscapeHatchWithdrawal(
address indexed who,
address indexed to,
address indexed token,
uint256 amount
);
event NewEmergencyCouncil(address newEmergencyCouncil);
event NewHermezGovernanceAddress(address newHermezGovernanceAddress);
// Event emitted when the contract is initialized
event InitializeWithdrawalDelayerEvent(
uint64 initialWithdrawalDelay,
address initialHermezGovernanceAddress,
address initialEmergencyCouncil
);
/**
* @notice withdrawalDelayerInitializer (Constructor)
* @param _initialWithdrawalDelay Initial withdrawal delay time in seconds to be able to withdraw the funds
* @param _initialHermezRollup Smart contract responsible of making deposits and it's able to change the delay
* @param _initialHermezGovernanceAddress can claim the funds in an emergency mode
* @param _initialEmergencyCouncil can claim the funds in an emergency and MAX_EMERGENCY_MODE_TIME exceeded
*/
constructor(
uint64 _initialWithdrawalDelay,
address _initialHermezRollup,
address _initialHermezGovernanceAddress,
address payable _initialEmergencyCouncil
) public {
}
/**
* @notice Getter of the current `_hermezGovernance`
* @return The `_hermezGovernance` value
*/
function getHermezGovernanceAddress()
external
override
view
returns (address)
{
}
/**
* @dev Allows the current governance to set the pendingGovernance address.
* @param newGovernance The address to transfer governance to.
*/
function transferGovernance(address newGovernance) public override {
}
/**
* @dev Allows the pendingGovernance address to finalize the transfer.
*/
function claimGovernance() public override {
}
/**
* @notice Getter of the current `_emergencyCouncil`
* @return The `_emergencyCouncil` value
*/
function getEmergencyCouncil() external override view returns (address) {
}
/**
* @dev Allows the current governance to set the pendingGovernance address.
* @param newEmergencyCouncil The address to transfer governance to.
*/
function transferEmergencyCouncil(address payable newEmergencyCouncil)
public
override
{
}
/**
* @dev Allows the pendingGovernance address to finalize the transfer.
*/
function claimEmergencyCouncil() public override {
}
/**
* @notice Getter of the current `_emergencyMode` status to know if the emergency mode is enable or disable
* @return The `_emergencyMode` value
*/
function isEmergencyMode() external override view returns (bool) {
}
/**
* @notice Getter to obtain the current withdrawal delay
* @return the current withdrawal delay time in seconds: `_withdrawalDelay`
*/
function getWithdrawalDelay() external override view returns (uint64) {
}
/**
* @notice Getter to obtain when emergency mode started
* @return the emergency mode starting time in seconds: `_emergencyModeStartingTime`
*/
function getEmergencyModeStartingTime()
external
override
view
returns (uint64)
{
}
/**
* @notice This function enables the emergency mode. Only the governance of the system can enable this mode. This cannot
* be deactivated in any case so it will be irreversible.
* @dev The activation time is saved in `_emergencyModeStartingTime` and this function can only be called
* once if it has not been previously activated.
* Events: `EmergencyModeEnabled` event.
*/
function enableEmergencyMode() external override {
}
/**
* @notice This function allows the governance to change the withdrawal delay time, this is the time that
* anyone needs to wait until a withdrawal of the funds is allowed. Since this time is calculated at the time of
* withdrawal, this change affects existing deposits. Can never exceed `MAX_WITHDRAWAL_DELAY`
* @dev It changes `_withdrawalDelay` if `_newWithdrawalDelay` it is less than or equal to MAX_WITHDRAWAL_DELAY
* @param _newWithdrawalDelay new delay time in seconds
* Events: `NewWithdrawalDelay` event.
*/
function changeWithdrawalDelay(uint64 _newWithdrawalDelay)
external
override
{
}
/**
* Returns the balance and the timestamp for a specific owner and token
* @param _owner who can claim the deposit once the delay time has expired (if not in emergency mode)
* @param _token address of the token to withdrawal (0x0 in case of Ether)
* @return `amount` Total amount withdrawable (if not in emergency mode)
* @return `depositTimestamp` Moment at which funds were deposited
*/
function depositInfo(address payable _owner, address _token)
external
override
view
returns (uint192, uint64)
{
}
/**
* Function to make a deposit in the WithdrawalDelayer smartcontract, only the Hermez rollup smartcontract can do it
* @dev In case of an Ether deposit, the address `0x0` will be used and the corresponding amount must be sent in the
* `msg.value`. In case of an ERC20 this smartcontract must have the approval to expend the token to
* deposit to be able to make a transferFrom to itself.
* @param _owner is who can claim the deposit once the withdrawal delay time has been exceeded
* @param _token address of the token deposited (`0x0` in case of Ether)
* @param _amount deposit amount
* Events: `Deposit`
*/
function deposit(
address _owner,
address _token,
uint192 _amount
) external override payable nonReentrant {
require(
msg.sender == hermezRollupAddress,
"WithdrawalDelayer::deposit: ONLY_ROLLUP"
);
if (msg.value != 0) {
require(
_token == address(0x0),
"WithdrawalDelayer::deposit: WRONG_TOKEN_ADDRESS"
);
require(
_amount == msg.value,
"WithdrawalDelayer::deposit: WRONG_AMOUNT"
);
} else {
require(<FILL_ME>)
/* solhint-disable avoid-low-level-calls */
(bool success, bytes memory data) = address(_token).call(
abi.encodeWithSelector(
_TRANSFERFROM_SIGNATURE,
hermezRollupAddress,
address(this),
_amount
)
);
// `transferFrom` method may return (bool) or nothing.
require(
success && (data.length == 0 || abi.decode(data, (bool))),
"WithdrawalDelayer::deposit: TOKEN_TRANSFER_FAILED"
);
}
_processDeposit(_owner, _token, _amount);
}
/**
* @notice Internal call to make a deposit
* @param _owner is who can claim the deposit once the withdrawal delay time has been exceeded
* @param _token address of the token deposited (`0x0` in case of Ether)
* @param _amount deposit amount
* Events: `Deposit`
*/
function _processDeposit(
address _owner,
address _token,
uint192 _amount
) internal {
}
/**
* This function allows the owner to withdawal the funds. Emergency mode cannot be enabled and it must have exceeded
* the withdrawal delay time
* @dev `NonReentrant` modifier is used as a protection despite the state is being previously updated
* @param _owner can claim the deposit once the delay time has expired
* @param _token address of the token to withdrawal (0x0 in case of Ether)
* Events: `Withdraw`
*/
function withdrawal(address payable _owner, address _token)
external
override
nonReentrant
{
}
/**
* Allows the Hermez Governance to withdawal the funds in the event that emergency mode was enable.
* @dev `NonReentrant` modifier is used as a protection despite the state is being previously updated and this is
* a security mechanism
* @param _to where the funds will be sent
* @param _token address of the token withdraw (0x0 in case of Ether)
* @param _amount the amount to send
* Events: `EscapeHatchWithdrawal`
*/
function escapeHatchWithdrawal(
address _to,
address _token,
uint256 _amount
) external override nonReentrant {
}
/**
* Internal function to perform a ETH Withdrawal
* @param to where the funds will be sent
* @param amount address of the token withdraw (0x0 in case of Ether)
*/
function _ethWithdrawal(address to, uint256 amount) internal {
}
/**
* Internal function to perform a Token Withdrawal
* @param tokenAddress address of the token to transfer
* @param to where the funds will be sent
* @param amount address of the token withdraw (0x0 in case of Ether)
*/
function _tokenWithdrawal(
address tokenAddress,
address to,
uint256 amount
) internal {
}
}
| IERC20(_token).allowance(hermezRollupAddress,address(this))>=_amount,"WithdrawalDelayer::deposit: NOT_ENOUGH_ALLOWANCE" | 310,379 | IERC20(_token).allowance(hermezRollupAddress,address(this))>=_amount |
"WithdrawalDelayer::withdrawal: WITHDRAWAL_NOT_ALLOWED" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.6.12;
import "../interfaces/IWithdrawalDelayer.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
contract WithdrawalDelayer is ReentrancyGuard, IWithdrawalDelayer {
struct DepositState {
uint192 amount;
uint64 depositTimestamp;
}
// bytes4(keccak256(bytes("transfer(address,uint256)")));
bytes4 constant _TRANSFER_SIGNATURE = 0xa9059cbb;
// bytes4(keccak256(bytes("transferFrom(address,address,uint256)")));
bytes4 constant _TRANSFERFROM_SIGNATURE = 0x23b872dd;
// bytes4(keccak256(bytes("deposit(address,address,uint192)")));
bytes4 constant _DEPOSIT_SIGNATURE = 0xcfc0b641;
uint64 public constant MAX_WITHDRAWAL_DELAY = 2 weeks; // Maximum time that the return of funds can be delayed
uint64 public constant MAX_EMERGENCY_MODE_TIME = 26 weeks; // Maximum time in a state of emergency before a
// resolution and after which the emergency council can redeem the funds
uint64 private _withdrawalDelay; // Current delay
uint64 private _emergencyModeStartingTime; // When emergency mode has started
address private _hermezGovernance; // Governance who control the system parameters
address public pendingGovernance;
address payable public pendingEmergencyCouncil;
address payable private _emergencyCouncil; // emergency council address who can redeem the funds after MAX_EMERGENCY_MODE_TIME
bool private _emergencyMode; // bool to set the emergency mode
address public hermezRollupAddress; // hermez Rollup Address who can send funds to this smart contract
mapping(bytes32 => DepositState) public deposits; // Mapping to keep track of deposits
event Deposit(
address indexed owner,
address indexed token,
uint192 amount,
uint64 depositTimestamp
);
event Withdraw(
address indexed token,
address indexed owner,
uint192 amount
);
event EmergencyModeEnabled();
event NewWithdrawalDelay(uint64 withdrawalDelay);
event EscapeHatchWithdrawal(
address indexed who,
address indexed to,
address indexed token,
uint256 amount
);
event NewEmergencyCouncil(address newEmergencyCouncil);
event NewHermezGovernanceAddress(address newHermezGovernanceAddress);
// Event emitted when the contract is initialized
event InitializeWithdrawalDelayerEvent(
uint64 initialWithdrawalDelay,
address initialHermezGovernanceAddress,
address initialEmergencyCouncil
);
/**
* @notice withdrawalDelayerInitializer (Constructor)
* @param _initialWithdrawalDelay Initial withdrawal delay time in seconds to be able to withdraw the funds
* @param _initialHermezRollup Smart contract responsible of making deposits and it's able to change the delay
* @param _initialHermezGovernanceAddress can claim the funds in an emergency mode
* @param _initialEmergencyCouncil can claim the funds in an emergency and MAX_EMERGENCY_MODE_TIME exceeded
*/
constructor(
uint64 _initialWithdrawalDelay,
address _initialHermezRollup,
address _initialHermezGovernanceAddress,
address payable _initialEmergencyCouncil
) public {
}
/**
* @notice Getter of the current `_hermezGovernance`
* @return The `_hermezGovernance` value
*/
function getHermezGovernanceAddress()
external
override
view
returns (address)
{
}
/**
* @dev Allows the current governance to set the pendingGovernance address.
* @param newGovernance The address to transfer governance to.
*/
function transferGovernance(address newGovernance) public override {
}
/**
* @dev Allows the pendingGovernance address to finalize the transfer.
*/
function claimGovernance() public override {
}
/**
* @notice Getter of the current `_emergencyCouncil`
* @return The `_emergencyCouncil` value
*/
function getEmergencyCouncil() external override view returns (address) {
}
/**
* @dev Allows the current governance to set the pendingGovernance address.
* @param newEmergencyCouncil The address to transfer governance to.
*/
function transferEmergencyCouncil(address payable newEmergencyCouncil)
public
override
{
}
/**
* @dev Allows the pendingGovernance address to finalize the transfer.
*/
function claimEmergencyCouncil() public override {
}
/**
* @notice Getter of the current `_emergencyMode` status to know if the emergency mode is enable or disable
* @return The `_emergencyMode` value
*/
function isEmergencyMode() external override view returns (bool) {
}
/**
* @notice Getter to obtain the current withdrawal delay
* @return the current withdrawal delay time in seconds: `_withdrawalDelay`
*/
function getWithdrawalDelay() external override view returns (uint64) {
}
/**
* @notice Getter to obtain when emergency mode started
* @return the emergency mode starting time in seconds: `_emergencyModeStartingTime`
*/
function getEmergencyModeStartingTime()
external
override
view
returns (uint64)
{
}
/**
* @notice This function enables the emergency mode. Only the governance of the system can enable this mode. This cannot
* be deactivated in any case so it will be irreversible.
* @dev The activation time is saved in `_emergencyModeStartingTime` and this function can only be called
* once if it has not been previously activated.
* Events: `EmergencyModeEnabled` event.
*/
function enableEmergencyMode() external override {
}
/**
* @notice This function allows the governance to change the withdrawal delay time, this is the time that
* anyone needs to wait until a withdrawal of the funds is allowed. Since this time is calculated at the time of
* withdrawal, this change affects existing deposits. Can never exceed `MAX_WITHDRAWAL_DELAY`
* @dev It changes `_withdrawalDelay` if `_newWithdrawalDelay` it is less than or equal to MAX_WITHDRAWAL_DELAY
* @param _newWithdrawalDelay new delay time in seconds
* Events: `NewWithdrawalDelay` event.
*/
function changeWithdrawalDelay(uint64 _newWithdrawalDelay)
external
override
{
}
/**
* Returns the balance and the timestamp for a specific owner and token
* @param _owner who can claim the deposit once the delay time has expired (if not in emergency mode)
* @param _token address of the token to withdrawal (0x0 in case of Ether)
* @return `amount` Total amount withdrawable (if not in emergency mode)
* @return `depositTimestamp` Moment at which funds were deposited
*/
function depositInfo(address payable _owner, address _token)
external
override
view
returns (uint192, uint64)
{
}
/**
* Function to make a deposit in the WithdrawalDelayer smartcontract, only the Hermez rollup smartcontract can do it
* @dev In case of an Ether deposit, the address `0x0` will be used and the corresponding amount must be sent in the
* `msg.value`. In case of an ERC20 this smartcontract must have the approval to expend the token to
* deposit to be able to make a transferFrom to itself.
* @param _owner is who can claim the deposit once the withdrawal delay time has been exceeded
* @param _token address of the token deposited (`0x0` in case of Ether)
* @param _amount deposit amount
* Events: `Deposit`
*/
function deposit(
address _owner,
address _token,
uint192 _amount
) external override payable nonReentrant {
}
/**
* @notice Internal call to make a deposit
* @param _owner is who can claim the deposit once the withdrawal delay time has been exceeded
* @param _token address of the token deposited (`0x0` in case of Ether)
* @param _amount deposit amount
* Events: `Deposit`
*/
function _processDeposit(
address _owner,
address _token,
uint192 _amount
) internal {
}
/**
* This function allows the owner to withdawal the funds. Emergency mode cannot be enabled and it must have exceeded
* the withdrawal delay time
* @dev `NonReentrant` modifier is used as a protection despite the state is being previously updated
* @param _owner can claim the deposit once the delay time has expired
* @param _token address of the token to withdrawal (0x0 in case of Ether)
* Events: `Withdraw`
*/
function withdrawal(address payable _owner, address _token)
external
override
nonReentrant
{
require(!_emergencyMode, "WithdrawalDelayer::deposit: EMERGENCY_MODE");
// We identify a deposit with the keccak of its owner and the token
bytes32 depositId = keccak256(abi.encodePacked(_owner, _token));
uint192 amount = deposits[depositId].amount;
require(amount > 0, "WithdrawalDelayer::withdrawal: NO_FUNDS");
require(<FILL_ME>)
// Update the state
deposits[depositId].amount = 0;
deposits[depositId].depositTimestamp = 0;
// Make the transfer
if (_token == address(0x0)) {
_ethWithdrawal(_owner, uint256(amount));
} else {
_tokenWithdrawal(_token, _owner, uint256(amount));
}
emit Withdraw(_token, _owner, amount);
}
/**
* Allows the Hermez Governance to withdawal the funds in the event that emergency mode was enable.
* @dev `NonReentrant` modifier is used as a protection despite the state is being previously updated and this is
* a security mechanism
* @param _to where the funds will be sent
* @param _token address of the token withdraw (0x0 in case of Ether)
* @param _amount the amount to send
* Events: `EscapeHatchWithdrawal`
*/
function escapeHatchWithdrawal(
address _to,
address _token,
uint256 _amount
) external override nonReentrant {
}
/**
* Internal function to perform a ETH Withdrawal
* @param to where the funds will be sent
* @param amount address of the token withdraw (0x0 in case of Ether)
*/
function _ethWithdrawal(address to, uint256 amount) internal {
}
/**
* Internal function to perform a Token Withdrawal
* @param tokenAddress address of the token to transfer
* @param to where the funds will be sent
* @param amount address of the token withdraw (0x0 in case of Ether)
*/
function _tokenWithdrawal(
address tokenAddress,
address to,
uint256 amount
) internal {
}
}
| uint64(now)>=deposits[depositId].depositTimestamp+_withdrawalDelay,"WithdrawalDelayer::withdrawal: WITHDRAWAL_NOT_ALLOWED" | 310,379 | uint64(now)>=deposits[depositId].depositTimestamp+_withdrawalDelay |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.