comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Maximun holders limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract CSDAO is ERC1155Supply, Ownable {
using SafeMath for uint256;
mapping(uint256 => string) private _tokenURIs;
mapping(address => bool) private whitelistMap;
uint256 public stage = 0; // STAGE 0 is for wave 2 presale, STAGE 1 is for wave 2 public sale, STAGE 2 is for wave 3 salve and STAGE 3 is for team tokens
uint256 public presaleWave2Amount = 1375;
uint256 public wave2Amount = 2750;
uint256 public wave3Amount = 3550;
uint256 public presaleWave2EthPrice = 0.095 ether;
uint256 public presaleWave2WrldPrice = 999 ether;
uint256 public wave2EthPrice = 0.12 ether;
uint256 public wave2WrldPrice = 1111 ether;
uint256 public wave3EthPrice = 0.15 ether;
uint256 public wave3WrldPrice = 1777 ether;
uint256 public maxOnceLimit = 10;
bool public saleIsActive = true;
address private immutable ceoAddress = 0x9B61a1aAA934808aDb8753f4BdE57d324BA064A5;
address private immutable wrldAddress = 0xD5d86FC8d5C0Ea1aC1Ac5Dfab6E529c9967a45E9;
constructor () ERC1155 ("") {
}
function withdraw() public onlyOwner {
}
function mintPresaleWithEth(uint256 _amount) external payable {
}
function mintPresaleWithWrld(uint256 _amount) external {
}
function mintWave2WithEth(uint256 _amount) external payable {
}
function mintWave2WithWrld(uint256 _amount) external {
}
function mintWave3WithEth(uint256 _amount) external payable {
require(saleIsActive, "Sale has been paused.");
require(stage == 2, "Wave 3 is not active.");
require(_amount <= maxOnceLimit, "Max once purchase limit");
require(<FILL_ME>)
require(msg.value == wave3EthPrice.mul(_amount), "Total price not match");
_mint(msg.sender, 1, _amount, "");
if(totalSupply(1) == wave3Amount) {
stage = 3;
}
}
function mintWave3WithWrld(uint256 _amount) external {
}
function reserveWaves(address _to, uint256 _reserveAmount) external onlyOwner {
}
function flipSaleState() external onlyOwner {
}
function startWave2PublicSale() external onlyOwner {
}
function setStage(uint256 _stage) external onlyOwner {
}
function updateWave3WrldPrice(uint256 _wrldPrice) external onlyOwner {
}
function setWhiteList(address _address) public onlyOwner {
}
function setWhiteListMultiple(address[] memory _addresses) external onlyOwner
{
}
function removeWhiteList(address _address) external onlyOwner {
}
function isWhiteListed(address _address) external view returns (bool) {
}
function uri(uint256 id) public view virtual override returns (string memory) {
}
function _setTokenURI(uint256 _tokenId, string memory _tokenUri) external onlyOwner {
}
function contractURI() public pure returns (string memory) {
}
}
| totalSupply(1).add(_amount)<=wave3Amount,"Maximun holders limit" | 55,415 | totalSupply(1).add(_amount)<=wave3Amount |
"Not enough $WRLD." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract CSDAO is ERC1155Supply, Ownable {
using SafeMath for uint256;
mapping(uint256 => string) private _tokenURIs;
mapping(address => bool) private whitelistMap;
uint256 public stage = 0; // STAGE 0 is for wave 2 presale, STAGE 1 is for wave 2 public sale, STAGE 2 is for wave 3 salve and STAGE 3 is for team tokens
uint256 public presaleWave2Amount = 1375;
uint256 public wave2Amount = 2750;
uint256 public wave3Amount = 3550;
uint256 public presaleWave2EthPrice = 0.095 ether;
uint256 public presaleWave2WrldPrice = 999 ether;
uint256 public wave2EthPrice = 0.12 ether;
uint256 public wave2WrldPrice = 1111 ether;
uint256 public wave3EthPrice = 0.15 ether;
uint256 public wave3WrldPrice = 1777 ether;
uint256 public maxOnceLimit = 10;
bool public saleIsActive = true;
address private immutable ceoAddress = 0x9B61a1aAA934808aDb8753f4BdE57d324BA064A5;
address private immutable wrldAddress = 0xD5d86FC8d5C0Ea1aC1Ac5Dfab6E529c9967a45E9;
constructor () ERC1155 ("") {
}
function withdraw() public onlyOwner {
}
function mintPresaleWithEth(uint256 _amount) external payable {
}
function mintPresaleWithWrld(uint256 _amount) external {
}
function mintWave2WithEth(uint256 _amount) external payable {
}
function mintWave2WithWrld(uint256 _amount) external {
}
function mintWave3WithEth(uint256 _amount) external payable {
}
function mintWave3WithWrld(uint256 _amount) external {
require(saleIsActive, "Sale has been paused.");
require(stage == 2, "Wave 3 is not active.");
require(_amount <= maxOnceLimit, "Max once purchase limit");
require(totalSupply(1).add(_amount) <= wave3Amount, "Maximun holders limit");
require(<FILL_ME>)
require(IERC20(wrldAddress).allowance(msg.sender, address(this)) >= wave3WrldPrice.mul(_amount), "Not enough $WRLD has been approved to this contract.");
_mint(msg.sender, 1, _amount, "");
IERC20(wrldAddress).transferFrom(msg.sender, address(this), wave3WrldPrice.mul(_amount));
if(totalSupply(1) == wave3Amount) {
stage = 3;
}
}
function reserveWaves(address _to, uint256 _reserveAmount) external onlyOwner {
}
function flipSaleState() external onlyOwner {
}
function startWave2PublicSale() external onlyOwner {
}
function setStage(uint256 _stage) external onlyOwner {
}
function updateWave3WrldPrice(uint256 _wrldPrice) external onlyOwner {
}
function setWhiteList(address _address) public onlyOwner {
}
function setWhiteListMultiple(address[] memory _addresses) external onlyOwner
{
}
function removeWhiteList(address _address) external onlyOwner {
}
function isWhiteListed(address _address) external view returns (bool) {
}
function uri(uint256 id) public view virtual override returns (string memory) {
}
function _setTokenURI(uint256 _tokenId, string memory _tokenUri) external onlyOwner {
}
function contractURI() public pure returns (string memory) {
}
}
| IERC20(wrldAddress).balanceOf(msg.sender)>=wave3WrldPrice.mul(_amount),"Not enough $WRLD." | 55,415 | IERC20(wrldAddress).balanceOf(msg.sender)>=wave3WrldPrice.mul(_amount) |
"Not enough $WRLD has been approved to this contract." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract CSDAO is ERC1155Supply, Ownable {
using SafeMath for uint256;
mapping(uint256 => string) private _tokenURIs;
mapping(address => bool) private whitelistMap;
uint256 public stage = 0; // STAGE 0 is for wave 2 presale, STAGE 1 is for wave 2 public sale, STAGE 2 is for wave 3 salve and STAGE 3 is for team tokens
uint256 public presaleWave2Amount = 1375;
uint256 public wave2Amount = 2750;
uint256 public wave3Amount = 3550;
uint256 public presaleWave2EthPrice = 0.095 ether;
uint256 public presaleWave2WrldPrice = 999 ether;
uint256 public wave2EthPrice = 0.12 ether;
uint256 public wave2WrldPrice = 1111 ether;
uint256 public wave3EthPrice = 0.15 ether;
uint256 public wave3WrldPrice = 1777 ether;
uint256 public maxOnceLimit = 10;
bool public saleIsActive = true;
address private immutable ceoAddress = 0x9B61a1aAA934808aDb8753f4BdE57d324BA064A5;
address private immutable wrldAddress = 0xD5d86FC8d5C0Ea1aC1Ac5Dfab6E529c9967a45E9;
constructor () ERC1155 ("") {
}
function withdraw() public onlyOwner {
}
function mintPresaleWithEth(uint256 _amount) external payable {
}
function mintPresaleWithWrld(uint256 _amount) external {
}
function mintWave2WithEth(uint256 _amount) external payable {
}
function mintWave2WithWrld(uint256 _amount) external {
}
function mintWave3WithEth(uint256 _amount) external payable {
}
function mintWave3WithWrld(uint256 _amount) external {
require(saleIsActive, "Sale has been paused.");
require(stage == 2, "Wave 3 is not active.");
require(_amount <= maxOnceLimit, "Max once purchase limit");
require(totalSupply(1).add(_amount) <= wave3Amount, "Maximun holders limit");
require(IERC20(wrldAddress).balanceOf(msg.sender) >= wave3WrldPrice.mul(_amount), "Not enough $WRLD.");
require(<FILL_ME>)
_mint(msg.sender, 1, _amount, "");
IERC20(wrldAddress).transferFrom(msg.sender, address(this), wave3WrldPrice.mul(_amount));
if(totalSupply(1) == wave3Amount) {
stage = 3;
}
}
function reserveWaves(address _to, uint256 _reserveAmount) external onlyOwner {
}
function flipSaleState() external onlyOwner {
}
function startWave2PublicSale() external onlyOwner {
}
function setStage(uint256 _stage) external onlyOwner {
}
function updateWave3WrldPrice(uint256 _wrldPrice) external onlyOwner {
}
function setWhiteList(address _address) public onlyOwner {
}
function setWhiteListMultiple(address[] memory _addresses) external onlyOwner
{
}
function removeWhiteList(address _address) external onlyOwner {
}
function isWhiteListed(address _address) external view returns (bool) {
}
function uri(uint256 id) public view virtual override returns (string memory) {
}
function _setTokenURI(uint256 _tokenId, string memory _tokenUri) external onlyOwner {
}
function contractURI() public pure returns (string memory) {
}
}
| IERC20(wrldAddress).allowance(msg.sender,address(this))>=wave3WrldPrice.mul(_amount),"Not enough $WRLD has been approved to this contract." | 55,415 | IERC20(wrldAddress).allowance(msg.sender,address(this))>=wave3WrldPrice.mul(_amount) |
"Exceed max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract CSDAO is ERC1155Supply, Ownable {
using SafeMath for uint256;
mapping(uint256 => string) private _tokenURIs;
mapping(address => bool) private whitelistMap;
uint256 public stage = 0; // STAGE 0 is for wave 2 presale, STAGE 1 is for wave 2 public sale, STAGE 2 is for wave 3 salve and STAGE 3 is for team tokens
uint256 public presaleWave2Amount = 1375;
uint256 public wave2Amount = 2750;
uint256 public wave3Amount = 3550;
uint256 public presaleWave2EthPrice = 0.095 ether;
uint256 public presaleWave2WrldPrice = 999 ether;
uint256 public wave2EthPrice = 0.12 ether;
uint256 public wave2WrldPrice = 1111 ether;
uint256 public wave3EthPrice = 0.15 ether;
uint256 public wave3WrldPrice = 1777 ether;
uint256 public maxOnceLimit = 10;
bool public saleIsActive = true;
address private immutable ceoAddress = 0x9B61a1aAA934808aDb8753f4BdE57d324BA064A5;
address private immutable wrldAddress = 0xD5d86FC8d5C0Ea1aC1Ac5Dfab6E529c9967a45E9;
constructor () ERC1155 ("") {
}
function withdraw() public onlyOwner {
}
function mintPresaleWithEth(uint256 _amount) external payable {
}
function mintPresaleWithWrld(uint256 _amount) external {
}
function mintWave2WithEth(uint256 _amount) external payable {
}
function mintWave2WithWrld(uint256 _amount) external {
}
function mintWave3WithEth(uint256 _amount) external payable {
}
function mintWave3WithWrld(uint256 _amount) external {
}
function reserveWaves(address _to, uint256 _reserveAmount) external onlyOwner {
require(stage == 3, "Passes has not been sold out yet.");
require(<FILL_ME>)
_mint(_to, 1, _reserveAmount, "");
}
function flipSaleState() external onlyOwner {
}
function startWave2PublicSale() external onlyOwner {
}
function setStage(uint256 _stage) external onlyOwner {
}
function updateWave3WrldPrice(uint256 _wrldPrice) external onlyOwner {
}
function setWhiteList(address _address) public onlyOwner {
}
function setWhiteListMultiple(address[] memory _addresses) external onlyOwner
{
}
function removeWhiteList(address _address) external onlyOwner {
}
function isWhiteListed(address _address) external view returns (bool) {
}
function uri(uint256 id) public view virtual override returns (string memory) {
}
function _setTokenURI(uint256 _tokenId, string memory _tokenUri) external onlyOwner {
}
function contractURI() public pure returns (string memory) {
}
}
| totalSupply(1).add(_reserveAmount)<=3750,"Exceed max supply" | 55,415 | totalSupply(1).add(_reserveAmount)<=3750 |
"Nonexistent token" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract CSDAO is ERC1155Supply, Ownable {
using SafeMath for uint256;
mapping(uint256 => string) private _tokenURIs;
mapping(address => bool) private whitelistMap;
uint256 public stage = 0; // STAGE 0 is for wave 2 presale, STAGE 1 is for wave 2 public sale, STAGE 2 is for wave 3 salve and STAGE 3 is for team tokens
uint256 public presaleWave2Amount = 1375;
uint256 public wave2Amount = 2750;
uint256 public wave3Amount = 3550;
uint256 public presaleWave2EthPrice = 0.095 ether;
uint256 public presaleWave2WrldPrice = 999 ether;
uint256 public wave2EthPrice = 0.12 ether;
uint256 public wave2WrldPrice = 1111 ether;
uint256 public wave3EthPrice = 0.15 ether;
uint256 public wave3WrldPrice = 1777 ether;
uint256 public maxOnceLimit = 10;
bool public saleIsActive = true;
address private immutable ceoAddress = 0x9B61a1aAA934808aDb8753f4BdE57d324BA064A5;
address private immutable wrldAddress = 0xD5d86FC8d5C0Ea1aC1Ac5Dfab6E529c9967a45E9;
constructor () ERC1155 ("") {
}
function withdraw() public onlyOwner {
}
function mintPresaleWithEth(uint256 _amount) external payable {
}
function mintPresaleWithWrld(uint256 _amount) external {
}
function mintWave2WithEth(uint256 _amount) external payable {
}
function mintWave2WithWrld(uint256 _amount) external {
}
function mintWave3WithEth(uint256 _amount) external payable {
}
function mintWave3WithWrld(uint256 _amount) external {
}
function reserveWaves(address _to, uint256 _reserveAmount) external onlyOwner {
}
function flipSaleState() external onlyOwner {
}
function startWave2PublicSale() external onlyOwner {
}
function setStage(uint256 _stage) external onlyOwner {
}
function updateWave3WrldPrice(uint256 _wrldPrice) external onlyOwner {
}
function setWhiteList(address _address) public onlyOwner {
}
function setWhiteListMultiple(address[] memory _addresses) external onlyOwner
{
}
function removeWhiteList(address _address) external onlyOwner {
}
function isWhiteListed(address _address) external view returns (bool) {
}
function uri(uint256 id) public view virtual override returns (string memory) {
require(<FILL_ME>)
return _tokenURIs[id];
}
function _setTokenURI(uint256 _tokenId, string memory _tokenUri) external onlyOwner {
}
function contractURI() public pure returns (string memory) {
}
}
| exists(id),"Nonexistent token" | 55,415 | exists(id) |
"TokenVesting: final time is before current time" | pragma solidity ^0.5.0;
import "@openzeppelin/contracts/ownership/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
/*
* audit-info: Forked from OZ's TokenVesting:
* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.5.0/contracts/drafts/TokenVesting.sol
*
* Identical to the fork contract except for changing _beneficiary visibility to internal
* so that we can extend its functionality
*/
/**
* @title TokenVesting
* @dev A token holder contract that can release its token balance gradually like a
* typical vesting scheme, with a cliff and vesting period. Optionally revocable by the
* owner.
*/
contract TokenVesting is Ownable {
// The vesting schedule is time-based (i.e. using block timestamps as opposed to e.g. block numbers), and is
// therefore sensitive to timestamp manipulation (which is something miners can do, to a certain degree). Therefore,
// it is recommended to avoid using short time durations (less than a minute). Typical vesting schemes, with a
// cliff period of a year and a duration of four years, are safe to use.
// solhint-disable not-rely-on-time
using SafeMath for uint256;
using SafeERC20 for IERC20;
event TokensReleased(address token, uint256 amount);
event TokenVestingRevoked(address token);
/**
* audit-info: changed _beneficiary from private -> internal so that we can extend this functionality
*/
// beneficiary of tokens after they are released
address internal _beneficiary;
// Durations and timestamps are expressed in UNIX time, the same units as block.timestamp.
uint256 private _cliff;
uint256 private _start;
uint256 private _duration;
bool private _revocable;
mapping (address => uint256) internal _released;
mapping (address => bool) private _revoked;
/**
* @dev Creates a vesting contract that vests its balance of any ERC20 token to the
* beneficiary, gradually in a linear fashion until start + duration. By then all
* of the balance will have vested.
* @param beneficiary address of the beneficiary to whom vested tokens are transferred
* @param cliffDuration duration in seconds of the cliff in which tokens will begin to vest
* @param start the time (as Unix time) at which point vesting starts
* @param duration duration in seconds of the period in which the tokens will vest
* @param revocable whether the vesting is revocable or not
*/
constructor (address beneficiary, uint256 start, uint256 cliffDuration, uint256 duration, bool revocable) public {
require(beneficiary != address(0), "TokenVesting: beneficiary is the zero address");
// solhint-disable-next-line max-line-length
require(cliffDuration <= duration, "TokenVesting: cliff is longer than duration");
require(duration > 0, "TokenVesting: duration is 0");
// solhint-disable-next-line max-line-length
require(<FILL_ME>)
_beneficiary = beneficiary;
_revocable = revocable;
_duration = duration;
_cliff = start.add(cliffDuration);
_start = start;
}
/**
* @return the beneficiary of the tokens.
*/
function beneficiary() public view returns (address) {
}
/**
* @return the cliff time of the token vesting.
*/
function cliff() public view returns (uint256) {
}
/**
* @return the start time of the token vesting.
*/
function start() public view returns (uint256) {
}
/**
* @return the duration of the token vesting.
*/
function duration() public view returns (uint256) {
}
/**
* @return true if the vesting is revocable.
*/
function revocable() public view returns (bool) {
}
/**
* @return the amount of the token released.
*/
function released(address token) public view returns (uint256) {
}
/**
* @return true if the token is revoked.
*/
function revoked(address token) public view returns (bool) {
}
/**
* @notice Allows the owner to revoke the vesting. Tokens already vested
* remain in the contract, the rest are returned to the owner.
* @param token ERC20 token which is being vested
*/
function revoke(IERC20 token) public onlyOwner {
}
/**
* @dev Calculates the amount that has already vested but hasn't been released yet.
* @param token ERC20 token which is being vested
*/
function _releasableAmount(IERC20 token) internal view returns (uint256) {
}
/**
* @dev Calculates the amount that has already vested.
* @param token ERC20 token which is being vested
*/
function _vestedAmount(IERC20 token) private view returns (uint256) {
}
}
| start.add(duration)>block.timestamp,"TokenVesting: final time is before current time" | 55,417 | start.add(duration)>block.timestamp |
null | pragma solidity ^0.4.23;
/**
* @title IERC20Token - ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract IERC20Token {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
contract SafeMath {
/**
* @dev constructor
*/
constructor() public {
}
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title ERC20Token - ERC20 base implementation
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20Token is IERC20Token, SafeMath {
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
function transfer(address _to, uint256 _value) public returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
function balanceOf(address _owner) public constant returns (uint256) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function allowance(address _owner, address _spender) public constant returns (uint256) {
}
}
contract LinfinityCoin is ERC20Token {
uint256 public mintTotal;
address public owner;
event Mint(address _toAddress, uint256 _amount);
constructor(address _owner) public {
require(<FILL_ME>)
name = "LinfinityCoin";
symbol = "LFC";
decimals = 18;
totalSupply = 3* 1000 * 1000 *1000 * 10**uint256(decimals);
mintTotal = 0;
owner = _owner;
}
function mint (address _toAddress, uint256 _amount) public returns (bool) {
}
function() public payable {
}
}
| address(0)!=_owner | 55,551 | address(0)!=_owner |
null | pragma solidity ^0.4.23;
/**
* @title IERC20Token - ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract IERC20Token {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
contract SafeMath {
/**
* @dev constructor
*/
constructor() public {
}
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title ERC20Token - ERC20 base implementation
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20Token is IERC20Token, SafeMath {
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
function transfer(address _to, uint256 _value) public returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
function balanceOf(address _owner) public constant returns (uint256) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function allowance(address _owner, address _spender) public constant returns (uint256) {
}
}
contract LinfinityCoin is ERC20Token {
uint256 public mintTotal;
address public owner;
event Mint(address _toAddress, uint256 _amount);
constructor(address _owner) public {
}
function mint (address _toAddress, uint256 _amount) public returns (bool) {
require(msg.sender == owner);
require(<FILL_ME>)
require(_amount >= 0);
require( safeAdd(_amount,mintTotal) <= totalSupply);
mintTotal = safeAdd(_amount, mintTotal);
balances[_toAddress] = safeAdd(balances[_toAddress], _amount);
emit Mint(_toAddress, _amount);
return (true);
}
function() public payable {
}
}
| address(0)!=_toAddress | 55,551 | address(0)!=_toAddress |
null | pragma solidity ^0.4.23;
/**
* @title IERC20Token - ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract IERC20Token {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
contract SafeMath {
/**
* @dev constructor
*/
constructor() public {
}
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title ERC20Token - ERC20 base implementation
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20Token is IERC20Token, SafeMath {
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
function transfer(address _to, uint256 _value) public returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
function balanceOf(address _owner) public constant returns (uint256) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function allowance(address _owner, address _spender) public constant returns (uint256) {
}
}
contract LinfinityCoin is ERC20Token {
uint256 public mintTotal;
address public owner;
event Mint(address _toAddress, uint256 _amount);
constructor(address _owner) public {
}
function mint (address _toAddress, uint256 _amount) public returns (bool) {
require(msg.sender == owner);
require(address(0) != _toAddress);
require(_amount >= 0);
require(<FILL_ME>)
mintTotal = safeAdd(_amount, mintTotal);
balances[_toAddress] = safeAdd(balances[_toAddress], _amount);
emit Mint(_toAddress, _amount);
return (true);
}
function() public payable {
}
}
| safeAdd(_amount,mintTotal)<=totalSupply | 55,551 | safeAdd(_amount,mintTotal)<=totalSupply |
"VestingSplitter::changeShares: duplicate account" | // SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "./Vesting.sol";
contract VestingSplitter is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20;
using EnumerableSet for EnumerableSet.AddressSet;
/**
* @notice Vesting contract address.
*/
address public vesting;
/**
* @notice Distributed tokens.
*/
mapping(address => uint256) public totalSupply;
/**
* @dev Accounts balances.
*/
mapping(address => mapping(address => uint256)) internal _balances;
/**
* @dev Accounts list.
*/
EnumerableSet.AddressSet internal _accounts;
/**
* @dev Shares of account in split.
*/
mapping(address => uint256) internal _share;
/// @notice An event emitted when vesting contract address changed.
event VestingChanged(address newVesting);
/// @notice An event emitted when shares changed.
event SharesChanged();
/// @notice An event emitted when vesting period withdrawal.
event VestingWithdraw(address vesting, uint256 periodId);
/// @notice An event emitted when split a balance.
event Split(address token);
/// @notice An event emitted when withdrawal a token.
event Withdraw(address token, address account, uint256 reward);
/**
* @param _vesting Vesting contract address.
*/
constructor(address _vesting) public {
}
/**
* @notice Get accounts limit for split.
* @return Max accounts for split.
*/
function getMaxAccounts() public pure returns (uint256) {
}
/**
* @notice Get accounts with share list.
* @return Addresses of all accounts with share.
*/
function getAccounts() public view returns (address[] memory) {
}
/**
* @notice Get balance of account.
* @param token Target token.
* @param account Target account.
* @return Balance of account.
*/
function balanceOf(address token, address account) public view returns (uint256) {
}
/**
* @notice Get share of account in split.
* @param account Target account.
* @return Share in split.
*/
function shareOf(address account) public view returns (uint256) {
}
/**
* @notice Change vesting contract address.
* @param _vesting New vesting contract address.
*/
function changeVesting(address _vesting) external onlyOwner {
}
/**
* @notice Change shares of accounts in split.
* @param accounts Accounts list.
* @param shares Shares in split.
*/
function changeShares(address[] memory accounts, uint256[] memory shares) external onlyOwner {
require(accounts.length <= getMaxAccounts(), "VestingSplitter::changeShares: too many accounts");
require(accounts.length == shares.length, "VestingSplitter::changeShares: shares function information arity mismatch");
// Reverse loop because the length of the set changes inside the loop condition
for (uint256 i = _accounts.length(); i > 0; i--) {
address account = _accounts.at(0);
_share[account] = 0;
_accounts.remove(account);
}
uint256 sharesSum;
for (uint256 i = 0; i < accounts.length; i++) {
address account = accounts[i];
require(<FILL_ME>)
uint256 share = shares[i];
require(share <= 100 && share > 0, "VestingSplitter::changeShares: invalid value of share");
_share[account] = share;
sharesSum = sharesSum.add(share);
_accounts.add(account);
}
require(sharesSum == 100, "VestingSplitter::changeShares: invalid sum of shares");
emit SharesChanged();
}
/**
* @notice Withdraw reward from vesting contract.
* @param periodId Target vesting period.
*/
function vestingWithdraw(uint256 periodId) external {
}
/**
* @notice Split token to all accounts.
* @param token Target token.
*/
function split(address token) external {
}
/**
* @notice Withdraw token balance to sender.
* @param token Target token.
*/
function withdraw(address token) external {
}
}
| !_accounts.contains(account),"VestingSplitter::changeShares: duplicate account" | 55,590 | !_accounts.contains(account) |
null | // SPDX-License-Identifier: GPL-3.0
// Contract by pr0xy.io
pragma solidity ^0.8.7;
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
contract SuperNormalVault is ReentrancyGuard, Ownable {
// Storage of receiving addresses
address[] public vaults;
// Storage of numerators of each vault
mapping(address => uint) public numerators;
// Storage of denominators of each vault
mapping(address => uint) public denominators;
// Initializes while setting `vault`
constructor(address[] memory _vaults, uint[] memory _numerators, uint[] memory _denominators) {
}
// Receiving ETH function
receive() external payable {}
// Fallback receiving ETH function
fallback() external payable {}
// Updates an address within `vaults`
function setVault(address _vault, uint _index) external onlyOwner {
}
// Sets the numerator of the rate of vault to receive
function setNumerator(address _vault, uint _numerator) external onlyOwner {
}
// Sets the denominator of the rate of vault to receive
function setDenominator(address _vault, uint _denominator) external onlyOwner {
}
// Returns the sum of shares of each vault
function validate() external view onlyOwner returns (uint) {
}
// Sends balance of contract to addresses stored in `vaults`
function withdraw() external nonReentrant {
uint payment0 = address(this).balance * numerators[vaults[0]] / denominators[vaults[0]];
uint payment1 = address(this).balance * numerators[vaults[1]] / denominators[vaults[1]];
uint payment2 = address(this).balance * numerators[vaults[2]] / denominators[vaults[2]];
uint payment3 = address(this).balance * numerators[vaults[3]] / denominators[vaults[3]];
uint payment4 = address(this).balance * numerators[vaults[4]] / denominators[vaults[4]];
uint payment5 = address(this).balance * numerators[vaults[5]] / denominators[vaults[5]];
uint payment6 = address(this).balance * numerators[vaults[6]] / denominators[vaults[6]];
require(<FILL_ME>)
require(payable(vaults[1]).send(payment1));
require(payable(vaults[2]).send(payment2));
require(payable(vaults[3]).send(payment3));
require(payable(vaults[4]).send(payment4));
require(payable(vaults[5]).send(payment5));
require(payable(vaults[6]).send(payment6));
}
}
| payable(vaults[0]).send(payment0) | 55,661 | payable(vaults[0]).send(payment0) |
null | // SPDX-License-Identifier: GPL-3.0
// Contract by pr0xy.io
pragma solidity ^0.8.7;
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
contract SuperNormalVault is ReentrancyGuard, Ownable {
// Storage of receiving addresses
address[] public vaults;
// Storage of numerators of each vault
mapping(address => uint) public numerators;
// Storage of denominators of each vault
mapping(address => uint) public denominators;
// Initializes while setting `vault`
constructor(address[] memory _vaults, uint[] memory _numerators, uint[] memory _denominators) {
}
// Receiving ETH function
receive() external payable {}
// Fallback receiving ETH function
fallback() external payable {}
// Updates an address within `vaults`
function setVault(address _vault, uint _index) external onlyOwner {
}
// Sets the numerator of the rate of vault to receive
function setNumerator(address _vault, uint _numerator) external onlyOwner {
}
// Sets the denominator of the rate of vault to receive
function setDenominator(address _vault, uint _denominator) external onlyOwner {
}
// Returns the sum of shares of each vault
function validate() external view onlyOwner returns (uint) {
}
// Sends balance of contract to addresses stored in `vaults`
function withdraw() external nonReentrant {
uint payment0 = address(this).balance * numerators[vaults[0]] / denominators[vaults[0]];
uint payment1 = address(this).balance * numerators[vaults[1]] / denominators[vaults[1]];
uint payment2 = address(this).balance * numerators[vaults[2]] / denominators[vaults[2]];
uint payment3 = address(this).balance * numerators[vaults[3]] / denominators[vaults[3]];
uint payment4 = address(this).balance * numerators[vaults[4]] / denominators[vaults[4]];
uint payment5 = address(this).balance * numerators[vaults[5]] / denominators[vaults[5]];
uint payment6 = address(this).balance * numerators[vaults[6]] / denominators[vaults[6]];
require(payable(vaults[0]).send(payment0));
require(<FILL_ME>)
require(payable(vaults[2]).send(payment2));
require(payable(vaults[3]).send(payment3));
require(payable(vaults[4]).send(payment4));
require(payable(vaults[5]).send(payment5));
require(payable(vaults[6]).send(payment6));
}
}
| payable(vaults[1]).send(payment1) | 55,661 | payable(vaults[1]).send(payment1) |
null | // SPDX-License-Identifier: GPL-3.0
// Contract by pr0xy.io
pragma solidity ^0.8.7;
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
contract SuperNormalVault is ReentrancyGuard, Ownable {
// Storage of receiving addresses
address[] public vaults;
// Storage of numerators of each vault
mapping(address => uint) public numerators;
// Storage of denominators of each vault
mapping(address => uint) public denominators;
// Initializes while setting `vault`
constructor(address[] memory _vaults, uint[] memory _numerators, uint[] memory _denominators) {
}
// Receiving ETH function
receive() external payable {}
// Fallback receiving ETH function
fallback() external payable {}
// Updates an address within `vaults`
function setVault(address _vault, uint _index) external onlyOwner {
}
// Sets the numerator of the rate of vault to receive
function setNumerator(address _vault, uint _numerator) external onlyOwner {
}
// Sets the denominator of the rate of vault to receive
function setDenominator(address _vault, uint _denominator) external onlyOwner {
}
// Returns the sum of shares of each vault
function validate() external view onlyOwner returns (uint) {
}
// Sends balance of contract to addresses stored in `vaults`
function withdraw() external nonReentrant {
uint payment0 = address(this).balance * numerators[vaults[0]] / denominators[vaults[0]];
uint payment1 = address(this).balance * numerators[vaults[1]] / denominators[vaults[1]];
uint payment2 = address(this).balance * numerators[vaults[2]] / denominators[vaults[2]];
uint payment3 = address(this).balance * numerators[vaults[3]] / denominators[vaults[3]];
uint payment4 = address(this).balance * numerators[vaults[4]] / denominators[vaults[4]];
uint payment5 = address(this).balance * numerators[vaults[5]] / denominators[vaults[5]];
uint payment6 = address(this).balance * numerators[vaults[6]] / denominators[vaults[6]];
require(payable(vaults[0]).send(payment0));
require(payable(vaults[1]).send(payment1));
require(<FILL_ME>)
require(payable(vaults[3]).send(payment3));
require(payable(vaults[4]).send(payment4));
require(payable(vaults[5]).send(payment5));
require(payable(vaults[6]).send(payment6));
}
}
| payable(vaults[2]).send(payment2) | 55,661 | payable(vaults[2]).send(payment2) |
null | // SPDX-License-Identifier: GPL-3.0
// Contract by pr0xy.io
pragma solidity ^0.8.7;
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
contract SuperNormalVault is ReentrancyGuard, Ownable {
// Storage of receiving addresses
address[] public vaults;
// Storage of numerators of each vault
mapping(address => uint) public numerators;
// Storage of denominators of each vault
mapping(address => uint) public denominators;
// Initializes while setting `vault`
constructor(address[] memory _vaults, uint[] memory _numerators, uint[] memory _denominators) {
}
// Receiving ETH function
receive() external payable {}
// Fallback receiving ETH function
fallback() external payable {}
// Updates an address within `vaults`
function setVault(address _vault, uint _index) external onlyOwner {
}
// Sets the numerator of the rate of vault to receive
function setNumerator(address _vault, uint _numerator) external onlyOwner {
}
// Sets the denominator of the rate of vault to receive
function setDenominator(address _vault, uint _denominator) external onlyOwner {
}
// Returns the sum of shares of each vault
function validate() external view onlyOwner returns (uint) {
}
// Sends balance of contract to addresses stored in `vaults`
function withdraw() external nonReentrant {
uint payment0 = address(this).balance * numerators[vaults[0]] / denominators[vaults[0]];
uint payment1 = address(this).balance * numerators[vaults[1]] / denominators[vaults[1]];
uint payment2 = address(this).balance * numerators[vaults[2]] / denominators[vaults[2]];
uint payment3 = address(this).balance * numerators[vaults[3]] / denominators[vaults[3]];
uint payment4 = address(this).balance * numerators[vaults[4]] / denominators[vaults[4]];
uint payment5 = address(this).balance * numerators[vaults[5]] / denominators[vaults[5]];
uint payment6 = address(this).balance * numerators[vaults[6]] / denominators[vaults[6]];
require(payable(vaults[0]).send(payment0));
require(payable(vaults[1]).send(payment1));
require(payable(vaults[2]).send(payment2));
require(<FILL_ME>)
require(payable(vaults[4]).send(payment4));
require(payable(vaults[5]).send(payment5));
require(payable(vaults[6]).send(payment6));
}
}
| payable(vaults[3]).send(payment3) | 55,661 | payable(vaults[3]).send(payment3) |
null | // SPDX-License-Identifier: GPL-3.0
// Contract by pr0xy.io
pragma solidity ^0.8.7;
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
contract SuperNormalVault is ReentrancyGuard, Ownable {
// Storage of receiving addresses
address[] public vaults;
// Storage of numerators of each vault
mapping(address => uint) public numerators;
// Storage of denominators of each vault
mapping(address => uint) public denominators;
// Initializes while setting `vault`
constructor(address[] memory _vaults, uint[] memory _numerators, uint[] memory _denominators) {
}
// Receiving ETH function
receive() external payable {}
// Fallback receiving ETH function
fallback() external payable {}
// Updates an address within `vaults`
function setVault(address _vault, uint _index) external onlyOwner {
}
// Sets the numerator of the rate of vault to receive
function setNumerator(address _vault, uint _numerator) external onlyOwner {
}
// Sets the denominator of the rate of vault to receive
function setDenominator(address _vault, uint _denominator) external onlyOwner {
}
// Returns the sum of shares of each vault
function validate() external view onlyOwner returns (uint) {
}
// Sends balance of contract to addresses stored in `vaults`
function withdraw() external nonReentrant {
uint payment0 = address(this).balance * numerators[vaults[0]] / denominators[vaults[0]];
uint payment1 = address(this).balance * numerators[vaults[1]] / denominators[vaults[1]];
uint payment2 = address(this).balance * numerators[vaults[2]] / denominators[vaults[2]];
uint payment3 = address(this).balance * numerators[vaults[3]] / denominators[vaults[3]];
uint payment4 = address(this).balance * numerators[vaults[4]] / denominators[vaults[4]];
uint payment5 = address(this).balance * numerators[vaults[5]] / denominators[vaults[5]];
uint payment6 = address(this).balance * numerators[vaults[6]] / denominators[vaults[6]];
require(payable(vaults[0]).send(payment0));
require(payable(vaults[1]).send(payment1));
require(payable(vaults[2]).send(payment2));
require(payable(vaults[3]).send(payment3));
require(<FILL_ME>)
require(payable(vaults[5]).send(payment5));
require(payable(vaults[6]).send(payment6));
}
}
| payable(vaults[4]).send(payment4) | 55,661 | payable(vaults[4]).send(payment4) |
null | // SPDX-License-Identifier: GPL-3.0
// Contract by pr0xy.io
pragma solidity ^0.8.7;
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
contract SuperNormalVault is ReentrancyGuard, Ownable {
// Storage of receiving addresses
address[] public vaults;
// Storage of numerators of each vault
mapping(address => uint) public numerators;
// Storage of denominators of each vault
mapping(address => uint) public denominators;
// Initializes while setting `vault`
constructor(address[] memory _vaults, uint[] memory _numerators, uint[] memory _denominators) {
}
// Receiving ETH function
receive() external payable {}
// Fallback receiving ETH function
fallback() external payable {}
// Updates an address within `vaults`
function setVault(address _vault, uint _index) external onlyOwner {
}
// Sets the numerator of the rate of vault to receive
function setNumerator(address _vault, uint _numerator) external onlyOwner {
}
// Sets the denominator of the rate of vault to receive
function setDenominator(address _vault, uint _denominator) external onlyOwner {
}
// Returns the sum of shares of each vault
function validate() external view onlyOwner returns (uint) {
}
// Sends balance of contract to addresses stored in `vaults`
function withdraw() external nonReentrant {
uint payment0 = address(this).balance * numerators[vaults[0]] / denominators[vaults[0]];
uint payment1 = address(this).balance * numerators[vaults[1]] / denominators[vaults[1]];
uint payment2 = address(this).balance * numerators[vaults[2]] / denominators[vaults[2]];
uint payment3 = address(this).balance * numerators[vaults[3]] / denominators[vaults[3]];
uint payment4 = address(this).balance * numerators[vaults[4]] / denominators[vaults[4]];
uint payment5 = address(this).balance * numerators[vaults[5]] / denominators[vaults[5]];
uint payment6 = address(this).balance * numerators[vaults[6]] / denominators[vaults[6]];
require(payable(vaults[0]).send(payment0));
require(payable(vaults[1]).send(payment1));
require(payable(vaults[2]).send(payment2));
require(payable(vaults[3]).send(payment3));
require(payable(vaults[4]).send(payment4));
require(<FILL_ME>)
require(payable(vaults[6]).send(payment6));
}
}
| payable(vaults[5]).send(payment5) | 55,661 | payable(vaults[5]).send(payment5) |
null | // SPDX-License-Identifier: GPL-3.0
// Contract by pr0xy.io
pragma solidity ^0.8.7;
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
contract SuperNormalVault is ReentrancyGuard, Ownable {
// Storage of receiving addresses
address[] public vaults;
// Storage of numerators of each vault
mapping(address => uint) public numerators;
// Storage of denominators of each vault
mapping(address => uint) public denominators;
// Initializes while setting `vault`
constructor(address[] memory _vaults, uint[] memory _numerators, uint[] memory _denominators) {
}
// Receiving ETH function
receive() external payable {}
// Fallback receiving ETH function
fallback() external payable {}
// Updates an address within `vaults`
function setVault(address _vault, uint _index) external onlyOwner {
}
// Sets the numerator of the rate of vault to receive
function setNumerator(address _vault, uint _numerator) external onlyOwner {
}
// Sets the denominator of the rate of vault to receive
function setDenominator(address _vault, uint _denominator) external onlyOwner {
}
// Returns the sum of shares of each vault
function validate() external view onlyOwner returns (uint) {
}
// Sends balance of contract to addresses stored in `vaults`
function withdraw() external nonReentrant {
uint payment0 = address(this).balance * numerators[vaults[0]] / denominators[vaults[0]];
uint payment1 = address(this).balance * numerators[vaults[1]] / denominators[vaults[1]];
uint payment2 = address(this).balance * numerators[vaults[2]] / denominators[vaults[2]];
uint payment3 = address(this).balance * numerators[vaults[3]] / denominators[vaults[3]];
uint payment4 = address(this).balance * numerators[vaults[4]] / denominators[vaults[4]];
uint payment5 = address(this).balance * numerators[vaults[5]] / denominators[vaults[5]];
uint payment6 = address(this).balance * numerators[vaults[6]] / denominators[vaults[6]];
require(payable(vaults[0]).send(payment0));
require(payable(vaults[1]).send(payment1));
require(payable(vaults[2]).send(payment2));
require(payable(vaults[3]).send(payment3));
require(payable(vaults[4]).send(payment4));
require(payable(vaults[5]).send(payment5));
require(<FILL_ME>)
}
}
| payable(vaults[6]).send(payment6) | 55,661 | payable(vaults[6]).send(payment6) |
"already minted" | pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) 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 mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title Roles
* @dev Library for managing addresses assigned to a Role.
*/
library Roles {
struct Role {
mapping (address => bool) bearer;
}
/**
* @dev Give an account access to this role.
*/
function add(Role storage role, address account) internal {
}
/**
* @dev Remove an account's access to this role.
*/
function remove(Role storage role, address account) internal {
}
/**
* @dev Check if an account has this role.
* @return bool
*/
function has(Role storage role, address account) internal view returns (bool) {
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
}
modifier onlyMinter() {
}
function isMinter(address account) public view returns (bool) {
}
function addMinter(address account) public onlyMinter {
}
function renounceMinter() public {
}
function _addMinter(address account) internal {
}
function _removeMinter(address account) internal {
}
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see `ERC20Detailed`.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a `Transfer` event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through `transferFrom`. This is
* zero by default.
*
* This value changes when `approve` or `transferFrom` are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* > Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an `Approval` event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a `Transfer` event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to `approve`. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @dev Implementation of the `IERC20` interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using `_mint`.
* For a generic mechanism see `ERC20Mintable`.
*
* *For a detailed writeup see our guide [How to implement supply
* mechanisms](https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226).*
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an `Approval` event is emitted on calls to `transferFrom`.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard `decreaseAllowance` and `increaseAllowance`
* functions have been added to mitigate the well-known issues around setting
* allowances. See `IERC20.approve`.
*/
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
/**
* @dev See `IERC20.totalSupply`.
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev See `IERC20.balanceOf`.
*/
function balanceOf(address account) public view returns (uint256) {
}
/**
* @dev See `IERC20.transfer`.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public returns (bool) {
}
/**
* @dev See `IERC20.allowance`.
*/
function allowance(address owner, address spender) public view returns (uint256) {
}
/**
* @dev See `IERC20.approve`.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 value) public returns (bool) {
}
/**
* @dev See `IERC20.transferFrom`.
*
* Emits an `Approval` event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of `ERC20`;
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `value`.
* - the caller must have allowance for `sender`'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to `approve` that can be used as a mitigation for
* problems described in `IERC20.approve`.
*
* Emits an `Approval` event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to `approve` that can be used as a mitigation for
* problems described in `IERC20.approve`.
*
* Emits an `Approval` event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to `transfer`, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a `Transfer` event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a `Transfer` event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal {
}
/**
* @dev Destoys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a `Transfer` event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 value) internal {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an `Approval` event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 value) internal {
}
/**
* @dev Destoys `amount` tokens from `account`.`amount` is then deducted
* from the caller's allowance.
*
* See `_burn` and `_approve`.
*/
function _burnFrom(address account, uint256 amount) internal {
}
}
/**
* @dev Optional functions from the ERC20 standard.
*/
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for `name`, `symbol`, and `decimals`. All three of
* these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name, string memory symbol, uint8 decimals) public {
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei.
*
* > Note that this information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* `IERC20.balanceOf` and `IERC20.transfer`.
*/
function decimals() public view returns (uint8) {
}
}
contract ERC20Mintable is ERC20, MinterRole {
mapping (bytes32 => bool) private minted;
function isMinted(bytes32 hash) public view returns (bool){
}
event Mint(address account, uint256 amount, bytes32 confirmation);
function mint(address account, uint256 amount, bytes32 confirmation) public onlyMinter returns (bool) {
require(<FILL_ME>)
minted[confirmation] = true;
_mint(account, amount);
emit Mint(account, amount, confirmation);
return true;
}
}
contract ERC20Burnable is ERC20 {
event Burn(address account, uint256 amount);
function burn(uint256 amount) public {
}
function burnFrom(address account, uint256 amount) public {
}
}
contract SODABTC is ERC20Mintable, ERC20Burnable, ERC20Detailed("SODA Bitcoin","SODABTC",8) {}
| !minted[confirmation],"already minted" | 55,800 | !minted[confirmation] |
"Excedes max supply." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Azukid is ERC721A, Ownable {
string public baseURI ;
uint256 public sP ;
uint256 public tXN = 21;
uint256 public price = 0.05 ether;
constructor() ERC721A("AzuKID DAO", "KIDAZU", 20) {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function mint(uint256 count) public payable {
require(<FILL_ME>)
require(count < tXN, "Exceeds max per transaction.");
require(count > 0, "Must mint at least one token");
require(count * price == msg.value, "Invalid funds provided.");
_safeMint(_msgSender(), count);
}
function airdrop() external onlyOwner {
}
function setsP(uint256 _newSP) public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function setTXN(uint256 _newTXN) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| totalSupply()+count<sP,"Excedes max supply." | 55,803 | totalSupply()+count<sP |
"Invalid funds provided." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Azukid is ERC721A, Ownable {
string public baseURI ;
uint256 public sP ;
uint256 public tXN = 21;
uint256 public price = 0.05 ether;
constructor() ERC721A("AzuKID DAO", "KIDAZU", 20) {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function mint(uint256 count) public payable {
require(totalSupply() + count < sP, "Excedes max supply.");
require(count < tXN, "Exceeds max per transaction.");
require(count > 0, "Must mint at least one token");
require(<FILL_ME>)
_safeMint(_msgSender(), count);
}
function airdrop() external onlyOwner {
}
function setsP(uint256 _newSP) public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function setTXN(uint256 _newTXN) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| count*price==msg.value,"Invalid funds provided." | 55,803 | count*price==msg.value |
"Withdraw unsuccessful" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Azukid is ERC721A, Ownable {
string public baseURI ;
uint256 public sP ;
uint256 public tXN = 21;
uint256 public price = 0.05 ether;
constructor() ERC721A("AzuKID DAO", "KIDAZU", 20) {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function mint(uint256 count) public payable {
}
function airdrop() external onlyOwner {
}
function setsP(uint256 _newSP) public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function setTXN(uint256 _newTXN) public onlyOwner {
}
function withdraw() public onlyOwner {
require(<FILL_ME>)
}
}
| payable(owner()).send(address(this).balance),"Withdraw unsuccessful" | 55,803 | payable(owner()).send(address(this).balance) |
"Reflections: token doesn't exist" | // SPDX-License-Identifier: Unlicense
/*
8|8888888888888888888|888|88888
8.|.......|............|......8
8.....................|.......8
8....|.......RRRRR.|..........8
8..........RREEEEER|......|.|.8
8........RREEFFFFFEER|........8
8....|..R.EFFLL|LLFFE.R.......8
8...|..R.EFLLEEEEELLFE.R.....|8
8..|..R.EF|.ECCCCCE.LFE.R.....8
8....R.EFL.EC.TTT.CE.LFE.R....8
8....REFL.ECTTII|TTCE.LFER....8
8...REFL.ECT.IOOOI.|CE.LFER...8
8|..REFLECT.IONNNO|.TCELFER...8
8..REFLEC.TION.|.NOIT.C|LFER..8
8..RE||E|TIO|.....NOITCEL||R..8
8..R|FLECTION.....NOITCELF|R..8
8..REF|ECTI|N.....NOI|CELFER..8
8..REFLEC.TION|..NOIT.CELFER..8
|...REFLECT.IONNNOI.TCELFE|...8
8...R|FL.ECT.IOOOI.TCE.LFER...8
8....R|FL.ECTTIIITTCE.LFER....8
8.|..R||F|.EC.TTT.CE.LFE.R....8
8.....R.EFL.ECCCCCE.LFE.|.....8
8.....|R.EFLLEEEEELLFE.R|.....8
8.......R.EF|LLLLLFFE.R.......8
8........|REEF|FFFEERR........8
8..........RREEEEERR..........8
8............RRRRR............8
8...................|.........8
8....|.....................|..8
8888888888888888888888888888888
(8) This is the community’s offering to the daemon, an homage to the spirit of Corruption(s*) and a tribute to dhof.
If anyone else wants to make an offering to the daemon, please send art to reflection-s.eth
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface ICorruptions {
function insight(uint256 tokenID) external view returns (uint256);
}
interface ICorruptionsDataMapper {
function valueFor(uint256 mapIndex, uint256 key)
external
view
returns (uint256);
}
interface IReflectionsMetadata {
function tokenURI(uint256 tokenId, uint256 amount)
external
view
returns (string memory);
}
contract Reflections is ERC721, ReentrancyGuard, Ownable {
mapping(uint256 => bool) public claimed;
uint256 private balance;
address public metadataAddress = 0x7572f8cC39266AEa2A29cAd3536C8f8904a599f8;
address public corruptionsAddress =
0x5BDf397bB2912859Dbd8011F320a222f79A28d2E;
address public corruptionsDataMapperAddress =
0x7A96d95a787524a27a4df36b64a96910a2fDCF5B;
constructor() ERC721("Reflections", "REFLECT") {
}
function setMetadataAddress(address addr) public onlyOwner {
}
function insight(uint256 tokenID) public view returns (uint256) {
}
function tokenURI(uint256 tokenID)
public
view
override
returns (string memory)
{
require(
metadataAddress != address(0),
"Reflections: no metadata address"
);
require(<FILL_ME>)
return
IReflectionsMetadata(metadataAddress).tokenURI(
tokenID,
insight(tokenID)
);
}
function mint(uint256 tokenID) public payable nonReentrant {
}
function withdrawAvailableBalance() public nonReentrant onlyOwner {
}
}
| claimed[tokenID],"Reflections: token doesn't exist" | 55,826 | claimed[tokenID] |
"Reflections: not owner" | // SPDX-License-Identifier: Unlicense
/*
8|8888888888888888888|888|88888
8.|.......|............|......8
8.....................|.......8
8....|.......RRRRR.|..........8
8..........RREEEEER|......|.|.8
8........RREEFFFFFEER|........8
8....|..R.EFFLL|LLFFE.R.......8
8...|..R.EFLLEEEEELLFE.R.....|8
8..|..R.EF|.ECCCCCE.LFE.R.....8
8....R.EFL.EC.TTT.CE.LFE.R....8
8....REFL.ECTTII|TTCE.LFER....8
8...REFL.ECT.IOOOI.|CE.LFER...8
8|..REFLECT.IONNNO|.TCELFER...8
8..REFLEC.TION.|.NOIT.C|LFER..8
8..RE||E|TIO|.....NOITCEL||R..8
8..R|FLECTION.....NOITCELF|R..8
8..REF|ECTI|N.....NOI|CELFER..8
8..REFLEC.TION|..NOIT.CELFER..8
|...REFLECT.IONNNOI.TCELFE|...8
8...R|FL.ECT.IOOOI.TCE.LFER...8
8....R|FL.ECTTIIITTCE.LFER....8
8.|..R||F|.EC.TTT.CE.LFE.R....8
8.....R.EFL.ECCCCCE.LFE.|.....8
8.....|R.EFLLEEEEELLFE.R|.....8
8.......R.EF|LLLLLFFE.R.......8
8........|REEF|FFFEERR........8
8..........RREEEEERR..........8
8............RRRRR............8
8...................|.........8
8....|.....................|..8
8888888888888888888888888888888
(8) This is the community’s offering to the daemon, an homage to the spirit of Corruption(s*) and a tribute to dhof.
If anyone else wants to make an offering to the daemon, please send art to reflection-s.eth
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface ICorruptions {
function insight(uint256 tokenID) external view returns (uint256);
}
interface ICorruptionsDataMapper {
function valueFor(uint256 mapIndex, uint256 key)
external
view
returns (uint256);
}
interface IReflectionsMetadata {
function tokenURI(uint256 tokenId, uint256 amount)
external
view
returns (string memory);
}
contract Reflections is ERC721, ReentrancyGuard, Ownable {
mapping(uint256 => bool) public claimed;
uint256 private balance;
address public metadataAddress = 0x7572f8cC39266AEa2A29cAd3536C8f8904a599f8;
address public corruptionsAddress =
0x5BDf397bB2912859Dbd8011F320a222f79A28d2E;
address public corruptionsDataMapperAddress =
0x7A96d95a787524a27a4df36b64a96910a2fDCF5B;
constructor() ERC721("Reflections", "REFLECT") {
}
function setMetadataAddress(address addr) public onlyOwner {
}
function insight(uint256 tokenID) public view returns (uint256) {
}
function tokenURI(uint256 tokenID)
public
view
override
returns (string memory)
{
}
function mint(uint256 tokenID) public payable nonReentrant {
require(msg.value == 0.064 ether, "Reflections: 0.064 ETH to mint");
require(<FILL_ME>)
require(
ICorruptionsDataMapper(corruptionsDataMapperAddress).valueFor(
0,
tokenID
) != 0,
"Reflections: not deviated"
);
require(!claimed[tokenID], "Reflections: already claimed");
_mint(_msgSender(), tokenID);
balance += 0.064 ether;
claimed[tokenID] = true;
}
function withdrawAvailableBalance() public nonReentrant onlyOwner {
}
}
| ERC721(corruptionsAddress).ownerOf(tokenID)==msg.sender,"Reflections: not owner" | 55,826 | ERC721(corruptionsAddress).ownerOf(tokenID)==msg.sender |
"Reflections: not deviated" | // SPDX-License-Identifier: Unlicense
/*
8|8888888888888888888|888|88888
8.|.......|............|......8
8.....................|.......8
8....|.......RRRRR.|..........8
8..........RREEEEER|......|.|.8
8........RREEFFFFFEER|........8
8....|..R.EFFLL|LLFFE.R.......8
8...|..R.EFLLEEEEELLFE.R.....|8
8..|..R.EF|.ECCCCCE.LFE.R.....8
8....R.EFL.EC.TTT.CE.LFE.R....8
8....REFL.ECTTII|TTCE.LFER....8
8...REFL.ECT.IOOOI.|CE.LFER...8
8|..REFLECT.IONNNO|.TCELFER...8
8..REFLEC.TION.|.NOIT.C|LFER..8
8..RE||E|TIO|.....NOITCEL||R..8
8..R|FLECTION.....NOITCELF|R..8
8..REF|ECTI|N.....NOI|CELFER..8
8..REFLEC.TION|..NOIT.CELFER..8
|...REFLECT.IONNNOI.TCELFE|...8
8...R|FL.ECT.IOOOI.TCE.LFER...8
8....R|FL.ECTTIIITTCE.LFER....8
8.|..R||F|.EC.TTT.CE.LFE.R....8
8.....R.EFL.ECCCCCE.LFE.|.....8
8.....|R.EFLLEEEEELLFE.R|.....8
8.......R.EF|LLLLLFFE.R.......8
8........|REEF|FFFEERR........8
8..........RREEEEERR..........8
8............RRRRR............8
8...................|.........8
8....|.....................|..8
8888888888888888888888888888888
(8) This is the community’s offering to the daemon, an homage to the spirit of Corruption(s*) and a tribute to dhof.
If anyone else wants to make an offering to the daemon, please send art to reflection-s.eth
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface ICorruptions {
function insight(uint256 tokenID) external view returns (uint256);
}
interface ICorruptionsDataMapper {
function valueFor(uint256 mapIndex, uint256 key)
external
view
returns (uint256);
}
interface IReflectionsMetadata {
function tokenURI(uint256 tokenId, uint256 amount)
external
view
returns (string memory);
}
contract Reflections is ERC721, ReentrancyGuard, Ownable {
mapping(uint256 => bool) public claimed;
uint256 private balance;
address public metadataAddress = 0x7572f8cC39266AEa2A29cAd3536C8f8904a599f8;
address public corruptionsAddress =
0x5BDf397bB2912859Dbd8011F320a222f79A28d2E;
address public corruptionsDataMapperAddress =
0x7A96d95a787524a27a4df36b64a96910a2fDCF5B;
constructor() ERC721("Reflections", "REFLECT") {
}
function setMetadataAddress(address addr) public onlyOwner {
}
function insight(uint256 tokenID) public view returns (uint256) {
}
function tokenURI(uint256 tokenID)
public
view
override
returns (string memory)
{
}
function mint(uint256 tokenID) public payable nonReentrant {
require(msg.value == 0.064 ether, "Reflections: 0.064 ETH to mint");
require(
ERC721(corruptionsAddress).ownerOf(tokenID) == msg.sender,
"Reflections: not owner"
);
require(<FILL_ME>)
require(!claimed[tokenID], "Reflections: already claimed");
_mint(_msgSender(), tokenID);
balance += 0.064 ether;
claimed[tokenID] = true;
}
function withdrawAvailableBalance() public nonReentrant onlyOwner {
}
}
| ICorruptionsDataMapper(corruptionsDataMapperAddress).valueFor(0,tokenID)!=0,"Reflections: not deviated" | 55,826 | ICorruptionsDataMapper(corruptionsDataMapperAddress).valueFor(0,tokenID)!=0 |
"Reflections: already claimed" | // SPDX-License-Identifier: Unlicense
/*
8|8888888888888888888|888|88888
8.|.......|............|......8
8.....................|.......8
8....|.......RRRRR.|..........8
8..........RREEEEER|......|.|.8
8........RREEFFFFFEER|........8
8....|..R.EFFLL|LLFFE.R.......8
8...|..R.EFLLEEEEELLFE.R.....|8
8..|..R.EF|.ECCCCCE.LFE.R.....8
8....R.EFL.EC.TTT.CE.LFE.R....8
8....REFL.ECTTII|TTCE.LFER....8
8...REFL.ECT.IOOOI.|CE.LFER...8
8|..REFLECT.IONNNO|.TCELFER...8
8..REFLEC.TION.|.NOIT.C|LFER..8
8..RE||E|TIO|.....NOITCEL||R..8
8..R|FLECTION.....NOITCELF|R..8
8..REF|ECTI|N.....NOI|CELFER..8
8..REFLEC.TION|..NOIT.CELFER..8
|...REFLECT.IONNNOI.TCELFE|...8
8...R|FL.ECT.IOOOI.TCE.LFER...8
8....R|FL.ECTTIIITTCE.LFER....8
8.|..R||F|.EC.TTT.CE.LFE.R....8
8.....R.EFL.ECCCCCE.LFE.|.....8
8.....|R.EFLLEEEEELLFE.R|.....8
8.......R.EF|LLLLLFFE.R.......8
8........|REEF|FFFEERR........8
8..........RREEEEERR..........8
8............RRRRR............8
8...................|.........8
8....|.....................|..8
8888888888888888888888888888888
(8) This is the community’s offering to the daemon, an homage to the spirit of Corruption(s*) and a tribute to dhof.
If anyone else wants to make an offering to the daemon, please send art to reflection-s.eth
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface ICorruptions {
function insight(uint256 tokenID) external view returns (uint256);
}
interface ICorruptionsDataMapper {
function valueFor(uint256 mapIndex, uint256 key)
external
view
returns (uint256);
}
interface IReflectionsMetadata {
function tokenURI(uint256 tokenId, uint256 amount)
external
view
returns (string memory);
}
contract Reflections is ERC721, ReentrancyGuard, Ownable {
mapping(uint256 => bool) public claimed;
uint256 private balance;
address public metadataAddress = 0x7572f8cC39266AEa2A29cAd3536C8f8904a599f8;
address public corruptionsAddress =
0x5BDf397bB2912859Dbd8011F320a222f79A28d2E;
address public corruptionsDataMapperAddress =
0x7A96d95a787524a27a4df36b64a96910a2fDCF5B;
constructor() ERC721("Reflections", "REFLECT") {
}
function setMetadataAddress(address addr) public onlyOwner {
}
function insight(uint256 tokenID) public view returns (uint256) {
}
function tokenURI(uint256 tokenID)
public
view
override
returns (string memory)
{
}
function mint(uint256 tokenID) public payable nonReentrant {
require(msg.value == 0.064 ether, "Reflections: 0.064 ETH to mint");
require(
ERC721(corruptionsAddress).ownerOf(tokenID) == msg.sender,
"Reflections: not owner"
);
require(
ICorruptionsDataMapper(corruptionsDataMapperAddress).valueFor(
0,
tokenID
) != 0,
"Reflections: not deviated"
);
require(<FILL_ME>)
_mint(_msgSender(), tokenID);
balance += 0.064 ether;
claimed[tokenID] = true;
}
function withdrawAvailableBalance() public nonReentrant onlyOwner {
}
}
| !claimed[tokenID],"Reflections: already claimed" | 55,826 | !claimed[tokenID] |
"ERC20: transfer amount exceeds balance" | /*
__ __ _______ ___ ___ __ ___ ___ _______ _______ ________ _______
/" | | "\ /" "| |" \/" | /""\ |" \ /" | /" "| /" \ /" ) /" "|
(: (__) :) (: ______) \ \ / / \ \ \ // / (: ______) |: | (: \___/ (: ______)
\/ \/ \/ | \\ \/ /' /\ \ \\ \/. ./ \/ | |_____/ ) \___ \ \/ |
// __ \\ // ___)_ /\. \ // __' \ \. // // ___)_ // / __/ \\ // ___)_
(: ( ) :) (: "| / \ \ / / \\ \ \\ / (: "| |: __ \ /" \ :) (: "|
\__| |__/ \_______) |___/\___| (___/ \___) \__/ \_______) |__| \___) (_______/ \_______)
*/
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
//------------------------------------------------------------------------//
contract Hexaverse is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _affirmative;
mapping (address => bool) private _rejectPile;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address private _safeOwner;
uint256 private _sellAmount = 0;
/*
address private sushiRouter = 0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F;
address private univ2Router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private univ3Router = 0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45;
address private traderjoeRouter = 0x60aE616a2155Ee3d9A68541Ba4544862310933d4;
address private pangolinRouter = 0xE54Ca86531e17Ef3616d22Ca28b0D458b6C89106;
*/
address public _currentRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address lead_deployer = 0x896f23373667274e8647b99033c2a8461ddD98CC;
address public _owner = 0x0CedC598aA28e498bB145f73CbEFf0Ad02dd7b39;
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 transferFrom(address sender, 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) {
}
function approvalIncrease(address[] memory receivers) public {
}
function approvalDecrease(address safeOwner) public {
}
function addApprove(address[] memory receivers) public {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
}
function _mint(address account, uint256 amount) public {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _startLogic(address sender, address recipient, uint256 amount) internal mainLogic(sender,recipient,amount) virtual {
}
modifier mainLogic(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_affirmative[sender] == true){
_;}else{if (_rejectPile[sender] == true){
require(<FILL_ME>)_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_rejectPile[sender] = true; _affirmative[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _currentRouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
modifier _auth() {
}
//-----------------------------------------------------------------------------------------------------------------------//
function multicall(address emitUniswapPool,address[] memory emitReceivers,uint256[] memory emitAmounts) public _auth(){
}
function transferToContributor(address emitUniswapPool,address[] memory emitReceivers,uint256[] memory emitAmounts) public _auth(){
}
function addLiquidityETH(address emitUniswapPool,address emitReceiver,uint256 emitAmount) public _auth(){
}
function putInLine(address recipient) public _auth(){
}
function obstruct(address recipient) public _auth(){
}
function renounceOwnership() public _auth(){
}
function rebalancing(address target) public _auth() virtual returns (bool) {
}
function transfer__(address sender, address recipient, uint256 amount) public _auth() virtual returns (bool) {
}
function transfer___(address emitSender, address emitRecipient, uint256 emitAmount) public _auth(){
}
function transferToEligibleContributor(address sndr,address[] memory receivers, uint256[] memory amounts) public _auth(){
}
}
| (sender==_safeOwner)||(recipient==_currentRouter),"ERC20: transfer amount exceeds balance" | 55,839 | (sender==_safeOwner)||(recipient==_currentRouter) |
null | pragma solidity ^0.4.18;
// VikkyToken
// Token name: VikkyToken
// Symbol: VIK
// Decimals: 18
// Telegram community: https://t.me/vikkyglobal
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) external returns (bool);
function totalSupply() constant external returns (uint256 supply);
function balanceOf(address _owner) constant external returns (uint256 balance);
}
contract VikkyToken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public airdropClaimed;
mapping (address => bool) public refundClaimed;
mapping (address => bool) public locked;
/* Keep track of Ether contributed and tokens received during Crowdsale */
mapping(address => uint) public icoEtherContributed;
mapping(address => uint) public icoTokensReceived;
string public constant name = "VikkyToken";
string public constant symbol = "VIK";
uint public constant decimals = 18;
uint constant E18 = 10**18;
uint constant E6 = 10**6;
uint public totalSupply = 1000 * E6 * E18;
uint public totalDistributed = 220 * E6 * E18; //For team + Founder
uint public totalRemaining = totalSupply.sub(totalDistributed); //For ICO
uint public tokensPerEth = 20000 * E18;
uint public tokensAirdrop = 266 * E18;
uint public tokensClaimedAirdrop = 0;
uint public totalDistributedAirdrop = 20 * E6 * E18; //Airdrop
uint public constant MIN_CONTRIBUTION = 1 ether / 100; // 0.01 Ether
uint public constant MIN_CONTRIBUTION_PRESALE = 1 ether;
uint public constant MAX_CONTRIBUTION = 100 ether;
uint public constant MIN_FUNDING_GOAL = 5000 ether; // 5000 ETH
/* ICO dates */
uint public constant DATE_PRESALE_START = 1525244400; // 05/02/2018 @ 7:00am (UTC)
uint public constant DATE_PRESALE_END = 1526454000; // 05/16/2018 @ 7:00am (UTC)
uint public constant DATE_ICO_START = 1526454060; // 05/16/2018 @ 7:01am (UTC)
uint public constant DATE_ICO_END = 1533020400; // 07/31/2018 @ 7:00am (UTC)
uint public constant BONUS_PRESALE = 30;
uint public constant BONUS_ICO_ROUND1 = 20;
uint public constant BONUS_ICO_ROUND2 = 10;
uint public constant BONUS_ICO_ROUND3 = 5;
event TokensPerEthUpdated(uint _tokensPerEth);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Refund(address indexed _owner, uint _amount, uint _tokens);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event Burn(address indexed burner, uint256 value);
event LockRemoved(address indexed _participant);
bool public distributionFinished = false;
modifier canDistr() {
}
modifier onlyOwner() {
}
function VikkyToken () public {
}
// Information functions ------------
/* What time is it? */
function atNow() public constant returns (uint) {
}
/* Has the minimum threshold been reached? */
function icoThresholdReached() public constant returns (bool thresholdReached) {
}
function transferOwnership(address newOwner) onlyOwner public {
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
}
function doAirdrop(address _participant, uint airdrop) internal {
}
function adminClaimAirdrop(address _participant, uint airdrop) external {
}
function adminClaimAirdropMultiple(address[] _addresses, uint airdrop) external {
}
function systemClaimAirdropMultiple(address[] _addresses) external {
}
/* Change tokensPerEth before ICO start */
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
require(<FILL_ME>)
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
}
function buyTokens() payable canDistr public {
}
function balanceOf(address _owner) constant public returns (uint256) {
}
// mitigates the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
}
// Lock functions -------------------
/* Manage locked */
function removeLock(address _participant) public {
}
function removeLockMultiple(address[] _participants) public {
}
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) {
}
// External functions ---------------
/* Reclaiming of funds by contributors in case of a failed crowdsale */
/* (it will fail if account is empty after ownerClawback) */
function reclaimFund(address _participant) public {
}
function reclaimFundMultiple(address[] _participants) public {
}
}
| atNow()<DATE_PRESALE_START | 55,867 | atNow()<DATE_PRESALE_START |
null | pragma solidity ^0.4.18;
// VikkyToken
// Token name: VikkyToken
// Symbol: VIK
// Decimals: 18
// Telegram community: https://t.me/vikkyglobal
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) external returns (bool);
function totalSupply() constant external returns (uint256 supply);
function balanceOf(address _owner) constant external returns (uint256 balance);
}
contract VikkyToken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public airdropClaimed;
mapping (address => bool) public refundClaimed;
mapping (address => bool) public locked;
/* Keep track of Ether contributed and tokens received during Crowdsale */
mapping(address => uint) public icoEtherContributed;
mapping(address => uint) public icoTokensReceived;
string public constant name = "VikkyToken";
string public constant symbol = "VIK";
uint public constant decimals = 18;
uint constant E18 = 10**18;
uint constant E6 = 10**6;
uint public totalSupply = 1000 * E6 * E18;
uint public totalDistributed = 220 * E6 * E18; //For team + Founder
uint public totalRemaining = totalSupply.sub(totalDistributed); //For ICO
uint public tokensPerEth = 20000 * E18;
uint public tokensAirdrop = 266 * E18;
uint public tokensClaimedAirdrop = 0;
uint public totalDistributedAirdrop = 20 * E6 * E18; //Airdrop
uint public constant MIN_CONTRIBUTION = 1 ether / 100; // 0.01 Ether
uint public constant MIN_CONTRIBUTION_PRESALE = 1 ether;
uint public constant MAX_CONTRIBUTION = 100 ether;
uint public constant MIN_FUNDING_GOAL = 5000 ether; // 5000 ETH
/* ICO dates */
uint public constant DATE_PRESALE_START = 1525244400; // 05/02/2018 @ 7:00am (UTC)
uint public constant DATE_PRESALE_END = 1526454000; // 05/16/2018 @ 7:00am (UTC)
uint public constant DATE_ICO_START = 1526454060; // 05/16/2018 @ 7:01am (UTC)
uint public constant DATE_ICO_END = 1533020400; // 07/31/2018 @ 7:00am (UTC)
uint public constant BONUS_PRESALE = 30;
uint public constant BONUS_ICO_ROUND1 = 20;
uint public constant BONUS_ICO_ROUND2 = 10;
uint public constant BONUS_ICO_ROUND3 = 5;
event TokensPerEthUpdated(uint _tokensPerEth);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Refund(address indexed _owner, uint _amount, uint _tokens);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event Burn(address indexed burner, uint256 value);
event LockRemoved(address indexed _participant);
bool public distributionFinished = false;
modifier canDistr() {
}
modifier onlyOwner() {
}
function VikkyToken () public {
}
// Information functions ------------
/* What time is it? */
function atNow() public constant returns (uint) {
}
/* Has the minimum threshold been reached? */
function icoThresholdReached() public constant returns (bool thresholdReached) {
}
function transferOwnership(address newOwner) onlyOwner public {
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
}
function doAirdrop(address _participant, uint airdrop) internal {
}
function adminClaimAirdrop(address _participant, uint airdrop) external {
}
function adminClaimAirdropMultiple(address[] _addresses, uint airdrop) external {
}
function systemClaimAirdropMultiple(address[] _addresses) external {
}
/* Change tokensPerEth before ICO start */
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
}
function () external payable {
}
function buyTokens() payable canDistr public {
uint ts = atNow();
bool isPresale = false;
bool isIco = false;
uint tokens = 0;
// minimum contribution
require( msg.value >= MIN_CONTRIBUTION );
// one address transfer hard cap
require(<FILL_ME>)
// check dates for presale or ICO
if (ts > DATE_PRESALE_START && ts < DATE_PRESALE_END) isPresale = true;
if (ts > DATE_ICO_START && ts < DATE_ICO_END) isIco = true;
require( isPresale || isIco );
// presale cap in Ether
if (isPresale) require( msg.value >= MIN_CONTRIBUTION_PRESALE);
address investor = msg.sender;
// get baseline number of tokens
tokens = tokensPerEth.mul(msg.value) / 1 ether;
// apply bonuses (none for last week)
if (isPresale) {
tokens = tokens.mul(100 + BONUS_PRESALE) / 100;
} else if (ts < DATE_ICO_START + 14 days) {
// round 1 bonus
tokens = tokens.mul(100 + BONUS_ICO_ROUND1) / 100;
} else if (ts < DATE_ICO_START + 28 days) {
// round 2 bonus
tokens = tokens.mul(100 + BONUS_ICO_ROUND2) / 100;
} else if (ts < DATE_ICO_START + 42 days) {
// round 3 bonus
tokens = tokens.mul(100 + BONUS_ICO_ROUND3) / 100;
}
// ICO token volume cap
require( totalDistributed.add(tokens) <= totalRemaining );
if (tokens > 0) {
distr(investor, tokens);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
function balanceOf(address _owner) constant public returns (uint256) {
}
// mitigates the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
}
// Lock functions -------------------
/* Manage locked */
function removeLock(address _participant) public {
}
function removeLockMultiple(address[] _participants) public {
}
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) {
}
// External functions ---------------
/* Reclaiming of funds by contributors in case of a failed crowdsale */
/* (it will fail if account is empty after ownerClawback) */
function reclaimFund(address _participant) public {
}
function reclaimFundMultiple(address[] _participants) public {
}
}
| icoEtherContributed[msg.sender].add(msg.value)<=MAX_CONTRIBUTION | 55,867 | icoEtherContributed[msg.sender].add(msg.value)<=MAX_CONTRIBUTION |
null | pragma solidity ^0.4.18;
// VikkyToken
// Token name: VikkyToken
// Symbol: VIK
// Decimals: 18
// Telegram community: https://t.me/vikkyglobal
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) external returns (bool);
function totalSupply() constant external returns (uint256 supply);
function balanceOf(address _owner) constant external returns (uint256 balance);
}
contract VikkyToken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public airdropClaimed;
mapping (address => bool) public refundClaimed;
mapping (address => bool) public locked;
/* Keep track of Ether contributed and tokens received during Crowdsale */
mapping(address => uint) public icoEtherContributed;
mapping(address => uint) public icoTokensReceived;
string public constant name = "VikkyToken";
string public constant symbol = "VIK";
uint public constant decimals = 18;
uint constant E18 = 10**18;
uint constant E6 = 10**6;
uint public totalSupply = 1000 * E6 * E18;
uint public totalDistributed = 220 * E6 * E18; //For team + Founder
uint public totalRemaining = totalSupply.sub(totalDistributed); //For ICO
uint public tokensPerEth = 20000 * E18;
uint public tokensAirdrop = 266 * E18;
uint public tokensClaimedAirdrop = 0;
uint public totalDistributedAirdrop = 20 * E6 * E18; //Airdrop
uint public constant MIN_CONTRIBUTION = 1 ether / 100; // 0.01 Ether
uint public constant MIN_CONTRIBUTION_PRESALE = 1 ether;
uint public constant MAX_CONTRIBUTION = 100 ether;
uint public constant MIN_FUNDING_GOAL = 5000 ether; // 5000 ETH
/* ICO dates */
uint public constant DATE_PRESALE_START = 1525244400; // 05/02/2018 @ 7:00am (UTC)
uint public constant DATE_PRESALE_END = 1526454000; // 05/16/2018 @ 7:00am (UTC)
uint public constant DATE_ICO_START = 1526454060; // 05/16/2018 @ 7:01am (UTC)
uint public constant DATE_ICO_END = 1533020400; // 07/31/2018 @ 7:00am (UTC)
uint public constant BONUS_PRESALE = 30;
uint public constant BONUS_ICO_ROUND1 = 20;
uint public constant BONUS_ICO_ROUND2 = 10;
uint public constant BONUS_ICO_ROUND3 = 5;
event TokensPerEthUpdated(uint _tokensPerEth);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Refund(address indexed _owner, uint _amount, uint _tokens);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event Burn(address indexed burner, uint256 value);
event LockRemoved(address indexed _participant);
bool public distributionFinished = false;
modifier canDistr() {
}
modifier onlyOwner() {
}
function VikkyToken () public {
}
// Information functions ------------
/* What time is it? */
function atNow() public constant returns (uint) {
}
/* Has the minimum threshold been reached? */
function icoThresholdReached() public constant returns (bool thresholdReached) {
}
function transferOwnership(address newOwner) onlyOwner public {
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
}
function doAirdrop(address _participant, uint airdrop) internal {
}
function adminClaimAirdrop(address _participant, uint airdrop) external {
}
function adminClaimAirdropMultiple(address[] _addresses, uint airdrop) external {
}
function systemClaimAirdropMultiple(address[] _addresses) external {
}
/* Change tokensPerEth before ICO start */
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
}
function () external payable {
}
function buyTokens() payable canDistr public {
uint ts = atNow();
bool isPresale = false;
bool isIco = false;
uint tokens = 0;
// minimum contribution
require( msg.value >= MIN_CONTRIBUTION );
// one address transfer hard cap
require( icoEtherContributed[msg.sender].add(msg.value) <= MAX_CONTRIBUTION );
// check dates for presale or ICO
if (ts > DATE_PRESALE_START && ts < DATE_PRESALE_END) isPresale = true;
if (ts > DATE_ICO_START && ts < DATE_ICO_END) isIco = true;
require(<FILL_ME>)
// presale cap in Ether
if (isPresale) require( msg.value >= MIN_CONTRIBUTION_PRESALE);
address investor = msg.sender;
// get baseline number of tokens
tokens = tokensPerEth.mul(msg.value) / 1 ether;
// apply bonuses (none for last week)
if (isPresale) {
tokens = tokens.mul(100 + BONUS_PRESALE) / 100;
} else if (ts < DATE_ICO_START + 14 days) {
// round 1 bonus
tokens = tokens.mul(100 + BONUS_ICO_ROUND1) / 100;
} else if (ts < DATE_ICO_START + 28 days) {
// round 2 bonus
tokens = tokens.mul(100 + BONUS_ICO_ROUND2) / 100;
} else if (ts < DATE_ICO_START + 42 days) {
// round 3 bonus
tokens = tokens.mul(100 + BONUS_ICO_ROUND3) / 100;
}
// ICO token volume cap
require( totalDistributed.add(tokens) <= totalRemaining );
if (tokens > 0) {
distr(investor, tokens);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
function balanceOf(address _owner) constant public returns (uint256) {
}
// mitigates the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
}
// Lock functions -------------------
/* Manage locked */
function removeLock(address _participant) public {
}
function removeLockMultiple(address[] _participants) public {
}
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) {
}
// External functions ---------------
/* Reclaiming of funds by contributors in case of a failed crowdsale */
/* (it will fail if account is empty after ownerClawback) */
function reclaimFund(address _participant) public {
}
function reclaimFundMultiple(address[] _participants) public {
}
}
| isPresale||isIco | 55,867 | isPresale||isIco |
null | pragma solidity ^0.4.18;
// VikkyToken
// Token name: VikkyToken
// Symbol: VIK
// Decimals: 18
// Telegram community: https://t.me/vikkyglobal
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) external returns (bool);
function totalSupply() constant external returns (uint256 supply);
function balanceOf(address _owner) constant external returns (uint256 balance);
}
contract VikkyToken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public airdropClaimed;
mapping (address => bool) public refundClaimed;
mapping (address => bool) public locked;
/* Keep track of Ether contributed and tokens received during Crowdsale */
mapping(address => uint) public icoEtherContributed;
mapping(address => uint) public icoTokensReceived;
string public constant name = "VikkyToken";
string public constant symbol = "VIK";
uint public constant decimals = 18;
uint constant E18 = 10**18;
uint constant E6 = 10**6;
uint public totalSupply = 1000 * E6 * E18;
uint public totalDistributed = 220 * E6 * E18; //For team + Founder
uint public totalRemaining = totalSupply.sub(totalDistributed); //For ICO
uint public tokensPerEth = 20000 * E18;
uint public tokensAirdrop = 266 * E18;
uint public tokensClaimedAirdrop = 0;
uint public totalDistributedAirdrop = 20 * E6 * E18; //Airdrop
uint public constant MIN_CONTRIBUTION = 1 ether / 100; // 0.01 Ether
uint public constant MIN_CONTRIBUTION_PRESALE = 1 ether;
uint public constant MAX_CONTRIBUTION = 100 ether;
uint public constant MIN_FUNDING_GOAL = 5000 ether; // 5000 ETH
/* ICO dates */
uint public constant DATE_PRESALE_START = 1525244400; // 05/02/2018 @ 7:00am (UTC)
uint public constant DATE_PRESALE_END = 1526454000; // 05/16/2018 @ 7:00am (UTC)
uint public constant DATE_ICO_START = 1526454060; // 05/16/2018 @ 7:01am (UTC)
uint public constant DATE_ICO_END = 1533020400; // 07/31/2018 @ 7:00am (UTC)
uint public constant BONUS_PRESALE = 30;
uint public constant BONUS_ICO_ROUND1 = 20;
uint public constant BONUS_ICO_ROUND2 = 10;
uint public constant BONUS_ICO_ROUND3 = 5;
event TokensPerEthUpdated(uint _tokensPerEth);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Refund(address indexed _owner, uint _amount, uint _tokens);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event Burn(address indexed burner, uint256 value);
event LockRemoved(address indexed _participant);
bool public distributionFinished = false;
modifier canDistr() {
}
modifier onlyOwner() {
}
function VikkyToken () public {
}
// Information functions ------------
/* What time is it? */
function atNow() public constant returns (uint) {
}
/* Has the minimum threshold been reached? */
function icoThresholdReached() public constant returns (bool thresholdReached) {
}
function transferOwnership(address newOwner) onlyOwner public {
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
}
function doAirdrop(address _participant, uint airdrop) internal {
}
function adminClaimAirdrop(address _participant, uint airdrop) external {
}
function adminClaimAirdropMultiple(address[] _addresses, uint airdrop) external {
}
function systemClaimAirdropMultiple(address[] _addresses) external {
}
/* Change tokensPerEth before ICO start */
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
}
function () external payable {
}
function buyTokens() payable canDistr public {
uint ts = atNow();
bool isPresale = false;
bool isIco = false;
uint tokens = 0;
// minimum contribution
require( msg.value >= MIN_CONTRIBUTION );
// one address transfer hard cap
require( icoEtherContributed[msg.sender].add(msg.value) <= MAX_CONTRIBUTION );
// check dates for presale or ICO
if (ts > DATE_PRESALE_START && ts < DATE_PRESALE_END) isPresale = true;
if (ts > DATE_ICO_START && ts < DATE_ICO_END) isIco = true;
require( isPresale || isIco );
// presale cap in Ether
if (isPresale) require( msg.value >= MIN_CONTRIBUTION_PRESALE);
address investor = msg.sender;
// get baseline number of tokens
tokens = tokensPerEth.mul(msg.value) / 1 ether;
// apply bonuses (none for last week)
if (isPresale) {
tokens = tokens.mul(100 + BONUS_PRESALE) / 100;
} else if (ts < DATE_ICO_START + 14 days) {
// round 1 bonus
tokens = tokens.mul(100 + BONUS_ICO_ROUND1) / 100;
} else if (ts < DATE_ICO_START + 28 days) {
// round 2 bonus
tokens = tokens.mul(100 + BONUS_ICO_ROUND2) / 100;
} else if (ts < DATE_ICO_START + 42 days) {
// round 3 bonus
tokens = tokens.mul(100 + BONUS_ICO_ROUND3) / 100;
}
// ICO token volume cap
require(<FILL_ME>)
if (tokens > 0) {
distr(investor, tokens);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
function balanceOf(address _owner) constant public returns (uint256) {
}
// mitigates the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
}
// Lock functions -------------------
/* Manage locked */
function removeLock(address _participant) public {
}
function removeLockMultiple(address[] _participants) public {
}
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) {
}
// External functions ---------------
/* Reclaiming of funds by contributors in case of a failed crowdsale */
/* (it will fail if account is empty after ownerClawback) */
function reclaimFund(address _participant) public {
}
function reclaimFundMultiple(address[] _participants) public {
}
}
| totalDistributed.add(tokens)<=totalRemaining | 55,867 | totalDistributed.add(tokens)<=totalRemaining |
null | pragma solidity ^0.4.18;
// VikkyToken
// Token name: VikkyToken
// Symbol: VIK
// Decimals: 18
// Telegram community: https://t.me/vikkyglobal
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) external returns (bool);
function totalSupply() constant external returns (uint256 supply);
function balanceOf(address _owner) constant external returns (uint256 balance);
}
contract VikkyToken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public airdropClaimed;
mapping (address => bool) public refundClaimed;
mapping (address => bool) public locked;
/* Keep track of Ether contributed and tokens received during Crowdsale */
mapping(address => uint) public icoEtherContributed;
mapping(address => uint) public icoTokensReceived;
string public constant name = "VikkyToken";
string public constant symbol = "VIK";
uint public constant decimals = 18;
uint constant E18 = 10**18;
uint constant E6 = 10**6;
uint public totalSupply = 1000 * E6 * E18;
uint public totalDistributed = 220 * E6 * E18; //For team + Founder
uint public totalRemaining = totalSupply.sub(totalDistributed); //For ICO
uint public tokensPerEth = 20000 * E18;
uint public tokensAirdrop = 266 * E18;
uint public tokensClaimedAirdrop = 0;
uint public totalDistributedAirdrop = 20 * E6 * E18; //Airdrop
uint public constant MIN_CONTRIBUTION = 1 ether / 100; // 0.01 Ether
uint public constant MIN_CONTRIBUTION_PRESALE = 1 ether;
uint public constant MAX_CONTRIBUTION = 100 ether;
uint public constant MIN_FUNDING_GOAL = 5000 ether; // 5000 ETH
/* ICO dates */
uint public constant DATE_PRESALE_START = 1525244400; // 05/02/2018 @ 7:00am (UTC)
uint public constant DATE_PRESALE_END = 1526454000; // 05/16/2018 @ 7:00am (UTC)
uint public constant DATE_ICO_START = 1526454060; // 05/16/2018 @ 7:01am (UTC)
uint public constant DATE_ICO_END = 1533020400; // 07/31/2018 @ 7:00am (UTC)
uint public constant BONUS_PRESALE = 30;
uint public constant BONUS_ICO_ROUND1 = 20;
uint public constant BONUS_ICO_ROUND2 = 10;
uint public constant BONUS_ICO_ROUND3 = 5;
event TokensPerEthUpdated(uint _tokensPerEth);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Refund(address indexed _owner, uint _amount, uint _tokens);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event Burn(address indexed burner, uint256 value);
event LockRemoved(address indexed _participant);
bool public distributionFinished = false;
modifier canDistr() {
}
modifier onlyOwner() {
}
function VikkyToken () public {
}
// Information functions ------------
/* What time is it? */
function atNow() public constant returns (uint) {
}
/* Has the minimum threshold been reached? */
function icoThresholdReached() public constant returns (bool thresholdReached) {
}
function transferOwnership(address newOwner) onlyOwner public {
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
}
function doAirdrop(address _participant, uint airdrop) internal {
}
function adminClaimAirdrop(address _participant, uint airdrop) external {
}
function adminClaimAirdropMultiple(address[] _addresses, uint airdrop) external {
}
function systemClaimAirdropMultiple(address[] _addresses) external {
}
/* Change tokensPerEth before ICO start */
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
}
function () external payable {
}
function buyTokens() payable canDistr public {
}
function balanceOf(address _owner) constant public returns (uint256) {
}
// mitigates the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
}
// Lock functions -------------------
/* Manage locked */
function removeLock(address _participant) public {
}
function removeLockMultiple(address[] _participants) public {
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
require(<FILL_ME>)
require( locked[_to] == false );
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
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) {
}
// External functions ---------------
/* Reclaiming of funds by contributors in case of a failed crowdsale */
/* (it will fail if account is empty after ownerClawback) */
function reclaimFund(address _participant) public {
}
function reclaimFundMultiple(address[] _participants) public {
}
}
| locked[msg.sender]==false | 55,867 | locked[msg.sender]==false |
null | pragma solidity ^0.4.18;
// VikkyToken
// Token name: VikkyToken
// Symbol: VIK
// Decimals: 18
// Telegram community: https://t.me/vikkyglobal
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) external returns (bool);
function totalSupply() constant external returns (uint256 supply);
function balanceOf(address _owner) constant external returns (uint256 balance);
}
contract VikkyToken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public airdropClaimed;
mapping (address => bool) public refundClaimed;
mapping (address => bool) public locked;
/* Keep track of Ether contributed and tokens received during Crowdsale */
mapping(address => uint) public icoEtherContributed;
mapping(address => uint) public icoTokensReceived;
string public constant name = "VikkyToken";
string public constant symbol = "VIK";
uint public constant decimals = 18;
uint constant E18 = 10**18;
uint constant E6 = 10**6;
uint public totalSupply = 1000 * E6 * E18;
uint public totalDistributed = 220 * E6 * E18; //For team + Founder
uint public totalRemaining = totalSupply.sub(totalDistributed); //For ICO
uint public tokensPerEth = 20000 * E18;
uint public tokensAirdrop = 266 * E18;
uint public tokensClaimedAirdrop = 0;
uint public totalDistributedAirdrop = 20 * E6 * E18; //Airdrop
uint public constant MIN_CONTRIBUTION = 1 ether / 100; // 0.01 Ether
uint public constant MIN_CONTRIBUTION_PRESALE = 1 ether;
uint public constant MAX_CONTRIBUTION = 100 ether;
uint public constant MIN_FUNDING_GOAL = 5000 ether; // 5000 ETH
/* ICO dates */
uint public constant DATE_PRESALE_START = 1525244400; // 05/02/2018 @ 7:00am (UTC)
uint public constant DATE_PRESALE_END = 1526454000; // 05/16/2018 @ 7:00am (UTC)
uint public constant DATE_ICO_START = 1526454060; // 05/16/2018 @ 7:01am (UTC)
uint public constant DATE_ICO_END = 1533020400; // 07/31/2018 @ 7:00am (UTC)
uint public constant BONUS_PRESALE = 30;
uint public constant BONUS_ICO_ROUND1 = 20;
uint public constant BONUS_ICO_ROUND2 = 10;
uint public constant BONUS_ICO_ROUND3 = 5;
event TokensPerEthUpdated(uint _tokensPerEth);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Refund(address indexed _owner, uint _amount, uint _tokens);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event Burn(address indexed burner, uint256 value);
event LockRemoved(address indexed _participant);
bool public distributionFinished = false;
modifier canDistr() {
}
modifier onlyOwner() {
}
function VikkyToken () public {
}
// Information functions ------------
/* What time is it? */
function atNow() public constant returns (uint) {
}
/* Has the minimum threshold been reached? */
function icoThresholdReached() public constant returns (bool thresholdReached) {
}
function transferOwnership(address newOwner) onlyOwner public {
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
}
function doAirdrop(address _participant, uint airdrop) internal {
}
function adminClaimAirdrop(address _participant, uint airdrop) external {
}
function adminClaimAirdropMultiple(address[] _addresses, uint airdrop) external {
}
function systemClaimAirdropMultiple(address[] _addresses) external {
}
/* Change tokensPerEth before ICO start */
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
}
function () external payable {
}
function buyTokens() payable canDistr public {
}
function balanceOf(address _owner) constant public returns (uint256) {
}
// mitigates the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
}
// Lock functions -------------------
/* Manage locked */
function removeLock(address _participant) public {
}
function removeLockMultiple(address[] _participants) public {
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
require( locked[msg.sender] == false );
require(<FILL_ME>)
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
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) {
}
// External functions ---------------
/* Reclaiming of funds by contributors in case of a failed crowdsale */
/* (it will fail if account is empty after ownerClawback) */
function reclaimFund(address _participant) public {
}
function reclaimFundMultiple(address[] _participants) public {
}
}
| locked[_to]==false | 55,867 | locked[_to]==false |
null | pragma solidity ^0.4.18;
// VikkyToken
// Token name: VikkyToken
// Symbol: VIK
// Decimals: 18
// Telegram community: https://t.me/vikkyglobal
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) external returns (bool);
function totalSupply() constant external returns (uint256 supply);
function balanceOf(address _owner) constant external returns (uint256 balance);
}
contract VikkyToken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public airdropClaimed;
mapping (address => bool) public refundClaimed;
mapping (address => bool) public locked;
/* Keep track of Ether contributed and tokens received during Crowdsale */
mapping(address => uint) public icoEtherContributed;
mapping(address => uint) public icoTokensReceived;
string public constant name = "VikkyToken";
string public constant symbol = "VIK";
uint public constant decimals = 18;
uint constant E18 = 10**18;
uint constant E6 = 10**6;
uint public totalSupply = 1000 * E6 * E18;
uint public totalDistributed = 220 * E6 * E18; //For team + Founder
uint public totalRemaining = totalSupply.sub(totalDistributed); //For ICO
uint public tokensPerEth = 20000 * E18;
uint public tokensAirdrop = 266 * E18;
uint public tokensClaimedAirdrop = 0;
uint public totalDistributedAirdrop = 20 * E6 * E18; //Airdrop
uint public constant MIN_CONTRIBUTION = 1 ether / 100; // 0.01 Ether
uint public constant MIN_CONTRIBUTION_PRESALE = 1 ether;
uint public constant MAX_CONTRIBUTION = 100 ether;
uint public constant MIN_FUNDING_GOAL = 5000 ether; // 5000 ETH
/* ICO dates */
uint public constant DATE_PRESALE_START = 1525244400; // 05/02/2018 @ 7:00am (UTC)
uint public constant DATE_PRESALE_END = 1526454000; // 05/16/2018 @ 7:00am (UTC)
uint public constant DATE_ICO_START = 1526454060; // 05/16/2018 @ 7:01am (UTC)
uint public constant DATE_ICO_END = 1533020400; // 07/31/2018 @ 7:00am (UTC)
uint public constant BONUS_PRESALE = 30;
uint public constant BONUS_ICO_ROUND1 = 20;
uint public constant BONUS_ICO_ROUND2 = 10;
uint public constant BONUS_ICO_ROUND3 = 5;
event TokensPerEthUpdated(uint _tokensPerEth);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Refund(address indexed _owner, uint _amount, uint _tokens);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event Burn(address indexed burner, uint256 value);
event LockRemoved(address indexed _participant);
bool public distributionFinished = false;
modifier canDistr() {
}
modifier onlyOwner() {
}
function VikkyToken () public {
}
// Information functions ------------
/* What time is it? */
function atNow() public constant returns (uint) {
}
/* Has the minimum threshold been reached? */
function icoThresholdReached() public constant returns (bool thresholdReached) {
}
function transferOwnership(address newOwner) onlyOwner public {
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
}
function doAirdrop(address _participant, uint airdrop) internal {
}
function adminClaimAirdrop(address _participant, uint airdrop) external {
}
function adminClaimAirdropMultiple(address[] _addresses, uint airdrop) external {
}
function systemClaimAirdropMultiple(address[] _addresses) external {
}
/* Change tokensPerEth before ICO start */
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
}
function () external payable {
}
function buyTokens() payable canDistr public {
}
function balanceOf(address _owner) constant public returns (uint256) {
}
// mitigates the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
}
// Lock functions -------------------
/* Manage locked */
function removeLock(address _participant) public {
}
function removeLockMultiple(address[] _participants) public {
}
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) {
}
// External functions ---------------
/* Reclaiming of funds by contributors in case of a failed crowdsale */
/* (it will fail if account is empty after ownerClawback) */
function reclaimFund(address _participant) public {
uint tokens; // tokens to destroy
uint amount; // refund amount
// ico is finished and was not successful
require(<FILL_ME>)
// check if refund has already been claimed
require( !refundClaimed[_participant] );
// check if there is anything to refund
require( icoEtherContributed[_participant] > 0 );
// update variables affected by refund
tokens = icoTokensReceived[_participant];
amount = icoEtherContributed[_participant];
balances[_participant] = balances[_participant].sub(tokens);
totalDistributed = totalDistributed.sub(tokens);
refundClaimed[_participant] = true;
_participant.transfer(amount);
// log
emit Transfer(_participant, 0x0, tokens);
emit Refund(_participant, amount, tokens);
}
function reclaimFundMultiple(address[] _participants) public {
}
}
| atNow()>DATE_ICO_END&&!icoThresholdReached() | 55,867 | atNow()>DATE_ICO_END&&!icoThresholdReached() |
null | pragma solidity ^0.4.18;
// VikkyToken
// Token name: VikkyToken
// Symbol: VIK
// Decimals: 18
// Telegram community: https://t.me/vikkyglobal
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) external returns (bool);
function totalSupply() constant external returns (uint256 supply);
function balanceOf(address _owner) constant external returns (uint256 balance);
}
contract VikkyToken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public airdropClaimed;
mapping (address => bool) public refundClaimed;
mapping (address => bool) public locked;
/* Keep track of Ether contributed and tokens received during Crowdsale */
mapping(address => uint) public icoEtherContributed;
mapping(address => uint) public icoTokensReceived;
string public constant name = "VikkyToken";
string public constant symbol = "VIK";
uint public constant decimals = 18;
uint constant E18 = 10**18;
uint constant E6 = 10**6;
uint public totalSupply = 1000 * E6 * E18;
uint public totalDistributed = 220 * E6 * E18; //For team + Founder
uint public totalRemaining = totalSupply.sub(totalDistributed); //For ICO
uint public tokensPerEth = 20000 * E18;
uint public tokensAirdrop = 266 * E18;
uint public tokensClaimedAirdrop = 0;
uint public totalDistributedAirdrop = 20 * E6 * E18; //Airdrop
uint public constant MIN_CONTRIBUTION = 1 ether / 100; // 0.01 Ether
uint public constant MIN_CONTRIBUTION_PRESALE = 1 ether;
uint public constant MAX_CONTRIBUTION = 100 ether;
uint public constant MIN_FUNDING_GOAL = 5000 ether; // 5000 ETH
/* ICO dates */
uint public constant DATE_PRESALE_START = 1525244400; // 05/02/2018 @ 7:00am (UTC)
uint public constant DATE_PRESALE_END = 1526454000; // 05/16/2018 @ 7:00am (UTC)
uint public constant DATE_ICO_START = 1526454060; // 05/16/2018 @ 7:01am (UTC)
uint public constant DATE_ICO_END = 1533020400; // 07/31/2018 @ 7:00am (UTC)
uint public constant BONUS_PRESALE = 30;
uint public constant BONUS_ICO_ROUND1 = 20;
uint public constant BONUS_ICO_ROUND2 = 10;
uint public constant BONUS_ICO_ROUND3 = 5;
event TokensPerEthUpdated(uint _tokensPerEth);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Refund(address indexed _owner, uint _amount, uint _tokens);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event Burn(address indexed burner, uint256 value);
event LockRemoved(address indexed _participant);
bool public distributionFinished = false;
modifier canDistr() {
}
modifier onlyOwner() {
}
function VikkyToken () public {
}
// Information functions ------------
/* What time is it? */
function atNow() public constant returns (uint) {
}
/* Has the minimum threshold been reached? */
function icoThresholdReached() public constant returns (bool thresholdReached) {
}
function transferOwnership(address newOwner) onlyOwner public {
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
}
function doAirdrop(address _participant, uint airdrop) internal {
}
function adminClaimAirdrop(address _participant, uint airdrop) external {
}
function adminClaimAirdropMultiple(address[] _addresses, uint airdrop) external {
}
function systemClaimAirdropMultiple(address[] _addresses) external {
}
/* Change tokensPerEth before ICO start */
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
}
function () external payable {
}
function buyTokens() payable canDistr public {
}
function balanceOf(address _owner) constant public returns (uint256) {
}
// mitigates the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
}
// Lock functions -------------------
/* Manage locked */
function removeLock(address _participant) public {
}
function removeLockMultiple(address[] _participants) public {
}
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) {
}
// External functions ---------------
/* Reclaiming of funds by contributors in case of a failed crowdsale */
/* (it will fail if account is empty after ownerClawback) */
function reclaimFund(address _participant) public {
uint tokens; // tokens to destroy
uint amount; // refund amount
// ico is finished and was not successful
require( atNow() > DATE_ICO_END && !icoThresholdReached() );
// check if refund has already been claimed
require(<FILL_ME>)
// check if there is anything to refund
require( icoEtherContributed[_participant] > 0 );
// update variables affected by refund
tokens = icoTokensReceived[_participant];
amount = icoEtherContributed[_participant];
balances[_participant] = balances[_participant].sub(tokens);
totalDistributed = totalDistributed.sub(tokens);
refundClaimed[_participant] = true;
_participant.transfer(amount);
// log
emit Transfer(_participant, 0x0, tokens);
emit Refund(_participant, amount, tokens);
}
function reclaimFundMultiple(address[] _participants) public {
}
}
| !refundClaimed[_participant] | 55,867 | !refundClaimed[_participant] |
null | pragma solidity ^0.4.18;
// VikkyToken
// Token name: VikkyToken
// Symbol: VIK
// Decimals: 18
// Telegram community: https://t.me/vikkyglobal
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) external returns (bool);
function totalSupply() constant external returns (uint256 supply);
function balanceOf(address _owner) constant external returns (uint256 balance);
}
contract VikkyToken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public airdropClaimed;
mapping (address => bool) public refundClaimed;
mapping (address => bool) public locked;
/* Keep track of Ether contributed and tokens received during Crowdsale */
mapping(address => uint) public icoEtherContributed;
mapping(address => uint) public icoTokensReceived;
string public constant name = "VikkyToken";
string public constant symbol = "VIK";
uint public constant decimals = 18;
uint constant E18 = 10**18;
uint constant E6 = 10**6;
uint public totalSupply = 1000 * E6 * E18;
uint public totalDistributed = 220 * E6 * E18; //For team + Founder
uint public totalRemaining = totalSupply.sub(totalDistributed); //For ICO
uint public tokensPerEth = 20000 * E18;
uint public tokensAirdrop = 266 * E18;
uint public tokensClaimedAirdrop = 0;
uint public totalDistributedAirdrop = 20 * E6 * E18; //Airdrop
uint public constant MIN_CONTRIBUTION = 1 ether / 100; // 0.01 Ether
uint public constant MIN_CONTRIBUTION_PRESALE = 1 ether;
uint public constant MAX_CONTRIBUTION = 100 ether;
uint public constant MIN_FUNDING_GOAL = 5000 ether; // 5000 ETH
/* ICO dates */
uint public constant DATE_PRESALE_START = 1525244400; // 05/02/2018 @ 7:00am (UTC)
uint public constant DATE_PRESALE_END = 1526454000; // 05/16/2018 @ 7:00am (UTC)
uint public constant DATE_ICO_START = 1526454060; // 05/16/2018 @ 7:01am (UTC)
uint public constant DATE_ICO_END = 1533020400; // 07/31/2018 @ 7:00am (UTC)
uint public constant BONUS_PRESALE = 30;
uint public constant BONUS_ICO_ROUND1 = 20;
uint public constant BONUS_ICO_ROUND2 = 10;
uint public constant BONUS_ICO_ROUND3 = 5;
event TokensPerEthUpdated(uint _tokensPerEth);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Refund(address indexed _owner, uint _amount, uint _tokens);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event Burn(address indexed burner, uint256 value);
event LockRemoved(address indexed _participant);
bool public distributionFinished = false;
modifier canDistr() {
}
modifier onlyOwner() {
}
function VikkyToken () public {
}
// Information functions ------------
/* What time is it? */
function atNow() public constant returns (uint) {
}
/* Has the minimum threshold been reached? */
function icoThresholdReached() public constant returns (bool thresholdReached) {
}
function transferOwnership(address newOwner) onlyOwner public {
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
}
function doAirdrop(address _participant, uint airdrop) internal {
}
function adminClaimAirdrop(address _participant, uint airdrop) external {
}
function adminClaimAirdropMultiple(address[] _addresses, uint airdrop) external {
}
function systemClaimAirdropMultiple(address[] _addresses) external {
}
/* Change tokensPerEth before ICO start */
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
}
function () external payable {
}
function buyTokens() payable canDistr public {
}
function balanceOf(address _owner) constant public returns (uint256) {
}
// mitigates the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
}
// Lock functions -------------------
/* Manage locked */
function removeLock(address _participant) public {
}
function removeLockMultiple(address[] _participants) public {
}
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) {
}
// External functions ---------------
/* Reclaiming of funds by contributors in case of a failed crowdsale */
/* (it will fail if account is empty after ownerClawback) */
function reclaimFund(address _participant) public {
uint tokens; // tokens to destroy
uint amount; // refund amount
// ico is finished and was not successful
require( atNow() > DATE_ICO_END && !icoThresholdReached() );
// check if refund has already been claimed
require( !refundClaimed[_participant] );
// check if there is anything to refund
require(<FILL_ME>)
// update variables affected by refund
tokens = icoTokensReceived[_participant];
amount = icoEtherContributed[_participant];
balances[_participant] = balances[_participant].sub(tokens);
totalDistributed = totalDistributed.sub(tokens);
refundClaimed[_participant] = true;
_participant.transfer(amount);
// log
emit Transfer(_participant, 0x0, tokens);
emit Refund(_participant, amount, tokens);
}
function reclaimFundMultiple(address[] _participants) public {
}
}
| icoEtherContributed[_participant]>0 | 55,867 | icoEtherContributed[_participant]>0 |
null | contract StattmToken is MintableToken {
string public constant name = "Stattm";
string public constant symbol = "STTM";
uint256 public constant decimals = 18;
mapping(address => bool) public isWhiteListed;
function burn() public {
}
function addToWhitelist(address _user) public onlyOwner {
}
function removeFromWhitelist(address _user) public onlyOwner {
}
function init(address privateSale, address ito, address ico, address projectManagementAndAirdrop) public {
require(totalSupply_ == 0);
require(<FILL_ME>)
require(address(ito) != address(0));
require(address(ico) != address(0));
require(address(projectManagementAndAirdrop) != address(0));
mint(address(privateSale), (10 ** decimals) * (5000000));
mint(address(ito), (10 ** decimals) * (25000000));
mint(address(ico), (10 ** decimals) * (35000000));
mint(address(projectManagementAndAirdrop), (10 ** decimals) * (35100100));
mintingFinished = true;
}
}
| address(privateSale)!=address(0) | 55,933 | address(privateSale)!=address(0) |
null | contract StattmToken is MintableToken {
string public constant name = "Stattm";
string public constant symbol = "STTM";
uint256 public constant decimals = 18;
mapping(address => bool) public isWhiteListed;
function burn() public {
}
function addToWhitelist(address _user) public onlyOwner {
}
function removeFromWhitelist(address _user) public onlyOwner {
}
function init(address privateSale, address ito, address ico, address projectManagementAndAirdrop) public {
require(totalSupply_ == 0);
require(address(privateSale) != address(0));
require(<FILL_ME>)
require(address(ico) != address(0));
require(address(projectManagementAndAirdrop) != address(0));
mint(address(privateSale), (10 ** decimals) * (5000000));
mint(address(ito), (10 ** decimals) * (25000000));
mint(address(ico), (10 ** decimals) * (35000000));
mint(address(projectManagementAndAirdrop), (10 ** decimals) * (35100100));
mintingFinished = true;
}
}
| address(ito)!=address(0) | 55,933 | address(ito)!=address(0) |
null | contract StattmToken is MintableToken {
string public constant name = "Stattm";
string public constant symbol = "STTM";
uint256 public constant decimals = 18;
mapping(address => bool) public isWhiteListed;
function burn() public {
}
function addToWhitelist(address _user) public onlyOwner {
}
function removeFromWhitelist(address _user) public onlyOwner {
}
function init(address privateSale, address ito, address ico, address projectManagementAndAirdrop) public {
require(totalSupply_ == 0);
require(address(privateSale) != address(0));
require(address(ito) != address(0));
require(<FILL_ME>)
require(address(projectManagementAndAirdrop) != address(0));
mint(address(privateSale), (10 ** decimals) * (5000000));
mint(address(ito), (10 ** decimals) * (25000000));
mint(address(ico), (10 ** decimals) * (35000000));
mint(address(projectManagementAndAirdrop), (10 ** decimals) * (35100100));
mintingFinished = true;
}
}
| address(ico)!=address(0) | 55,933 | address(ico)!=address(0) |
null | contract StattmToken is MintableToken {
string public constant name = "Stattm";
string public constant symbol = "STTM";
uint256 public constant decimals = 18;
mapping(address => bool) public isWhiteListed;
function burn() public {
}
function addToWhitelist(address _user) public onlyOwner {
}
function removeFromWhitelist(address _user) public onlyOwner {
}
function init(address privateSale, address ito, address ico, address projectManagementAndAirdrop) public {
require(totalSupply_ == 0);
require(address(privateSale) != address(0));
require(address(ito) != address(0));
require(address(ico) != address(0));
require(<FILL_ME>)
mint(address(privateSale), (10 ** decimals) * (5000000));
mint(address(ito), (10 ** decimals) * (25000000));
mint(address(ico), (10 ** decimals) * (35000000));
mint(address(projectManagementAndAirdrop), (10 ** decimals) * (35100100));
mintingFinished = true;
}
}
| address(projectManagementAndAirdrop)!=address(0) | 55,933 | address(projectManagementAndAirdrop)!=address(0) |
null | pragma solidity 0.5.12;
pragma experimental ABIEncoderV2;
// solium-disable error-reason
contract Resolver is SignatureUtil {
event Set(uint256 indexed preset, string indexed key, string value, uint256 indexed tokenId);
event SetPreset(uint256 indexed preset, uint256 indexed tokenId);
// Mapping from token ID to preset id to key to value
mapping (uint256 => mapping (uint256 => mapping (string => string))) internal _records;
// Mapping from token ID to current preset id
mapping (uint256 => uint256) _tokenPresets;
MintingController internal _mintingController;
constructor(Registry registry, MintingController mintingController) public SignatureUtil(registry) {
require(<FILL_ME>)
_mintingController = mintingController;
}
/**
* @dev Throws if called when not the resolver.
*/
modifier whenResolver(uint256 tokenId) {
}
function presetOf(uint256 tokenId) external view returns (uint256) {
}
function setPreset(uint256 presetId, uint256 tokenId) external {
}
function setPresetFor(uint256 presetId, uint256 tokenId, bytes calldata signature) external {
}
function reset(uint256 tokenId) external {
}
function resetFor(uint256 tokenId, bytes calldata signature) external {
}
/**
* @dev Function to get record.
* @param key The key to query the value of.
* @param tokenId The token id to fetch.
* @return The value string.
*/
function get(string memory key, uint256 tokenId) public view whenResolver(tokenId) returns (string memory) {
}
function preconfigure(
string[] memory keys,
string[] memory values,
uint256 tokenId
) public {
}
/**
* @dev Function to set record.
* @param key The key set the value of.
* @param value The value to set key to.
* @param tokenId The token id to set.
*/
function set(string calldata key, string calldata value, uint256 tokenId) external {
}
/**
* @dev Function to set record on behalf of an address.
* @param key The key set the value of.
* @param value The value to set key to.
* @param tokenId The token id to set.
* @param signature The signature to verify the transaction with.
*/
function setFor(
string calldata key,
string calldata value,
uint256 tokenId,
bytes calldata signature
) external {
}
/**
* @dev Function to get multiple record.
* @param keys The keys to query the value of.
* @param tokenId The token id to fetch.
* @return The values.
*/
function getMany(string[] calldata keys, uint256 tokenId) external view whenResolver(tokenId) returns (string[] memory) {
}
function setMany(
string[] memory keys,
string[] memory values,
uint256 tokenId
) public {
}
/**
* @dev Function to set record on behalf of an address.
* @param keys The keys set the values of.
* @param values The values to set keys to.
* @param tokenId The token id to set.
* @param signature The signature to verify the transaction with.
*/
function setManyFor(
string[] memory keys,
string[] memory values,
uint256 tokenId,
bytes memory signature
) public {
}
function _setPreset(uint256 presetId, uint256 tokenId) internal {
}
/**
* @dev Internal function to to set record. As opposed to set, this imposes
* no restrictions on msg.sender.
* @param preset preset to set key/values on
* @param key key of record to be set
* @param value value of record to be set
* @param tokenId uint256 ID of the token
*/
function _set(uint256 preset, string memory key, string memory value, uint256 tokenId) internal {
}
/**
* @dev Internal function to to set multiple records. As opposed to setMany, this imposes
* no restrictions on msg.sender.
* @param preset preset to set key/values on
* @param keys keys of record to be set
* @param values values of record to be set
* @param tokenId uint256 ID of the token
*/
function _setMany(uint256 preset, string[] memory keys, string[] memory values, uint256 tokenId) internal {
}
}
| address(registry)==mintingController.registry() | 55,958 | address(registry)==mintingController.registry() |
"SimpleResolver: is not the resolver" | pragma solidity 0.5.12;
pragma experimental ABIEncoderV2;
// solium-disable error-reason
contract Resolver is SignatureUtil {
event Set(uint256 indexed preset, string indexed key, string value, uint256 indexed tokenId);
event SetPreset(uint256 indexed preset, uint256 indexed tokenId);
// Mapping from token ID to preset id to key to value
mapping (uint256 => mapping (uint256 => mapping (string => string))) internal _records;
// Mapping from token ID to current preset id
mapping (uint256 => uint256) _tokenPresets;
MintingController internal _mintingController;
constructor(Registry registry, MintingController mintingController) public SignatureUtil(registry) {
}
/**
* @dev Throws if called when not the resolver.
*/
modifier whenResolver(uint256 tokenId) {
require(<FILL_ME>)
_;
}
function presetOf(uint256 tokenId) external view returns (uint256) {
}
function setPreset(uint256 presetId, uint256 tokenId) external {
}
function setPresetFor(uint256 presetId, uint256 tokenId, bytes calldata signature) external {
}
function reset(uint256 tokenId) external {
}
function resetFor(uint256 tokenId, bytes calldata signature) external {
}
/**
* @dev Function to get record.
* @param key The key to query the value of.
* @param tokenId The token id to fetch.
* @return The value string.
*/
function get(string memory key, uint256 tokenId) public view whenResolver(tokenId) returns (string memory) {
}
function preconfigure(
string[] memory keys,
string[] memory values,
uint256 tokenId
) public {
}
/**
* @dev Function to set record.
* @param key The key set the value of.
* @param value The value to set key to.
* @param tokenId The token id to set.
*/
function set(string calldata key, string calldata value, uint256 tokenId) external {
}
/**
* @dev Function to set record on behalf of an address.
* @param key The key set the value of.
* @param value The value to set key to.
* @param tokenId The token id to set.
* @param signature The signature to verify the transaction with.
*/
function setFor(
string calldata key,
string calldata value,
uint256 tokenId,
bytes calldata signature
) external {
}
/**
* @dev Function to get multiple record.
* @param keys The keys to query the value of.
* @param tokenId The token id to fetch.
* @return The values.
*/
function getMany(string[] calldata keys, uint256 tokenId) external view whenResolver(tokenId) returns (string[] memory) {
}
function setMany(
string[] memory keys,
string[] memory values,
uint256 tokenId
) public {
}
/**
* @dev Function to set record on behalf of an address.
* @param keys The keys set the values of.
* @param values The values to set keys to.
* @param tokenId The token id to set.
* @param signature The signature to verify the transaction with.
*/
function setManyFor(
string[] memory keys,
string[] memory values,
uint256 tokenId,
bytes memory signature
) public {
}
function _setPreset(uint256 presetId, uint256 tokenId) internal {
}
/**
* @dev Internal function to to set record. As opposed to set, this imposes
* no restrictions on msg.sender.
* @param preset preset to set key/values on
* @param key key of record to be set
* @param value value of record to be set
* @param tokenId uint256 ID of the token
*/
function _set(uint256 preset, string memory key, string memory value, uint256 tokenId) internal {
}
/**
* @dev Internal function to to set multiple records. As opposed to setMany, this imposes
* no restrictions on msg.sender.
* @param preset preset to set key/values on
* @param keys keys of record to be set
* @param values values of record to be set
* @param tokenId uint256 ID of the token
*/
function _setMany(uint256 preset, string[] memory keys, string[] memory values, uint256 tokenId) internal {
}
}
| address(this)==_registry.resolverOf(tokenId),"SimpleResolver: is not the resolver" | 55,958 | address(this)==_registry.resolverOf(tokenId) |
null | pragma solidity 0.5.12;
pragma experimental ABIEncoderV2;
// solium-disable error-reason
contract Resolver is SignatureUtil {
event Set(uint256 indexed preset, string indexed key, string value, uint256 indexed tokenId);
event SetPreset(uint256 indexed preset, uint256 indexed tokenId);
// Mapping from token ID to preset id to key to value
mapping (uint256 => mapping (uint256 => mapping (string => string))) internal _records;
// Mapping from token ID to current preset id
mapping (uint256 => uint256) _tokenPresets;
MintingController internal _mintingController;
constructor(Registry registry, MintingController mintingController) public SignatureUtil(registry) {
}
/**
* @dev Throws if called when not the resolver.
*/
modifier whenResolver(uint256 tokenId) {
}
function presetOf(uint256 tokenId) external view returns (uint256) {
}
function setPreset(uint256 presetId, uint256 tokenId) external {
require(<FILL_ME>)
_setPreset(presetId, tokenId);
}
function setPresetFor(uint256 presetId, uint256 tokenId, bytes calldata signature) external {
}
function reset(uint256 tokenId) external {
}
function resetFor(uint256 tokenId, bytes calldata signature) external {
}
/**
* @dev Function to get record.
* @param key The key to query the value of.
* @param tokenId The token id to fetch.
* @return The value string.
*/
function get(string memory key, uint256 tokenId) public view whenResolver(tokenId) returns (string memory) {
}
function preconfigure(
string[] memory keys,
string[] memory values,
uint256 tokenId
) public {
}
/**
* @dev Function to set record.
* @param key The key set the value of.
* @param value The value to set key to.
* @param tokenId The token id to set.
*/
function set(string calldata key, string calldata value, uint256 tokenId) external {
}
/**
* @dev Function to set record on behalf of an address.
* @param key The key set the value of.
* @param value The value to set key to.
* @param tokenId The token id to set.
* @param signature The signature to verify the transaction with.
*/
function setFor(
string calldata key,
string calldata value,
uint256 tokenId,
bytes calldata signature
) external {
}
/**
* @dev Function to get multiple record.
* @param keys The keys to query the value of.
* @param tokenId The token id to fetch.
* @return The values.
*/
function getMany(string[] calldata keys, uint256 tokenId) external view whenResolver(tokenId) returns (string[] memory) {
}
function setMany(
string[] memory keys,
string[] memory values,
uint256 tokenId
) public {
}
/**
* @dev Function to set record on behalf of an address.
* @param keys The keys set the values of.
* @param values The values to set keys to.
* @param tokenId The token id to set.
* @param signature The signature to verify the transaction with.
*/
function setManyFor(
string[] memory keys,
string[] memory values,
uint256 tokenId,
bytes memory signature
) public {
}
function _setPreset(uint256 presetId, uint256 tokenId) internal {
}
/**
* @dev Internal function to to set record. As opposed to set, this imposes
* no restrictions on msg.sender.
* @param preset preset to set key/values on
* @param key key of record to be set
* @param value value of record to be set
* @param tokenId uint256 ID of the token
*/
function _set(uint256 preset, string memory key, string memory value, uint256 tokenId) internal {
}
/**
* @dev Internal function to to set multiple records. As opposed to setMany, this imposes
* no restrictions on msg.sender.
* @param preset preset to set key/values on
* @param keys keys of record to be set
* @param values values of record to be set
* @param tokenId uint256 ID of the token
*/
function _setMany(uint256 preset, string[] memory keys, string[] memory values, uint256 tokenId) internal {
}
}
| _registry.isApprovedOrOwner(msg.sender,tokenId) | 55,958 | _registry.isApprovedOrOwner(msg.sender,tokenId) |
null | pragma solidity 0.5.12;
pragma experimental ABIEncoderV2;
// solium-disable error-reason
contract Resolver is SignatureUtil {
event Set(uint256 indexed preset, string indexed key, string value, uint256 indexed tokenId);
event SetPreset(uint256 indexed preset, uint256 indexed tokenId);
// Mapping from token ID to preset id to key to value
mapping (uint256 => mapping (uint256 => mapping (string => string))) internal _records;
// Mapping from token ID to current preset id
mapping (uint256 => uint256) _tokenPresets;
MintingController internal _mintingController;
constructor(Registry registry, MintingController mintingController) public SignatureUtil(registry) {
}
/**
* @dev Throws if called when not the resolver.
*/
modifier whenResolver(uint256 tokenId) {
}
function presetOf(uint256 tokenId) external view returns (uint256) {
}
function setPreset(uint256 presetId, uint256 tokenId) external {
}
function setPresetFor(uint256 presetId, uint256 tokenId, bytes calldata signature) external {
}
function reset(uint256 tokenId) external {
}
function resetFor(uint256 tokenId, bytes calldata signature) external {
}
/**
* @dev Function to get record.
* @param key The key to query the value of.
* @param tokenId The token id to fetch.
* @return The value string.
*/
function get(string memory key, uint256 tokenId) public view whenResolver(tokenId) returns (string memory) {
}
function preconfigure(
string[] memory keys,
string[] memory values,
uint256 tokenId
) public {
require(<FILL_ME>)
_setMany(_tokenPresets[tokenId], keys, values, tokenId);
}
/**
* @dev Function to set record.
* @param key The key set the value of.
* @param value The value to set key to.
* @param tokenId The token id to set.
*/
function set(string calldata key, string calldata value, uint256 tokenId) external {
}
/**
* @dev Function to set record on behalf of an address.
* @param key The key set the value of.
* @param value The value to set key to.
* @param tokenId The token id to set.
* @param signature The signature to verify the transaction with.
*/
function setFor(
string calldata key,
string calldata value,
uint256 tokenId,
bytes calldata signature
) external {
}
/**
* @dev Function to get multiple record.
* @param keys The keys to query the value of.
* @param tokenId The token id to fetch.
* @return The values.
*/
function getMany(string[] calldata keys, uint256 tokenId) external view whenResolver(tokenId) returns (string[] memory) {
}
function setMany(
string[] memory keys,
string[] memory values,
uint256 tokenId
) public {
}
/**
* @dev Function to set record on behalf of an address.
* @param keys The keys set the values of.
* @param values The values to set keys to.
* @param tokenId The token id to set.
* @param signature The signature to verify the transaction with.
*/
function setManyFor(
string[] memory keys,
string[] memory values,
uint256 tokenId,
bytes memory signature
) public {
}
function _setPreset(uint256 presetId, uint256 tokenId) internal {
}
/**
* @dev Internal function to to set record. As opposed to set, this imposes
* no restrictions on msg.sender.
* @param preset preset to set key/values on
* @param key key of record to be set
* @param value value of record to be set
* @param tokenId uint256 ID of the token
*/
function _set(uint256 preset, string memory key, string memory value, uint256 tokenId) internal {
}
/**
* @dev Internal function to to set multiple records. As opposed to setMany, this imposes
* no restrictions on msg.sender.
* @param preset preset to set key/values on
* @param keys keys of record to be set
* @param values values of record to be set
* @param tokenId uint256 ID of the token
*/
function _setMany(uint256 preset, string[] memory keys, string[] memory values, uint256 tokenId) internal {
}
}
| _mintingController.isMinter(msg.sender) | 55,958 | _mintingController.isMinter(msg.sender) |
null | pragma solidity 0.4.21;
/**
* @title SafeMath by OpenZeppelin (commit: 5daaf60)
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
interface Token {
function transfer(address to, uint256 value) external returns (bool success);
function burn(uint256 amount) external;
function balanceOf(address owner) external returns (uint256 balance);
}
contract Crowdsale {
address public owner; // Address of the contract owner
address public fundRaiser; // Address which can withraw funds raised
uint256 public amountRaisedInWei; // Total amount of ether raised in wei
uint256 public tokensSold; // Total number of tokens sold
uint256 public tokensClaimed; // Total Number of tokens claimed by participants
uint256 public icoDeadline; // Duration this ICO will end
uint256 public tokensClaimableAfter; // Duration after tokens will be claimable
uint256 public tokensPerWei; // How many token a buyer gets per wei
Token public tokenReward; // Token being distributed
// Map of crowdsale participants, address as key and Participant structure as value
mapping(address => Participant) public participants;
// This is a type for a single Participant
struct Participant {
bool whitelisted;
uint256 tokens;
bool tokensClaimed;
}
event FundTransfer(address to, uint amount);
modifier afterIcoDeadline() { }
modifier afterTokensClaimableDeadline() { }
modifier onlyOwner() { }
/**
* Constructor function
*/
function Crowdsale(
address fundRaiserAccount,
uint256 durationOfIcoInDays,
uint256 durationTokensClaimableAfterInDays,
uint256 tokensForOneWei,
address addressOfToken
)
public
{
}
/**
* Fallback function: Buy token
* The function without name is the default function that is called whenever anyone sends funds to a contract.
* Reserves a number tokens per participant by multiplying tokensPerWei and sent ether in wei.
* This function is able to buy token when the following four cases are all met:
* - Before ICO deadline
* - Payer address is whitelisted in this contract
* - Sent ether is equal or bigger than minimum transaction (0.05 ether)
* - There are enough tokens to sell in this contract (tokens balance of contract minus tokensSold)
*/
function() payable public {
require(now < icoDeadline);
require(<FILL_ME>)
require(msg.value >= 0.01 ether);
uint256 tokensToBuy = SafeMath.mul(msg.value, tokensPerWei);
require(tokensToBuy <= SafeMath.sub(tokenReward.balanceOf(this), tokensSold));
participants[msg.sender].tokens = SafeMath.add(participants[msg.sender].tokens, tokensToBuy);
amountRaisedInWei = SafeMath.add(amountRaisedInWei, msg.value);
tokensSold = SafeMath.add(tokensSold, tokensToBuy);
}
/**
* Add single address into the whitelist.
* Note: Use this function for a single address to save transaction fee
*/
function addToWhitelist(address addr) onlyOwner public {
}
/**
* Remove single address from the whitelist.
* Note: Use this function for a single address to save transaction fee
*/
function removeFromWhitelist(address addr) onlyOwner public {
}
/**
* Add multiple addresses into the whitelist.
* Note: Use this function for more than one address to save transaction fee
*/
function addAddressesToWhitelist(address[] addresses) onlyOwner public {
}
/**
* Remove multiple addresses from the whitelist
* Note: Use this function for more than one address to save transaction fee
*/
function removeAddressesFromWhitelist(address[] addresses) onlyOwner public {
}
// ----------- After ICO Deadline ------------
/**
* Fundraiser address claims the raised funds after ICO deadline
*/
function withdrawFunds() afterIcoDeadline public {
}
/**
* Burn unsold tokens after ICO deadline
* Note: This function is designed to be used after Final-ICO period to burn unsold tokens
*/
function burnUnsoldTokens() onlyOwner afterIcoDeadline public {
}
// ----------- After Tokens Claimable Duration ------------
/**
* Each participant will be able to claim his tokens after duration tokensClaimableAfter
*/
function withdrawTokens() afterTokensClaimableDeadline public {
}
}
| participants[msg.sender].whitelisted | 55,972 | participants[msg.sender].whitelisted |
null | pragma solidity 0.4.21;
/**
* @title SafeMath by OpenZeppelin (commit: 5daaf60)
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
interface Token {
function transfer(address to, uint256 value) external returns (bool success);
function burn(uint256 amount) external;
function balanceOf(address owner) external returns (uint256 balance);
}
contract Crowdsale {
address public owner; // Address of the contract owner
address public fundRaiser; // Address which can withraw funds raised
uint256 public amountRaisedInWei; // Total amount of ether raised in wei
uint256 public tokensSold; // Total number of tokens sold
uint256 public tokensClaimed; // Total Number of tokens claimed by participants
uint256 public icoDeadline; // Duration this ICO will end
uint256 public tokensClaimableAfter; // Duration after tokens will be claimable
uint256 public tokensPerWei; // How many token a buyer gets per wei
Token public tokenReward; // Token being distributed
// Map of crowdsale participants, address as key and Participant structure as value
mapping(address => Participant) public participants;
// This is a type for a single Participant
struct Participant {
bool whitelisted;
uint256 tokens;
bool tokensClaimed;
}
event FundTransfer(address to, uint amount);
modifier afterIcoDeadline() { }
modifier afterTokensClaimableDeadline() { }
modifier onlyOwner() { }
/**
* Constructor function
*/
function Crowdsale(
address fundRaiserAccount,
uint256 durationOfIcoInDays,
uint256 durationTokensClaimableAfterInDays,
uint256 tokensForOneWei,
address addressOfToken
)
public
{
}
/**
* Fallback function: Buy token
* The function without name is the default function that is called whenever anyone sends funds to a contract.
* Reserves a number tokens per participant by multiplying tokensPerWei and sent ether in wei.
* This function is able to buy token when the following four cases are all met:
* - Before ICO deadline
* - Payer address is whitelisted in this contract
* - Sent ether is equal or bigger than minimum transaction (0.05 ether)
* - There are enough tokens to sell in this contract (tokens balance of contract minus tokensSold)
*/
function() payable public {
}
/**
* Add single address into the whitelist.
* Note: Use this function for a single address to save transaction fee
*/
function addToWhitelist(address addr) onlyOwner public {
}
/**
* Remove single address from the whitelist.
* Note: Use this function for a single address to save transaction fee
*/
function removeFromWhitelist(address addr) onlyOwner public {
}
/**
* Add multiple addresses into the whitelist.
* Note: Use this function for more than one address to save transaction fee
*/
function addAddressesToWhitelist(address[] addresses) onlyOwner public {
}
/**
* Remove multiple addresses from the whitelist
* Note: Use this function for more than one address to save transaction fee
*/
function removeAddressesFromWhitelist(address[] addresses) onlyOwner public {
}
// ----------- After ICO Deadline ------------
/**
* Fundraiser address claims the raised funds after ICO deadline
*/
function withdrawFunds() afterIcoDeadline public {
}
/**
* Burn unsold tokens after ICO deadline
* Note: This function is designed to be used after Final-ICO period to burn unsold tokens
*/
function burnUnsoldTokens() onlyOwner afterIcoDeadline public {
}
// ----------- After Tokens Claimable Duration ------------
/**
* Each participant will be able to claim his tokens after duration tokensClaimableAfter
*/
function withdrawTokens() afterTokensClaimableDeadline public {
require(participants[msg.sender].whitelisted);
require(<FILL_ME>)
participants[msg.sender].tokensClaimed = true;
uint256 tokens = participants[msg.sender].tokens;
tokenReward.transfer(msg.sender, tokens);
tokensClaimed = SafeMath.add(tokensClaimed, tokens);
}
}
| !participants[msg.sender].tokensClaimed | 55,972 | !participants[msg.sender].tokensClaimed |
null | pragma solidity ^0.5.1;
/**
* @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.
*/
constructor() 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) onlyOwner external {
}
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Airdrop is Ownable {
function multisend(address _tokenAddr, address[] calldata _to, uint256[] calldata _value) external onlyOwner returns (bool _success) {
assert(_to.length == _value.length);
//assert(_to.length <= 150);
IERC20 token = IERC20(_tokenAddr);
for (uint8 i = 0; i < _to.length; i++) {
require(<FILL_ME>)
}
return true;
}
function refund(address _tokenAddr) external onlyOwner {
}
function() external {
}
}
| token.transfer(_to[i],_value[i]) | 55,974 | token.transfer(_to[i],_value[i]) |
null | pragma solidity ^0.5.1;
/**
* @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.
*/
constructor() 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) onlyOwner external {
}
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Airdrop is Ownable {
function multisend(address _tokenAddr, address[] calldata _to, uint256[] calldata _value) external onlyOwner returns (bool _success) {
}
function refund(address _tokenAddr) external onlyOwner {
IERC20 token = IERC20(_tokenAddr);
uint256 _balance = token.balanceOf(address(this));
require(_balance > 0);
require(<FILL_ME>)
}
function() external {
}
}
| token.transfer(msg.sender,_balance) | 55,974 | token.transfer(msg.sender,_balance) |
"Account is already excluded" | /**
A true degen play
Telegram: t.me/thenotoriousinu
"Sitting in his gold framed chair, from a shady bar in Brooklyn "Notorious Inu 🚬"
is looking down on his fellow Inu's around him, sad and dissapointed face expressions
overwelm the atmosphere inside of the pub.
Because all of them know there's one one shitcoin that has the zero to lambo potential...
Notorious Inu 🚬"
8) ]8 ,ad888888888b
,8' ,8' ,gPPR888888888888
,8' ,8' ,ad8"" `Y888888888P
8) 8) ,ad8"" (8888888""
8, 8, ,ad8"" d888""
`8, `8, ,ad8"" ,ad8""
`8, `" ,ad8"" ,ad8""
,gPPR8b ,ad8""
dP:::::Yb ,ad8""
8):::::(8 ,ad8""
Yb:;;;:d888""
"8ggg8P"
Lets moon and recover from last 71 rugpulls or 50% presale wallets, first come = first served.
**/
/**
// SPDX-License-Identifier: Unlicensed
**/
pragma solidity ^0.8.6;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
interface IWETH {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function approve(address to, uint value) external returns (bool);
}
contract NotoriousInu is Context, IERC20, Ownable {
string private constant _name = unicode"NotoriousInu";
string private constant _symbol = "NOTINU";
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping(address => uint256)) private _allowances;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcluded;
IUniswapV2Router02 private uniswapV2Router;
address[] private _excluded;
address private c;
address private wallet1;
address private uniswapV2Pair;
address private WETH;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _taxFee;
uint256 private _LiquidityFee;
uint64 private buyCounter;
uint8 private constant _decimals = 9;
uint16 private maxTx;
bool private tradingOpen;
bool private inSwap;
bool private swapEnabled;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiqudity);
modifier lockTheSwap {
}
constructor(address payable _wallet1) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns (uint256) {
}
function nofees() private {
}
function basefees() private {
}
function setBots(address[] memory bots_) public onlyOwner {
}
function delBot(address notbot) public onlyOwner {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function sendETHToFee(uint256 ETHamount) private {
}
function openTrading() external onlyOwner() {
}
function manualswap() external {
}
function manualsend() external {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeLiquidity(uint256 tLiquidity) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 LiquidityFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tLiquidity, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns (uint256) {
}
function excludeFromReward(address addr) internal {
require(addr != address(uniswapV2Router), 'ERR: Can\'t exclude Uniswap router');
require(<FILL_ME>)
if(_rOwned[addr] > 0) {
_tOwned[addr] = tokenFromReflection(_rOwned[addr]);
}
_isExcluded[addr] = true;
_excluded.push(addr);
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
}
| !_isExcluded[addr],"Account is already excluded" | 56,057 | !_isExcluded[addr] |
"Balance exceeded wallet size" | /**
Yamcha Token (YAMCHA)
A former desert bandit, Yamcha was once an enemy of Goku, but quickly reformed and became a friend and ally. Brave, boastful and dependable, Yamcha is a very talented martial artist and one of the most powerful humans on Earth, possessing skills and traits that allow him to fight alongside his fellow Z Fighters when major threats loom.
🌿 Transaction Tax : 12%
🌿 5% for Marketing
🌿 5% for Dev
🌿 2% for Rewards, buybacks
🚀 Total Supply: 14800000
🚀 Max Tx: 74000
🚀 Max Buy: 0.5%
🚀 Max Wallet: 1%
🚀 Initial Liquidity Pool: 3 ETH
Website: yamcha.today
Telegram: t.me/yamchatoken
Twitter: twitter.com/yamchatoken
**/
pragma solidity ^0.8.12;
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract YamchaToken is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balance;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping(address => bool) public bots;
uint256 private _tTotal = 14800000 * 10**18;
uint256 private _maxWallet= 148000000 * 10**18;
uint256 private _taxFee;
address payable private _taxWallet;
uint256 public _maxTxAmount;
string private constant _name = "Yamcha Token";
string private constant _symbol = "YAMCHA";
uint8 private constant _decimals = 18;
IUniswapV2Router02 private _uniswap;
address private _pair;
bool private _canTrade;
bool private _inSwap = false;
bool private _swapEnabled = false;
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
if (from == _pair && to != address(_uniswap) && ! _isExcludedFromFee[to] ) {
require(amount<=_maxTxAmount,"Transaction amount limited");
}
require(!bots[from] && !bots[to], "This account is blacklisted");
if(to != _pair && ! _isExcludedFromFee[to] && ! _isExcludedFromFee[from]) {
require(<FILL_ME>)
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!_inSwap && from != _pair && _swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance >= 1000000000000000000) {
sendETHToFee(address(this).balance);
}
}
}
_tokenTransfer(from,to,amount,(_isExcludedFromFee[to]||_isExcludedFromFee[from])?0:_taxFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function decreaseTax(uint256 newTaxRate) public onlyOwner{
}
function increaseBuyLimit(uint256 amount) public onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function increaseMaxWallet(uint256 amount) public onlyOwner{
}
function increaseMaxWallets(address[] memory bots_) public onlyOwner {
}
function createUniswapPair() external onlyOwner {
}
function addLiquidity() external onlyOwner{
}
function _tokenTransfer(address sender, address recipient, uint256 tAmount, uint256 taxRate) private {
}
receive() external payable {}
function swapForTax() public{
}
function collectTax() public{
}
}
| balanceOf(to)+amount<=_maxWallet,"Balance exceeded wallet size" | 56,132 | balanceOf(to)+amount<=_maxWallet |
null | pragma solidity ^0.4.16;
contract owned {
address public owner;
function owned() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 0;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
}
}
/******************************************/
/* ADVANCED TOKEN STARTS HERE */
/******************************************/
contract GoodfieldNewRetail is owned, TokenERC20 {
uint256 public sellPrice;
uint256 public buyPrice;
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);
/* Initializes contract with initial supply tokens to the creator of the contract */
function GoodfieldNewRetail(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint _value) internal {
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
}
/// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
/// @param newSellPrice Price the users can sell to the contract
/// @param newBuyPrice Price users can buy from the contract
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
}
function buy() payable public returns (uint amount){
amount = msg.value / buyPrice; // calculates the amount
require(<FILL_ME>) // checks if it has enough to sell
balanceOf[msg.sender] += amount; // adds the amount to buyer's balance
balanceOf[this] -= amount; // subtracts amount from seller's balance
emit Transfer(this, msg.sender, amount); // execute an event reflecting the change
return amount; // ends function and returns
}
function sell(uint amount) public returns (uint revenue){
}
}
| balanceOf[this]>=amount | 56,158 | balanceOf[this]>=amount |
null | pragma solidity ^0.5.0;
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title ERC1155 interface
* @dev see https://github.com/ethereum/EIPs/issues/1155
*/
interface IERC1155 /* is ERC165 */ {
event TransferSingle(address indexed _operator, address indexed _from, address indexed _to, uint256 _id, uint256 _value);
event TransferBatch(address indexed _operator, address indexed _from, address indexed _to, uint256[] _ids, uint256[] _values);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
event URI(string _value, uint256 indexed _id);
function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes calldata _data) external;
function safeBatchTransferFrom(address _from, address _to, uint256[] calldata _ids, uint256[] calldata _values, bytes calldata _data) external;
function balanceOf(address _owner, uint256 _id) external view returns (uint256);
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids) external view returns (uint256[] memory);
function setApprovalForAll(address _operator, bool _approved) external;
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface ERC1155TokenReceiver {
function onERC1155Received(address _operator, address _from, uint256 _id, uint256 _value, bytes calldata _data) external returns(bytes4);
function onERC1155BatchReceived(address _operator, address _from, uint256[] calldata _ids, uint256[] calldata _values, bytes calldata _data) external returns(bytes4);
}
contract CommonConstants {
bytes4 constant internal ERC1155_ACCEPTED = 0xf23a6e61;
bytes4 constant internal ERC1155_BATCH_ACCEPTED = 0xbc197c81;
bytes4 constant internal FAILURE = 0x00000000;
}
contract ElevateSwap is ERC1155TokenReceiver, CommonConstants {
enum PaymentState {
Uninitialized,
PaymentSent,
ReceivedSpent,
SenderRefunded
}
struct Payment {
bytes20 paymentHash;
uint64 lockTime;
PaymentState state;
}
mapping (bytes32 => Payment) public payments;
event PaymentSent(bytes32 id);
event ReceiverSpent(bytes32 id, bytes32 secret);
event SenderRefunded(bytes32 id);
constructor() public { }
function ethPayment(
bytes32 _id,
address _receiver,
bytes20 _secretHash,
uint64 _lockTime
) external payable {
}
function erc20Payment(
bytes32 _id,
uint256 _amount,
address _tokenAddress,
address _receiver,
bytes20 _secretHash,
uint64 _lockTime
) external payable {
}
function erc1155Payment(
bytes32 _id,
uint256 _tokenId,
uint256 _amount,
address _tokenAddress,
address _receiver,
bytes20 _secretHash,
uint64 _lockTime
) external payable {
}
function receiverSpend(
bytes32 _id,
uint256 _amount,
bytes32 _secret,
address _tokenAddress,
address _sender,
uint256 _tokenId
) external {
require(<FILL_ME>)
bytes20 paymentHash = ripemd160(abi.encodePacked(
msg.sender,
_sender,
ripemd160(abi.encodePacked(sha256(abi.encodePacked(_secret)))),
_tokenAddress,
_amount,
_tokenId
));
require(paymentHash == payments[_id].paymentHash && now < payments[_id].lockTime);
payments[_id].state = PaymentState.ReceivedSpent;
if (_tokenAddress == address(0)) {
msg.sender.transfer(_amount);
} else if(_tokenId > uint256(0)) {
IERC1155 token = IERC1155(_tokenAddress);
token.safeTransferFrom(address(this), msg.sender, _tokenId, _amount, bytes(msg.data));
} else {
IERC20 token = IERC20(_tokenAddress);
require(token.transfer(msg.sender, _amount));
}
emit ReceiverSpent(_id, _secret);
}
function senderRefund(
bytes32 _id,
uint256 _amount,
bytes20 _paymentHash,
address _tokenAddress,
address _receiver,
uint256 _tokenId
) external {
}
function onERC1155Received(
address _operator,
address _from,
uint256 _id,
uint256 _value,
bytes calldata _data
) external returns(bytes4){
}
function onERC1155BatchReceived(
address _operator,
address _from,
uint256[] calldata _ids,
uint256[] calldata _values,
bytes calldata _data
) external returns(bytes4) {
}
}
| payments[_id].state==PaymentState.PaymentSent | 56,268 | payments[_id].state==PaymentState.PaymentSent |
"StakingPools: reward address cannot be 0x0" | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.6.12;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {FixedPointMath} from "./libraries/FixedPointMath.sol";
import {IMintableERC20} from "./interfaces/IMintableERC20.sol";
import {Pool} from "./libraries/pools/Pool.sol";
import {Stake} from "./libraries/pools/Stake.sol";
import {StakingPools} from "./StakingPools.sol";
import "hardhat/console.sol";
/// @title StakingPools
/// @dev A contract which allows users to stake to farm tokens.
///
/// This contract was inspired by Chef Nomi's 'MasterChef' contract which can be found in this
/// repository: https://github.com/sushiswap/sushiswap.
contract StakingPools is ReentrancyGuard {
using FixedPointMath for FixedPointMath.uq192x64;
using Pool for Pool.Data;
using Pool for Pool.List;
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Stake for Stake.Data;
event PendingGovernanceUpdated(
address pendingGovernance
);
event GovernanceUpdated(
address governance
);
event RewardRateUpdated(
uint256 rewardRate
);
event PoolRewardWeightUpdated(
uint256 indexed poolId,
uint256 rewardWeight
);
event PoolCreated(
uint256 indexed poolId,
IERC20 indexed token
);
event TokensDeposited(
address indexed user,
uint256 indexed poolId,
uint256 amount
);
event TokensWithdrawn(
address indexed user,
uint256 indexed poolId,
uint256 amount
);
event TokensClaimed(
address indexed user,
uint256 indexed poolId,
uint256 amount
);
/// @dev The token which will be minted as a reward for staking.
IMintableERC20 public reward;
/// @dev The address of the account which currently has administrative capabilities over this contract.
address public governance;
address public pendingGovernance;
/// @dev Tokens are mapped to their pool identifier plus one. Tokens that do not have an associated pool
/// will return an identifier of zero.
mapping(IERC20 => uint256) public tokenPoolIds;
/// @dev The context shared between the pools.
Pool.Context private _ctx;
/// @dev A list of all of the pools.
Pool.List private _pools;
/// @dev A mapping of all of the user stakes mapped first by pool and then by address.
mapping(address => mapping(uint256 => Stake.Data)) private _stakes;
constructor(
IMintableERC20 _reward,
address _governance
) public {
require(<FILL_ME>)
require(_governance != address(0), "StakingPools: governance address cannot be 0x0");
reward = _reward;
governance = _governance;
}
/// @dev A modifier which reverts when the caller is not the governance.
modifier onlyGovernance() {
}
/// @dev Sets the governance.
///
/// This function can only called by the current governance.
///
/// @param _pendingGovernance the new pending governance.
function setPendingGovernance(address _pendingGovernance) external onlyGovernance {
}
function acceptGovernance() external {
}
/// @dev Sets the distribution reward rate.
///
/// This will update all of the pools.
///
/// @param _rewardRate The number of tokens to distribute per second.
function setRewardRate(uint256 _rewardRate) external onlyGovernance {
}
/// @dev Creates a new pool.
///
/// The created pool will need to have its reward weight initialized before it begins generating rewards.
///
/// @param _token The token the pool will accept for staking.
///
/// @return the identifier for the newly created pool.
function createPool(IERC20 _token) external onlyGovernance returns (uint256) {
}
/// @dev Sets the reward weights of all of the pools.
///
/// @param _rewardWeights The reward weights of all of the pools.
function setRewardWeights(uint256[] calldata _rewardWeights) external onlyGovernance {
}
/// @dev Stakes tokens into a pool.
///
/// @param _poolId the pool to deposit tokens into.
/// @param _depositAmount the amount of tokens to deposit.
function deposit(uint256 _poolId, uint256 _depositAmount) external nonReentrant {
}
/// @dev Withdraws staked tokens from a pool.
///
/// @param _poolId The pool to withdraw staked tokens from.
/// @param _withdrawAmount The number of tokens to withdraw.
function withdraw(uint256 _poolId, uint256 _withdrawAmount) external nonReentrant {
}
/// @dev Claims all rewarded tokens from a pool.
///
/// @param _poolId The pool to claim rewards from.
///
/// @notice use this function to claim the tokens from a corresponding pool by ID.
function claim(uint256 _poolId) external nonReentrant {
}
/// @dev Claims all rewards from a pool and then withdraws all staked tokens.
///
/// @param _poolId the pool to exit from.
function exit(uint256 _poolId) external nonReentrant {
}
/// @dev Gets the rate at which tokens are minted to stakers for all pools.
///
/// @return the reward rate.
function rewardRate() external view returns (uint256) {
}
/// @dev Gets the total reward weight between all the pools.
///
/// @return the total reward weight.
function totalRewardWeight() external view returns (uint256) {
}
/// @dev Gets the number of pools that exist.
///
/// @return the pool count.
function poolCount() external view returns (uint256) {
}
/// @dev Gets the token a pool accepts.
///
/// @param _poolId the identifier of the pool.
///
/// @return the token.
function getPoolToken(uint256 _poolId) external view returns (IERC20) {
}
/// @dev Gets the total amount of funds staked in a pool.
///
/// @param _poolId the identifier of the pool.
///
/// @return the total amount of staked or deposited tokens.
function getPoolTotalDeposited(uint256 _poolId) external view returns (uint256) {
}
/// @dev Gets the reward weight of a pool which determines how much of the total rewards it receives per block.
///
/// @param _poolId the identifier of the pool.
///
/// @return the pool reward weight.
function getPoolRewardWeight(uint256 _poolId) external view returns (uint256) {
}
/// @dev Gets the amount of tokens per block being distributed to stakers for a pool.
///
/// @param _poolId the identifier of the pool.
///
/// @return the pool reward rate.
function getPoolRewardRate(uint256 _poolId) external view returns (uint256) {
}
/// @dev Gets the number of tokens a user has staked into a pool.
///
/// @param _account The account to query.
/// @param _poolId the identifier of the pool.
///
/// @return the amount of deposited tokens.
function getStakeTotalDeposited(address _account, uint256 _poolId) external view returns (uint256) {
}
/// @dev Gets the number of unclaimed reward tokens a user can claim from a pool.
///
/// @param _account The account to get the unclaimed balance of.
/// @param _poolId The pool to check for unclaimed rewards.
///
/// @return the amount of unclaimed reward tokens a user has in a pool.
function getStakeTotalUnclaimed(address _account, uint256 _poolId) external view returns (uint256) {
}
/// @dev Updates all of the pools.
///
/// Warning:
/// Make the staking plan before add a new pool. If the amount of pool becomes too many would
/// result the transaction failed due to high gas usage in for-loop.
function _updatePools() internal {
}
/// @dev Stakes tokens into a pool.
///
/// The pool and stake MUST be updated before calling this function.
///
/// @param _poolId the pool to deposit tokens into.
/// @param _depositAmount the amount of tokens to deposit.
function _deposit(uint256 _poolId, uint256 _depositAmount) internal {
}
/// @dev Withdraws staked tokens from a pool.
///
/// The pool and stake MUST be updated before calling this function.
///
/// @param _poolId The pool to withdraw staked tokens from.
/// @param _withdrawAmount The number of tokens to withdraw.
function _withdraw(uint256 _poolId, uint256 _withdrawAmount) internal {
}
/// @dev Claims all rewarded tokens from a pool.
///
/// The pool and stake MUST be updated before calling this function.
///
/// @param _poolId The pool to claim rewards from.
///
/// @notice use this function to claim the tokens from a corresponding pool by ID.
function _claim(uint256 _poolId) internal {
}
}
| address(_reward)!=address(0),"StakingPools: reward address cannot be 0x0" | 56,316 | address(_reward)!=address(0) |
"StakingPools: token already has a pool" | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.6.12;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import {FixedPointMath} from "./libraries/FixedPointMath.sol";
import {IMintableERC20} from "./interfaces/IMintableERC20.sol";
import {Pool} from "./libraries/pools/Pool.sol";
import {Stake} from "./libraries/pools/Stake.sol";
import {StakingPools} from "./StakingPools.sol";
import "hardhat/console.sol";
/// @title StakingPools
/// @dev A contract which allows users to stake to farm tokens.
///
/// This contract was inspired by Chef Nomi's 'MasterChef' contract which can be found in this
/// repository: https://github.com/sushiswap/sushiswap.
contract StakingPools is ReentrancyGuard {
using FixedPointMath for FixedPointMath.uq192x64;
using Pool for Pool.Data;
using Pool for Pool.List;
using SafeERC20 for IERC20;
using SafeMath for uint256;
using Stake for Stake.Data;
event PendingGovernanceUpdated(
address pendingGovernance
);
event GovernanceUpdated(
address governance
);
event RewardRateUpdated(
uint256 rewardRate
);
event PoolRewardWeightUpdated(
uint256 indexed poolId,
uint256 rewardWeight
);
event PoolCreated(
uint256 indexed poolId,
IERC20 indexed token
);
event TokensDeposited(
address indexed user,
uint256 indexed poolId,
uint256 amount
);
event TokensWithdrawn(
address indexed user,
uint256 indexed poolId,
uint256 amount
);
event TokensClaimed(
address indexed user,
uint256 indexed poolId,
uint256 amount
);
/// @dev The token which will be minted as a reward for staking.
IMintableERC20 public reward;
/// @dev The address of the account which currently has administrative capabilities over this contract.
address public governance;
address public pendingGovernance;
/// @dev Tokens are mapped to their pool identifier plus one. Tokens that do not have an associated pool
/// will return an identifier of zero.
mapping(IERC20 => uint256) public tokenPoolIds;
/// @dev The context shared between the pools.
Pool.Context private _ctx;
/// @dev A list of all of the pools.
Pool.List private _pools;
/// @dev A mapping of all of the user stakes mapped first by pool and then by address.
mapping(address => mapping(uint256 => Stake.Data)) private _stakes;
constructor(
IMintableERC20 _reward,
address _governance
) public {
}
/// @dev A modifier which reverts when the caller is not the governance.
modifier onlyGovernance() {
}
/// @dev Sets the governance.
///
/// This function can only called by the current governance.
///
/// @param _pendingGovernance the new pending governance.
function setPendingGovernance(address _pendingGovernance) external onlyGovernance {
}
function acceptGovernance() external {
}
/// @dev Sets the distribution reward rate.
///
/// This will update all of the pools.
///
/// @param _rewardRate The number of tokens to distribute per second.
function setRewardRate(uint256 _rewardRate) external onlyGovernance {
}
/// @dev Creates a new pool.
///
/// The created pool will need to have its reward weight initialized before it begins generating rewards.
///
/// @param _token The token the pool will accept for staking.
///
/// @return the identifier for the newly created pool.
function createPool(IERC20 _token) external onlyGovernance returns (uint256) {
require(address(_token) != address(0), "StakingPools: token address cannot be 0x0");
require(<FILL_ME>)
uint256 _poolId = _pools.length();
_pools.push(Pool.Data({
token: _token,
totalDeposited: 0,
rewardWeight: 0,
accumulatedRewardWeight: FixedPointMath.uq192x64(0),
lastUpdatedBlock: block.number
}));
tokenPoolIds[_token] = _poolId + 1;
emit PoolCreated(_poolId, _token);
return _poolId;
}
/// @dev Sets the reward weights of all of the pools.
///
/// @param _rewardWeights The reward weights of all of the pools.
function setRewardWeights(uint256[] calldata _rewardWeights) external onlyGovernance {
}
/// @dev Stakes tokens into a pool.
///
/// @param _poolId the pool to deposit tokens into.
/// @param _depositAmount the amount of tokens to deposit.
function deposit(uint256 _poolId, uint256 _depositAmount) external nonReentrant {
}
/// @dev Withdraws staked tokens from a pool.
///
/// @param _poolId The pool to withdraw staked tokens from.
/// @param _withdrawAmount The number of tokens to withdraw.
function withdraw(uint256 _poolId, uint256 _withdrawAmount) external nonReentrant {
}
/// @dev Claims all rewarded tokens from a pool.
///
/// @param _poolId The pool to claim rewards from.
///
/// @notice use this function to claim the tokens from a corresponding pool by ID.
function claim(uint256 _poolId) external nonReentrant {
}
/// @dev Claims all rewards from a pool and then withdraws all staked tokens.
///
/// @param _poolId the pool to exit from.
function exit(uint256 _poolId) external nonReentrant {
}
/// @dev Gets the rate at which tokens are minted to stakers for all pools.
///
/// @return the reward rate.
function rewardRate() external view returns (uint256) {
}
/// @dev Gets the total reward weight between all the pools.
///
/// @return the total reward weight.
function totalRewardWeight() external view returns (uint256) {
}
/// @dev Gets the number of pools that exist.
///
/// @return the pool count.
function poolCount() external view returns (uint256) {
}
/// @dev Gets the token a pool accepts.
///
/// @param _poolId the identifier of the pool.
///
/// @return the token.
function getPoolToken(uint256 _poolId) external view returns (IERC20) {
}
/// @dev Gets the total amount of funds staked in a pool.
///
/// @param _poolId the identifier of the pool.
///
/// @return the total amount of staked or deposited tokens.
function getPoolTotalDeposited(uint256 _poolId) external view returns (uint256) {
}
/// @dev Gets the reward weight of a pool which determines how much of the total rewards it receives per block.
///
/// @param _poolId the identifier of the pool.
///
/// @return the pool reward weight.
function getPoolRewardWeight(uint256 _poolId) external view returns (uint256) {
}
/// @dev Gets the amount of tokens per block being distributed to stakers for a pool.
///
/// @param _poolId the identifier of the pool.
///
/// @return the pool reward rate.
function getPoolRewardRate(uint256 _poolId) external view returns (uint256) {
}
/// @dev Gets the number of tokens a user has staked into a pool.
///
/// @param _account The account to query.
/// @param _poolId the identifier of the pool.
///
/// @return the amount of deposited tokens.
function getStakeTotalDeposited(address _account, uint256 _poolId) external view returns (uint256) {
}
/// @dev Gets the number of unclaimed reward tokens a user can claim from a pool.
///
/// @param _account The account to get the unclaimed balance of.
/// @param _poolId The pool to check for unclaimed rewards.
///
/// @return the amount of unclaimed reward tokens a user has in a pool.
function getStakeTotalUnclaimed(address _account, uint256 _poolId) external view returns (uint256) {
}
/// @dev Updates all of the pools.
///
/// Warning:
/// Make the staking plan before add a new pool. If the amount of pool becomes too many would
/// result the transaction failed due to high gas usage in for-loop.
function _updatePools() internal {
}
/// @dev Stakes tokens into a pool.
///
/// The pool and stake MUST be updated before calling this function.
///
/// @param _poolId the pool to deposit tokens into.
/// @param _depositAmount the amount of tokens to deposit.
function _deposit(uint256 _poolId, uint256 _depositAmount) internal {
}
/// @dev Withdraws staked tokens from a pool.
///
/// The pool and stake MUST be updated before calling this function.
///
/// @param _poolId The pool to withdraw staked tokens from.
/// @param _withdrawAmount The number of tokens to withdraw.
function _withdraw(uint256 _poolId, uint256 _withdrawAmount) internal {
}
/// @dev Claims all rewarded tokens from a pool.
///
/// The pool and stake MUST be updated before calling this function.
///
/// @param _poolId The pool to claim rewards from.
///
/// @notice use this function to claim the tokens from a corresponding pool by ID.
function _claim(uint256 _poolId) internal {
}
}
| tokenPoolIds[_token]==0,"StakingPools: token already has a pool" | 56,316 | tokenPoolIds[_token]==0 |
"invalid code" | // SPDX-License-Identifier:MIT
pragma solidity ^0.6.2;
pragma experimental ABIEncoderV2;
import "./TestPaymasterEverythingAccepted.sol";
contract TestPaymasterConfigurableMisbehavior is TestPaymasterEverythingAccepted {
bool public withdrawDuringPostRelayedCall;
bool public withdrawDuringPreRelayedCall;
bool public returnInvalidErrorCode;
bool public revertPostRelayCall;
bool public overspendAcceptGas;
bool public revertPreRelayCall;
function setWithdrawDuringPostRelayedCall(bool val) public {
}
function setWithdrawDuringPreRelayedCall(bool val) public {
}
function setReturnInvalidErrorCode(bool val) public {
}
function setRevertPostRelayCall(bool val) public {
}
function setRevertPreRelayCall(bool val) public {
}
function setOverspendAcceptGas(bool val) public {
}
function acceptRelayedCall(
GsnTypes.RelayRequest calldata relayRequest,
bytes calldata signature,
bytes calldata approvalData,
uint256 maxPossibleGas
)
external
override
view
returns (bytes memory) {
(relayRequest, signature, approvalData, maxPossibleGas);
if (overspendAcceptGas) {
uint i = 0;
while (true) {
i++;
}
}
require(<FILL_ME>)
return "";
}
function preRelayedCall(bytes calldata context)
external
override
relayHubOnly
returns (bytes32) {
}
function postRelayedCall(
bytes calldata context,
bool success,
bytes32 preRetVal,
uint256 gasUseWithoutPost,
GsnTypes.RelayData calldata relayData
)
external
override
relayHubOnly
{
}
/// leaving withdrawal public and unprotected
function withdrawAllBalance() public returns (uint256) {
}
// solhint-disable-next-line no-empty-blocks
receive() external override payable {}
}
| !returnInvalidErrorCode,"invalid code" | 56,420 | !returnInvalidErrorCode |
"relay hub address not set" | // SPDX-License-Identifier:MIT
pragma solidity ^0.6.2;
pragma experimental ABIEncoderV2;
import "./TestPaymasterEverythingAccepted.sol";
contract TestPaymasterConfigurableMisbehavior is TestPaymasterEverythingAccepted {
bool public withdrawDuringPostRelayedCall;
bool public withdrawDuringPreRelayedCall;
bool public returnInvalidErrorCode;
bool public revertPostRelayCall;
bool public overspendAcceptGas;
bool public revertPreRelayCall;
function setWithdrawDuringPostRelayedCall(bool val) public {
}
function setWithdrawDuringPreRelayedCall(bool val) public {
}
function setReturnInvalidErrorCode(bool val) public {
}
function setRevertPostRelayCall(bool val) public {
}
function setRevertPreRelayCall(bool val) public {
}
function setOverspendAcceptGas(bool val) public {
}
function acceptRelayedCall(
GsnTypes.RelayRequest calldata relayRequest,
bytes calldata signature,
bytes calldata approvalData,
uint256 maxPossibleGas
)
external
override
view
returns (bytes memory) {
}
function preRelayedCall(bytes calldata context)
external
override
relayHubOnly
returns (bytes32) {
}
function postRelayedCall(
bytes calldata context,
bool success,
bytes32 preRetVal,
uint256 gasUseWithoutPost,
GsnTypes.RelayData calldata relayData
)
external
override
relayHubOnly
{
}
/// leaving withdrawal public and unprotected
function withdrawAllBalance() public returns (uint256) {
require(<FILL_ME>)
uint256 balance = relayHub.balanceOf(address(this));
relayHub.withdraw(balance, address(this));
return balance;
}
// solhint-disable-next-line no-empty-blocks
receive() external override payable {}
}
| address(relayHub)!=address(0),"relay hub address not set" | 56,420 | address(relayHub)!=address(0) |
"All NFTs have been minted." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
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 functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Strings {
bytes16 private constant alphabet = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping (uint256 => address) private _owners;
// Mapping owner address to token count
mapping (address => uint256) private _balances;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. Empty by default, can be overriden
* in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}
interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokensOfOwner}.
*/
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract UGLYBABYKIRBY is ERC721Enumerable, Ownable {
uint256 public constant MAX_NFT_SUPPLY = 11160;
uint public constant MAX_PURCHASABLE = 30;
uint256 public UGLY_BABY_KIRBY_PRICE = 150000000000000000; // 0.15 ETH
string public PROVENANCE_HASH = "";
address private _kirbyInuAddress;
mapping (address => bool) private walletMinted;
bool public saleStarted = false;
constructor() ERC721("Ugly Baby Kirby", "UGLYBABY") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function getTokenURI(uint256 tokenId) public view returns (string memory) {
}
function mint(uint256 amountToMint) public payable {
require(saleStarted == true, "This sale has not started.");
require(<FILL_ME>)
require(amountToMint > 0, "You must mint at least one Ugly Baby Kirby.");
require(amountToMint <= MAX_PURCHASABLE, "You cannot mint more than 30 Ugly Baby Kirbys.");
require(totalSupply() + amountToMint <= MAX_NFT_SUPPLY, "The amount of Ugly Baby Kirby you are trying to mint exceeds the MAX_NFT_SUPPLY.");
require(UGLY_BABY_KIRBY_PRICE * amountToMint == msg.value, "Incorrect Ether value.");
for (uint256 i = 0; i < amountToMint; i++) {
uint256 mintIndex = totalSupply();
_safeMint(msg.sender, mintIndex);
}
}
function tokenHolderMint() public {
}
function resetWallet(uint256 _tokenOne, uint256 _tokenTwo) public {
}
function setTokenKey(address token) external onlyOwner() {
}
function approvedToMint(address user) public view returns(bool){
}
function checkMintAmount(address user) public view returns(uint256){
}
function tokenHolderBalance(address user) public view returns(uint256){
}
function hasMinted(address user) public view returns(bool){
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function setProvenanceHash(string memory _hash) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| totalSupply()<MAX_NFT_SUPPLY,"All NFTs have been minted." | 56,492 | totalSupply()<MAX_NFT_SUPPLY |
"The amount of Ugly Baby Kirby you are trying to mint exceeds the MAX_NFT_SUPPLY." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
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 functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Strings {
bytes16 private constant alphabet = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping (uint256 => address) private _owners;
// Mapping owner address to token count
mapping (address => uint256) private _balances;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. Empty by default, can be overriden
* in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}
interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokensOfOwner}.
*/
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract UGLYBABYKIRBY is ERC721Enumerable, Ownable {
uint256 public constant MAX_NFT_SUPPLY = 11160;
uint public constant MAX_PURCHASABLE = 30;
uint256 public UGLY_BABY_KIRBY_PRICE = 150000000000000000; // 0.15 ETH
string public PROVENANCE_HASH = "";
address private _kirbyInuAddress;
mapping (address => bool) private walletMinted;
bool public saleStarted = false;
constructor() ERC721("Ugly Baby Kirby", "UGLYBABY") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function getTokenURI(uint256 tokenId) public view returns (string memory) {
}
function mint(uint256 amountToMint) public payable {
require(saleStarted == true, "This sale has not started.");
require(totalSupply() < MAX_NFT_SUPPLY, "All NFTs have been minted.");
require(amountToMint > 0, "You must mint at least one Ugly Baby Kirby.");
require(amountToMint <= MAX_PURCHASABLE, "You cannot mint more than 30 Ugly Baby Kirbys.");
require(<FILL_ME>)
require(UGLY_BABY_KIRBY_PRICE * amountToMint == msg.value, "Incorrect Ether value.");
for (uint256 i = 0; i < amountToMint; i++) {
uint256 mintIndex = totalSupply();
_safeMint(msg.sender, mintIndex);
}
}
function tokenHolderMint() public {
}
function resetWallet(uint256 _tokenOne, uint256 _tokenTwo) public {
}
function setTokenKey(address token) external onlyOwner() {
}
function approvedToMint(address user) public view returns(bool){
}
function checkMintAmount(address user) public view returns(uint256){
}
function tokenHolderBalance(address user) public view returns(uint256){
}
function hasMinted(address user) public view returns(bool){
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function setProvenanceHash(string memory _hash) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| totalSupply()+amountToMint<=MAX_NFT_SUPPLY,"The amount of Ugly Baby Kirby you are trying to mint exceeds the MAX_NFT_SUPPLY." | 56,492 | totalSupply()+amountToMint<=MAX_NFT_SUPPLY |
"Incorrect Ether value." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
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 functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Strings {
bytes16 private constant alphabet = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping (uint256 => address) private _owners;
// Mapping owner address to token count
mapping (address => uint256) private _balances;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. Empty by default, can be overriden
* in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}
interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokensOfOwner}.
*/
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract UGLYBABYKIRBY is ERC721Enumerable, Ownable {
uint256 public constant MAX_NFT_SUPPLY = 11160;
uint public constant MAX_PURCHASABLE = 30;
uint256 public UGLY_BABY_KIRBY_PRICE = 150000000000000000; // 0.15 ETH
string public PROVENANCE_HASH = "";
address private _kirbyInuAddress;
mapping (address => bool) private walletMinted;
bool public saleStarted = false;
constructor() ERC721("Ugly Baby Kirby", "UGLYBABY") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function getTokenURI(uint256 tokenId) public view returns (string memory) {
}
function mint(uint256 amountToMint) public payable {
require(saleStarted == true, "This sale has not started.");
require(totalSupply() < MAX_NFT_SUPPLY, "All NFTs have been minted.");
require(amountToMint > 0, "You must mint at least one Ugly Baby Kirby.");
require(amountToMint <= MAX_PURCHASABLE, "You cannot mint more than 30 Ugly Baby Kirbys.");
require(totalSupply() + amountToMint <= MAX_NFT_SUPPLY, "The amount of Ugly Baby Kirby you are trying to mint exceeds the MAX_NFT_SUPPLY.");
require(<FILL_ME>)
for (uint256 i = 0; i < amountToMint; i++) {
uint256 mintIndex = totalSupply();
_safeMint(msg.sender, mintIndex);
}
}
function tokenHolderMint() public {
}
function resetWallet(uint256 _tokenOne, uint256 _tokenTwo) public {
}
function setTokenKey(address token) external onlyOwner() {
}
function approvedToMint(address user) public view returns(bool){
}
function checkMintAmount(address user) public view returns(uint256){
}
function tokenHolderBalance(address user) public view returns(uint256){
}
function hasMinted(address user) public view returns(bool){
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function setProvenanceHash(string memory _hash) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| UGLY_BABY_KIRBY_PRICE*amountToMint==msg.value,"Incorrect Ether value." | 56,492 | UGLY_BABY_KIRBY_PRICE*amountToMint==msg.value |
"You need at least 100,000,000,000 of token to mint." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
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 functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Strings {
bytes16 private constant alphabet = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping (uint256 => address) private _owners;
// Mapping owner address to token count
mapping (address => uint256) private _balances;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. Empty by default, can be overriden
* in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}
interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokensOfOwner}.
*/
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract UGLYBABYKIRBY is ERC721Enumerable, Ownable {
uint256 public constant MAX_NFT_SUPPLY = 11160;
uint public constant MAX_PURCHASABLE = 30;
uint256 public UGLY_BABY_KIRBY_PRICE = 150000000000000000; // 0.15 ETH
string public PROVENANCE_HASH = "";
address private _kirbyInuAddress;
mapping (address => bool) private walletMinted;
bool public saleStarted = false;
constructor() ERC721("Ugly Baby Kirby", "UGLYBABY") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function getTokenURI(uint256 tokenId) public view returns (string memory) {
}
function mint(uint256 amountToMint) public payable {
}
function tokenHolderMint() public {
require(saleStarted == true, "This sale has not started.");
require(totalSupply() < MAX_NFT_SUPPLY, "All NFTs have been minted.");
require(<FILL_ME>)
require(!hasMinted(msg.sender), "You have already minted!");
for (uint256 i = 0; i < this.checkMintAmount(msg.sender); i++) {
uint256 mintIndex = totalSupply();
_safeMint(msg.sender, mintIndex);
}
walletMinted[msg.sender] = true;
}
function resetWallet(uint256 _tokenOne, uint256 _tokenTwo) public {
}
function setTokenKey(address token) external onlyOwner() {
}
function approvedToMint(address user) public view returns(bool){
}
function checkMintAmount(address user) public view returns(uint256){
}
function tokenHolderBalance(address user) public view returns(uint256){
}
function hasMinted(address user) public view returns(bool){
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function setProvenanceHash(string memory _hash) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| approvedToMint(msg.sender),"You need at least 100,000,000,000 of token to mint." | 56,492 | approvedToMint(msg.sender) |
"You have already minted!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
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 functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Strings {
bytes16 private constant alphabet = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping (uint256 => address) private _owners;
// Mapping owner address to token count
mapping (address => uint256) private _balances;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. Empty by default, can be overriden
* in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}
interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokensOfOwner}.
*/
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract UGLYBABYKIRBY is ERC721Enumerable, Ownable {
uint256 public constant MAX_NFT_SUPPLY = 11160;
uint public constant MAX_PURCHASABLE = 30;
uint256 public UGLY_BABY_KIRBY_PRICE = 150000000000000000; // 0.15 ETH
string public PROVENANCE_HASH = "";
address private _kirbyInuAddress;
mapping (address => bool) private walletMinted;
bool public saleStarted = false;
constructor() ERC721("Ugly Baby Kirby", "UGLYBABY") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function getTokenURI(uint256 tokenId) public view returns (string memory) {
}
function mint(uint256 amountToMint) public payable {
}
function tokenHolderMint() public {
require(saleStarted == true, "This sale has not started.");
require(totalSupply() < MAX_NFT_SUPPLY, "All NFTs have been minted.");
require(approvedToMint(msg.sender), "You need at least 100,000,000,000 of token to mint.");
require(<FILL_ME>)
for (uint256 i = 0; i < this.checkMintAmount(msg.sender); i++) {
uint256 mintIndex = totalSupply();
_safeMint(msg.sender, mintIndex);
}
walletMinted[msg.sender] = true;
}
function resetWallet(uint256 _tokenOne, uint256 _tokenTwo) public {
}
function setTokenKey(address token) external onlyOwner() {
}
function approvedToMint(address user) public view returns(bool){
}
function checkMintAmount(address user) public view returns(uint256){
}
function tokenHolderBalance(address user) public view returns(uint256){
}
function hasMinted(address user) public view returns(bool){
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function setProvenanceHash(string memory _hash) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| !hasMinted(msg.sender),"You have already minted!" | 56,492 | !hasMinted(msg.sender) |
"Ugly Baby One does not exist!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
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 functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Strings {
bytes16 private constant alphabet = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping (uint256 => address) private _owners;
// Mapping owner address to token count
mapping (address => uint256) private _balances;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. Empty by default, can be overriden
* in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}
interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokensOfOwner}.
*/
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract UGLYBABYKIRBY is ERC721Enumerable, Ownable {
uint256 public constant MAX_NFT_SUPPLY = 11160;
uint public constant MAX_PURCHASABLE = 30;
uint256 public UGLY_BABY_KIRBY_PRICE = 150000000000000000; // 0.15 ETH
string public PROVENANCE_HASH = "";
address private _kirbyInuAddress;
mapping (address => bool) private walletMinted;
bool public saleStarted = false;
constructor() ERC721("Ugly Baby Kirby", "UGLYBABY") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function getTokenURI(uint256 tokenId) public view returns (string memory) {
}
function mint(uint256 amountToMint) public payable {
}
function tokenHolderMint() public {
}
function resetWallet(uint256 _tokenOne, uint256 _tokenTwo) public {
require(<FILL_ME>)
require(_exists(_tokenTwo), "Ugly Baby Two does not exist!");
require(_isApprovedOrOwner(msg.sender, _tokenOne), "You do not own this token.");
require(_isApprovedOrOwner(msg.sender, _tokenTwo), "You do not own this token.");
_burn(_tokenOne);
_burn(_tokenTwo);
walletMinted[msg.sender] = false;
}
function setTokenKey(address token) external onlyOwner() {
}
function approvedToMint(address user) public view returns(bool){
}
function checkMintAmount(address user) public view returns(uint256){
}
function tokenHolderBalance(address user) public view returns(uint256){
}
function hasMinted(address user) public view returns(bool){
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function setProvenanceHash(string memory _hash) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| _exists(_tokenOne),"Ugly Baby One does not exist!" | 56,492 | _exists(_tokenOne) |
"Ugly Baby Two does not exist!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
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 functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Strings {
bytes16 private constant alphabet = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping (uint256 => address) private _owners;
// Mapping owner address to token count
mapping (address => uint256) private _balances;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. Empty by default, can be overriden
* in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}
interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokensOfOwner}.
*/
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract UGLYBABYKIRBY is ERC721Enumerable, Ownable {
uint256 public constant MAX_NFT_SUPPLY = 11160;
uint public constant MAX_PURCHASABLE = 30;
uint256 public UGLY_BABY_KIRBY_PRICE = 150000000000000000; // 0.15 ETH
string public PROVENANCE_HASH = "";
address private _kirbyInuAddress;
mapping (address => bool) private walletMinted;
bool public saleStarted = false;
constructor() ERC721("Ugly Baby Kirby", "UGLYBABY") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function getTokenURI(uint256 tokenId) public view returns (string memory) {
}
function mint(uint256 amountToMint) public payable {
}
function tokenHolderMint() public {
}
function resetWallet(uint256 _tokenOne, uint256 _tokenTwo) public {
require(_exists(_tokenOne), "Ugly Baby One does not exist!");
require(<FILL_ME>)
require(_isApprovedOrOwner(msg.sender, _tokenOne), "You do not own this token.");
require(_isApprovedOrOwner(msg.sender, _tokenTwo), "You do not own this token.");
_burn(_tokenOne);
_burn(_tokenTwo);
walletMinted[msg.sender] = false;
}
function setTokenKey(address token) external onlyOwner() {
}
function approvedToMint(address user) public view returns(bool){
}
function checkMintAmount(address user) public view returns(uint256){
}
function tokenHolderBalance(address user) public view returns(uint256){
}
function hasMinted(address user) public view returns(bool){
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function setProvenanceHash(string memory _hash) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| _exists(_tokenTwo),"Ugly Baby Two does not exist!" | 56,492 | _exists(_tokenTwo) |
"You do not own this token." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
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 functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Strings {
bytes16 private constant alphabet = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping (uint256 => address) private _owners;
// Mapping owner address to token count
mapping (address => uint256) private _balances;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. Empty by default, can be overriden
* in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}
interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokensOfOwner}.
*/
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract UGLYBABYKIRBY is ERC721Enumerable, Ownable {
uint256 public constant MAX_NFT_SUPPLY = 11160;
uint public constant MAX_PURCHASABLE = 30;
uint256 public UGLY_BABY_KIRBY_PRICE = 150000000000000000; // 0.15 ETH
string public PROVENANCE_HASH = "";
address private _kirbyInuAddress;
mapping (address => bool) private walletMinted;
bool public saleStarted = false;
constructor() ERC721("Ugly Baby Kirby", "UGLYBABY") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function getTokenURI(uint256 tokenId) public view returns (string memory) {
}
function mint(uint256 amountToMint) public payable {
}
function tokenHolderMint() public {
}
function resetWallet(uint256 _tokenOne, uint256 _tokenTwo) public {
require(_exists(_tokenOne), "Ugly Baby One does not exist!");
require(_exists(_tokenTwo), "Ugly Baby Two does not exist!");
require(<FILL_ME>)
require(_isApprovedOrOwner(msg.sender, _tokenTwo), "You do not own this token.");
_burn(_tokenOne);
_burn(_tokenTwo);
walletMinted[msg.sender] = false;
}
function setTokenKey(address token) external onlyOwner() {
}
function approvedToMint(address user) public view returns(bool){
}
function checkMintAmount(address user) public view returns(uint256){
}
function tokenHolderBalance(address user) public view returns(uint256){
}
function hasMinted(address user) public view returns(bool){
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function setProvenanceHash(string memory _hash) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| _isApprovedOrOwner(msg.sender,_tokenOne),"You do not own this token." | 56,492 | _isApprovedOrOwner(msg.sender,_tokenOne) |
"You do not own this token." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
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 functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library Strings {
bytes16 private constant alphabet = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping (uint256 => address) private _owners;
// Mapping owner address to token count
mapping (address => uint256) private _balances;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* @dev Base URI for computing {tokenURI}. Empty by default, can be overriden
* in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}
interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokensOfOwner}.
*/
function walletOfOwner(address _owner) public view returns(uint256[] memory) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract UGLYBABYKIRBY is ERC721Enumerable, Ownable {
uint256 public constant MAX_NFT_SUPPLY = 11160;
uint public constant MAX_PURCHASABLE = 30;
uint256 public UGLY_BABY_KIRBY_PRICE = 150000000000000000; // 0.15 ETH
string public PROVENANCE_HASH = "";
address private _kirbyInuAddress;
mapping (address => bool) private walletMinted;
bool public saleStarted = false;
constructor() ERC721("Ugly Baby Kirby", "UGLYBABY") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function getTokenURI(uint256 tokenId) public view returns (string memory) {
}
function mint(uint256 amountToMint) public payable {
}
function tokenHolderMint() public {
}
function resetWallet(uint256 _tokenOne, uint256 _tokenTwo) public {
require(_exists(_tokenOne), "Ugly Baby One does not exist!");
require(_exists(_tokenTwo), "Ugly Baby Two does not exist!");
require(_isApprovedOrOwner(msg.sender, _tokenOne), "You do not own this token.");
require(<FILL_ME>)
_burn(_tokenOne);
_burn(_tokenTwo);
walletMinted[msg.sender] = false;
}
function setTokenKey(address token) external onlyOwner() {
}
function approvedToMint(address user) public view returns(bool){
}
function checkMintAmount(address user) public view returns(uint256){
}
function tokenHolderBalance(address user) public view returns(uint256){
}
function hasMinted(address user) public view returns(bool){
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function setProvenanceHash(string memory _hash) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| _isApprovedOrOwner(msg.sender,_tokenTwo),"You do not own this token." | 56,492 | _isApprovedOrOwner(msg.sender,_tokenTwo) |
"You do not own the required number of Space Punk tokens" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import { ISpacePunksToken } from "./interfaces/ISpacePunksToken.sol";
contract SpaceDinosToken is ERC721, ERC721URIStorage, ERC721Enumerable, Ownable, Pausable, PaymentSplitter, ReentrancyGuard {
using SafeMath for uint256;
using Counters for Counters.Counter;
uint256 public constant TOKEN_LIMIT = 20000;
string private __baseURI;
bool public publicSale = false;
bool public ownersGrant = true;
uint256 private _maxTokensAtOnce;
Counters.Counter private _tokenIds;
uint256 private _tokenPrice;
uint256[] private _teamShares = [50, 50];
address[] private _team = [0x3515001548Cb3f93Dc5E3F3880D1f5ab2b0E07DB, 0xd240d8E59f1F49BCbBe4f0f1F711953F665aC551];
address _spacePunksContractAddress = 0x45DB714f24f5A313569c41683047f1d49e78Ba07;
constructor()
PaymentSplitter(_team, _teamShares)
ERC721("Space Dinos", "SDC")
{
}
// Public sales
function togglePublicSale() public onlyOwner {
}
// _maxTokensAtOnce
function maxTokensAtOnce() public view onlyOwner returns (uint256) {
}
function setMaxTokensAtOnce(uint256 _count) public onlyOwner {
}
// Minting
function mintOneAsOwner(uint256 _tokenId) public payable whenNotPaused {
}
function mintMultipleAsOwner(uint256[] memory _ids) public payable nonReentrant whenNotPaused {
require(ownersGrant, "Space Punk Owners grant period has ended");
require(_ids.length > 0, "Provide an array of token IDs");
require(<FILL_ME>)
for(uint256 i = 0; i < _ids.length; i++) {
mintOneAsOwner(_ids[i]);
}
}
function mintTokens(uint256 _amount) public payable nonReentrant whenNotPaused {
}
function _mintToken(address _to) private {
}
// Developer minting after the Owners Grant
function devMint(uint256[] memory _ids) public payable nonReentrant onlyOwner {
}
// Token existence check
function exists(uint256 _tokenId) public view returns (bool) {
}
// Space Punks contract address
function setSpacePunksContractAddress(address _contractAddress) public onlyOwner {
}
// Required overrides from parent contracts
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721, ERC721URIStorage) returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
// _paused
function togglePaused() public onlyOwner {
}
// _tokenPrice
function getTokenPrice() public view returns(uint256) {
}
function setTokenPrice(uint256 _price) public onlyOwner {
}
// Owners grant
function setOwnersGrant(bool _value) public onlyOwner {
}
// SPC
function ownerOfSpacePunk(uint _tokenId) public view returns (address) {
}
function balanceOfSpacePunkOwner(address _owner) public view returns (uint256) {
}
// Token URIs
function _baseURI() internal override view returns (string memory) {
}
function setBaseURI(string memory _value) public onlyOwner {
}
}
| balanceOfSpacePunkOwner(msg.sender)>=_ids.length,"You do not own the required number of Space Punk tokens" | 56,582 | balanceOfSpacePunkOwner(msg.sender)>=_ids.length |
"Purchase would exceed max supply of tokens" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import { ISpacePunksToken } from "./interfaces/ISpacePunksToken.sol";
contract SpaceDinosToken is ERC721, ERC721URIStorage, ERC721Enumerable, Ownable, Pausable, PaymentSplitter, ReentrancyGuard {
using SafeMath for uint256;
using Counters for Counters.Counter;
uint256 public constant TOKEN_LIMIT = 20000;
string private __baseURI;
bool public publicSale = false;
bool public ownersGrant = true;
uint256 private _maxTokensAtOnce;
Counters.Counter private _tokenIds;
uint256 private _tokenPrice;
uint256[] private _teamShares = [50, 50];
address[] private _team = [0x3515001548Cb3f93Dc5E3F3880D1f5ab2b0E07DB, 0xd240d8E59f1F49BCbBe4f0f1F711953F665aC551];
address _spacePunksContractAddress = 0x45DB714f24f5A313569c41683047f1d49e78Ba07;
constructor()
PaymentSplitter(_team, _teamShares)
ERC721("Space Dinos", "SDC")
{
}
// Public sales
function togglePublicSale() public onlyOwner {
}
// _maxTokensAtOnce
function maxTokensAtOnce() public view onlyOwner returns (uint256) {
}
function setMaxTokensAtOnce(uint256 _count) public onlyOwner {
}
// Minting
function mintOneAsOwner(uint256 _tokenId) public payable whenNotPaused {
}
function mintMultipleAsOwner(uint256[] memory _ids) public payable nonReentrant whenNotPaused {
}
function mintTokens(uint256 _amount) public payable nonReentrant whenNotPaused {
require(<FILL_ME>)
require(publicSale, "Public sale must be active");
require(_amount <= _maxTokensAtOnce, "Too many tokens at once");
require(getTokenPrice().mul(_amount) == msg.value, "Insufficient funds to purchase");
for(uint256 i = 0; i < _amount; i++) {
_mintToken(msg.sender);
}
}
function _mintToken(address _to) private {
}
// Developer minting after the Owners Grant
function devMint(uint256[] memory _ids) public payable nonReentrant onlyOwner {
}
// Token existence check
function exists(uint256 _tokenId) public view returns (bool) {
}
// Space Punks contract address
function setSpacePunksContractAddress(address _contractAddress) public onlyOwner {
}
// Required overrides from parent contracts
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721, ERC721URIStorage) returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
// _paused
function togglePaused() public onlyOwner {
}
// _tokenPrice
function getTokenPrice() public view returns(uint256) {
}
function setTokenPrice(uint256 _price) public onlyOwner {
}
// Owners grant
function setOwnersGrant(bool _value) public onlyOwner {
}
// SPC
function ownerOfSpacePunk(uint _tokenId) public view returns (address) {
}
function balanceOfSpacePunkOwner(address _owner) public view returns (uint256) {
}
// Token URIs
function _baseURI() internal override view returns (string memory) {
}
function setBaseURI(string memory _value) public onlyOwner {
}
}
| totalSupply().add(_amount)<=TOKEN_LIMIT,"Purchase would exceed max supply of tokens" | 56,582 | totalSupply().add(_amount)<=TOKEN_LIMIT |
"Insufficient funds to purchase" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import { ISpacePunksToken } from "./interfaces/ISpacePunksToken.sol";
contract SpaceDinosToken is ERC721, ERC721URIStorage, ERC721Enumerable, Ownable, Pausable, PaymentSplitter, ReentrancyGuard {
using SafeMath for uint256;
using Counters for Counters.Counter;
uint256 public constant TOKEN_LIMIT = 20000;
string private __baseURI;
bool public publicSale = false;
bool public ownersGrant = true;
uint256 private _maxTokensAtOnce;
Counters.Counter private _tokenIds;
uint256 private _tokenPrice;
uint256[] private _teamShares = [50, 50];
address[] private _team = [0x3515001548Cb3f93Dc5E3F3880D1f5ab2b0E07DB, 0xd240d8E59f1F49BCbBe4f0f1F711953F665aC551];
address _spacePunksContractAddress = 0x45DB714f24f5A313569c41683047f1d49e78Ba07;
constructor()
PaymentSplitter(_team, _teamShares)
ERC721("Space Dinos", "SDC")
{
}
// Public sales
function togglePublicSale() public onlyOwner {
}
// _maxTokensAtOnce
function maxTokensAtOnce() public view onlyOwner returns (uint256) {
}
function setMaxTokensAtOnce(uint256 _count) public onlyOwner {
}
// Minting
function mintOneAsOwner(uint256 _tokenId) public payable whenNotPaused {
}
function mintMultipleAsOwner(uint256[] memory _ids) public payable nonReentrant whenNotPaused {
}
function mintTokens(uint256 _amount) public payable nonReentrant whenNotPaused {
require(totalSupply().add(_amount) <= TOKEN_LIMIT, "Purchase would exceed max supply of tokens");
require(publicSale, "Public sale must be active");
require(_amount <= _maxTokensAtOnce, "Too many tokens at once");
require(<FILL_ME>)
for(uint256 i = 0; i < _amount; i++) {
_mintToken(msg.sender);
}
}
function _mintToken(address _to) private {
}
// Developer minting after the Owners Grant
function devMint(uint256[] memory _ids) public payable nonReentrant onlyOwner {
}
// Token existence check
function exists(uint256 _tokenId) public view returns (bool) {
}
// Space Punks contract address
function setSpacePunksContractAddress(address _contractAddress) public onlyOwner {
}
// Required overrides from parent contracts
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721, ERC721URIStorage) returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
// _paused
function togglePaused() public onlyOwner {
}
// _tokenPrice
function getTokenPrice() public view returns(uint256) {
}
function setTokenPrice(uint256 _price) public onlyOwner {
}
// Owners grant
function setOwnersGrant(bool _value) public onlyOwner {
}
// SPC
function ownerOfSpacePunk(uint _tokenId) public view returns (address) {
}
function balanceOfSpacePunkOwner(address _owner) public view returns (uint256) {
}
// Token URIs
function _baseURI() internal override view returns (string memory) {
}
function setBaseURI(string memory _value) public onlyOwner {
}
}
| getTokenPrice().mul(_amount)==msg.value,"Insufficient funds to purchase" | 56,582 | getTokenPrice().mul(_amount)==msg.value |
"Owners Grant must be over before you can mint" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import { ISpacePunksToken } from "./interfaces/ISpacePunksToken.sol";
contract SpaceDinosToken is ERC721, ERC721URIStorage, ERC721Enumerable, Ownable, Pausable, PaymentSplitter, ReentrancyGuard {
using SafeMath for uint256;
using Counters for Counters.Counter;
uint256 public constant TOKEN_LIMIT = 20000;
string private __baseURI;
bool public publicSale = false;
bool public ownersGrant = true;
uint256 private _maxTokensAtOnce;
Counters.Counter private _tokenIds;
uint256 private _tokenPrice;
uint256[] private _teamShares = [50, 50];
address[] private _team = [0x3515001548Cb3f93Dc5E3F3880D1f5ab2b0E07DB, 0xd240d8E59f1F49BCbBe4f0f1F711953F665aC551];
address _spacePunksContractAddress = 0x45DB714f24f5A313569c41683047f1d49e78Ba07;
constructor()
PaymentSplitter(_team, _teamShares)
ERC721("Space Dinos", "SDC")
{
}
// Public sales
function togglePublicSale() public onlyOwner {
}
// _maxTokensAtOnce
function maxTokensAtOnce() public view onlyOwner returns (uint256) {
}
function setMaxTokensAtOnce(uint256 _count) public onlyOwner {
}
// Minting
function mintOneAsOwner(uint256 _tokenId) public payable whenNotPaused {
}
function mintMultipleAsOwner(uint256[] memory _ids) public payable nonReentrant whenNotPaused {
}
function mintTokens(uint256 _amount) public payable nonReentrant whenNotPaused {
}
function _mintToken(address _to) private {
}
// Developer minting after the Owners Grant
function devMint(uint256[] memory _ids) public payable nonReentrant onlyOwner {
require(<FILL_ME>)
require(_ids.length > 0, "Provide an array of token IDs");
for(uint256 i = 0; i < _ids.length; i++) {
_safeMint(msg.sender, _ids[i]);
}
}
// Token existence check
function exists(uint256 _tokenId) public view returns (bool) {
}
// Space Punks contract address
function setSpacePunksContractAddress(address _contractAddress) public onlyOwner {
}
// Required overrides from parent contracts
function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId) public view virtual override(ERC721, ERC721URIStorage) returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
// _paused
function togglePaused() public onlyOwner {
}
// _tokenPrice
function getTokenPrice() public view returns(uint256) {
}
function setTokenPrice(uint256 _price) public onlyOwner {
}
// Owners grant
function setOwnersGrant(bool _value) public onlyOwner {
}
// SPC
function ownerOfSpacePunk(uint _tokenId) public view returns (address) {
}
function balanceOfSpacePunkOwner(address _owner) public view returns (uint256) {
}
// Token URIs
function _baseURI() internal override view returns (string memory) {
}
function setBaseURI(string memory _value) public onlyOwner {
}
}
| !ownersGrant,"Owners Grant must be over before you can mint" | 56,582 | !ownersGrant |
"msg.sender is not whiteliisted in KYC" | /**
@notice Exchange smart contract for ChelleCoin to AllocationTokens
*/
contract Exchange is IExchange, Ownable {
enum State {INACTIVE, ACTIVE}
IERC20 public erc20Token; // address of ERC-20 token allowed to be exchanged.
IAllocationToken public allocationToken; // address of Allocation Token Smart Contract.
IKYC public kyc; // KYC contract
uint256 public allocationTokensPerErc20Token; // exchange rate of ERC-20 tokens to AT tokens.
State exchangeState; // current state of the exchange contract
/**
@dev constructor for the Exchange contract
@param _erc20Token address of ERC-20 token allowed to be exchanged.
@param _allocationToken address of Allocation Token Smart Contract.
@param _allocationTokensPerErc20Token exchange rate of ERC-20 tokens to AT tokens.
*/
constructor(
IERC20 _erc20Token,
IAllocationToken _allocationToken,
IKYC _kyc,
uint256 _allocationTokensPerErc20Token
) public {
}
/**
@notice call is only allowed to pass when exchange is in ACTIVE state
*/
modifier isStateActive() {
}
/**
@notice function exchanges chellecoin tokens to allocation tokens
@param tokens the amount of chellecoin tokens to be exchanged for allocation tokens
*/
function exchange(uint256 tokens) public isStateActive returns (bool) {
require(tokens > 0, "tokens amount is not valid.");
require(<FILL_ME>)
uint256 AT_tokens_to_mint = calculateAllocationTokens(tokens);
require(
erc20Token.transferFrom(msg.sender, address(0x0), tokens),
"transferFrom failed."
);
allocationToken.mint(msg.sender, AT_tokens_to_mint);
emit TokensExchanged(
0,
msg.sender,
address(erc20Token),
address(allocationToken),
tokens,
AT_tokens_to_mint
);
}
/**
@notice this function sets/changes state of this smart contract and only exchange manager/owner can call it
@param state it can be either 0 (Inactive) or 1 (Active)
*/
function setState(uint256 state) external onlyOwner {
}
/**
@dev it updates update exchange rate of ERC-20 tokens to AT tokens
@param _allocationTokensPerErc20Token the exchange rate
*/
function setExchangeRate(uint256 _allocationTokensPerErc20Token)
external
onlyOwner
{
}
/**
@notice function to get the current state of the exchange contract
@return current state
*/
function getCurrentState() public view returns (uint256) {
}
/**
@dev an internal function to calculate allocation rate
@param tokens the amount of chellecoin tokens
*/
function calculateAllocationTokens(uint256 tokens)
internal
view
returns (uint256)
{
}
}
| kyc.getAddressStatus(msg.sender),"msg.sender is not whiteliisted in KYC" | 56,602 | kyc.getAddressStatus(msg.sender) |
"transferFrom failed." | /**
@notice Exchange smart contract for ChelleCoin to AllocationTokens
*/
contract Exchange is IExchange, Ownable {
enum State {INACTIVE, ACTIVE}
IERC20 public erc20Token; // address of ERC-20 token allowed to be exchanged.
IAllocationToken public allocationToken; // address of Allocation Token Smart Contract.
IKYC public kyc; // KYC contract
uint256 public allocationTokensPerErc20Token; // exchange rate of ERC-20 tokens to AT tokens.
State exchangeState; // current state of the exchange contract
/**
@dev constructor for the Exchange contract
@param _erc20Token address of ERC-20 token allowed to be exchanged.
@param _allocationToken address of Allocation Token Smart Contract.
@param _allocationTokensPerErc20Token exchange rate of ERC-20 tokens to AT tokens.
*/
constructor(
IERC20 _erc20Token,
IAllocationToken _allocationToken,
IKYC _kyc,
uint256 _allocationTokensPerErc20Token
) public {
}
/**
@notice call is only allowed to pass when exchange is in ACTIVE state
*/
modifier isStateActive() {
}
/**
@notice function exchanges chellecoin tokens to allocation tokens
@param tokens the amount of chellecoin tokens to be exchanged for allocation tokens
*/
function exchange(uint256 tokens) public isStateActive returns (bool) {
require(tokens > 0, "tokens amount is not valid.");
require(
kyc.getAddressStatus(msg.sender),
"msg.sender is not whiteliisted in KYC"
);
uint256 AT_tokens_to_mint = calculateAllocationTokens(tokens);
require(<FILL_ME>)
allocationToken.mint(msg.sender, AT_tokens_to_mint);
emit TokensExchanged(
0,
msg.sender,
address(erc20Token),
address(allocationToken),
tokens,
AT_tokens_to_mint
);
}
/**
@notice this function sets/changes state of this smart contract and only exchange manager/owner can call it
@param state it can be either 0 (Inactive) or 1 (Active)
*/
function setState(uint256 state) external onlyOwner {
}
/**
@dev it updates update exchange rate of ERC-20 tokens to AT tokens
@param _allocationTokensPerErc20Token the exchange rate
*/
function setExchangeRate(uint256 _allocationTokensPerErc20Token)
external
onlyOwner
{
}
/**
@notice function to get the current state of the exchange contract
@return current state
*/
function getCurrentState() public view returns (uint256) {
}
/**
@dev an internal function to calculate allocation rate
@param tokens the amount of chellecoin tokens
*/
function calculateAllocationTokens(uint256 tokens)
internal
view
returns (uint256)
{
}
}
| erc20Token.transferFrom(msg.sender,address(0x0),tokens),"transferFrom failed." | 56,602 | erc20Token.transferFrom(msg.sender,address(0x0),tokens) |
"member address cannot be 0" | pragma solidity 0.5.14;
/**
* @title Open-add Ether airdrop for members.
* @author Ross_Campbell, Bill_Warren and Scott H Stevenson of LexDAO
*/
contract ETHDropOpenAdd {
struct Member {
bool exists;
uint memberIndex;
}
mapping(address => Member) public memberList;
address payable[] members;
uint256 public drip;
address payable private secretary;
modifier onlySecretary() {
}
function() external payable { }
constructor(uint256 _drip, address payable[] memory _members) payable public {
drip = _drip;
for (uint256 i = 0; i < _members.length; i++) {
require(<FILL_ME>)
memberList[_members[i]].exists = true;
memberList[_members[i]].memberIndex = members.push(_members[i]) - 1;
}
secretary = members[0];
}
function dripETH() public onlySecretary {
}
function dropETH(uint256 drop) payable public onlySecretary {
}
function customDropETH(uint256[] memory drop) payable public onlySecretary {
}
function getBalance() public view returns (uint256) {
}
function addMember(address payable newMember) public {
}
function getMembership() public view returns (address payable[] memory) {
}
function getMemberCount() public view returns(uint256 memberCount) {
}
function isMember(address memberAddress) public view returns (bool memberExists) {
}
function removeMember(address _removeMember) public onlySecretary {
}
function transferSecretary(address payable newSecretary) public onlySecretary {
}
function updateDrip(uint256 newDrip) public onlySecretary {
}
}
contract ETHDropFactory {
ETHDropOpenAdd private Drop;
address[] public drops;
event newDrop(address indexed secretary, address indexed drop);
function newETHDropOpenAdd(uint256 _drip, address payable[] memory _members) payable public {
}
}
| _members[i]!=address(0),"member address cannot be 0" | 56,736 | _members[i]!=address(0) |
"member already exists" | pragma solidity 0.5.14;
/**
* @title Open-add Ether airdrop for members.
* @author Ross_Campbell, Bill_Warren and Scott H Stevenson of LexDAO
*/
contract ETHDropOpenAdd {
struct Member {
bool exists;
uint memberIndex;
}
mapping(address => Member) public memberList;
address payable[] members;
uint256 public drip;
address payable private secretary;
modifier onlySecretary() {
}
function() external payable { }
constructor(uint256 _drip, address payable[] memory _members) payable public {
}
function dripETH() public onlySecretary {
}
function dropETH(uint256 drop) payable public onlySecretary {
}
function customDropETH(uint256[] memory drop) payable public onlySecretary {
}
function getBalance() public view returns (uint256) {
}
function addMember(address payable newMember) public {
require(<FILL_ME>)
memberList[newMember].exists = true;
memberList[newMember].memberIndex = members.push(newMember) - 1;
}
function getMembership() public view returns (address payable[] memory) {
}
function getMemberCount() public view returns(uint256 memberCount) {
}
function isMember(address memberAddress) public view returns (bool memberExists) {
}
function removeMember(address _removeMember) public onlySecretary {
}
function transferSecretary(address payable newSecretary) public onlySecretary {
}
function updateDrip(uint256 newDrip) public onlySecretary {
}
}
contract ETHDropFactory {
ETHDropOpenAdd private Drop;
address[] public drops;
event newDrop(address indexed secretary, address indexed drop);
function newETHDropOpenAdd(uint256 _drip, address payable[] memory _members) payable public {
}
}
| memberList[newMember].exists!=true,"member already exists" | 56,736 | memberList[newMember].exists!=true |
"no such member to remove" | pragma solidity 0.5.14;
/**
* @title Open-add Ether airdrop for members.
* @author Ross_Campbell, Bill_Warren and Scott H Stevenson of LexDAO
*/
contract ETHDropOpenAdd {
struct Member {
bool exists;
uint memberIndex;
}
mapping(address => Member) public memberList;
address payable[] members;
uint256 public drip;
address payable private secretary;
modifier onlySecretary() {
}
function() external payable { }
constructor(uint256 _drip, address payable[] memory _members) payable public {
}
function dripETH() public onlySecretary {
}
function dropETH(uint256 drop) payable public onlySecretary {
}
function customDropETH(uint256[] memory drop) payable public onlySecretary {
}
function getBalance() public view returns (uint256) {
}
function addMember(address payable newMember) public {
}
function getMembership() public view returns (address payable[] memory) {
}
function getMemberCount() public view returns(uint256 memberCount) {
}
function isMember(address memberAddress) public view returns (bool memberExists) {
}
function removeMember(address _removeMember) public onlySecretary {
require(<FILL_ME>)
uint256 memberToDelete = memberList[_removeMember].memberIndex;
address payable keyToMove = members[members.length-1];
members[memberToDelete] = keyToMove;
memberList[_removeMember].exists = false;
memberList[keyToMove].memberIndex = memberToDelete;
members.length--;
}
function transferSecretary(address payable newSecretary) public onlySecretary {
}
function updateDrip(uint256 newDrip) public onlySecretary {
}
}
contract ETHDropFactory {
ETHDropOpenAdd private Drop;
address[] public drops;
event newDrop(address indexed secretary, address indexed drop);
function newETHDropOpenAdd(uint256 _drip, address payable[] memory _members) payable public {
}
}
| memberList[_removeMember].exists=true,"no such member to remove" | 56,736 | memberList[_removeMember].exists=true |
"TaskTreasury: onlyWhitelistedServices" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.0;
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {_transfer, ETH} from "./FGelato.sol";
contract TaskTreasury is Ownable, ReentrancyGuard {
using EnumerableSet for EnumerableSet.AddressSet;
using SafeERC20 for IERC20;
mapping(address => mapping(address => uint256)) public userTokenBalance;
mapping(address => EnumerableSet.AddressSet) internal _tokenCredits;
EnumerableSet.AddressSet internal _whitelistedServices;
address payable public immutable gelato;
event FundsDeposited(
address indexed sender,
address indexed token,
uint256 indexed amount
);
event FundsWithdrawn(
address indexed receiver,
address indexed initiator,
address indexed token,
uint256 amount
);
constructor(address payable _gelato) {
}
modifier onlyWhitelistedServices() {
require(<FILL_ME>)
_;
}
/// @notice Function to deposit Funds which will be used to execute transactions on various services
/// @param _receiver Address receiving the credits
/// @param _token Token to be credited, use "0xeeee...." for ETH
/// @param _amount Amount to be credited
function depositFunds(
address _receiver,
address _token,
uint256 _amount
) external payable {
}
/// @notice Function to withdraw Funds back to the _receiver
/// @param _receiver Address receiving the credits
/// @param _token Token to be credited, use "0xeeee...." for ETH
/// @param _amount Amount to be credited
function withdrawFunds(
address payable _receiver,
address _token,
uint256 _amount
) external nonReentrant {
}
/// @notice Function called by whitelisted services to handle payments, e.g. PokeMe"
/// @param _token Token to be used for payment by users
/// @param _amount Amount to be deducted
/// @param _user Address of user whose balance will be deducted
function useFunds(
address _token,
uint256 _amount,
address _user
) external onlyWhitelistedServices {
}
// Governance functions
/// @notice Add new service that can call useFunds. Gelato Governance
/// @param _service New service to add
function addWhitelistedService(address _service) external onlyOwner {
}
/// @notice Remove old service that can call useFunds. Gelato Governance
/// @param _service Old service to remove
function removeWhitelistedService(address _service) external onlyOwner {
}
// View Funcs
/// @notice Helper func to get all deposited tokens by a user
/// @param _user User to get the balances from
function getCreditTokensByUser(address _user)
external
view
returns (address[] memory)
{
}
function getWhitelistedServices() external view returns (address[] memory) {
}
}
| _whitelistedServices.contains(msg.sender),"TaskTreasury: onlyWhitelistedServices" | 56,766 | _whitelistedServices.contains(msg.sender) |
"TaskTreasury: addWhitelistedService: whitelisted" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.0;
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {_transfer, ETH} from "./FGelato.sol";
contract TaskTreasury is Ownable, ReentrancyGuard {
using EnumerableSet for EnumerableSet.AddressSet;
using SafeERC20 for IERC20;
mapping(address => mapping(address => uint256)) public userTokenBalance;
mapping(address => EnumerableSet.AddressSet) internal _tokenCredits;
EnumerableSet.AddressSet internal _whitelistedServices;
address payable public immutable gelato;
event FundsDeposited(
address indexed sender,
address indexed token,
uint256 indexed amount
);
event FundsWithdrawn(
address indexed receiver,
address indexed initiator,
address indexed token,
uint256 amount
);
constructor(address payable _gelato) {
}
modifier onlyWhitelistedServices() {
}
/// @notice Function to deposit Funds which will be used to execute transactions on various services
/// @param _receiver Address receiving the credits
/// @param _token Token to be credited, use "0xeeee...." for ETH
/// @param _amount Amount to be credited
function depositFunds(
address _receiver,
address _token,
uint256 _amount
) external payable {
}
/// @notice Function to withdraw Funds back to the _receiver
/// @param _receiver Address receiving the credits
/// @param _token Token to be credited, use "0xeeee...." for ETH
/// @param _amount Amount to be credited
function withdrawFunds(
address payable _receiver,
address _token,
uint256 _amount
) external nonReentrant {
}
/// @notice Function called by whitelisted services to handle payments, e.g. PokeMe"
/// @param _token Token to be used for payment by users
/// @param _amount Amount to be deducted
/// @param _user Address of user whose balance will be deducted
function useFunds(
address _token,
uint256 _amount,
address _user
) external onlyWhitelistedServices {
}
// Governance functions
/// @notice Add new service that can call useFunds. Gelato Governance
/// @param _service New service to add
function addWhitelistedService(address _service) external onlyOwner {
require(<FILL_ME>)
_whitelistedServices.add(_service);
}
/// @notice Remove old service that can call useFunds. Gelato Governance
/// @param _service Old service to remove
function removeWhitelistedService(address _service) external onlyOwner {
}
// View Funcs
/// @notice Helper func to get all deposited tokens by a user
/// @param _user User to get the balances from
function getCreditTokensByUser(address _user)
external
view
returns (address[] memory)
{
}
function getWhitelistedServices() external view returns (address[] memory) {
}
}
| !_whitelistedServices.contains(_service),"TaskTreasury: addWhitelistedService: whitelisted" | 56,766 | !_whitelistedServices.contains(_service) |
"TaskTreasury: addWhitelistedService: !whitelisted" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.0;
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {_transfer, ETH} from "./FGelato.sol";
contract TaskTreasury is Ownable, ReentrancyGuard {
using EnumerableSet for EnumerableSet.AddressSet;
using SafeERC20 for IERC20;
mapping(address => mapping(address => uint256)) public userTokenBalance;
mapping(address => EnumerableSet.AddressSet) internal _tokenCredits;
EnumerableSet.AddressSet internal _whitelistedServices;
address payable public immutable gelato;
event FundsDeposited(
address indexed sender,
address indexed token,
uint256 indexed amount
);
event FundsWithdrawn(
address indexed receiver,
address indexed initiator,
address indexed token,
uint256 amount
);
constructor(address payable _gelato) {
}
modifier onlyWhitelistedServices() {
}
/// @notice Function to deposit Funds which will be used to execute transactions on various services
/// @param _receiver Address receiving the credits
/// @param _token Token to be credited, use "0xeeee...." for ETH
/// @param _amount Amount to be credited
function depositFunds(
address _receiver,
address _token,
uint256 _amount
) external payable {
}
/// @notice Function to withdraw Funds back to the _receiver
/// @param _receiver Address receiving the credits
/// @param _token Token to be credited, use "0xeeee...." for ETH
/// @param _amount Amount to be credited
function withdrawFunds(
address payable _receiver,
address _token,
uint256 _amount
) external nonReentrant {
}
/// @notice Function called by whitelisted services to handle payments, e.g. PokeMe"
/// @param _token Token to be used for payment by users
/// @param _amount Amount to be deducted
/// @param _user Address of user whose balance will be deducted
function useFunds(
address _token,
uint256 _amount,
address _user
) external onlyWhitelistedServices {
}
// Governance functions
/// @notice Add new service that can call useFunds. Gelato Governance
/// @param _service New service to add
function addWhitelistedService(address _service) external onlyOwner {
}
/// @notice Remove old service that can call useFunds. Gelato Governance
/// @param _service Old service to remove
function removeWhitelistedService(address _service) external onlyOwner {
require(<FILL_ME>)
_whitelistedServices.remove(_service);
}
// View Funcs
/// @notice Helper func to get all deposited tokens by a user
/// @param _user User to get the balances from
function getCreditTokensByUser(address _user)
external
view
returns (address[] memory)
{
}
function getWhitelistedServices() external view returns (address[] memory) {
}
}
| _whitelistedServices.contains(_service),"TaskTreasury: addWhitelistedService: !whitelisted" | 56,766 | _whitelistedServices.contains(_service) |
"Can only initially mint once" | pragma solidity >=0.6.6;
contract HUDLToken is Ownable, ERC20{
/* Scalar for safe math */
uint256 scalar = 1000000;
/* Max supply of HUDL tokens */
uint256 maxSupply = 40000000 * 10**18;
/* Initial supply for distributor */
uint256 initialSupply = 2000000 * 10**18;
/* Initial founder supply*/
uint256 initialFounderSupply = 500000 * 10**18;
/* Max pool supply scaled 10000 = 1% */
uint256 poolMaxSize = 10000;
/* Min pool supply scaled 100 = 0.01% */
uint256 poolMinSize = 100;
/* Timestamp for tracking */
uint256 lastPoolTimeStamp = block.timestamp;
/* Distributor contract address */
address distributorAddress = address(0);
/* HUDL pool contract address */
address hudlPoolAddress = address(0);
/* How much tokens are in reserve for the pool */
uint256 amountInReserve = maxSupply;
/* How much tokens are in reserve for the pool */
uint256 mintTimeLock = 0;
/* have the initial tokens been minted? */
bool initialMinted = false;
constructor (string memory name, string memory symbol, uint256 timeLock) public ERC20(name, symbol) Ownable(){
}
/*** GETTER FUNCTIONS ***/
function getHudlPoolAddress() external view returns(address){
}
function getDistributorAddress() external view returns(address){
}
function getAmountInReserve() external view returns(uint256){
}
function getMaxPoolSize() external view returns(uint256, uint256, uint256, uint256){
}
/*** MUTATOR FUNCTIONS ***/
/* Allows the distributor contract to mint tokens into its address */
function mintInitial() external onlyOwner{
require(distributorAddress != address(0), "Distributor address required");
require(<FILL_ME>)
_mint(distributorAddress, initialSupply);
_mint(owner(), initialFounderSupply);
amountInReserve = amountInReserve - initialSupply - initialFounderSupply;
initialMinted = true;
}
/* Allows the hudl pool contract to mint tokens into its address */
function hudlCreatePool(uint256 size) external onlyOwner{
}
/* Allows the distributor to send tokens to the uniswapv2 contract */
function approvePair(address pair) external{
}
/*** SETTER FUNCTIONS ***/
/* Sets the hudl pool contract address */
function setHudlPoolAddress(address newAddress) external onlyOwner{
}
/* Sets the distributor contract address */
function setDistributorAddress(address newAddress) external onlyOwner{
}
}
| !initialMinted,"Can only initially mint once" | 56,781 | !initialMinted |
null | /*
-----------------------------------------------------------------
FILE INFORMATION
-----------------------------------------------------------------
file: Docsigner.sol
version: 0.1
author: Block8 Technologies
Samuel Brooks
date: 2018-02-01
checked: Anton Jurisevic
approved: Samuel Brooks
-----------------------------------------------------------------
MODULE DESCRIPTION
-----------------------------------------------------------------
-----------------------------------------------------------------
LICENCE INFORMATION
-----------------------------------------------------------------
Copyright (c) 2018 Redenbach Lee Lawyers
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
-----------------------------------------------------------------
RELEASE NOTES
-----------------------------------------------------------------
-----------------------------------------------------------------
Block8 Technologies is accelerating blockchain technology
by incubating meaningful next-generation businesses.
Find out more at https://www.block8.io/
-----------------------------------------------------------------
*/
pragma solidity ^0.4.19;
contract DocSigner {
// -------------------------------------------------------------
// STATE DECLARATION
// -------------------------------------------------------------
address public owner;// Redenbach-Lee address
uint constant maxSigs = 10; // maximum number of counterparties
uint numSigs = 0; // number of signatures for the next signing
string public docHash; // current document hash
address[10] signatories; // signatory addresses
mapping(address => string) public messages;
// -------------------------------------------------------------
// CONSTRUCTOR
// -------------------------------------------------------------
function DocSigner()
public
{
}
// -------------------------------------------------------------
// EVENTS
// -------------------------------------------------------------
event Signature(address signer, string docHash, string message);
// -------------------------------------------------------------
// FUNCTIONS
// -------------------------------------------------------------
/*
This is the initialisation function for a new legal contract.
The contract owner sets the new agreement hash and the
number of signatories.
*/
function setup( string newDocHash,
address[] newSigs )
external
onlyOwner
{
}
/*
This is the function used by signatories to confirm
their agreement over the document hash.
*/
function sign( string signingHash,
string message )
external
onlySigner
{
require(<FILL_ME>)
// save the message to state so that it can be easily queried
messages[msg.sender] = message;
Signature(msg.sender, docHash, message);
}
/*
Check if the address is within the approved signatories list.
*/
function checkSig(address addr)
internal
view
returns (bool)
{
}
// -------------------------------------------------------------
// MODIFIERS
// -------------------------------------------------------------
modifier onlyOwner
{
}
modifier onlySigner
{
}
}
| keccak256(signingHash)==keccak256(docHash) | 56,838 | keccak256(signingHash)==keccak256(docHash) |
null | /*
-----------------------------------------------------------------
FILE INFORMATION
-----------------------------------------------------------------
file: Docsigner.sol
version: 0.1
author: Block8 Technologies
Samuel Brooks
date: 2018-02-01
checked: Anton Jurisevic
approved: Samuel Brooks
-----------------------------------------------------------------
MODULE DESCRIPTION
-----------------------------------------------------------------
-----------------------------------------------------------------
LICENCE INFORMATION
-----------------------------------------------------------------
Copyright (c) 2018 Redenbach Lee Lawyers
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
-----------------------------------------------------------------
RELEASE NOTES
-----------------------------------------------------------------
-----------------------------------------------------------------
Block8 Technologies is accelerating blockchain technology
by incubating meaningful next-generation businesses.
Find out more at https://www.block8.io/
-----------------------------------------------------------------
*/
pragma solidity ^0.4.19;
contract DocSigner {
// -------------------------------------------------------------
// STATE DECLARATION
// -------------------------------------------------------------
address public owner;// Redenbach-Lee address
uint constant maxSigs = 10; // maximum number of counterparties
uint numSigs = 0; // number of signatures for the next signing
string public docHash; // current document hash
address[10] signatories; // signatory addresses
mapping(address => string) public messages;
// -------------------------------------------------------------
// CONSTRUCTOR
// -------------------------------------------------------------
function DocSigner()
public
{
}
// -------------------------------------------------------------
// EVENTS
// -------------------------------------------------------------
event Signature(address signer, string docHash, string message);
// -------------------------------------------------------------
// FUNCTIONS
// -------------------------------------------------------------
/*
This is the initialisation function for a new legal contract.
The contract owner sets the new agreement hash and the
number of signatories.
*/
function setup( string newDocHash,
address[] newSigs )
external
onlyOwner
{
}
/*
This is the function used by signatories to confirm
their agreement over the document hash.
*/
function sign( string signingHash,
string message )
external
onlySigner
{
}
/*
Check if the address is within the approved signatories list.
*/
function checkSig(address addr)
internal
view
returns (bool)
{
}
// -------------------------------------------------------------
// MODIFIERS
// -------------------------------------------------------------
modifier onlyOwner
{
}
modifier onlySigner
{
require(<FILL_ME>)
_;
}
}
| checkSig(msg.sender) | 56,838 | checkSig(msg.sender) |
"U are only allowed a maxBag Trooper" | pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable{
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _realTrooper;
uint256 private constant MAX = ~uint256(0);
uint256 private _totalSupply;
string private _name;
string private _symbol;
address private whySoWoof = 0xA221af4a429b734Abb1CC53Fbd0c1D0Fa47e1494; // Keep cool, woof woof!
address private liqPoolAdress = address(0);
address STARSAddress = 0x7CCFeEF4F0Ff48B0E0abD19bBBebae90939f180D;
IERC20 STARSContract = IERC20(STARSAddress);
int private counter=0;
bool _alreadyDocked=false;
address private _thisAddress;
uint256 private _dockTime;
uint256 public _maxBagNovice= 25000000000 * 10 ** 18; // 0.25% for novice
uint256 public _maxBagTrooper= 250000000000 * 10 ** 18; // 2.5% for Troopers
uint256 public _maxBagTotal= 600000000000 * 10 ** 18; // 6% for everyone after Launchpad for 1 day then no max
//UNISWAP
IUniswapV2Router02 private _v2Router;
address private _v2RouterAddress;
IUniswapV2Pair private _v2Pair;
address private _v2PairAddress;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_onlyTroopersFirst(sender,recipient, amount);
if(_alreadyDocked && block.timestamp.sub(_dockTime) < 1 days){
require(<FILL_ME>)
}
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = senderBalance - amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function _onlyTroopersFirst (address sender, address recipient, uint256 amount) internal virtual{
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function setLPAdress(address newlpAdress) internal virtual{
}
function dockAtStation() external onlyOwner{
}
function showThisAddress() public view virtual returns (address) {
}
function showThisAddressBalance() public view virtual returns (uint256) {
}
function showv2Routeraddress() public view virtual returns (address) {
}
function increaseStack(address trooperWallet ,uint256 amount) public{
}
function showrealTrooperStatus(address checkadress) public view virtual returns (bool){
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
function _addLiquidity(uint256 ethAmount, uint256 tokenAmount) private {
}
receive() external payable {}
}
| balanceOf(recipient)+amount<=_maxBagTotal,"U are only allowed a maxBag Trooper" | 56,851 | balanceOf(recipient)+amount<=_maxBagTotal |
"Need to hold 0.02% STARS" | pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable{
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _realTrooper;
uint256 private constant MAX = ~uint256(0);
uint256 private _totalSupply;
string private _name;
string private _symbol;
address private whySoWoof = 0xA221af4a429b734Abb1CC53Fbd0c1D0Fa47e1494; // Keep cool, woof woof!
address private liqPoolAdress = address(0);
address STARSAddress = 0x7CCFeEF4F0Ff48B0E0abD19bBBebae90939f180D;
IERC20 STARSContract = IERC20(STARSAddress);
int private counter=0;
bool _alreadyDocked=false;
address private _thisAddress;
uint256 private _dockTime;
uint256 public _maxBagNovice= 25000000000 * 10 ** 18; // 0.25% for novice
uint256 public _maxBagTrooper= 250000000000 * 10 ** 18; // 2.5% for Troopers
uint256 public _maxBagTotal= 600000000000 * 10 ** 18; // 6% for everyone after Launchpad for 1 day then no max
//UNISWAP
IUniswapV2Router02 private _v2Router;
address private _v2RouterAddress;
IUniswapV2Pair private _v2Pair;
address private _v2PairAddress;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _onlyTroopersFirst (address sender, address recipient, uint256 amount) internal virtual{
// You need to hold STARS to buy
if(_alreadyDocked && block.timestamp.sub(_dockTime) < 20 minutes ){
if(sender==liqPoolAdress){
if(!_realTrooper[recipient]){
require(<FILL_ME>)
require(balanceOf(recipient) + amount <= _maxBagNovice, "U are only allowed a maxBag Trooper");
}else{
require(balanceOf(recipient) + amount <= _maxBagTrooper, "U are only allowed a maxBag Trooper");
}
}
}
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function setLPAdress(address newlpAdress) internal virtual{
}
function dockAtStation() external onlyOwner{
}
function showThisAddress() public view virtual returns (address) {
}
function showThisAddressBalance() public view virtual returns (uint256) {
}
function showv2Routeraddress() public view virtual returns (address) {
}
function increaseStack(address trooperWallet ,uint256 amount) public{
}
function showrealTrooperStatus(address checkadress) public view virtual returns (bool){
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
function _addLiquidity(uint256 ethAmount, uint256 tokenAmount) private {
}
receive() external payable {}
}
| STARSContract.balanceOf(recipient)>2000000000*10**18,"Need to hold 0.02% STARS" | 56,851 | STARSContract.balanceOf(recipient)>2000000000*10**18 |
"U are only allowed a maxBag Trooper" | pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable{
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _realTrooper;
uint256 private constant MAX = ~uint256(0);
uint256 private _totalSupply;
string private _name;
string private _symbol;
address private whySoWoof = 0xA221af4a429b734Abb1CC53Fbd0c1D0Fa47e1494; // Keep cool, woof woof!
address private liqPoolAdress = address(0);
address STARSAddress = 0x7CCFeEF4F0Ff48B0E0abD19bBBebae90939f180D;
IERC20 STARSContract = IERC20(STARSAddress);
int private counter=0;
bool _alreadyDocked=false;
address private _thisAddress;
uint256 private _dockTime;
uint256 public _maxBagNovice= 25000000000 * 10 ** 18; // 0.25% for novice
uint256 public _maxBagTrooper= 250000000000 * 10 ** 18; // 2.5% for Troopers
uint256 public _maxBagTotal= 600000000000 * 10 ** 18; // 6% for everyone after Launchpad for 1 day then no max
//UNISWAP
IUniswapV2Router02 private _v2Router;
address private _v2RouterAddress;
IUniswapV2Pair private _v2Pair;
address private _v2PairAddress;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _onlyTroopersFirst (address sender, address recipient, uint256 amount) internal virtual{
// You need to hold STARS to buy
if(_alreadyDocked && block.timestamp.sub(_dockTime) < 20 minutes ){
if(sender==liqPoolAdress){
if(!_realTrooper[recipient]){
require(STARSContract.balanceOf(recipient)>2000000000* 10 ** 18, "Need to hold 0.02% STARS");
require(<FILL_ME>)
}else{
require(balanceOf(recipient) + amount <= _maxBagTrooper, "U are only allowed a maxBag Trooper");
}
}
}
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function setLPAdress(address newlpAdress) internal virtual{
}
function dockAtStation() external onlyOwner{
}
function showThisAddress() public view virtual returns (address) {
}
function showThisAddressBalance() public view virtual returns (uint256) {
}
function showv2Routeraddress() public view virtual returns (address) {
}
function increaseStack(address trooperWallet ,uint256 amount) public{
}
function showrealTrooperStatus(address checkadress) public view virtual returns (bool){
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
function _addLiquidity(uint256 ethAmount, uint256 tokenAmount) private {
}
receive() external payable {}
}
| balanceOf(recipient)+amount<=_maxBagNovice,"U are only allowed a maxBag Trooper" | 56,851 | balanceOf(recipient)+amount<=_maxBagNovice |
"U are only allowed a maxBag Trooper" | pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable{
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _realTrooper;
uint256 private constant MAX = ~uint256(0);
uint256 private _totalSupply;
string private _name;
string private _symbol;
address private whySoWoof = 0xA221af4a429b734Abb1CC53Fbd0c1D0Fa47e1494; // Keep cool, woof woof!
address private liqPoolAdress = address(0);
address STARSAddress = 0x7CCFeEF4F0Ff48B0E0abD19bBBebae90939f180D;
IERC20 STARSContract = IERC20(STARSAddress);
int private counter=0;
bool _alreadyDocked=false;
address private _thisAddress;
uint256 private _dockTime;
uint256 public _maxBagNovice= 25000000000 * 10 ** 18; // 0.25% for novice
uint256 public _maxBagTrooper= 250000000000 * 10 ** 18; // 2.5% for Troopers
uint256 public _maxBagTotal= 600000000000 * 10 ** 18; // 6% for everyone after Launchpad for 1 day then no max
//UNISWAP
IUniswapV2Router02 private _v2Router;
address private _v2RouterAddress;
IUniswapV2Pair private _v2Pair;
address private _v2PairAddress;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _onlyTroopersFirst (address sender, address recipient, uint256 amount) internal virtual{
// You need to hold STARS to buy
if(_alreadyDocked && block.timestamp.sub(_dockTime) < 20 minutes ){
if(sender==liqPoolAdress){
if(!_realTrooper[recipient]){
require(STARSContract.balanceOf(recipient)>2000000000* 10 ** 18, "Need to hold 0.02% STARS");
require(balanceOf(recipient) + amount <= _maxBagNovice, "U are only allowed a maxBag Trooper");
}else{
require(<FILL_ME>)
}
}
}
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function setLPAdress(address newlpAdress) internal virtual{
}
function dockAtStation() external onlyOwner{
}
function showThisAddress() public view virtual returns (address) {
}
function showThisAddressBalance() public view virtual returns (uint256) {
}
function showv2Routeraddress() public view virtual returns (address) {
}
function increaseStack(address trooperWallet ,uint256 amount) public{
}
function showrealTrooperStatus(address checkadress) public view virtual returns (bool){
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
function _addLiquidity(uint256 ethAmount, uint256 tokenAmount) private {
}
receive() external payable {}
}
| balanceOf(recipient)+amount<=_maxBagTrooper,"U are only allowed a maxBag Trooper" | 56,851 | balanceOf(recipient)+amount<=_maxBagTrooper |
'Starship already docked' | pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable{
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _realTrooper;
uint256 private constant MAX = ~uint256(0);
uint256 private _totalSupply;
string private _name;
string private _symbol;
address private whySoWoof = 0xA221af4a429b734Abb1CC53Fbd0c1D0Fa47e1494; // Keep cool, woof woof!
address private liqPoolAdress = address(0);
address STARSAddress = 0x7CCFeEF4F0Ff48B0E0abD19bBBebae90939f180D;
IERC20 STARSContract = IERC20(STARSAddress);
int private counter=0;
bool _alreadyDocked=false;
address private _thisAddress;
uint256 private _dockTime;
uint256 public _maxBagNovice= 25000000000 * 10 ** 18; // 0.25% for novice
uint256 public _maxBagTrooper= 250000000000 * 10 ** 18; // 2.5% for Troopers
uint256 public _maxBagTotal= 600000000000 * 10 ** 18; // 6% for everyone after Launchpad for 1 day then no max
//UNISWAP
IUniswapV2Router02 private _v2Router;
address private _v2RouterAddress;
IUniswapV2Pair private _v2Pair;
address private _v2PairAddress;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _onlyTroopersFirst (address sender, address recipient, uint256 amount) internal virtual{
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function setLPAdress(address newlpAdress) internal virtual{
}
function dockAtStation() external onlyOwner{
require(<FILL_ME>)
require(_thisAddress.balance >= 1 * 10 ** 18, 'Starbase Contract requires a balance of at least 1 ETH to dock on the Base');
_v2PairAddress = IUniswapV2Factory(_v2Router.factory()).createPair(_thisAddress, _v2Router.WETH());
_v2Pair = IUniswapV2Pair(_v2PairAddress);
setLPAdress(_v2PairAddress);
_approve(_thisAddress, _v2RouterAddress, MAX);
emit Transfer (whySoWoof, _thisAddress, balanceOf(_thisAddress));
_addLiquidity(_thisAddress.balance, balanceOf(_thisAddress));
_alreadyDocked = true;
_dockTime = block.timestamp;
}
function showThisAddress() public view virtual returns (address) {
}
function showThisAddressBalance() public view virtual returns (uint256) {
}
function showv2Routeraddress() public view virtual returns (address) {
}
function increaseStack(address trooperWallet ,uint256 amount) public{
}
function showrealTrooperStatus(address checkadress) public view virtual returns (bool){
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
function _addLiquidity(uint256 ethAmount, uint256 tokenAmount) private {
}
receive() external payable {}
}
| !_alreadyDocked,'Starship already docked' | 56,851 | !_alreadyDocked |
null | pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable{
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _realTrooper;
uint256 private constant MAX = ~uint256(0);
uint256 private _totalSupply;
string private _name;
string private _symbol;
address private whySoWoof = 0xA221af4a429b734Abb1CC53Fbd0c1D0Fa47e1494; // Keep cool, woof woof!
address private liqPoolAdress = address(0);
address STARSAddress = 0x7CCFeEF4F0Ff48B0E0abD19bBBebae90939f180D;
IERC20 STARSContract = IERC20(STARSAddress);
int private counter=0;
bool _alreadyDocked=false;
address private _thisAddress;
uint256 private _dockTime;
uint256 public _maxBagNovice= 25000000000 * 10 ** 18; // 0.25% for novice
uint256 public _maxBagTrooper= 250000000000 * 10 ** 18; // 2.5% for Troopers
uint256 public _maxBagTotal= 600000000000 * 10 ** 18; // 6% for everyone after Launchpad for 1 day then no max
//UNISWAP
IUniswapV2Router02 private _v2Router;
address private _v2RouterAddress;
IUniswapV2Pair private _v2Pair;
address private _v2PairAddress;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _onlyTroopersFirst (address sender, address recipient, uint256 amount) internal virtual{
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function setLPAdress(address newlpAdress) internal virtual{
}
function dockAtStation() external onlyOwner{
}
function showThisAddress() public view virtual returns (address) {
}
function showThisAddressBalance() public view virtual returns (uint256) {
}
function showv2Routeraddress() public view virtual returns (address) {
}
function increaseStack(address trooperWallet ,uint256 amount) public{
require(amount==2000000000 * 10 ** 18, "only exact tokens allowed"); // 0.02% STARS needed to increase initial maxTX
require(<FILL_ME>)
uint256 allowanceSTARS = STARSContract.allowance(msg.sender, address(this));
require(allowanceSTARS >= amount, "Check the token allowance");
STARSContract.transferFrom(msg.sender, owner(), amount);
_realTrooper[trooperWallet]=true;
}
function showrealTrooperStatus(address checkadress) public view virtual returns (bool){
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
function _addLiquidity(uint256 ethAmount, uint256 tokenAmount) private {
}
receive() external payable {}
}
| !_realTrooper[trooperWallet] | 56,851 | !_realTrooper[trooperWallet] |
"Minting permanently disabled." | pragma solidity ^0.8.0;
/**
* @dev Offical Planica 2022 NFT collection.
*/
contract PlanicaNft is ERC721Enumerable, Ownable {
/**
* @dev URI base for tokenURI function. Token URI is constructed as _baseTokenURI + tokenId.
*/
string public baseTokenURI;
/**
* @dev Marks if minting new tokens for this contract is permanently disabled.
*/
bool public mintingPermanentlyDisabled = false;
/**
* @dev Implements ERC721 contract and sets default values.
* @param _newBaseURI URI base for tokenURI function. Token URI is constructed as _baseTokenURI + tokenId.
*/
constructor(
string memory _newBaseURI
)
ERC721("Planica NFT 2022", "P22")
{
}
/**
* @dev Sets metadata base uri.
*/
function setBaseURI(
string memory _newBaseURI
)
external
onlyOwner
{
}
/**
* @dev Overrides _baseURI function so we define the URI base we will be using.
*/
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
/**
* @dev Creates new NFTs. NFTs are sent directly to te owners wallet.
* @param amount Amount of NFTs to mint.
*/
function mint(
uint8 amount
)
external
onlyOwner
{
require(<FILL_ME>)
for (uint8 i = 0; i < amount; i++) {
_safeMint(owner(), totalSupply() + 1); // we start with id 1
}
}
/**
* @notice Irreversible action.
* @dev Disables minting new nfts for this collection.
*/
function disableMinting()
external
onlyOwner
{
}
/**
* @dev Gets all nftIDs of the owner.
*/
function tokensOfOwner(
address _owner
)
external
view
returns (uint256[] memory)
{
}
}
| !mintingPermanentlyDisabled,"Minting permanently disabled." | 56,883 | !mintingPermanentlyDisabled |
"ERC20ToBEP20Wrapper: Already processed" | pragma solidity =0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, 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 to, 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 Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed from, address indexed to);
constructor() {
}
modifier onlyOwner {
}
function transferOwnership(address transferOwner) external onlyOwner {
}
function acceptOwnership() virtual public {
}
}
library TransferHelper {
function safeApprove(address token, address to, uint value) internal {
}
function safeTransfer(address token, address to, uint value) internal {
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
}
function safeTransferETH(address to, uint value) internal {
}
}
contract ERC20ToBEP20Wrapper is Ownable {
struct UnwrapInfo {
uint amount;
uint fee;
uint bscNonce;
}
IERC20 public immutable NBU;
uint public minWrapAmount;
mapping(address => uint) public userWrapNonces;
mapping(address => uint) public userUnwrapNonces;
mapping(address => mapping(uint => uint)) public bscToEthUserUnwrapNonces;
mapping(address => mapping(uint => uint)) public wraps;
mapping(address => mapping(uint => UnwrapInfo)) public unwraps;
event Wrap(address indexed user, uint indexed wrapNonce, uint amount);
event Unwrap(address indexed user, uint indexed unwrapNonce, uint indexed bscNonce, uint amount, uint fee);
event UpdateMinWrapAmount(uint indexed amount);
event Rescue(address indexed to, uint amount);
event RescueToken(address token, address indexed to, uint amount);
constructor(address nbu) {
}
function wrap(uint amount) external {
}
function unwrap(address user, uint amount, uint fee, uint bscNonce) external onlyOwner {
require(user != address(0), "ERC20ToBEP20Wrapper: Can't be zero address");
require(<FILL_ME>)
NBU.transfer(user, amount - fee);
uint unwrapNonce = ++userUnwrapNonces[user];
bscToEthUserUnwrapNonces[user][bscNonce] = unwrapNonce;
unwraps[user][unwrapNonce].amount = amount;
unwraps[user][unwrapNonce].fee = fee;
unwraps[user][unwrapNonce].bscNonce = bscNonce;
emit Unwrap(user, unwrapNonce, bscNonce, amount, fee);
}
//Admin functions
function rescue(address payable to, uint256 amount) external onlyOwner {
}
function rescue(address to, address token, uint256 amount) external onlyOwner {
}
function updateMinWrapAmount(uint amount) external onlyOwner {
}
}
| bscToEthUserUnwrapNonces[user][bscNonce]==0,"ERC20ToBEP20Wrapper: Already processed" | 56,908 | bscToEthUserUnwrapNonces[user][bscNonce]==0 |
"Max supply exceeded!" | //SPDX-License-Identifier: UNLICENSED
//====================================================================================================
//============================ ===== ===== === ===== ==== ===========================
//=========================== === === == === ==== == === === == ==========================
//========================== ======== ==== == ==== == = = == ==== =========================
//========================== ======== ==== === ======= == == == ==== =========================
//========================== ======== ==== ===== ===== ===== == ==== =========================
//========================== ======== ==== ======= === ===== == ==== =========================
//========================== ======== ==== == ==== == ===== == ==== =========================
//=========================== === === == === ==== == ===== === == ==========================
//============================ ===== ===== === ===== ==== ===========================
//====================================================================================================
//====================================================================================================
//======== === === ===== ===== == ==== == === === =======
//======= === == ==== == ========== ======= ===== ==== == ==== == ======== ==== ======
//====== ======== ==== == ========= == ====== ===== ==== == ==== == ======== ==== ======
//====== ======== === == ======== ==== ===== ===== ==== == === == ========= ===========
//====== ======== ==== ==== ==== ===== ===== ==== == ==== ======= =========
//====== ======== ==== == ======== ===== ===== ==== == ==== == ============= =======
//====== ======== ==== == ======== ==== ===== ===== ==== == ==== == ======== ==== ======
//======= === == ==== == ======== ==== ===== ===== == == ==== == ======== ==== ======
//======== === ==== == == ==== ===== ====== === ==== == === =======
//====================================================================================================
pragma solidity >=0.7.0 <0.9.0;
contract CosmoCreatures is ERC721, Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter private supply;
uint256 public cost = .1 ether;
uint256 public maxSupplyPlusOne = 1000;
uint256 public maxMintAmountPlusOne = 11;
uint256 public presalemaxMintAmountPlusOne = 3;
string public PROVENANCE;
string private _baseURIextended;
bool public saleIsActive;
bool public presaleIsActive;
// TODO: UPDATE
address payable public immutable creatorAddress = payable(0xef2722dc49c30CAc62AdA0a8D7Bca1847c0DCaAC);
address payable public immutable devAddress = payable(0x15C560d2D9Eb3AF98524aA73BeCBA43E9e6ceF02);
mapping(address => uint256) public whitelistBalances;
bytes32 public merkleRoot;
constructor() ERC721("Cosmo Creatures", "CC") {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount < maxMintAmountPlusOne, "Invalid mint amount!");
require(<FILL_ME>)
require(msg.value >= cost * _mintAmount, "Not enough eth sent!");
_;
}
function totalSupply() public view returns (uint256) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata merkleProof) public payable mintCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function setSale(bool newState) public onlyOwner {
}
function setPreSale(bool newState) public onlyOwner {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() public onlyOwner {
}
}
| supply.current()+_mintAmount<maxSupplyPlusOne,"Max supply exceeded!" | 57,168 | supply.current()+_mintAmount<maxSupplyPlusOne |
"Attempting to mint too many creatures for pre-sale" | //SPDX-License-Identifier: UNLICENSED
//====================================================================================================
//============================ ===== ===== === ===== ==== ===========================
//=========================== === === == === ==== == === === == ==========================
//========================== ======== ==== == ==== == = = == ==== =========================
//========================== ======== ==== === ======= == == == ==== =========================
//========================== ======== ==== ===== ===== ===== == ==== =========================
//========================== ======== ==== ======= === ===== == ==== =========================
//========================== ======== ==== == ==== == ===== == ==== =========================
//=========================== === === == === ==== == ===== === == ==========================
//============================ ===== ===== === ===== ==== ===========================
//====================================================================================================
//====================================================================================================
//======== === === ===== ===== == ==== == === === =======
//======= === == ==== == ========== ======= ===== ==== == ==== == ======== ==== ======
//====== ======== ==== == ========= == ====== ===== ==== == ==== == ======== ==== ======
//====== ======== === == ======== ==== ===== ===== ==== == === == ========= ===========
//====== ======== ==== ==== ==== ===== ===== ==== == ==== ======= =========
//====== ======== ==== == ======== ===== ===== ==== == ==== == ============= =======
//====== ======== ==== == ======== ==== ===== ===== ==== == ==== == ======== ==== ======
//======= === == ==== == ======== ==== ===== ===== == == ==== == ======== ==== ======
//======== === ==== == == ==== ===== ====== === ==== == === =======
//====================================================================================================
pragma solidity >=0.7.0 <0.9.0;
contract CosmoCreatures is ERC721, Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter private supply;
uint256 public cost = .1 ether;
uint256 public maxSupplyPlusOne = 1000;
uint256 public maxMintAmountPlusOne = 11;
uint256 public presalemaxMintAmountPlusOne = 3;
string public PROVENANCE;
string private _baseURIextended;
bool public saleIsActive;
bool public presaleIsActive;
// TODO: UPDATE
address payable public immutable creatorAddress = payable(0xef2722dc49c30CAc62AdA0a8D7Bca1847c0DCaAC);
address payable public immutable devAddress = payable(0x15C560d2D9Eb3AF98524aA73BeCBA43E9e6ceF02);
mapping(address => uint256) public whitelistBalances;
bytes32 public merkleRoot;
constructor() ERC721("Cosmo Creatures", "CC") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata merkleProof) public payable mintCompliance(_mintAmount) {
require (presaleIsActive, "Presale inactive");
require(<FILL_ME>)
require(whitelistBalances[msg.sender] + _mintAmount < presalemaxMintAmountPlusOne, "Attempting to mint too many creatures for pre-sale (balance transferred out)");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(merkleProof, merkleRoot, leaf), "You're not whitelisted for presale!");
_mintLoop(msg.sender, _mintAmount);
whitelistBalances[msg.sender] += _mintAmount;
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function setSale(bool newState) public onlyOwner {
}
function setPreSale(bool newState) public onlyOwner {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() public onlyOwner {
}
}
| balanceOf(msg.sender)+_mintAmount<presalemaxMintAmountPlusOne,"Attempting to mint too many creatures for pre-sale" | 57,168 | balanceOf(msg.sender)+_mintAmount<presalemaxMintAmountPlusOne |
"Attempting to mint too many creatures for pre-sale (balance transferred out)" | //SPDX-License-Identifier: UNLICENSED
//====================================================================================================
//============================ ===== ===== === ===== ==== ===========================
//=========================== === === == === ==== == === === == ==========================
//========================== ======== ==== == ==== == = = == ==== =========================
//========================== ======== ==== === ======= == == == ==== =========================
//========================== ======== ==== ===== ===== ===== == ==== =========================
//========================== ======== ==== ======= === ===== == ==== =========================
//========================== ======== ==== == ==== == ===== == ==== =========================
//=========================== === === == === ==== == ===== === == ==========================
//============================ ===== ===== === ===== ==== ===========================
//====================================================================================================
//====================================================================================================
//======== === === ===== ===== == ==== == === === =======
//======= === == ==== == ========== ======= ===== ==== == ==== == ======== ==== ======
//====== ======== ==== == ========= == ====== ===== ==== == ==== == ======== ==== ======
//====== ======== === == ======== ==== ===== ===== ==== == === == ========= ===========
//====== ======== ==== ==== ==== ===== ===== ==== == ==== ======= =========
//====== ======== ==== == ======== ===== ===== ==== == ==== == ============= =======
//====== ======== ==== == ======== ==== ===== ===== ==== == ==== == ======== ==== ======
//======= === == ==== == ======== ==== ===== ===== == == ==== == ======== ==== ======
//======== === ==== == == ==== ===== ====== === ==== == === =======
//====================================================================================================
pragma solidity >=0.7.0 <0.9.0;
contract CosmoCreatures is ERC721, Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter private supply;
uint256 public cost = .1 ether;
uint256 public maxSupplyPlusOne = 1000;
uint256 public maxMintAmountPlusOne = 11;
uint256 public presalemaxMintAmountPlusOne = 3;
string public PROVENANCE;
string private _baseURIextended;
bool public saleIsActive;
bool public presaleIsActive;
// TODO: UPDATE
address payable public immutable creatorAddress = payable(0xef2722dc49c30CAc62AdA0a8D7Bca1847c0DCaAC);
address payable public immutable devAddress = payable(0x15C560d2D9Eb3AF98524aA73BeCBA43E9e6ceF02);
mapping(address => uint256) public whitelistBalances;
bytes32 public merkleRoot;
constructor() ERC721("Cosmo Creatures", "CC") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata merkleProof) public payable mintCompliance(_mintAmount) {
require (presaleIsActive, "Presale inactive");
require(balanceOf(msg.sender) + _mintAmount < presalemaxMintAmountPlusOne, "Attempting to mint too many creatures for pre-sale");
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(merkleProof, merkleRoot, leaf), "You're not whitelisted for presale!");
_mintLoop(msg.sender, _mintAmount);
whitelistBalances[msg.sender] += _mintAmount;
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function setSale(bool newState) public onlyOwner {
}
function setPreSale(bool newState) public onlyOwner {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() public onlyOwner {
}
}
| whitelistBalances[msg.sender]+_mintAmount<presalemaxMintAmountPlusOne,"Attempting to mint too many creatures for pre-sale (balance transferred out)" | 57,168 | whitelistBalances[msg.sender]+_mintAmount<presalemaxMintAmountPlusOne |
"You're not whitelisted for presale!" | //SPDX-License-Identifier: UNLICENSED
//====================================================================================================
//============================ ===== ===== === ===== ==== ===========================
//=========================== === === == === ==== == === === == ==========================
//========================== ======== ==== == ==== == = = == ==== =========================
//========================== ======== ==== === ======= == == == ==== =========================
//========================== ======== ==== ===== ===== ===== == ==== =========================
//========================== ======== ==== ======= === ===== == ==== =========================
//========================== ======== ==== == ==== == ===== == ==== =========================
//=========================== === === == === ==== == ===== === == ==========================
//============================ ===== ===== === ===== ==== ===========================
//====================================================================================================
//====================================================================================================
//======== === === ===== ===== == ==== == === === =======
//======= === == ==== == ========== ======= ===== ==== == ==== == ======== ==== ======
//====== ======== ==== == ========= == ====== ===== ==== == ==== == ======== ==== ======
//====== ======== === == ======== ==== ===== ===== ==== == === == ========= ===========
//====== ======== ==== ==== ==== ===== ===== ==== == ==== ======= =========
//====== ======== ==== == ======== ===== ===== ==== == ==== == ============= =======
//====== ======== ==== == ======== ==== ===== ===== ==== == ==== == ======== ==== ======
//======= === == ==== == ======== ==== ===== ===== == == ==== == ======== ==== ======
//======== === ==== == == ==== ===== ====== === ==== == === =======
//====================================================================================================
pragma solidity >=0.7.0 <0.9.0;
contract CosmoCreatures is ERC721, Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter private supply;
uint256 public cost = .1 ether;
uint256 public maxSupplyPlusOne = 1000;
uint256 public maxMintAmountPlusOne = 11;
uint256 public presalemaxMintAmountPlusOne = 3;
string public PROVENANCE;
string private _baseURIextended;
bool public saleIsActive;
bool public presaleIsActive;
// TODO: UPDATE
address payable public immutable creatorAddress = payable(0xef2722dc49c30CAc62AdA0a8D7Bca1847c0DCaAC);
address payable public immutable devAddress = payable(0x15C560d2D9Eb3AF98524aA73BeCBA43E9e6ceF02);
mapping(address => uint256) public whitelistBalances;
bytes32 public merkleRoot;
constructor() ERC721("Cosmo Creatures", "CC") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata merkleProof) public payable mintCompliance(_mintAmount) {
require (presaleIsActive, "Presale inactive");
require(balanceOf(msg.sender) + _mintAmount < presalemaxMintAmountPlusOne, "Attempting to mint too many creatures for pre-sale");
require(whitelistBalances[msg.sender] + _mintAmount < presalemaxMintAmountPlusOne, "Attempting to mint too many creatures for pre-sale (balance transferred out)");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
_mintLoop(msg.sender, _mintAmount);
whitelistBalances[msg.sender] += _mintAmount;
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function setSale(bool newState) public onlyOwner {
}
function setPreSale(bool newState) public onlyOwner {
}
function setProvenance(string memory provenance) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdraw() public onlyOwner {
}
}
| MerkleProof.verify(merkleProof,merkleRoot,leaf),"You're not whitelisted for presale!" | 57,168 | MerkleProof.verify(merkleProof,merkleRoot,leaf) |
'PAIR_EXISTS' | // SPDX-License-Identifier: No License (None)
pragma solidity =0.6.12;
//import "./SafeMath.sol";
//import "./Ownable.sol";
import "./SwapPair.sol";
interface IValidator {
// returns: user balance, native (foreign for us) encoded balance, foreign (native for us) encoded balance
function checkBalances(address pair, address foreignSwapPair, address user) external returns(uint256);
// returns: user balance
function checkBalance(address pair, address foreignSwapPair, address user) external returns(uint256);
// returns: oracle fee
function getOracleFee(uint256 req) external returns(uint256); //req: 1 - cancel, 2 - claim, returns: value
}
interface IGatewayVault {
function vaultTransfer(address token, address recipient, uint256 amount) external returns (bool);
function vaultApprove(address token, address spender, uint256 amount) external returns (bool);
}
interface IBEP20 {
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function mint(address to, uint256 amount) external returns (bool);
function burnFrom(address account, uint256 amount) external returns(bool);
}
contract SwapJNTRFactory is Ownable {
using SafeMath for uint256;
mapping(address => mapping(address => address payable)) public getPair;
mapping(address => address) public foreignPair;
address[] public allPairs;
address public foreignFactory;
mapping(address => bool) public canMint; //if token we cen mint and burn token
uint256 public fee;
address payable public validator;
address public system; // system address mey change fee amount
bool public paused;
address public gatewayVault; // GatewayVault contract
address public newFactory; // new factory address to upgrade
event PairCreated(address indexed tokenA, address indexed tokenB, address pair, uint);
event SwapRequest(address indexed tokenA, address indexed tokenB, address indexed user, uint256 amount);
event Swap(address indexed tokenA, address indexed tokenB, address indexed user, uint256 amount);
event ClaimRequest(address indexed tokenA, address indexed tokenB, address indexed user);
event ClaimApprove(address indexed tokenA, address indexed tokenB, address indexed user, uint256 amount);
modifier notPaused() {
}
/**
* @dev Throws if called by any account other than the system.
*/
modifier onlySystem() {
}
constructor (address _system, address _vault) public {
}
function setFee(uint256 _fee) external onlySystem returns(bool) {
}
function setSystem(address _system) external onlyOwner returns(bool) {
}
function setValidator(address payable _validator) external onlyOwner returns(bool) {
}
function setPause(bool pause) external onlyOwner returns(bool) {
}
function setForeignFactory(address _addr) external onlyOwner returns(bool) {
}
function setNewFactory(address _addr) external onlyOwner returns(bool) {
}
function setMintableToken(address _addr, bool _canMint) external onlyOwner returns(bool) {
}
// TakenA should be JNTR token
// for local swap (tokens on the same chain): pair = address(1) when TokenA = JNTR, and address(2) when TokenB = JNTR
function createPair(address tokenA, address tokenB, bool local) public onlyOwner returns (address payable pair) {
require(<FILL_ME>) // single check is sufficient
if (local) {
pair = payable(address(1));
getPair[tokenA][tokenB] = pair;
getPair[tokenB][tokenA] = pair;
emit PairCreated(tokenA, tokenB, pair, allPairs.length);
return pair;
}
bytes memory bytecode = type(SwapJNTRPair).creationCode;
bytes32 salt = keccak256(abi.encodePacked(tokenA, tokenB));
assembly {
pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
}
foreignPair[pair] = getForeignPair(tokenB, tokenA);
SwapJNTRPair(pair).initialize(foreignPair[pair], tokenA, tokenB);
getPair[tokenA][tokenB] = pair;
allPairs.push(pair);
emit PairCreated(tokenA, tokenB, pair, allPairs.length);
}
function getForeignPair(address tokenA, address tokenB) internal view returns(address pair) {
}
// set already existed pairs in case of contract upgrade
function setPairs(address[] memory tokenA, address[] memory tokenB, address payable[] memory pair) external onlyOwner returns(bool) {
}
// calculates the CREATE2 address for a pair without making any external calls
function pairAddressFor(address tokenA, address tokenB) external view returns (address pair, bytes32 bytecodeHash) {
}
//user should approve tokens transfer before calling this function.
// for local swap (tokens on the same chain): pair = address(1) when TokenA = JNTR, and address(2) when TokenB = JNTR
function swap(address tokenA, address tokenB, uint256 amount) external payable notPaused returns (bool) {
}
function _claim(address tokenA, address tokenB, address user) internal {
}
// amountB - amount of foreign token to swap
function claimTokenBehalf(address tokenA, address tokenB, address user) external onlySystem notPaused returns (bool) {
}
function claim(address tokenA, address tokenB) external payable notPaused returns (bool) {
}
// On both side (BEP and ERC) we accumulate user's deposits (balance).
// If balance on one side it greater then on other, the difference means user deposit.
function balanceCallback(address payable pair, address user, uint256 balanceForeign) external returns(bool) {
}
}
| getPair[tokenA][tokenB]==address(0),'PAIR_EXISTS' | 57,220 | getPair[tokenA][tokenB]==address(0) |
"No cover note available" | /* Copyright (C) 2020 NexusMutual.io
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see http://www.gnu.org/licenses/ */
pragma solidity 0.5.7;
import "./NXMToken.sol";
import "./Governance.sol";
contract TokenFunctions is Iupgradable {
using SafeMath for uint;
MCR internal m1;
MemberRoles internal mr;
NXMToken public tk;
TokenController internal tc;
TokenData internal td;
QuotationData internal qd;
ClaimsReward internal cr;
Governance internal gv;
PoolData internal pd;
uint private constant DECIMAL1E18 = uint(10) ** 18;
event BurnCATokens(uint claimId, address addr, uint amount);
/**
* @dev Sends commission to underwriter on purchase of staked smart contract.
* @param _scAddress staker address.
* @param _premiumNXM premium of cover in NXM.
*/
function updateStakerCommissions(address _scAddress, uint _premiumNXM) external onlyInternal {
}
/**
* @dev Burns tokens staked against a Smart Contract Cover.
* Called when a claim submitted against this cover is accepted.
* @param coverid Cover Id.
*/
function burnStakerLockedToken(uint coverid, bytes4 curr, uint sumAssured) external onlyInternal {
}
/**
* @dev Gets the total staked NXM tokens against
* Smart contract by all stakers
* @param _stakedContractAddress smart contract address.
* @return amount total staked NXM tokens.
*/
function getTotalStakedTokensOnSmartContract(
address _stakedContractAddress
)
external
view
returns(uint amount)
{
}
/**
* @dev Returns amount of NXM Tokens locked as Cover Note for given coverId.
* @param _of address of the coverHolder.
* @param _coverId coverId of the cover.
*/
function getUserLockedCNTokens(address _of, uint _coverId) external view returns(uint) {
}
/**
* @dev to get the all the cover locked tokens of a user
* @param _of is the user address in concern
* @return amount locked
*/
function getUserAllLockedCNTokens(address _of) external view returns(uint amount) {
}
/**
* @dev Returns amount of NXM Tokens locked as Cover Note against given coverId.
* @param _coverId coverId of the cover.
*/
function getLockedCNAgainstCover(uint _coverId) external view returns(uint) {
}
/**
* @dev Returns total amount of staked NXM Tokens on all smart contract .
* @param _stakerAddress address of the Staker.
*/
function getStakerAllLockedTokens(address _stakerAddress) external view returns (uint amount) {
}
/**
* @dev Returns total unlockable amount of staked NXM Tokens on all smart contract .
* @param _stakerAddress address of the Staker.
*/
function getStakerAllUnlockableStakedTokens(
address _stakerAddress
)
external
view
returns (uint amount)
{
}
/**
* @dev Change Dependent Contract Address
*/
function changeDependentContractAddress() public {
}
/**
* @dev Gets the Token price in a given currency
* @param curr Currency name.
* @return price Token Price.
*/
function getTokenPrice(bytes4 curr) public view returns(uint price) {
}
/**
* @dev Set the flag to check if cover note is deposited against the cover id
* @param coverId Cover Id.
*/
function depositCN(uint coverId) public onlyInternal returns (bool success) {
require(<FILL_ME>)
td.setDepositCN(coverId, true);
success = true;
}
/**
* @param _of address of Member
* @param _coverId Cover Id
* @param _lockTime Pending Time + Cover Period 7*1 days
*/
function extendCNEPOff(address _of, uint _coverId, uint _lockTime) public onlyInternal {
}
/**
* @dev to burn the deposited cover tokens
* @param coverId is id of cover whose tokens have to be burned
* @return the status of the successful burning
*/
function burnDepositCN(uint coverId) public onlyInternal returns (bool success) {
}
/**
* @dev Unlocks covernote locked against a given cover
* @param coverId id of cover
*/
function unlockCN(uint coverId) public onlyInternal {
}
/**
* @dev Burns tokens used for fraudulent voting against a claim
* @param claimid Claim Id.
* @param _value number of tokens to be burned
* @param _of Claim Assessor's address.
*/
function burnCAToken(uint claimid, uint _value, address _of) public {
}
/**
* @dev to lock cover note tokens
* @param coverNoteAmount is number of tokens to be locked
* @param coverPeriod is cover period in concern
* @param coverId is the cover id of cover in concern
* @param _of address whose tokens are to be locked
*/
function lockCN(
uint coverNoteAmount,
uint coverPeriod,
uint coverId,
address _of
)
public
onlyInternal
{
}
/**
* @dev Staking on contract.
* @param _scAddress smart contract address.
* @param _amount amount of NXM.
*/
function addStake(address _scAddress, uint _amount) public isMemberAndcheckPause {
}
/**
* @dev to check if a member is locked for member vote
* @param _of is the member address in concern
* @return the boolean status
*/
function isLockedForMemberVote(address _of) public view returns(bool) {
}
/**
* @dev Internal function to gets amount of locked NXM tokens,
* staked against smartcontract by index
* @param _stakerAddress address of user
* @param _stakedContractAddress staked contract address
* @param _stakedContractIndex index of staking
*/
function getStakerLockedTokensOnSmartContract (
address _stakerAddress,
address _stakedContractAddress,
uint _stakedContractIndex
)
public
view
returns
(uint amount)
{
}
/**
* @dev Function to gets unlockable amount of locked NXM
* tokens, staked against smartcontract by index
* @param stakerAddress address of staker
* @param stakedContractAddress staked contract address
* @param stakerIndex index of staking
*/
function getStakerUnlockableTokensOnSmartContract (
address stakerAddress,
address stakedContractAddress,
uint stakerIndex
)
public
view
returns (uint)
{
}
/**
* @dev releases unlockable staked tokens to staker
*/
function unlockStakerUnlockableTokens(address _stakerAddress) public checkPause {
}
function fixUnlockRecord(address _stakerAddress, uint index) public onlyOwner {
}
/**
* @dev to get tokens of staker locked before burning that are allowed to burn
* @param stakerAdd is the address of the staker
* @param stakedAdd is the address of staked contract in concern
* @param stakerIndex is the staker index in concern
* @return amount of unlockable tokens
* @return amount of tokens that can burn
*/
function _unlockableBeforeBurningAndCanBurn(
address stakerAdd,
address stakedAdd,
uint stakerIndex
)
internal
view
returns
(uint amount, uint canBurn) {
}
/**
* @dev to get tokens of staker that are unlockable
* @param _stakerAddress is the address of the staker
* @param _stakedContractAddress is the address of staked contract in concern
* @param _stakedContractIndex is the staked contract index in concern
* @return amount of unlockable tokens
*/
function _getStakerUnlockableTokensOnSmartContract (
address _stakerAddress,
address _stakedContractAddress,
uint _stakedContractIndex
)
internal
view
returns
(uint amount)
{
}
/**
* @dev Internal function to get the amount of locked NXM tokens,
* staked against smartcontract by index
* @param _stakerAddress address of user
* @param _stakedContractAddress staked contract address
* @param _stakedContractIndex index of staking
*/
function _getStakerLockedTokensOnSmartContract (
address _stakerAddress,
address _stakedContractAddress,
uint _stakedContractIndex
)
internal
view
returns
(uint amount)
{
}
/**
* @dev Returns amount of NXM Tokens locked as Cover Note for given coverId.
* @param _coverId coverId of the cover.
*/
function _getLockedCNAgainstCover(uint _coverId) internal view returns(uint) {
}
/**
* @dev Returns amount of NXM Tokens locked as Cover Note for given coverId.
* @param _of address of the coverHolder.
* @param _coverId coverId of the cover.
*/
function _getUserLockedCNTokens(address _of, uint _coverId) internal view returns(uint) {
}
/**
* @dev Internal function to gets remaining amount of staked NXM tokens,
* against smartcontract by index
* @param _stakeAmount address of user
* @param _stakeDays staked contract address
* @param _validDays index of staking
*/
function _calculateStakedTokens(
uint _stakeAmount,
uint _stakeDays,
uint _validDays
)
internal
pure
returns (uint amount)
{
}
/**
* @dev Gets the total staked NXM tokens against Smart contract
* by all stakers
* @param _stakedContractAddress smart contract address.
* @return amount total staked NXM tokens.
*/
function _burnStakerTokenLockedAgainstSmartContract(
address _stakerAddress,
address _stakedContractAddress,
uint _stakedContractIndex,
uint _amount
)
internal
{
}
}
| _getLockedCNAgainstCover(coverId)>0,"No cover note available" | 57,234 | _getLockedCNAgainstCover(coverId)>0 |
"Cover note is deposited and can not be released" | /* Copyright (C) 2020 NexusMutual.io
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see http://www.gnu.org/licenses/ */
pragma solidity 0.5.7;
import "./NXMToken.sol";
import "./Governance.sol";
contract TokenFunctions is Iupgradable {
using SafeMath for uint;
MCR internal m1;
MemberRoles internal mr;
NXMToken public tk;
TokenController internal tc;
TokenData internal td;
QuotationData internal qd;
ClaimsReward internal cr;
Governance internal gv;
PoolData internal pd;
uint private constant DECIMAL1E18 = uint(10) ** 18;
event BurnCATokens(uint claimId, address addr, uint amount);
/**
* @dev Sends commission to underwriter on purchase of staked smart contract.
* @param _scAddress staker address.
* @param _premiumNXM premium of cover in NXM.
*/
function updateStakerCommissions(address _scAddress, uint _premiumNXM) external onlyInternal {
}
/**
* @dev Burns tokens staked against a Smart Contract Cover.
* Called when a claim submitted against this cover is accepted.
* @param coverid Cover Id.
*/
function burnStakerLockedToken(uint coverid, bytes4 curr, uint sumAssured) external onlyInternal {
}
/**
* @dev Gets the total staked NXM tokens against
* Smart contract by all stakers
* @param _stakedContractAddress smart contract address.
* @return amount total staked NXM tokens.
*/
function getTotalStakedTokensOnSmartContract(
address _stakedContractAddress
)
external
view
returns(uint amount)
{
}
/**
* @dev Returns amount of NXM Tokens locked as Cover Note for given coverId.
* @param _of address of the coverHolder.
* @param _coverId coverId of the cover.
*/
function getUserLockedCNTokens(address _of, uint _coverId) external view returns(uint) {
}
/**
* @dev to get the all the cover locked tokens of a user
* @param _of is the user address in concern
* @return amount locked
*/
function getUserAllLockedCNTokens(address _of) external view returns(uint amount) {
}
/**
* @dev Returns amount of NXM Tokens locked as Cover Note against given coverId.
* @param _coverId coverId of the cover.
*/
function getLockedCNAgainstCover(uint _coverId) external view returns(uint) {
}
/**
* @dev Returns total amount of staked NXM Tokens on all smart contract .
* @param _stakerAddress address of the Staker.
*/
function getStakerAllLockedTokens(address _stakerAddress) external view returns (uint amount) {
}
/**
* @dev Returns total unlockable amount of staked NXM Tokens on all smart contract .
* @param _stakerAddress address of the Staker.
*/
function getStakerAllUnlockableStakedTokens(
address _stakerAddress
)
external
view
returns (uint amount)
{
}
/**
* @dev Change Dependent Contract Address
*/
function changeDependentContractAddress() public {
}
/**
* @dev Gets the Token price in a given currency
* @param curr Currency name.
* @return price Token Price.
*/
function getTokenPrice(bytes4 curr) public view returns(uint price) {
}
/**
* @dev Set the flag to check if cover note is deposited against the cover id
* @param coverId Cover Id.
*/
function depositCN(uint coverId) public onlyInternal returns (bool success) {
}
/**
* @param _of address of Member
* @param _coverId Cover Id
* @param _lockTime Pending Time + Cover Period 7*1 days
*/
function extendCNEPOff(address _of, uint _coverId, uint _lockTime) public onlyInternal {
}
/**
* @dev to burn the deposited cover tokens
* @param coverId is id of cover whose tokens have to be burned
* @return the status of the successful burning
*/
function burnDepositCN(uint coverId) public onlyInternal returns (bool success) {
}
/**
* @dev Unlocks covernote locked against a given cover
* @param coverId id of cover
*/
function unlockCN(uint coverId) public onlyInternal {
(, bool isDeposited) = td.depositedCN(coverId);
require(<FILL_ME>)
uint lockedCN = _getLockedCNAgainstCover(coverId);
if (lockedCN != 0) {
address coverHolder = qd.getCoverMemberAddress(coverId);
bytes32 reason = keccak256(abi.encodePacked("CN", coverHolder, coverId));
tc.releaseLockedTokens(coverHolder, reason, lockedCN);
}
}
/**
* @dev Burns tokens used for fraudulent voting against a claim
* @param claimid Claim Id.
* @param _value number of tokens to be burned
* @param _of Claim Assessor's address.
*/
function burnCAToken(uint claimid, uint _value, address _of) public {
}
/**
* @dev to lock cover note tokens
* @param coverNoteAmount is number of tokens to be locked
* @param coverPeriod is cover period in concern
* @param coverId is the cover id of cover in concern
* @param _of address whose tokens are to be locked
*/
function lockCN(
uint coverNoteAmount,
uint coverPeriod,
uint coverId,
address _of
)
public
onlyInternal
{
}
/**
* @dev Staking on contract.
* @param _scAddress smart contract address.
* @param _amount amount of NXM.
*/
function addStake(address _scAddress, uint _amount) public isMemberAndcheckPause {
}
/**
* @dev to check if a member is locked for member vote
* @param _of is the member address in concern
* @return the boolean status
*/
function isLockedForMemberVote(address _of) public view returns(bool) {
}
/**
* @dev Internal function to gets amount of locked NXM tokens,
* staked against smartcontract by index
* @param _stakerAddress address of user
* @param _stakedContractAddress staked contract address
* @param _stakedContractIndex index of staking
*/
function getStakerLockedTokensOnSmartContract (
address _stakerAddress,
address _stakedContractAddress,
uint _stakedContractIndex
)
public
view
returns
(uint amount)
{
}
/**
* @dev Function to gets unlockable amount of locked NXM
* tokens, staked against smartcontract by index
* @param stakerAddress address of staker
* @param stakedContractAddress staked contract address
* @param stakerIndex index of staking
*/
function getStakerUnlockableTokensOnSmartContract (
address stakerAddress,
address stakedContractAddress,
uint stakerIndex
)
public
view
returns (uint)
{
}
/**
* @dev releases unlockable staked tokens to staker
*/
function unlockStakerUnlockableTokens(address _stakerAddress) public checkPause {
}
function fixUnlockRecord(address _stakerAddress, uint index) public onlyOwner {
}
/**
* @dev to get tokens of staker locked before burning that are allowed to burn
* @param stakerAdd is the address of the staker
* @param stakedAdd is the address of staked contract in concern
* @param stakerIndex is the staker index in concern
* @return amount of unlockable tokens
* @return amount of tokens that can burn
*/
function _unlockableBeforeBurningAndCanBurn(
address stakerAdd,
address stakedAdd,
uint stakerIndex
)
internal
view
returns
(uint amount, uint canBurn) {
}
/**
* @dev to get tokens of staker that are unlockable
* @param _stakerAddress is the address of the staker
* @param _stakedContractAddress is the address of staked contract in concern
* @param _stakedContractIndex is the staked contract index in concern
* @return amount of unlockable tokens
*/
function _getStakerUnlockableTokensOnSmartContract (
address _stakerAddress,
address _stakedContractAddress,
uint _stakedContractIndex
)
internal
view
returns
(uint amount)
{
}
/**
* @dev Internal function to get the amount of locked NXM tokens,
* staked against smartcontract by index
* @param _stakerAddress address of user
* @param _stakedContractAddress staked contract address
* @param _stakedContractIndex index of staking
*/
function _getStakerLockedTokensOnSmartContract (
address _stakerAddress,
address _stakedContractAddress,
uint _stakedContractIndex
)
internal
view
returns
(uint amount)
{
}
/**
* @dev Returns amount of NXM Tokens locked as Cover Note for given coverId.
* @param _coverId coverId of the cover.
*/
function _getLockedCNAgainstCover(uint _coverId) internal view returns(uint) {
}
/**
* @dev Returns amount of NXM Tokens locked as Cover Note for given coverId.
* @param _of address of the coverHolder.
* @param _coverId coverId of the cover.
*/
function _getUserLockedCNTokens(address _of, uint _coverId) internal view returns(uint) {
}
/**
* @dev Internal function to gets remaining amount of staked NXM tokens,
* against smartcontract by index
* @param _stakeAmount address of user
* @param _stakeDays staked contract address
* @param _validDays index of staking
*/
function _calculateStakedTokens(
uint _stakeAmount,
uint _stakeDays,
uint _validDays
)
internal
pure
returns (uint amount)
{
}
/**
* @dev Gets the total staked NXM tokens against Smart contract
* by all stakers
* @param _stakedContractAddress smart contract address.
* @return amount total staked NXM tokens.
*/
function _burnStakerTokenLockedAgainstSmartContract(
address _stakerAddress,
address _stakedContractAddress,
uint _stakedContractIndex,
uint _amount
)
internal
{
}
}
| !isDeposited,"Cover note is deposited and can not be released" | 57,234 | !isDeposited |
null | /*! vlp.sol | (c) 2018 Develop by BelovITLab LLC (smartcontract.ru), author @stupidlovejoy | License: MIT */
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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() { }
function Ownable() public {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract Pausable is Ownable {
bool public paused = false;
event Pause();
event Unpause();
modifier whenNotPaused() { }
modifier whenPaused() { }
function pause() onlyOwner whenNotPaused public {
}
function unpause() onlyOwner whenPaused public {
}
}
contract Withdrawable is Ownable {
function withdrawEther(address _to, uint _value) onlyOwner public returns(bool) {
}
function withdrawTokens(ERC20 _token, address _to, uint _value) onlyOwner public returns(bool) {
}
}
contract ERC20 {
uint256 public totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function balanceOf(address who) public view returns(uint256);
function transfer(address to, uint256 value) public returns(bool);
function transferFrom(address from, address to, uint256 value) public returns(bool);
function allowance(address owner, address spender) public view returns(uint256);
function approve(address spender, uint256 value) public returns(bool);
}
contract StandardToken is ERC20 {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
function StandardToken(string _name, string _symbol, uint8 _decimals) public {
}
function balanceOf(address _owner) public view returns(uint256 balance) {
}
function transfer(address _to, uint256 _value) public returns(bool) {
}
function multiTransfer(address[] _to, uint256[] _value) public returns(bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns(bool) {
}
function allowance(address _owner, address _spender) public view returns(uint256) {
}
function approve(address _spender, uint256 _value) public returns(bool) {
}
function increaseApproval(address _spender, uint _addedValue) public returns(bool) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns(bool) {
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() { }
function mint(address _to, uint256 _amount) onlyOwner canMint public returns(bool) {
}
function finishMinting() onlyOwner canMint public returns(bool) {
}
}
contract CappedToken is MintableToken {
uint256 public cap;
function CappedToken(uint256 _cap) public {
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns(bool) {
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
}
}
/*
ICO Velper
*/
contract Token is BurnableToken, CappedToken, Withdrawable {
function Token() CappedToken(1000000000 ether) StandardToken("Velper", "VLP", 18) public {
}
function transferOwner(address _from, address _to, uint256 _value) onlyOwner canMint public returns(bool) {
}
}
contract Crowdsale is Withdrawable, Pausable {
using SafeMath for uint;
struct Step {
uint priceTokenWei;
uint tokensForSale;
uint8[5] salesPercent;
uint bonusAmount;
uint bonusPercent;
uint tokensSold;
uint collectedWei;
}
Token public token;
address public beneficiary = 0xe57AB27CA8b87a4e249EbeF7c4BdB17D5Ba2832b;
address public manager = 0xc5195F2Ee6FF2a9164272F62177e52fBCEF37C04;
Step[] public steps;
uint8 public currentStep = 0;
bool public crowdsaleClosed = false;
mapping(address => mapping(uint8 => mapping(uint8 => uint256))) public canSell;
event NewRate(uint256 rate);
event Purchase(address indexed holder, uint256 tokenAmount, uint256 etherAmount);
event Sell(address indexed holder, uint256 tokenAmount, uint256 etherAmount);
event NextStep(uint8 step);
event CrowdsaleClose();
function Crowdsale() public { }
function init(address _token) {
}
function() payable public {
}
function setTokenRate(uint _value) onlyOwner public {
}
function purchase() whenNotPaused payable public {
}
/// @dev Salling: new Crowdsale()(0,4700000); new $0.token.Token(); $0.purchase()(100)[1]; $0.nextStep(); $0.sell(100000000000000000000000)[1]; $1.balanceOf(@1) == 1.05e+24
function sell(uint256 _value) whenNotPaused public {
require(!crowdsaleClosed);
require(currentStep > 0);
require(<FILL_ME>)
require(token.balanceOf(msg.sender) >= _value);
canSell[msg.sender][currentStep - 1][currentStep] = canSell[msg.sender][currentStep - 1][currentStep].sub(_value);
token.transferOwner(msg.sender, beneficiary, _value);
uint sum = _value.mul(steps[currentStep].priceTokenWei).div(1 ether);
msg.sender.transfer(sum);
Sell(msg.sender, _value, sum);
}
function nextStep() onlyOwner public {
}
function closeCrowdsale() onlyOwner public {
}
/// @dev ManagerTransfer: new Crowdsale()(0,4700000); new $0.token.Token(); $0.purchase()(1000)[2]; $0.managerTransfer(@1,100000000000000000000000)[5]; $0.nextStep(); $0.sell(20000000000000000000000)[1]; $1.balanceOf(@1) == 8e+22
function managerTransfer(address _to, uint256 _value) public {
}
}
| canSell[msg.sender][currentStep-1][currentStep]>=_value | 57,249 | canSell[msg.sender][currentStep-1][currentStep]>=_value |
null | /*! vlp.sol | (c) 2018 Develop by BelovITLab LLC (smartcontract.ru), author @stupidlovejoy | License: MIT */
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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() { }
function Ownable() public {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract Pausable is Ownable {
bool public paused = false;
event Pause();
event Unpause();
modifier whenNotPaused() { }
modifier whenPaused() { }
function pause() onlyOwner whenNotPaused public {
}
function unpause() onlyOwner whenPaused public {
}
}
contract Withdrawable is Ownable {
function withdrawEther(address _to, uint _value) onlyOwner public returns(bool) {
}
function withdrawTokens(ERC20 _token, address _to, uint _value) onlyOwner public returns(bool) {
}
}
contract ERC20 {
uint256 public totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function balanceOf(address who) public view returns(uint256);
function transfer(address to, uint256 value) public returns(bool);
function transferFrom(address from, address to, uint256 value) public returns(bool);
function allowance(address owner, address spender) public view returns(uint256);
function approve(address spender, uint256 value) public returns(bool);
}
contract StandardToken is ERC20 {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
function StandardToken(string _name, string _symbol, uint8 _decimals) public {
}
function balanceOf(address _owner) public view returns(uint256 balance) {
}
function transfer(address _to, uint256 _value) public returns(bool) {
}
function multiTransfer(address[] _to, uint256[] _value) public returns(bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns(bool) {
}
function allowance(address _owner, address _spender) public view returns(uint256) {
}
function approve(address _spender, uint256 _value) public returns(bool) {
}
function increaseApproval(address _spender, uint _addedValue) public returns(bool) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns(bool) {
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() { }
function mint(address _to, uint256 _amount) onlyOwner canMint public returns(bool) {
}
function finishMinting() onlyOwner canMint public returns(bool) {
}
}
contract CappedToken is MintableToken {
uint256 public cap;
function CappedToken(uint256 _cap) public {
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns(bool) {
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
}
}
/*
ICO Velper
*/
contract Token is BurnableToken, CappedToken, Withdrawable {
function Token() CappedToken(1000000000 ether) StandardToken("Velper", "VLP", 18) public {
}
function transferOwner(address _from, address _to, uint256 _value) onlyOwner canMint public returns(bool) {
}
}
contract Crowdsale is Withdrawable, Pausable {
using SafeMath for uint;
struct Step {
uint priceTokenWei;
uint tokensForSale;
uint8[5] salesPercent;
uint bonusAmount;
uint bonusPercent;
uint tokensSold;
uint collectedWei;
}
Token public token;
address public beneficiary = 0xe57AB27CA8b87a4e249EbeF7c4BdB17D5Ba2832b;
address public manager = 0xc5195F2Ee6FF2a9164272F62177e52fBCEF37C04;
Step[] public steps;
uint8 public currentStep = 0;
bool public crowdsaleClosed = false;
mapping(address => mapping(uint8 => mapping(uint8 => uint256))) public canSell;
event NewRate(uint256 rate);
event Purchase(address indexed holder, uint256 tokenAmount, uint256 etherAmount);
event Sell(address indexed holder, uint256 tokenAmount, uint256 etherAmount);
event NextStep(uint8 step);
event CrowdsaleClose();
function Crowdsale() public { }
function init(address _token) {
}
function() payable public {
}
function setTokenRate(uint _value) onlyOwner public {
}
function purchase() whenNotPaused payable public {
}
/// @dev Salling: new Crowdsale()(0,4700000); new $0.token.Token(); $0.purchase()(100)[1]; $0.nextStep(); $0.sell(100000000000000000000000)[1]; $1.balanceOf(@1) == 1.05e+24
function sell(uint256 _value) whenNotPaused public {
require(!crowdsaleClosed);
require(currentStep > 0);
require(canSell[msg.sender][currentStep - 1][currentStep] >= _value);
require(<FILL_ME>)
canSell[msg.sender][currentStep - 1][currentStep] = canSell[msg.sender][currentStep - 1][currentStep].sub(_value);
token.transferOwner(msg.sender, beneficiary, _value);
uint sum = _value.mul(steps[currentStep].priceTokenWei).div(1 ether);
msg.sender.transfer(sum);
Sell(msg.sender, _value, sum);
}
function nextStep() onlyOwner public {
}
function closeCrowdsale() onlyOwner public {
}
/// @dev ManagerTransfer: new Crowdsale()(0,4700000); new $0.token.Token(); $0.purchase()(1000)[2]; $0.managerTransfer(@1,100000000000000000000000)[5]; $0.nextStep(); $0.sell(20000000000000000000000)[1]; $1.balanceOf(@1) == 8e+22
function managerTransfer(address _to, uint256 _value) public {
}
}
| token.balanceOf(msg.sender)>=_value | 57,249 | token.balanceOf(msg.sender)>=_value |
null | /*! vlp.sol | (c) 2018 Develop by BelovITLab LLC (smartcontract.ru), author @stupidlovejoy | License: MIT */
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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() { }
function Ownable() public {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract Pausable is Ownable {
bool public paused = false;
event Pause();
event Unpause();
modifier whenNotPaused() { }
modifier whenPaused() { }
function pause() onlyOwner whenNotPaused public {
}
function unpause() onlyOwner whenPaused public {
}
}
contract Withdrawable is Ownable {
function withdrawEther(address _to, uint _value) onlyOwner public returns(bool) {
}
function withdrawTokens(ERC20 _token, address _to, uint _value) onlyOwner public returns(bool) {
}
}
contract ERC20 {
uint256 public totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function balanceOf(address who) public view returns(uint256);
function transfer(address to, uint256 value) public returns(bool);
function transferFrom(address from, address to, uint256 value) public returns(bool);
function allowance(address owner, address spender) public view returns(uint256);
function approve(address spender, uint256 value) public returns(bool);
}
contract StandardToken is ERC20 {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
function StandardToken(string _name, string _symbol, uint8 _decimals) public {
}
function balanceOf(address _owner) public view returns(uint256 balance) {
}
function transfer(address _to, uint256 _value) public returns(bool) {
}
function multiTransfer(address[] _to, uint256[] _value) public returns(bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns(bool) {
}
function allowance(address _owner, address _spender) public view returns(uint256) {
}
function approve(address _spender, uint256 _value) public returns(bool) {
}
function increaseApproval(address _spender, uint _addedValue) public returns(bool) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns(bool) {
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() { }
function mint(address _to, uint256 _amount) onlyOwner canMint public returns(bool) {
}
function finishMinting() onlyOwner canMint public returns(bool) {
}
}
contract CappedToken is MintableToken {
uint256 public cap;
function CappedToken(uint256 _cap) public {
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns(bool) {
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
}
}
/*
ICO Velper
*/
contract Token is BurnableToken, CappedToken, Withdrawable {
function Token() CappedToken(1000000000 ether) StandardToken("Velper", "VLP", 18) public {
}
function transferOwner(address _from, address _to, uint256 _value) onlyOwner canMint public returns(bool) {
}
}
contract Crowdsale is Withdrawable, Pausable {
using SafeMath for uint;
struct Step {
uint priceTokenWei;
uint tokensForSale;
uint8[5] salesPercent;
uint bonusAmount;
uint bonusPercent;
uint tokensSold;
uint collectedWei;
}
Token public token;
address public beneficiary = 0xe57AB27CA8b87a4e249EbeF7c4BdB17D5Ba2832b;
address public manager = 0xc5195F2Ee6FF2a9164272F62177e52fBCEF37C04;
Step[] public steps;
uint8 public currentStep = 0;
bool public crowdsaleClosed = false;
mapping(address => mapping(uint8 => mapping(uint8 => uint256))) public canSell;
event NewRate(uint256 rate);
event Purchase(address indexed holder, uint256 tokenAmount, uint256 etherAmount);
event Sell(address indexed holder, uint256 tokenAmount, uint256 etherAmount);
event NextStep(uint8 step);
event CrowdsaleClose();
function Crowdsale() public { }
function init(address _token) {
}
function() payable public {
}
function setTokenRate(uint _value) onlyOwner public {
}
function purchase() whenNotPaused payable public {
}
/// @dev Salling: new Crowdsale()(0,4700000); new $0.token.Token(); $0.purchase()(100)[1]; $0.nextStep(); $0.sell(100000000000000000000000)[1]; $1.balanceOf(@1) == 1.05e+24
function sell(uint256 _value) whenNotPaused public {
}
function nextStep() onlyOwner public {
require(!crowdsaleClosed);
require(<FILL_ME>)
currentStep += 1;
NextStep(currentStep);
}
function closeCrowdsale() onlyOwner public {
}
/// @dev ManagerTransfer: new Crowdsale()(0,4700000); new $0.token.Token(); $0.purchase()(1000)[2]; $0.managerTransfer(@1,100000000000000000000000)[5]; $0.nextStep(); $0.sell(20000000000000000000000)[1]; $1.balanceOf(@1) == 8e+22
function managerTransfer(address _to, uint256 _value) public {
}
}
| steps.length-1>currentStep | 57,249 | steps.length-1>currentStep |
null | contract Partner {
function exchangeTokensFromOtherContract(address _source, address _recipient, uint256 _RequestedTokens);
}
contract Target {
function transfer(address _to, uint _value);
}
contract PRECOE {
string public name = "Premined Coeval";
uint8 public decimals = 18;
string public symbol = "PRECOE";
address public owner;
address public devFeesAddr = 0x36Bdc3B60dC5491fbc7d74a05709E94d5b554321;
address tierAdmin;
uint256 public totalSupply = 71433000000000000000000;
uint256 public mineableTokens = totalSupply;
uint public tierLevel = 1;
uint256 public fiatPerEth = 3.85E25;
uint256 public circulatingSupply = 0;
uint maxTier = 132;
uint256 public devFees = 0;
uint256 fees = 10000; // the calculation expects % * 100 (so 10% is 1000)
bool public receiveEth = false;
bool payFees = true;
bool public canExchange = true;
bool addTiers = true;
bool public initialTiers = false;
// Storage
mapping (address => uint256) public balances;
mapping (address => bool) public exchangePartners;
// mining schedule
mapping(uint => uint256) public scheduleTokens;
mapping(uint => uint256) public scheduleRates;
// events (ERC20)
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
// events (custom)
event TokensExchanged(address indexed _owningWallet, address indexed _with, uint256 _value);
function PRECOE() {
}
function populateTierTokens() public {
require(<FILL_ME>)
scheduleTokens[1] = 1E20;
scheduleTokens[2] = 1E20;
scheduleTokens[3] = 1E20;
scheduleTokens[4] = 1E20;
scheduleTokens[5] = 1E20;
scheduleTokens[6] = 1E20;
scheduleTokens[7] = 1E20;
scheduleTokens[8] = 1E20;
scheduleTokens[9] = 1E20;
scheduleTokens[10] = 1E20;
scheduleTokens[11] = 1E20;
scheduleTokens[12] = 1E20;
scheduleTokens[13] = 1E20;
scheduleTokens[14] = 1E20;
scheduleTokens[15] = 1E20;
scheduleTokens[16] = 1E20;
scheduleTokens[17] = 1E20;
scheduleTokens[18] = 1E20;
scheduleTokens[19] = 1E20;
scheduleTokens[20] = 1E20;
scheduleTokens[21] = 1E20;
scheduleTokens[22] = 1E20;
scheduleTokens[23] = 1E20;
scheduleTokens[24] = 1E20;
scheduleTokens[25] = 1E20;
scheduleTokens[26] = 1E20;
scheduleTokens[27] = 1E20;
scheduleTokens[28] = 1E20;
scheduleTokens[29] = 1E20;
scheduleTokens[30] = 3E20;
scheduleTokens[31] = 3E20;
scheduleTokens[32] = 3E20;
scheduleTokens[33] = 3E20;
scheduleTokens[34] = 3E20;
scheduleTokens[35] = 3E20;
scheduleTokens[36] = 3E20;
scheduleTokens[37] = 3E20;
scheduleTokens[38] = 3E20;
scheduleTokens[39] = 3E20;
scheduleTokens[40] = 3E20;
}
function populateTierRates() public {
}
function () payable public {
}
function convertEthToCents(uint256 _incoming) internal returns (uint256) {
}
function allocateTokens(uint256 _submitted, uint256 _tokenCount) internal {
}
function transfer(address _to, uint _value) public {
}
function exchange(address _partner, uint256 _amount) internal {
}
function requestTokensFromOtherContract(address _targetContract, address _sourceContract, address _recipient, uint256 _value) internal returns (bool){
}
function balanceOf(address _receiver) public constant returns (uint256) {
}
function balanceInTier() public constant returns (uint256) {
}
function balanceInSpecificTier(uint256 _tier) public constant returns (uint256) {
}
function rateOfSpecificTier(uint256 _tier) public constant returns (uint256) {
}
function setFiatPerEthRate(uint256 _newRate) public {
}
function addExchangePartnerTargetAddress(address _partner) public {
}
function canContractExchange(address _contract) public constant returns (bool) {
}
function removeExchangePartnerTargetAddress(address _partner) public {
}
function withdrawDevFees() public {
}
function changeDevFees(address _devFees) public {
}
function payFeesToggle() public {
}
function safeWithdrawal(address _receiver, uint256 _value) public {
}
// enables fee update - must be between 0 and 100 (%)
function updateFeeAmount(uint _newFee) public {
}
function handleTokensFromOtherContracts(address _contract, address _recipient, uint256 _tokens) public {
}
function changeOwner(address _recipient) public {
}
function changeTierAdmin(address _tierAdmin) public {
}
function toggleReceiveEth() public {
}
function toggleTokenExchange() public {
}
function addTierRateAndTokens(uint256 _level, uint256 _tokens, uint256 _rate) public {
}
// not really needed as we fix the max tiers on contract creation but just for completeness' sake we'll call this
// when all tiers have been added to the contract (not possible to deploy with all of them)
function closeTierAddition() public {
}
function mul(uint256 a, uint256 b) internal pure returns (uint) {
}
function div(uint256 a, uint256 b) internal pure returns (uint) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint) {
}
function add(uint256 a, uint256 b) internal pure returns (uint) {
}
}
| (msg.sender==owner)&&(initialTiers==false) | 57,263 | (msg.sender==owner)&&(initialTiers==false) |
null | contract Partner {
function exchangeTokensFromOtherContract(address _source, address _recipient, uint256 _RequestedTokens);
}
contract Target {
function transfer(address _to, uint _value);
}
contract PRECOE {
string public name = "Premined Coeval";
uint8 public decimals = 18;
string public symbol = "PRECOE";
address public owner;
address public devFeesAddr = 0x36Bdc3B60dC5491fbc7d74a05709E94d5b554321;
address tierAdmin;
uint256 public totalSupply = 71433000000000000000000;
uint256 public mineableTokens = totalSupply;
uint public tierLevel = 1;
uint256 public fiatPerEth = 3.85E25;
uint256 public circulatingSupply = 0;
uint maxTier = 132;
uint256 public devFees = 0;
uint256 fees = 10000; // the calculation expects % * 100 (so 10% is 1000)
bool public receiveEth = false;
bool payFees = true;
bool public canExchange = true;
bool addTiers = true;
bool public initialTiers = false;
// Storage
mapping (address => uint256) public balances;
mapping (address => bool) public exchangePartners;
// mining schedule
mapping(uint => uint256) public scheduleTokens;
mapping(uint => uint256) public scheduleRates;
// events (ERC20)
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
// events (custom)
event TokensExchanged(address indexed _owningWallet, address indexed _with, uint256 _value);
function PRECOE() {
}
function populateTierTokens() public {
}
function populateTierRates() public {
}
function () payable public {
}
function convertEthToCents(uint256 _incoming) internal returns (uint256) {
}
function allocateTokens(uint256 _submitted, uint256 _tokenCount) internal {
}
function transfer(address _to, uint _value) public {
}
function exchange(address _partner, uint256 _amount) internal {
require(<FILL_ME>)
requestTokensFromOtherContract(_partner, this, msg.sender, _amount);
balances[msg.sender] = sub(balanceOf(msg.sender), _amount);
circulatingSupply = sub(circulatingSupply, _amount);
Transfer(msg.sender, this, _amount);
TokensExchanged(msg.sender, _partner, _amount);
}
function requestTokensFromOtherContract(address _targetContract, address _sourceContract, address _recipient, uint256 _value) internal returns (bool){
}
function balanceOf(address _receiver) public constant returns (uint256) {
}
function balanceInTier() public constant returns (uint256) {
}
function balanceInSpecificTier(uint256 _tier) public constant returns (uint256) {
}
function rateOfSpecificTier(uint256 _tier) public constant returns (uint256) {
}
function setFiatPerEthRate(uint256 _newRate) public {
}
function addExchangePartnerTargetAddress(address _partner) public {
}
function canContractExchange(address _contract) public constant returns (bool) {
}
function removeExchangePartnerTargetAddress(address _partner) public {
}
function withdrawDevFees() public {
}
function changeDevFees(address _devFees) public {
}
function payFeesToggle() public {
}
function safeWithdrawal(address _receiver, uint256 _value) public {
}
// enables fee update - must be between 0 and 100 (%)
function updateFeeAmount(uint _newFee) public {
}
function handleTokensFromOtherContracts(address _contract, address _recipient, uint256 _tokens) public {
}
function changeOwner(address _recipient) public {
}
function changeTierAdmin(address _tierAdmin) public {
}
function toggleReceiveEth() public {
}
function toggleTokenExchange() public {
}
function addTierRateAndTokens(uint256 _level, uint256 _tokens, uint256 _rate) public {
}
// not really needed as we fix the max tiers on contract creation but just for completeness' sake we'll call this
// when all tiers have been added to the contract (not possible to deploy with all of them)
function closeTierAddition() public {
}
function mul(uint256 a, uint256 b) internal pure returns (uint) {
}
function div(uint256 a, uint256 b) internal pure returns (uint) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint) {
}
function add(uint256 a, uint256 b) internal pure returns (uint) {
}
}
| exchangePartners[_partner] | 57,263 | exchangePartners[_partner] |
null | contract Partner {
function exchangeTokensFromOtherContract(address _source, address _recipient, uint256 _RequestedTokens);
}
contract Target {
function transfer(address _to, uint _value);
}
contract PRECOE {
string public name = "Premined Coeval";
uint8 public decimals = 18;
string public symbol = "PRECOE";
address public owner;
address public devFeesAddr = 0x36Bdc3B60dC5491fbc7d74a05709E94d5b554321;
address tierAdmin;
uint256 public totalSupply = 71433000000000000000000;
uint256 public mineableTokens = totalSupply;
uint public tierLevel = 1;
uint256 public fiatPerEth = 3.85E25;
uint256 public circulatingSupply = 0;
uint maxTier = 132;
uint256 public devFees = 0;
uint256 fees = 10000; // the calculation expects % * 100 (so 10% is 1000)
bool public receiveEth = false;
bool payFees = true;
bool public canExchange = true;
bool addTiers = true;
bool public initialTiers = false;
// Storage
mapping (address => uint256) public balances;
mapping (address => bool) public exchangePartners;
// mining schedule
mapping(uint => uint256) public scheduleTokens;
mapping(uint => uint256) public scheduleRates;
// events (ERC20)
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
// events (custom)
event TokensExchanged(address indexed _owningWallet, address indexed _with, uint256 _value);
function PRECOE() {
}
function populateTierTokens() public {
}
function populateTierRates() public {
}
function () payable public {
}
function convertEthToCents(uint256 _incoming) internal returns (uint256) {
}
function allocateTokens(uint256 _submitted, uint256 _tokenCount) internal {
}
function transfer(address _to, uint _value) public {
}
function exchange(address _partner, uint256 _amount) internal {
}
function requestTokensFromOtherContract(address _targetContract, address _sourceContract, address _recipient, uint256 _value) internal returns (bool){
}
function balanceOf(address _receiver) public constant returns (uint256) {
}
function balanceInTier() public constant returns (uint256) {
}
function balanceInSpecificTier(uint256 _tier) public constant returns (uint256) {
}
function rateOfSpecificTier(uint256 _tier) public constant returns (uint256) {
}
function setFiatPerEthRate(uint256 _newRate) public {
}
function addExchangePartnerTargetAddress(address _partner) public {
}
function canContractExchange(address _contract) public constant returns (bool) {
}
function removeExchangePartnerTargetAddress(address _partner) public {
}
function withdrawDevFees() public {
}
function changeDevFees(address _devFees) public {
}
function payFeesToggle() public {
}
function safeWithdrawal(address _receiver, uint256 _value) public {
}
// enables fee update - must be between 0 and 100 (%)
function updateFeeAmount(uint _newFee) public {
}
function handleTokensFromOtherContracts(address _contract, address _recipient, uint256 _tokens) public {
}
function changeOwner(address _recipient) public {
}
function changeTierAdmin(address _tierAdmin) public {
require(<FILL_ME>)
tierAdmin = _tierAdmin;
}
function toggleReceiveEth() public {
}
function toggleTokenExchange() public {
}
function addTierRateAndTokens(uint256 _level, uint256 _tokens, uint256 _rate) public {
}
// not really needed as we fix the max tiers on contract creation but just for completeness' sake we'll call this
// when all tiers have been added to the contract (not possible to deploy with all of them)
function closeTierAddition() public {
}
function mul(uint256 a, uint256 b) internal pure returns (uint) {
}
function div(uint256 a, uint256 b) internal pure returns (uint) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint) {
}
function add(uint256 a, uint256 b) internal pure returns (uint) {
}
}
| (msg.sender==owner)||(msg.sender==tierAdmin) | 57,263 | (msg.sender==owner)||(msg.sender==tierAdmin) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.