comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"failed" | pragma solidity 0.8.0;
contract Holder is ERC1155Holder {
ERC1155 nft_contract;
ERC20 metagold_contract;
address public owner;
uint256 tokenYields = 10;
uint256 yieldTime = 1 days;
uint256 stakingTime = 365 * 5 days;
uint256 stakingStart;
mapping(uint256 => address) public stakers;
mapping(uint256 => uint256) public staking_time;
modifier tokenIdWhiteList(uint256[] memory tokenIds) {
}
modifier isStakingAlive() {
}
modifier isStakingEnded() {
}
modifier onlyOwner() {
}
constructor(
address _metagold_contract,
address _nft_contractAddress,
address _owner
) {
}
function stake(uint256[] memory tokenIds, uint256[] memory tokenValues)
external
isStakingAlive
tokenIdWhiteList(tokenIds)
returns (bool)
{
}
function unstake(uint256[] memory tokenIds, uint256[] memory tokenValues)
external
returns (bool)
{
// unstake logic
uint256 _tokenYield;
for (uint256 i = 0; i < tokenIds.length; i++) {
require(
stakers[tokenIds[i]] == msg.sender,
"User didn't stake the contract"
);
_tokenYield += CalculateYield(tokenIds[i]);
stakers[tokenIds[i]] = address(0);
staking_time[tokenIds[i]] = 0;
}
nft_contract.safeBatchTransferFrom(
address(this),
msg.sender,
tokenIds,
tokenValues,
""
);
// user gets rewards
require(<FILL_ME>)
return true;
}
function claimRewrad(uint256[] memory tokenIds) external returns (bool) {
}
function CalculateYield(uint256 tokenId) public view returns (uint256) {
}
function SafeNFTWithdraw(
uint256[] memory tokenIds,
uint256[] memory tokenValues
) external returns (bool) {
}
function postStakeWithdraw() external onlyOwner isStakingEnded {
}
function changeAdmin(address _newAdmin) external onlyOwner {
}
}
| metagold_contract.transfer(msg.sender,_tokenYield),"failed" | 285,975 | metagold_contract.transfer(msg.sender,_tokenYield) |
"User haven't staked the token" | pragma solidity 0.8.0;
contract Holder is ERC1155Holder {
ERC1155 nft_contract;
ERC20 metagold_contract;
address public owner;
uint256 tokenYields = 10;
uint256 yieldTime = 1 days;
uint256 stakingTime = 365 * 5 days;
uint256 stakingStart;
mapping(uint256 => address) public stakers;
mapping(uint256 => uint256) public staking_time;
modifier tokenIdWhiteList(uint256[] memory tokenIds) {
}
modifier isStakingAlive() {
}
modifier isStakingEnded() {
}
modifier onlyOwner() {
}
constructor(
address _metagold_contract,
address _nft_contractAddress,
address _owner
) {
}
function stake(uint256[] memory tokenIds, uint256[] memory tokenValues)
external
isStakingAlive
tokenIdWhiteList(tokenIds)
returns (bool)
{
}
function unstake(uint256[] memory tokenIds, uint256[] memory tokenValues)
external
returns (bool)
{
}
function claimRewrad(uint256[] memory tokenIds) external returns (bool) {
}
function CalculateYield(uint256 tokenId) public view returns (uint256) {
require(<FILL_ME>)
uint256 timeStaked;
if (block.timestamp <= stakingTime + stakingStart) {
// staking time is valid
timeStaked = block.timestamp - staking_time[tokenId];
} else {
// staking time ended
timeStaked = stakingTime + stakingStart - staking_time[tokenId];
}
uint256 yield = (timeStaked / yieldTime) * tokenYields;
return yield * 1 ether;
}
function SafeNFTWithdraw(
uint256[] memory tokenIds,
uint256[] memory tokenValues
) external returns (bool) {
}
function postStakeWithdraw() external onlyOwner isStakingEnded {
}
function changeAdmin(address _newAdmin) external onlyOwner {
}
}
| stakers[tokenId]==msg.sender,"User haven't staked the token" | 285,975 | stakers[tokenId]==msg.sender |
null | pragma solidity 0.8.0;
contract Holder is ERC1155Holder {
ERC1155 nft_contract;
ERC20 metagold_contract;
address public owner;
uint256 tokenYields = 10;
uint256 yieldTime = 1 days;
uint256 stakingTime = 365 * 5 days;
uint256 stakingStart;
mapping(uint256 => address) public stakers;
mapping(uint256 => uint256) public staking_time;
modifier tokenIdWhiteList(uint256[] memory tokenIds) {
}
modifier isStakingAlive() {
}
modifier isStakingEnded() {
}
modifier onlyOwner() {
}
constructor(
address _metagold_contract,
address _nft_contractAddress,
address _owner
) {
}
function stake(uint256[] memory tokenIds, uint256[] memory tokenValues)
external
isStakingAlive
tokenIdWhiteList(tokenIds)
returns (bool)
{
}
function unstake(uint256[] memory tokenIds, uint256[] memory tokenValues)
external
returns (bool)
{
}
function claimRewrad(uint256[] memory tokenIds) external returns (bool) {
}
function CalculateYield(uint256 tokenId) public view returns (uint256) {
}
function SafeNFTWithdraw(
uint256[] memory tokenIds,
uint256[] memory tokenValues
) external returns (bool) {
}
function postStakeWithdraw() external onlyOwner isStakingEnded {
uint256 remaning = metagold_contract.balanceOf(address(this));
require(<FILL_ME>)
}
function changeAdmin(address _newAdmin) external onlyOwner {
}
}
| metagold_contract.transfer(msg.sender,remaning) | 285,975 | metagold_contract.transfer(msg.sender,remaning) |
"Not enought SOV tokens" | // SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.7.6;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "../interfaces/ISovWrapper.sol";
import "../interfaces/ISmartPool.sol";
import "../interfaces/IMintableERC20.sol";
import "hardhat/console.sol";
contract PoolRouter {
using SafeMath for uint256;
uint256 public constant LIQ_FEE_DECIMALS = 1000000; // 6 decimals
uint256 public constant PROTOCOL_FEE_DECIMALS = 100000; // 5 decimals
uint256 public constant MAX_OUT_RATIO = (uint256(10**18) / 3) + 1;
uint256 public protocolFee = 99950; // 100% - 0.050%
ISmartPool public smartPool;
ISovWrapper public wrappingContract;
IMintableERC20 public sovToken;
address public treasury;
constructor(
address _smartPool,
address _wrappingContract,
address _treasury,
address _sovToken,
uint256 _protocolFee
) {
}
/**
This methods performs the following actions:
1. pull token for user
2. joinswap into balancer pool, recieving lp
3. stake lp tokens into Wrapping Contrat which mints SOV to User
*/
function deposit(
address tokenIn,
uint256 tokenAmountIn,
uint256 minPoolAmountOut,
uint256 liquidationFee
) public {
}
/**
This methods performs the following actions:
1. pull tokens for user
2. join into balancer pool, recieving lp
3. stake lp tokens into Wrapping Contrat which mints SOV to User
*/
function depositAll(
uint256 poolAmountOut,
uint256[] calldata maxTokensAmountIn,
uint256 liquidationFee
) public {
}
/**
This methods performs the following actions:
1. burn SOV from user and unstake lp
2. exitswap lp into one of the underlyings
3. send the underlying to the User
*/
function withdraw(
address tokenOut,
uint256 poolAmountIn,
uint256 minAmountOut
) public {
require(<FILL_ME>)
// burns SOV from sender
sovToken.burn(msg.sender, poolAmountIn);
//recieve LP from sender to here
wrappingContract.withdraw(msg.sender, poolAmountIn);
//get balance before exitswap
uint256 balanceBefore = IERC20(tokenOut).balanceOf(address(this));
//swaps LP for underlying
smartPool.exitswapPoolAmountIn(tokenOut, poolAmountIn, minAmountOut);
//get balance after exitswap
uint256 balanceAfter = IERC20(tokenOut).balanceOf(address(this));
//take fee before transfer out
uint256 amountMinusFee = (balanceAfter.sub(balanceBefore))
.mul(protocolFee)
.div(PROTOCOL_FEE_DECIMALS);
IERC20(tokenOut).transfer(msg.sender, amountMinusFee);
}
/**
This methods performs the following actions:
1. burn SOV from user and unstake lp
2. exitswap lp into all of the underlyings
3. send the underlyings to the User
*/
function withdrawAll(uint256 poolAmountIn, uint256[] memory minAmountsOut)
public
{
}
/**
This methods performs the following actions:
1. burn SOV from caller and unstake lp of liquidatedUser
2. exitswap lp into one of the underlyings
3. send the underlying to the caller
4. transfer fee from caller to liquidatedUser
*/
function liquidate(
address liquidatedUser,
address tokenOut,
uint256 poolAmountIn,
uint256 minAmountOut
) public {
}
// transfer the entire fees collected in this contract to DAO treasury
function collectFeesToDAO(address token) public {
}
/**
VIEWS
*/
// gets all tokens currently in the pool
function getPoolTokens() public view returns (address[] memory) {
}
// gets all tokens currently in the pool
function getTokenWeights() public view returns (uint256[] memory) {
}
// gets current LP exchange rate for single Asset
function getSovAmountOutSingle(
address tokenIn,
uint256 tokenAmountIn,
uint256 minPoolAmountOut
) public view returns (uint256 poolAmountOut) {
}
// gets current LP exchange rate for single Asset
function getTokensAmountIn(
uint256 poolAmountOut,
uint256[] calldata maxAmountsIn
) public view returns (uint256[] memory actualAmountsIn) {
}
// gets current LP exchange rate for single token
function getSovAmountInSingle(
address tokenOut,
uint256 tokenAmountOut,
uint256 maxPoolAmountIn
) public view returns (uint256 poolAmountIn) {
}
// gets current LP exchange rate for single token
function getTokenAmountOutSingle(
address tokenOut,
uint256 poolAmountIn,
uint256 minTokenAmountOut
) public view returns (uint256 tokenAmountOut) {
}
// gets current LP exchange rate for all
function getTokensAmountOut(
uint256 poolAmountIn,
uint256[] calldata minAmountsOut
) public view returns (uint256[] memory actualAmountsOut) {
}
// gets current LP exchange rate for single Asset
function _getTokensAmountIn(
uint256 poolAmountOut,
uint256[] calldata maxAmountsIn
) internal view returns (uint256[] memory actualAmountsIn) {
}
}
| sovToken.balanceOf(msg.sender)>=poolAmountIn,"Not enought SOV tokens" | 286,123 | sovToken.balanceOf(msg.sender)>=poolAmountIn |
"Insuffiecient allowance for liquidation Fee" | // SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.7.6;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "../interfaces/ISovWrapper.sol";
import "../interfaces/ISmartPool.sol";
import "../interfaces/IMintableERC20.sol";
import "hardhat/console.sol";
contract PoolRouter {
using SafeMath for uint256;
uint256 public constant LIQ_FEE_DECIMALS = 1000000; // 6 decimals
uint256 public constant PROTOCOL_FEE_DECIMALS = 100000; // 5 decimals
uint256 public constant MAX_OUT_RATIO = (uint256(10**18) / 3) + 1;
uint256 public protocolFee = 99950; // 100% - 0.050%
ISmartPool public smartPool;
ISovWrapper public wrappingContract;
IMintableERC20 public sovToken;
address public treasury;
constructor(
address _smartPool,
address _wrappingContract,
address _treasury,
address _sovToken,
uint256 _protocolFee
) {
}
/**
This methods performs the following actions:
1. pull token for user
2. joinswap into balancer pool, recieving lp
3. stake lp tokens into Wrapping Contrat which mints SOV to User
*/
function deposit(
address tokenIn,
uint256 tokenAmountIn,
uint256 minPoolAmountOut,
uint256 liquidationFee
) public {
}
/**
This methods performs the following actions:
1. pull tokens for user
2. join into balancer pool, recieving lp
3. stake lp tokens into Wrapping Contrat which mints SOV to User
*/
function depositAll(
uint256 poolAmountOut,
uint256[] calldata maxTokensAmountIn,
uint256 liquidationFee
) public {
}
/**
This methods performs the following actions:
1. burn SOV from user and unstake lp
2. exitswap lp into one of the underlyings
3. send the underlying to the User
*/
function withdraw(
address tokenOut,
uint256 poolAmountIn,
uint256 minAmountOut
) public {
}
/**
This methods performs the following actions:
1. burn SOV from user and unstake lp
2. exitswap lp into all of the underlyings
3. send the underlyings to the User
*/
function withdrawAll(uint256 poolAmountIn, uint256[] memory minAmountsOut)
public
{
}
/**
This methods performs the following actions:
1. burn SOV from caller and unstake lp of liquidatedUser
2. exitswap lp into one of the underlyings
3. send the underlying to the caller
4. transfer fee from caller to liquidatedUser
*/
function liquidate(
address liquidatedUser,
address tokenOut,
uint256 poolAmountIn,
uint256 minAmountOut
) public {
require(
sovToken.balanceOf(msg.sender) >= poolAmountIn,
"Not enought SOV tokens"
);
// burns SOV from sender
sovToken.burn(msg.sender, poolAmountIn);
// recieve LP to here
wrappingContract.liquidate(msg.sender, liquidatedUser, poolAmountIn);
//get balance before exitswap
uint256 balanceBefore = IERC20(tokenOut).balanceOf(address(this));
//swaps LP for underlying
smartPool.exitswapPoolAmountIn(tokenOut, poolAmountIn, minAmountOut);
//get balance after exitswap
uint256 balanceAfter = IERC20(tokenOut).balanceOf(address(this));
//take protocol fee before transfer
uint256 amountMinusFee = (balanceAfter.sub(balanceBefore))
.mul(protocolFee)
.div(100000);
IERC20(tokenOut).transfer(msg.sender, amountMinusFee);
// liquidation fee is paid in tokenOut tokens, it is set by lpOwner at deposit
uint256 liquidationFeeAmount = (balanceAfter.sub(balanceBefore))
.mul(wrappingContract.liquidationFee(liquidatedUser))
.div(LIQ_FEE_DECIMALS);
require(<FILL_ME>)
// transfer liquidation fee from liquidator to original owner
IERC20(tokenOut).transferFrom(
msg.sender,
liquidatedUser,
liquidationFeeAmount
);
}
// transfer the entire fees collected in this contract to DAO treasury
function collectFeesToDAO(address token) public {
}
/**
VIEWS
*/
// gets all tokens currently in the pool
function getPoolTokens() public view returns (address[] memory) {
}
// gets all tokens currently in the pool
function getTokenWeights() public view returns (uint256[] memory) {
}
// gets current LP exchange rate for single Asset
function getSovAmountOutSingle(
address tokenIn,
uint256 tokenAmountIn,
uint256 minPoolAmountOut
) public view returns (uint256 poolAmountOut) {
}
// gets current LP exchange rate for single Asset
function getTokensAmountIn(
uint256 poolAmountOut,
uint256[] calldata maxAmountsIn
) public view returns (uint256[] memory actualAmountsIn) {
}
// gets current LP exchange rate for single token
function getSovAmountInSingle(
address tokenOut,
uint256 tokenAmountOut,
uint256 maxPoolAmountIn
) public view returns (uint256 poolAmountIn) {
}
// gets current LP exchange rate for single token
function getTokenAmountOutSingle(
address tokenOut,
uint256 poolAmountIn,
uint256 minTokenAmountOut
) public view returns (uint256 tokenAmountOut) {
}
// gets current LP exchange rate for all
function getTokensAmountOut(
uint256 poolAmountIn,
uint256[] calldata minAmountsOut
) public view returns (uint256[] memory actualAmountsOut) {
}
// gets current LP exchange rate for single Asset
function _getTokensAmountIn(
uint256 poolAmountOut,
uint256[] calldata maxAmountsIn
) internal view returns (uint256[] memory actualAmountsIn) {
}
}
| IERC20(tokenOut).allowance(msg.sender,address(this))>=liquidationFeeAmount,"Insuffiecient allowance for liquidation Fee" | 286,123 | IERC20(tokenOut).allowance(msg.sender,address(this))>=liquidationFeeAmount |
null | pragma solidity 0.5.11;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
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) public onlyOwner {
}
}
/**
* @title ERC20Basic
*/
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is ERC20Basic, Ownable {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
}
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(allowed[_from][msg.sender] >= _value);
require(<FILL_ME>)
require(balances[_to].add(_value) > balances[_to]); // Check for overflows
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
/**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
}
}
/**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is StandardToken {
event Pause();
event Unpause();
bool public paused = false;
address public founder;
/**
* @dev modifier to allow actions only when the contract IS paused
*/
modifier whenNotPaused() {
}
/**
* @dev modifier to allow actions only when the contract IS NOT paused
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() public onlyOwner whenNotPaused {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() public onlyOwner whenPaused {
}
}
contract PausableToken is Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
}
//The functions below surve no real purpose. Even if one were to approve another to spend
//tokens on their behalf, those tokens will still only be transferable when the token contract
//is not paused.
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
}
}
contract CCS is PausableToken {
string public name;
string public symbol;
uint8 public decimals;
/**
* @dev Constructor that gives the founder all of the existing tokens.
*/
constructor() public {
}
/** @dev Fires on every freeze of tokens
* @param _owner address The owner address of frozen tokens.
* @param amount uint256 The amount of tokens frozen
*/
event TokenFreezeEvent(address indexed _owner, uint256 amount);
/** @dev Fires on every unfreeze of tokens
* @param _owner address The owner address of unfrozen tokens.
* @param amount uint256 The amount of tokens unfrozen
*/
event TokenUnfreezeEvent(address indexed _owner, uint256 amount);
event TokensBurned(address indexed _owner, uint256 _tokens);
mapping(address => uint256) internal frozenTokenBalances;
function freezeTokens(address _owner, uint256 _value) public onlyOwner {
}
function unfreezeTokens(address _owner, uint256 _value) public onlyOwner {
}
function setFrozenBalance(address _owner, uint256 _newValue) internal {
}
function balanceOf(address _owner) view public returns(uint256) {
}
function getTotalBalance(address _owner) view public returns(uint256) {
}
/**
* @dev Gets the amount of tokens which belong to the specified address BUT are frozen now.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount of frozen tokens owned by the passed address.
*/
function getFrozenBalance(address _owner) view public returns(uint256) {
}
/*
* @dev Token burn function
* @param _tokens uint256 amount of tokens to burn
*/
function burnTokens(uint256 _tokens) public onlyOwner {
}
function destroy(address payable _benefitiary) external onlyOwner{
}
}
| balanceOf(_from)>=_value | 286,142 | balanceOf(_from)>=_value |
null | pragma solidity 0.5.11;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
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) public onlyOwner {
}
}
/**
* @title ERC20Basic
*/
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is ERC20Basic, Ownable {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
}
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
/**
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
*/
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
}
}
/**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is StandardToken {
event Pause();
event Unpause();
bool public paused = false;
address public founder;
/**
* @dev modifier to allow actions only when the contract IS paused
*/
modifier whenNotPaused() {
require(<FILL_ME>)
_;
}
/**
* @dev modifier to allow actions only when the contract IS NOT paused
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() public onlyOwner whenNotPaused {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() public onlyOwner whenPaused {
}
}
contract PausableToken is Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
}
//The functions below surve no real purpose. Even if one were to approve another to spend
//tokens on their behalf, those tokens will still only be transferable when the token contract
//is not paused.
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
}
}
contract CCS is PausableToken {
string public name;
string public symbol;
uint8 public decimals;
/**
* @dev Constructor that gives the founder all of the existing tokens.
*/
constructor() public {
}
/** @dev Fires on every freeze of tokens
* @param _owner address The owner address of frozen tokens.
* @param amount uint256 The amount of tokens frozen
*/
event TokenFreezeEvent(address indexed _owner, uint256 amount);
/** @dev Fires on every unfreeze of tokens
* @param _owner address The owner address of unfrozen tokens.
* @param amount uint256 The amount of tokens unfrozen
*/
event TokenUnfreezeEvent(address indexed _owner, uint256 amount);
event TokensBurned(address indexed _owner, uint256 _tokens);
mapping(address => uint256) internal frozenTokenBalances;
function freezeTokens(address _owner, uint256 _value) public onlyOwner {
}
function unfreezeTokens(address _owner, uint256 _value) public onlyOwner {
}
function setFrozenBalance(address _owner, uint256 _newValue) internal {
}
function balanceOf(address _owner) view public returns(uint256) {
}
function getTotalBalance(address _owner) view public returns(uint256) {
}
/**
* @dev Gets the amount of tokens which belong to the specified address BUT are frozen now.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount of frozen tokens owned by the passed address.
*/
function getFrozenBalance(address _owner) view public returns(uint256) {
}
/*
* @dev Token burn function
* @param _tokens uint256 amount of tokens to burn
*/
function burnTokens(uint256 _tokens) public onlyOwner {
}
function destroy(address payable _benefitiary) external onlyOwner{
}
}
| !paused||msg.sender==founder | 286,142 | !paused||msg.sender==founder |
"TokenVesting: token already revoked" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
import "./ERC20Custom.sol";
import "./ERC20.sol";
import "./SafeMath.sol";
/**
* @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.
*
* Modified from OpenZeppelin's TokenVesting.sol draft
*/
contract TokenVesting {
// 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;
event TokensReleased(uint256 amount);
event TokenVestingRevoked();
// beneficiary of tokens after they are released
address private _beneficiary;
// owner (grantor) of the tokens
address private _owner;
// Durations and timestamps are expressed in UNIX time, the same units as block.timestamp.
uint256 private _cliff;
uint256 private _start;
uint256 private _duration;
address public _PEGS_contract_address;
ERC20 PEGS;
address public _timelock_address;
bool public _revocable;
uint256 private _released;
bool public _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 {
}
function setPEGSAddress(address PEGS_address) public {
}
function setTimelockAddress(address timelock_address) public {
}
/**
* @return the beneficiary of the tokens.
*/
function getBeneficiary() public view returns (address) {
}
/**
* @return the cliff time of the token vesting.
*/
function getCliff() public view returns (uint256) {
}
/**
* @return the start time of the token vesting.
*/
function getStart() public view returns (uint256) {
}
/**
* @return the duration of the token vesting.
*/
function getDuration() public view returns (uint256) {
}
/**
* @return true if the vesting is revocable.
*/
function getRevocable() public view returns (bool) {
}
/**
* @return the amount of the token released.
*/
function getReleased() public view returns (uint256) {
}
/**
* @return true if the token is revoked.
*/
function getRevoked() public view returns (bool) {
}
/**
* @notice Transfers vested tokens to beneficiary.
*/
function release() public {
}
/**
* @notice Allows the owner to revoke the vesting. Tokens already vested
* remain in the contract, the rest are returned to the owner.
*/
function revoke() public {
require(msg.sender == _timelock_address, "Must be called by the timelock contract");
require(_revocable, "TokenVesting: cannot revoke");
require(<FILL_ME>)
uint256 balance = PEGS.balanceOf(address(this));
uint256 unreleased = _releasableAmount();
uint256 refund = balance.sub(unreleased);
_revoked = true;
PEGS.transfer(_owner, refund);
emit TokenVestingRevoked();
}
// Added to support recovering possible airdrops
function recoverERC20(address tokenAddress, uint256 tokenAmount) external {
}
/**
* @dev Calculates the amount that has already vested but hasn't been released yet.
*/
function _releasableAmount() private view returns (uint256) {
}
/**
* @dev Calculates the amount that has already vested.
*/
function _vestedAmount() private view returns (uint256) {
}
uint256[44] private __gap;
}
| !_revoked,"TokenVesting: token already revoked" | 286,183 | !_revoked |
null | pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ApproveAndCallReceiver {
function receiveApproval(
address _from,
uint256 _amount,
address _token,
bytes _data
) public;
}
//normal contract. already compiled as bin
contract Controlled {
/// @notice The address of the controller is the only address that can call
/// a function with this modifier
modifier onlyController {
}
//block for check//bool private initialed = false;
address public controller;
function Controlled() public {
}
/// @notice Changes the controller of the contract
/// @param _newController The new controller of the contract
function changeController(address _newController) onlyController public {
}
}
//abstract contract. used for interface
contract TokenController {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
function proxyPayment(address _owner) payable public returns(bool);
/// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
/// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return False if the controller does not authorize the approval
function onApprove(address _owner, address _spender, uint _amount) public returns(bool);
}
contract ERC20Token {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contract since public getter functions are not
currently recognised as an implementation of the matching abstract
function by the compiler.
*/
/// total amount of tokens
uint256 public totalSupply;
//function totalSupply() public constant returns (uint256 balance);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
mapping (address => uint256) public balanceOf;
//function balanceOf(address _owner) public constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
mapping (address => mapping (address => uint256)) public allowance;
//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);
}
contract TokenI is ERC20Token, Controlled {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
// ERC20 Methods
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(
address _spender,
uint256 _amount,
bytes _extraData
) public returns (bool success);
// Generate and destroy tokens
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _owner The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _owner, uint _amount) public returns (bool);
/// @notice Burns `_amount` tokens from `_owner`
/// @param _owner The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _owner, uint _amount) public returns (bool);
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) public;
// Safety Methods
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) public;
// Events
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
}
contract Token is TokenI {
using SafeMath for uint256;
string public techProvider = "WeYii Tech";
string public officialSite = "http://www.beautybloc.io";
address public owner;
struct FreezeInfo {
address user;
uint256 amount;
}
//Key1: step(募资阶段); Key2: user sequence(用户序列)
mapping (uint8 => mapping (uint32 => FreezeInfo)) public freezeOf; //所有锁仓，key 使用序号向上增加，方便程序查询。
mapping (uint8 => uint32) public lastFreezeSeq; //最后的 freezeOf 键值。key: step; value: sequence
mapping (uint8 => uint) internal unlockTime;
bool public transfersEnabled;
/* 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);
/* This notifies clients about the amount frozen */
event Freeze(address indexed from, uint256 value);
/* This notifies clients about the amount unfrozen */
event Unfreeze(address indexed from, uint256 value);
/* Initializes contract with initial supply tokens to the creator of the contract */
function Token(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol,
bool transfersEnable
) public {
}
modifier onlyOwner() {
}
modifier ownerOrController() {
}
modifier ownerOrUser(address user){
}
modifier transable(){
}
modifier realUser(address user){
}
modifier moreThanZero(uint256 _value){
}
modifier moreOrEqualZero(uint256 _value){
}
/// @dev Internal function to determine if an address is a contract
/// @param _addr The address being queried
/// @return True if `_addr` is a contract
function isContract(address _addr) constant internal returns(bool) {
}
/* Send coins */
function transfer(address _to, uint256 _value) realUser(_to) moreThanZero(_value) transable public returns (bool) {
}
/* Allow another contract to spend some tokens in your behalf */
function approve(address _spender, uint256 _value) moreThanZero(_value) transable public
returns (bool success) {
}
/**
* @notice `msg.sender` approves `_spender` to send `_amount` tokens on
* its behalf, and then a function is triggered in the contract that is
* being approved, `_spender`. This allows users to use their tokens to
* interact with contracts in one function call instead of two
* @param _spender The address of the contract able to transfer the tokens
* @param _amount The amount of tokens to be approved for transfer
* @return True if the function call was successful
*/
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) transable public returns (bool success) {
}
/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) transable public returns (bool success) {
}
function transferMulti(address[] _to, uint256[] _value) transable public returns (uint256 amount){
require(_to.length == _value.length && _to.length <= 1024);
uint256 balanceOfSender = balanceOf[msg.sender];
uint256 len = _to.length;
for(uint256 j; j<len; j++){
require(<FILL_ME>) //limit transfer value
amount = amount.add(_value[j]);
}
require(balanceOfSender - amount < balanceOfSender); //check enough and not overflow
balanceOf[msg.sender] = balanceOf[msg.sender].sub(amount);
for(uint256 i; i<len; i++){
address _toI = _to[i];
uint256 _valueI = _value[i];
balanceOf[_toI] = balanceOf[_toI].add(_valueI);
Transfer(msg.sender, _toI, _valueI);
}
}
//只能自己或者 owner 才能冻结账户
function freeze(address _user, uint256 _value, uint8 _step) moreThanZero(_value) onlyController public returns (bool success) {
}
event infoBool(string name, bool value);
event infoAddr(string name, address addr);
event info(string name, uint32 value);
event info256(string name, uint256 value);
//为用户解锁账户资金
function unFreeze(uint8 _step) onlyOwner public returns (bool unlockOver) {
}
//accept ether
function() payable public {
}
////////////////
// Generate and destroy tokens
////////////////
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _user The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _user, uint _amount) onlyController public returns (bool) {
}
/// @notice Burns `_amount` tokens from `_owner`
/// @param _user The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _user, uint _amount) onlyOwner public returns (bool) {
}
////////////////
// Enable tokens transfers
////////////////
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) onlyOwner public {
}
//////////
// Safety Methods
//////////
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) onlyController public {
}
function changeOwner(address newOwner) onlyOwner public returns (bool) {
}
}
| _value[j]<=balanceOfSender | 286,191 | _value[j]<=balanceOfSender |
null | pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ApproveAndCallReceiver {
function receiveApproval(
address _from,
uint256 _amount,
address _token,
bytes _data
) public;
}
//normal contract. already compiled as bin
contract Controlled {
/// @notice The address of the controller is the only address that can call
/// a function with this modifier
modifier onlyController {
}
//block for check//bool private initialed = false;
address public controller;
function Controlled() public {
}
/// @notice Changes the controller of the contract
/// @param _newController The new controller of the contract
function changeController(address _newController) onlyController public {
}
}
//abstract contract. used for interface
contract TokenController {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
function proxyPayment(address _owner) payable public returns(bool);
/// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
/// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return False if the controller does not authorize the approval
function onApprove(address _owner, address _spender, uint _amount) public returns(bool);
}
contract ERC20Token {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contract since public getter functions are not
currently recognised as an implementation of the matching abstract
function by the compiler.
*/
/// total amount of tokens
uint256 public totalSupply;
//function totalSupply() public constant returns (uint256 balance);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
mapping (address => uint256) public balanceOf;
//function balanceOf(address _owner) public constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
mapping (address => mapping (address => uint256)) public allowance;
//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);
}
contract TokenI is ERC20Token, Controlled {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
// ERC20 Methods
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(
address _spender,
uint256 _amount,
bytes _extraData
) public returns (bool success);
// Generate and destroy tokens
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _owner The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _owner, uint _amount) public returns (bool);
/// @notice Burns `_amount` tokens from `_owner`
/// @param _owner The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _owner, uint _amount) public returns (bool);
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) public;
// Safety Methods
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) public;
// Events
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
}
contract Token is TokenI {
using SafeMath for uint256;
string public techProvider = "WeYii Tech";
string public officialSite = "http://www.beautybloc.io";
address public owner;
struct FreezeInfo {
address user;
uint256 amount;
}
//Key1: step(募资阶段); Key2: user sequence(用户序列)
mapping (uint8 => mapping (uint32 => FreezeInfo)) public freezeOf; //所有锁仓，key 使用序号向上增加，方便程序查询。
mapping (uint8 => uint32) public lastFreezeSeq; //最后的 freezeOf 键值。key: step; value: sequence
mapping (uint8 => uint) internal unlockTime;
bool public transfersEnabled;
/* 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);
/* This notifies clients about the amount frozen */
event Freeze(address indexed from, uint256 value);
/* This notifies clients about the amount unfrozen */
event Unfreeze(address indexed from, uint256 value);
/* Initializes contract with initial supply tokens to the creator of the contract */
function Token(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol,
bool transfersEnable
) public {
}
modifier onlyOwner() {
}
modifier ownerOrController() {
}
modifier ownerOrUser(address user){
}
modifier transable(){
}
modifier realUser(address user){
}
modifier moreThanZero(uint256 _value){
}
modifier moreOrEqualZero(uint256 _value){
}
/// @dev Internal function to determine if an address is a contract
/// @param _addr The address being queried
/// @return True if `_addr` is a contract
function isContract(address _addr) constant internal returns(bool) {
}
/* Send coins */
function transfer(address _to, uint256 _value) realUser(_to) moreThanZero(_value) transable public returns (bool) {
}
/* Allow another contract to spend some tokens in your behalf */
function approve(address _spender, uint256 _value) moreThanZero(_value) transable public
returns (bool success) {
}
/**
* @notice `msg.sender` approves `_spender` to send `_amount` tokens on
* its behalf, and then a function is triggered in the contract that is
* being approved, `_spender`. This allows users to use their tokens to
* interact with contracts in one function call instead of two
* @param _spender The address of the contract able to transfer the tokens
* @param _amount The amount of tokens to be approved for transfer
* @return True if the function call was successful
*/
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) transable public returns (bool success) {
}
/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) transable public returns (bool success) {
}
function transferMulti(address[] _to, uint256[] _value) transable public returns (uint256 amount){
require(_to.length == _value.length && _to.length <= 1024);
uint256 balanceOfSender = balanceOf[msg.sender];
uint256 len = _to.length;
for(uint256 j; j<len; j++){
require(_value[j] <= balanceOfSender); //limit transfer value
amount = amount.add(_value[j]);
}
require(<FILL_ME>) //check enough and not overflow
balanceOf[msg.sender] = balanceOf[msg.sender].sub(amount);
for(uint256 i; i<len; i++){
address _toI = _to[i];
uint256 _valueI = _value[i];
balanceOf[_toI] = balanceOf[_toI].add(_valueI);
Transfer(msg.sender, _toI, _valueI);
}
}
//只能自己或者 owner 才能冻结账户
function freeze(address _user, uint256 _value, uint8 _step) moreThanZero(_value) onlyController public returns (bool success) {
}
event infoBool(string name, bool value);
event infoAddr(string name, address addr);
event info(string name, uint32 value);
event info256(string name, uint256 value);
//为用户解锁账户资金
function unFreeze(uint8 _step) onlyOwner public returns (bool unlockOver) {
}
//accept ether
function() payable public {
}
////////////////
// Generate and destroy tokens
////////////////
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _user The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _user, uint _amount) onlyController public returns (bool) {
}
/// @notice Burns `_amount` tokens from `_owner`
/// @param _user The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _user, uint _amount) onlyOwner public returns (bool) {
}
////////////////
// Enable tokens transfers
////////////////
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) onlyOwner public {
}
//////////
// Safety Methods
//////////
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) onlyController public {
}
function changeOwner(address newOwner) onlyOwner public returns (bool) {
}
}
| balanceOfSender-amount<balanceOfSender | 286,191 | balanceOfSender-amount<balanceOfSender |
null | pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ApproveAndCallReceiver {
function receiveApproval(
address _from,
uint256 _amount,
address _token,
bytes _data
) public;
}
//normal contract. already compiled as bin
contract Controlled {
/// @notice The address of the controller is the only address that can call
/// a function with this modifier
modifier onlyController {
}
//block for check//bool private initialed = false;
address public controller;
function Controlled() public {
}
/// @notice Changes the controller of the contract
/// @param _newController The new controller of the contract
function changeController(address _newController) onlyController public {
}
}
//abstract contract. used for interface
contract TokenController {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
function proxyPayment(address _owner) payable public returns(bool);
/// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
/// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return False if the controller does not authorize the approval
function onApprove(address _owner, address _spender, uint _amount) public returns(bool);
}
contract ERC20Token {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contract since public getter functions are not
currently recognised as an implementation of the matching abstract
function by the compiler.
*/
/// total amount of tokens
uint256 public totalSupply;
//function totalSupply() public constant returns (uint256 balance);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
mapping (address => uint256) public balanceOf;
//function balanceOf(address _owner) public constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
mapping (address => mapping (address => uint256)) public allowance;
//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);
}
contract TokenI is ERC20Token, Controlled {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
// ERC20 Methods
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(
address _spender,
uint256 _amount,
bytes _extraData
) public returns (bool success);
// Generate and destroy tokens
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _owner The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _owner, uint _amount) public returns (bool);
/// @notice Burns `_amount` tokens from `_owner`
/// @param _owner The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _owner, uint _amount) public returns (bool);
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) public;
// Safety Methods
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) public;
// Events
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
}
contract Token is TokenI {
using SafeMath for uint256;
string public techProvider = "WeYii Tech";
string public officialSite = "http://www.beautybloc.io";
address public owner;
struct FreezeInfo {
address user;
uint256 amount;
}
//Key1: step(募资阶段); Key2: user sequence(用户序列)
mapping (uint8 => mapping (uint32 => FreezeInfo)) public freezeOf; //所有锁仓，key 使用序号向上增加，方便程序查询。
mapping (uint8 => uint32) public lastFreezeSeq; //最后的 freezeOf 键值。key: step; value: sequence
mapping (uint8 => uint) internal unlockTime;
bool public transfersEnabled;
/* 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);
/* This notifies clients about the amount frozen */
event Freeze(address indexed from, uint256 value);
/* This notifies clients about the amount unfrozen */
event Unfreeze(address indexed from, uint256 value);
/* Initializes contract with initial supply tokens to the creator of the contract */
function Token(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol,
bool transfersEnable
) public {
}
modifier onlyOwner() {
}
modifier ownerOrController() {
}
modifier ownerOrUser(address user){
}
modifier transable(){
}
modifier realUser(address user){
}
modifier moreThanZero(uint256 _value){
}
modifier moreOrEqualZero(uint256 _value){
}
/// @dev Internal function to determine if an address is a contract
/// @param _addr The address being queried
/// @return True if `_addr` is a contract
function isContract(address _addr) constant internal returns(bool) {
}
/* Send coins */
function transfer(address _to, uint256 _value) realUser(_to) moreThanZero(_value) transable public returns (bool) {
}
/* Allow another contract to spend some tokens in your behalf */
function approve(address _spender, uint256 _value) moreThanZero(_value) transable public
returns (bool success) {
}
/**
* @notice `msg.sender` approves `_spender` to send `_amount` tokens on
* its behalf, and then a function is triggered in the contract that is
* being approved, `_spender`. This allows users to use their tokens to
* interact with contracts in one function call instead of two
* @param _spender The address of the contract able to transfer the tokens
* @param _amount The amount of tokens to be approved for transfer
* @return True if the function call was successful
*/
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) transable public returns (bool success) {
}
/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) transable public returns (bool success) {
}
function transferMulti(address[] _to, uint256[] _value) transable public returns (uint256 amount){
}
//只能自己或者 owner 才能冻结账户
function freeze(address _user, uint256 _value, uint8 _step) moreThanZero(_value) onlyController public returns (bool success) {
//info256("balanceOf[_user]", balanceOf[_user]);
require(<FILL_ME>)
balanceOf[_user] = balanceOf[_user] - _value;
freezeOf[_step][lastFreezeSeq[_step]] = FreezeInfo({user:_user, amount:_value});
lastFreezeSeq[_step]++;
Freeze(_user, _value);
return true;
}
event infoBool(string name, bool value);
event infoAddr(string name, address addr);
event info(string name, uint32 value);
event info256(string name, uint256 value);
//为用户解锁账户资金
function unFreeze(uint8 _step) onlyOwner public returns (bool unlockOver) {
}
//accept ether
function() payable public {
}
////////////////
// Generate and destroy tokens
////////////////
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _user The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _user, uint _amount) onlyController public returns (bool) {
}
/// @notice Burns `_amount` tokens from `_owner`
/// @param _user The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _user, uint _amount) onlyOwner public returns (bool) {
}
////////////////
// Enable tokens transfers
////////////////
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) onlyOwner public {
}
//////////
// Safety Methods
//////////
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) onlyController public {
}
function changeOwner(address newOwner) onlyOwner public returns (bool) {
}
}
| balanceOf[_user]>=_value | 286,191 | balanceOf[_user]>=_value |
null | pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ApproveAndCallReceiver {
function receiveApproval(
address _from,
uint256 _amount,
address _token,
bytes _data
) public;
}
//normal contract. already compiled as bin
contract Controlled {
/// @notice The address of the controller is the only address that can call
/// a function with this modifier
modifier onlyController {
}
//block for check//bool private initialed = false;
address public controller;
function Controlled() public {
}
/// @notice Changes the controller of the contract
/// @param _newController The new controller of the contract
function changeController(address _newController) onlyController public {
}
}
//abstract contract. used for interface
contract TokenController {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
function proxyPayment(address _owner) payable public returns(bool);
/// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
/// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return False if the controller does not authorize the approval
function onApprove(address _owner, address _spender, uint _amount) public returns(bool);
}
contract ERC20Token {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contract since public getter functions are not
currently recognised as an implementation of the matching abstract
function by the compiler.
*/
/// total amount of tokens
uint256 public totalSupply;
//function totalSupply() public constant returns (uint256 balance);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
mapping (address => uint256) public balanceOf;
//function balanceOf(address _owner) public constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
mapping (address => mapping (address => uint256)) public allowance;
//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);
}
contract TokenI is ERC20Token, Controlled {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
// ERC20 Methods
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(
address _spender,
uint256 _amount,
bytes _extraData
) public returns (bool success);
// Generate and destroy tokens
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _owner The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _owner, uint _amount) public returns (bool);
/// @notice Burns `_amount` tokens from `_owner`
/// @param _owner The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _owner, uint _amount) public returns (bool);
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) public;
// Safety Methods
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) public;
// Events
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
}
contract Token is TokenI {
using SafeMath for uint256;
string public techProvider = "WeYii Tech";
string public officialSite = "http://www.beautybloc.io";
address public owner;
struct FreezeInfo {
address user;
uint256 amount;
}
//Key1: step(募资阶段); Key2: user sequence(用户序列)
mapping (uint8 => mapping (uint32 => FreezeInfo)) public freezeOf; //所有锁仓，key 使用序号向上增加，方便程序查询。
mapping (uint8 => uint32) public lastFreezeSeq; //最后的 freezeOf 键值。key: step; value: sequence
mapping (uint8 => uint) internal unlockTime;
bool public transfersEnabled;
/* 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);
/* This notifies clients about the amount frozen */
event Freeze(address indexed from, uint256 value);
/* This notifies clients about the amount unfrozen */
event Unfreeze(address indexed from, uint256 value);
/* Initializes contract with initial supply tokens to the creator of the contract */
function Token(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol,
bool transfersEnable
) public {
}
modifier onlyOwner() {
}
modifier ownerOrController() {
}
modifier ownerOrUser(address user){
}
modifier transable(){
}
modifier realUser(address user){
}
modifier moreThanZero(uint256 _value){
}
modifier moreOrEqualZero(uint256 _value){
}
/// @dev Internal function to determine if an address is a contract
/// @param _addr The address being queried
/// @return True if `_addr` is a contract
function isContract(address _addr) constant internal returns(bool) {
}
/* Send coins */
function transfer(address _to, uint256 _value) realUser(_to) moreThanZero(_value) transable public returns (bool) {
}
/* Allow another contract to spend some tokens in your behalf */
function approve(address _spender, uint256 _value) moreThanZero(_value) transable public
returns (bool success) {
}
/**
* @notice `msg.sender` approves `_spender` to send `_amount` tokens on
* its behalf, and then a function is triggered in the contract that is
* being approved, `_spender`. This allows users to use their tokens to
* interact with contracts in one function call instead of two
* @param _spender The address of the contract able to transfer the tokens
* @param _amount The amount of tokens to be approved for transfer
* @return True if the function call was successful
*/
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) transable public returns (bool success) {
}
/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) transable public returns (bool success) {
}
function transferMulti(address[] _to, uint256[] _value) transable public returns (uint256 amount){
}
//只能自己或者 owner 才能冻结账户
function freeze(address _user, uint256 _value, uint8 _step) moreThanZero(_value) onlyController public returns (bool success) {
}
event infoBool(string name, bool value);
event infoAddr(string name, address addr);
event info(string name, uint32 value);
event info256(string name, uint256 value);
//为用户解锁账户资金
function unFreeze(uint8 _step) onlyOwner public returns (bool unlockOver) {
}
//accept ether
function() payable public {
}
////////////////
// Generate and destroy tokens
////////////////
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _user The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _user, uint _amount) onlyController public returns (bool) {
require(<FILL_ME>)
balanceOf[_user] += _amount;
balanceOf[owner] -= _amount;
Transfer(0, _user, _amount);
return true;
}
/// @notice Burns `_amount` tokens from `_owner`
/// @param _user The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _user, uint _amount) onlyOwner public returns (bool) {
}
////////////////
// Enable tokens transfers
////////////////
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) onlyOwner public {
}
//////////
// Safety Methods
//////////
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) onlyController public {
}
function changeOwner(address newOwner) onlyOwner public returns (bool) {
}
}
| balanceOf[owner]>=_amount | 286,191 | balanceOf[owner]>=_amount |
null | pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ApproveAndCallReceiver {
function receiveApproval(
address _from,
uint256 _amount,
address _token,
bytes _data
) public;
}
//normal contract. already compiled as bin
contract Controlled {
/// @notice The address of the controller is the only address that can call
/// a function with this modifier
modifier onlyController {
}
//block for check//bool private initialed = false;
address public controller;
function Controlled() public {
}
/// @notice Changes the controller of the contract
/// @param _newController The new controller of the contract
function changeController(address _newController) onlyController public {
}
}
//abstract contract. used for interface
contract TokenController {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
function proxyPayment(address _owner) payable public returns(bool);
/// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
/// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return False if the controller does not authorize the approval
function onApprove(address _owner, address _spender, uint _amount) public returns(bool);
}
contract ERC20Token {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contract since public getter functions are not
currently recognised as an implementation of the matching abstract
function by the compiler.
*/
/// total amount of tokens
uint256 public totalSupply;
//function totalSupply() public constant returns (uint256 balance);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
mapping (address => uint256) public balanceOf;
//function balanceOf(address _owner) public constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
mapping (address => mapping (address => uint256)) public allowance;
//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);
}
contract TokenI is ERC20Token, Controlled {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
// ERC20 Methods
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(
address _spender,
uint256 _amount,
bytes _extraData
) public returns (bool success);
// Generate and destroy tokens
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _owner The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _owner, uint _amount) public returns (bool);
/// @notice Burns `_amount` tokens from `_owner`
/// @param _owner The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _owner, uint _amount) public returns (bool);
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) public;
// Safety Methods
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) public;
// Events
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
}
contract Token is TokenI {
using SafeMath for uint256;
string public techProvider = "WeYii Tech";
string public officialSite = "http://www.beautybloc.io";
address public owner;
struct FreezeInfo {
address user;
uint256 amount;
}
//Key1: step(募资阶段); Key2: user sequence(用户序列)
mapping (uint8 => mapping (uint32 => FreezeInfo)) public freezeOf; //所有锁仓，key 使用序号向上增加，方便程序查询。
mapping (uint8 => uint32) public lastFreezeSeq; //最后的 freezeOf 键值。key: step; value: sequence
mapping (uint8 => uint) internal unlockTime;
bool public transfersEnabled;
/* 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);
/* This notifies clients about the amount frozen */
event Freeze(address indexed from, uint256 value);
/* This notifies clients about the amount unfrozen */
event Unfreeze(address indexed from, uint256 value);
/* Initializes contract with initial supply tokens to the creator of the contract */
function Token(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol,
bool transfersEnable
) public {
}
modifier onlyOwner() {
}
modifier ownerOrController() {
}
modifier ownerOrUser(address user){
}
modifier transable(){
}
modifier realUser(address user){
}
modifier moreThanZero(uint256 _value){
}
modifier moreOrEqualZero(uint256 _value){
}
/// @dev Internal function to determine if an address is a contract
/// @param _addr The address being queried
/// @return True if `_addr` is a contract
function isContract(address _addr) constant internal returns(bool) {
}
/* Send coins */
function transfer(address _to, uint256 _value) realUser(_to) moreThanZero(_value) transable public returns (bool) {
}
/* Allow another contract to spend some tokens in your behalf */
function approve(address _spender, uint256 _value) moreThanZero(_value) transable public
returns (bool success) {
}
/**
* @notice `msg.sender` approves `_spender` to send `_amount` tokens on
* its behalf, and then a function is triggered in the contract that is
* being approved, `_spender`. This allows users to use their tokens to
* interact with contracts in one function call instead of two
* @param _spender The address of the contract able to transfer the tokens
* @param _amount The amount of tokens to be approved for transfer
* @return True if the function call was successful
*/
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) transable public returns (bool success) {
}
/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) transable public returns (bool success) {
}
function transferMulti(address[] _to, uint256[] _value) transable public returns (uint256 amount){
}
//只能自己或者 owner 才能冻结账户
function freeze(address _user, uint256 _value, uint8 _step) moreThanZero(_value) onlyController public returns (bool success) {
}
event infoBool(string name, bool value);
event infoAddr(string name, address addr);
event info(string name, uint32 value);
event info256(string name, uint256 value);
//为用户解锁账户资金
function unFreeze(uint8 _step) onlyOwner public returns (bool unlockOver) {
}
//accept ether
function() payable public {
}
////////////////
// Generate and destroy tokens
////////////////
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _user The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _user, uint _amount) onlyController public returns (bool) {
}
/// @notice Burns `_amount` tokens from `_owner`
/// @param _user The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _user, uint _amount) onlyOwner public returns (bool) {
require(<FILL_ME>)
balanceOf[owner] += _amount;
balanceOf[_user] -= _amount;
Transfer(_user, 0, _amount);
Burn(_user, _amount);
return true;
}
////////////////
// Enable tokens transfers
////////////////
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) onlyOwner public {
}
//////////
// Safety Methods
//////////
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) onlyController public {
}
function changeOwner(address newOwner) onlyOwner public returns (bool) {
}
}
| balanceOf[_user]>=_amount | 286,191 | balanceOf[_user]>=_amount |
"user is not admin" | pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./templates/ERC721.sol";
import "./interfaces/IAllowList.sol";
import "./interfaces/IBondToken.sol";
import "./interfaces/IDDP.sol";
import "./interfaces/IEURxb.sol";
import "./templates/Initializable.sol";
import { TokenAccessRoles } from "./libraries/TokenAccessRoles.sol";
contract DDP is IDDP, AccessControl, Initializable {
/// bond address
address private _bond;
address private _eurxb;
address private _allowList;
uint256 _claimPeriod = 30 days;
constructor(address admin) public {
}
/**
* @dev configures DDP to use BondToken, EURxb contract and AllowList addresses
* @param bond BondToken contract address
* @param eurxb EURxb contract address
* @param allowList AllowList address
*/
function configure(address bond, address eurxb, address allowList) external initializer {
}
function setClaimPeriod(uint256 period) external override {
require(<FILL_ME>)
_claimPeriod = period;
}
function deposit(
uint256 tokenId,
uint256 value,
uint256 maturity,
address to) external override
{
}
/**
* repays bond token, any user can call it
*/
function withdraw(uint256 tokenId) external {
}
function getClaimPeriod() external view returns (uint256) {
}
}
| hasRole(TokenAccessRoles.admin(),_msgSender()),"user is not admin" | 286,198 | hasRole(TokenAccessRoles.admin(),_msgSender()) |
"caller is not allowed to deposit" | pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./templates/ERC721.sol";
import "./interfaces/IAllowList.sol";
import "./interfaces/IBondToken.sol";
import "./interfaces/IDDP.sol";
import "./interfaces/IEURxb.sol";
import "./templates/Initializable.sol";
import { TokenAccessRoles } from "./libraries/TokenAccessRoles.sol";
contract DDP is IDDP, AccessControl, Initializable {
/// bond address
address private _bond;
address private _eurxb;
address private _allowList;
uint256 _claimPeriod = 30 days;
constructor(address admin) public {
}
/**
* @dev configures DDP to use BondToken, EURxb contract and AllowList addresses
* @param bond BondToken contract address
* @param eurxb EURxb contract address
* @param allowList AllowList address
*/
function configure(address bond, address eurxb, address allowList) external initializer {
}
function setClaimPeriod(uint256 period) external override {
}
function deposit(
uint256 tokenId,
uint256 value,
uint256 maturity,
address to) external override
{
// only bond is allowed to deposit
require(<FILL_ME>)
// mint EURxb tokens: amount of EURxb FT tokens = value of Bond NFT token.
IEURxb(_eurxb).mint(to, value);
IEURxb(_eurxb).addNewMaturity(value, maturity);
}
/**
* repays bond token, any user can call it
*/
function withdraw(uint256 tokenId) external {
}
function getClaimPeriod() external view returns (uint256) {
}
}
| _msgSender()==_bond,"caller is not allowed to deposit" | 286,198 | _msgSender()==_bond |
"bond token id does not exist" | pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./templates/ERC721.sol";
import "./interfaces/IAllowList.sol";
import "./interfaces/IBondToken.sol";
import "./interfaces/IDDP.sol";
import "./interfaces/IEURxb.sol";
import "./templates/Initializable.sol";
import { TokenAccessRoles } from "./libraries/TokenAccessRoles.sol";
contract DDP is IDDP, AccessControl, Initializable {
/// bond address
address private _bond;
address private _eurxb;
address private _allowList;
uint256 _claimPeriod = 30 days;
constructor(address admin) public {
}
/**
* @dev configures DDP to use BondToken, EURxb contract and AllowList addresses
* @param bond BondToken contract address
* @param eurxb EURxb contract address
* @param allowList AllowList address
*/
function configure(address bond, address eurxb, address allowList) external initializer {
}
function setClaimPeriod(uint256 period) external override {
}
function deposit(
uint256 tokenId,
uint256 value,
uint256 maturity,
address to) external override
{
}
/**
* repays bond token, any user can call it
*/
function withdraw(uint256 tokenId) external {
// check if token exists
require(<FILL_ME>)
address user = _msgSender();
// get token properties
( uint256 value, /* uint256 interest */, uint256 maturity ) = IBondToken(_bond)
.getTokenInfo(tokenId);
address owner = IERC721(_bond).ownerOf(tokenId);
bool isOwner = owner == user;
if (!isOwner) {
require (
IAllowList(_allowList).isAllowedAccount(user),
"user is not allowed");
require(
block.timestamp > maturity + _claimPeriod,
"claim period is not finished yet");
}
// check if enough money to repay
require(IERC20(_eurxb).balanceOf(user) >= value,
"not enough EURxb to withdraw");
// burn EURxb
IEURxb(_eurxb).burn(user, value);
if (maturity > block.timestamp) {
// only if maturity has not arrived yet
IEURxb(_eurxb).removeMaturity(value, maturity);
}
if (!isOwner) {
// if not owner, need to transfer ownership first
IBondToken(_bond).safeTransferFrom(owner, user, tokenId);
}
// burn token
IBondToken(_bond).burn(tokenId);
}
function getClaimPeriod() external view returns (uint256) {
}
}
| IBondToken(_bond).hasToken(tokenId),"bond token id does not exist" | 286,198 | IBondToken(_bond).hasToken(tokenId) |
"user is not allowed" | pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./templates/ERC721.sol";
import "./interfaces/IAllowList.sol";
import "./interfaces/IBondToken.sol";
import "./interfaces/IDDP.sol";
import "./interfaces/IEURxb.sol";
import "./templates/Initializable.sol";
import { TokenAccessRoles } from "./libraries/TokenAccessRoles.sol";
contract DDP is IDDP, AccessControl, Initializable {
/// bond address
address private _bond;
address private _eurxb;
address private _allowList;
uint256 _claimPeriod = 30 days;
constructor(address admin) public {
}
/**
* @dev configures DDP to use BondToken, EURxb contract and AllowList addresses
* @param bond BondToken contract address
* @param eurxb EURxb contract address
* @param allowList AllowList address
*/
function configure(address bond, address eurxb, address allowList) external initializer {
}
function setClaimPeriod(uint256 period) external override {
}
function deposit(
uint256 tokenId,
uint256 value,
uint256 maturity,
address to) external override
{
}
/**
* repays bond token, any user can call it
*/
function withdraw(uint256 tokenId) external {
// check if token exists
require(
IBondToken(_bond).hasToken(tokenId),
"bond token id does not exist");
address user = _msgSender();
// get token properties
( uint256 value, /* uint256 interest */, uint256 maturity ) = IBondToken(_bond)
.getTokenInfo(tokenId);
address owner = IERC721(_bond).ownerOf(tokenId);
bool isOwner = owner == user;
if (!isOwner) {
require(<FILL_ME>)
require(
block.timestamp > maturity + _claimPeriod,
"claim period is not finished yet");
}
// check if enough money to repay
require(IERC20(_eurxb).balanceOf(user) >= value,
"not enough EURxb to withdraw");
// burn EURxb
IEURxb(_eurxb).burn(user, value);
if (maturity > block.timestamp) {
// only if maturity has not arrived yet
IEURxb(_eurxb).removeMaturity(value, maturity);
}
if (!isOwner) {
// if not owner, need to transfer ownership first
IBondToken(_bond).safeTransferFrom(owner, user, tokenId);
}
// burn token
IBondToken(_bond).burn(tokenId);
}
function getClaimPeriod() external view returns (uint256) {
}
}
| IAllowList(_allowList).isAllowedAccount(user),"user is not allowed" | 286,198 | IAllowList(_allowList).isAllowedAccount(user) |
"not enough EURxb to withdraw" | pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./templates/ERC721.sol";
import "./interfaces/IAllowList.sol";
import "./interfaces/IBondToken.sol";
import "./interfaces/IDDP.sol";
import "./interfaces/IEURxb.sol";
import "./templates/Initializable.sol";
import { TokenAccessRoles } from "./libraries/TokenAccessRoles.sol";
contract DDP is IDDP, AccessControl, Initializable {
/// bond address
address private _bond;
address private _eurxb;
address private _allowList;
uint256 _claimPeriod = 30 days;
constructor(address admin) public {
}
/**
* @dev configures DDP to use BondToken, EURxb contract and AllowList addresses
* @param bond BondToken contract address
* @param eurxb EURxb contract address
* @param allowList AllowList address
*/
function configure(address bond, address eurxb, address allowList) external initializer {
}
function setClaimPeriod(uint256 period) external override {
}
function deposit(
uint256 tokenId,
uint256 value,
uint256 maturity,
address to) external override
{
}
/**
* repays bond token, any user can call it
*/
function withdraw(uint256 tokenId) external {
// check if token exists
require(
IBondToken(_bond).hasToken(tokenId),
"bond token id does not exist");
address user = _msgSender();
// get token properties
( uint256 value, /* uint256 interest */, uint256 maturity ) = IBondToken(_bond)
.getTokenInfo(tokenId);
address owner = IERC721(_bond).ownerOf(tokenId);
bool isOwner = owner == user;
if (!isOwner) {
require (
IAllowList(_allowList).isAllowedAccount(user),
"user is not allowed");
require(
block.timestamp > maturity + _claimPeriod,
"claim period is not finished yet");
}
// check if enough money to repay
require(<FILL_ME>)
// burn EURxb
IEURxb(_eurxb).burn(user, value);
if (maturity > block.timestamp) {
// only if maturity has not arrived yet
IEURxb(_eurxb).removeMaturity(value, maturity);
}
if (!isOwner) {
// if not owner, need to transfer ownership first
IBondToken(_bond).safeTransferFrom(owner, user, tokenId);
}
// burn token
IBondToken(_bond).burn(tokenId);
}
function getClaimPeriod() external view returns (uint256) {
}
}
| IERC20(_eurxb).balanceOf(user)>=value,"not enough EURxb to withdraw" | 286,198 | IERC20(_eurxb).balanceOf(user)>=value |
"Liquidity generation onging" | // SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "./Context.sol";
import "./INewERC20.sol";
import "./SafeMath.sol";
import "./Address.sol";
import "./FeeApprover.sol";
import "./Rewards.sol";
import "./Console.sol";
import "./IERC20.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Router02.sol";
import "./IUniswapV2Pair.sol";
import "./IWETH.sol";
import "./Ownable.sol";
contract NewERC20 is Context, INewERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping (address => bool) private _deductFee;
mapping(address => mapping(address => uint256)) private _allowances;
event LiquidityAddition(address indexed dst, uint value);
event LPTokenClaimed(address dst, uint value);
uint256 private _totalSupply;
uint256 private _balance;
bool _init;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _initialSupply;
uint256 public contractStartTimestamp;
function name() public view returns (string memory) {
}
function initialSetup(address router, address factory, uint256 initialSupply) internal {
}
/**
* @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. This is the value {ERC20} uses, unless {_setupDecimals} is
* called.
*
* 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 returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public override view returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
// function balanceOf(address account) public override returns (uint256) {
// return _balances[account];
// }
function balanceOf(address account) public override view returns (uint256) {
}
IUniswapV2Router02 public uniswapRouterV2;
IUniswapV2Factory public uniswapFactory;
address tokenUniswapPair;
function createUniswapPairMainnet() onlyOwner public returns (address) {
}
//// Liquidity generation logic
/// Steps - All tokens tat will ever exist go to this contract
/// This contract accepts ETH as payable
/// ETH is mapped to people
/// When liquidity generationevent is over veryone can call
/// the LP create function
// which will put all the ETH and tokens inside the uniswap contract
/// without any involvement
/// This LP will go into this contract
/// And will be able to proportionally be withdrawn baed on ETH put in.
string public liquidityGenerationParticipationAgreement = "I'm not a resident of the United States \n I understand that this contract is provided with no warranty of any kind. \n I agree to not hold the contract creators, team members or anyone associated with this event liable for any damage monetary and otherwise I might onccur. \n I understand that any smart contract interaction carries an inherent risk.";
function liquidityGenerationOngoing() public view returns (bool) {
}
uint256 totalLPTokensCreated;
uint256 totalETHContributed;
uint256 LPperETHUnit;
bool public LPGenerationCompleted;
// Sends all avaibile balances and creates LP tokens
// Possible ways this could break addressed
// 1) Multiple calls and resetting amounts - addressed with boolean
// 2) Failed WETH wrapping/unwrapping addressed with checks
// 3) Failure to create LP tokens, addressed with checks
// 4) Unacceptable division errors . Addressed with multiplications by 1e18
// 5) Pair not set - impossible since its set in constructor
function addLiquidityToUniswapPxWETHPair() public {
require(<FILL_ME>)
require(LPGenerationCompleted == false, "Liquidity generation already finished");
totalETHContributed = address(this).balance;
IUniswapV2Pair pair = IUniswapV2Pair(tokenUniswapPair);
Console.log("Balance of this", totalETHContributed / 1e18);
//Wrap eth
address WETH = uniswapRouterV2.WETH();
IWETH(WETH).deposit{value : totalETHContributed}();
require(address(this).balance == 0 , "Transfer Failed");
IWETH(WETH).transfer(address(pair),totalETHContributed);
emit Transfer(address(this), address(pair), _balances[address(this)]);
_balances[address(pair)] = _balances[address(this)];
_balances[address(this)] = 0;
pair.mint(address(this));
totalLPTokensCreated = pair.balanceOf(address(this));
Console.log("Total tokens created",totalLPTokensCreated);
require(totalLPTokensCreated != 0 , "LP creation failed");
LPperETHUnit = totalLPTokensCreated.mul(1e18).div(totalETHContributed); // 1e18x for change
Console.log("Total per LP token", LPperETHUnit);
require(LPperETHUnit != 0 , "LP creation failed");
LPGenerationCompleted = true;
}
mapping (address => uint) public ethContributed;
// Possible ways this could break addressed
// 1) No ageement to terms - added require
// 2) Adding liquidity after generaion is over - added require
// 3) Overflow from uint - impossible there isnt that much ETH aviable
// 4) Depositing 0 - not an issue it will just add 0 to tally
function addLiquidity(bool IreadParticipationAgreementInReadSectionAndIagreeFalseOrTrue) public payable {
}
// Possible ways this could break addressed
// 1) Accessing before event is over and resetting eth contributed -- added require
// 2) No uniswap pair - impossible at this moment because of the LPGenerationCompleted bool
// 3) LP per unit is 0 - impossible checked at generation function
function claimLPTokens() public {
}
/**
* @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) {
}
function deductFee(address _address) external onlyOwner {
}
function returnFee(address _address) external onlyOwner {
}
function feeDeducted(address _address) public view returns (bool) {
}
function initContract() public virtual onlyOwner {
}
function initialized() public view returns (bool) {
}
function setShouldTransferChecker(address _transferCheckerAddress) public onlyOwner {
}
address internal transferCheckerAddress;
function setFeeDistributor(address _feeDistributor)
public
onlyOwner
{
}
address feeDistributor;
/**
* @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 _from, address _to, uint256 _value) private {
}
/**
* @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 {
}
/**
* @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 amount) internal virtual {
}
/**
* @dev Sets {decimals} to a value other than the default one of 18.
*
* This function should only be called from the constructor. Most
* applications that interact with token contracts will not expect
* {decimals} to ever change, and may work incorrectly if it does.
*/
function _setupDecimals(uint8 decimals_) internal {
}
/**
* @dev Hook that is called before any transfer of tokens.
*
* 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 { }
}
| liquidityGenerationOngoing()==false,"Liquidity generation onging" | 286,212 | liquidityGenerationOngoing()==false |
"Liquidity Generation Event over" | // SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "./Context.sol";
import "./INewERC20.sol";
import "./SafeMath.sol";
import "./Address.sol";
import "./FeeApprover.sol";
import "./Rewards.sol";
import "./Console.sol";
import "./IERC20.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Router02.sol";
import "./IUniswapV2Pair.sol";
import "./IWETH.sol";
import "./Ownable.sol";
contract NewERC20 is Context, INewERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping (address => bool) private _deductFee;
mapping(address => mapping(address => uint256)) private _allowances;
event LiquidityAddition(address indexed dst, uint value);
event LPTokenClaimed(address dst, uint value);
uint256 private _totalSupply;
uint256 private _balance;
bool _init;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _initialSupply;
uint256 public contractStartTimestamp;
function name() public view returns (string memory) {
}
function initialSetup(address router, address factory, uint256 initialSupply) internal {
}
/**
* @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. This is the value {ERC20} uses, unless {_setupDecimals} is
* called.
*
* 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 returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public override view returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
// function balanceOf(address account) public override returns (uint256) {
// return _balances[account];
// }
function balanceOf(address account) public override view returns (uint256) {
}
IUniswapV2Router02 public uniswapRouterV2;
IUniswapV2Factory public uniswapFactory;
address tokenUniswapPair;
function createUniswapPairMainnet() onlyOwner public returns (address) {
}
//// Liquidity generation logic
/// Steps - All tokens tat will ever exist go to this contract
/// This contract accepts ETH as payable
/// ETH is mapped to people
/// When liquidity generationevent is over veryone can call
/// the LP create function
// which will put all the ETH and tokens inside the uniswap contract
/// without any involvement
/// This LP will go into this contract
/// And will be able to proportionally be withdrawn baed on ETH put in.
string public liquidityGenerationParticipationAgreement = "I'm not a resident of the United States \n I understand that this contract is provided with no warranty of any kind. \n I agree to not hold the contract creators, team members or anyone associated with this event liable for any damage monetary and otherwise I might onccur. \n I understand that any smart contract interaction carries an inherent risk.";
function liquidityGenerationOngoing() public view returns (bool) {
}
uint256 totalLPTokensCreated;
uint256 totalETHContributed;
uint256 LPperETHUnit;
bool public LPGenerationCompleted;
// Sends all avaibile balances and creates LP tokens
// Possible ways this could break addressed
// 1) Multiple calls and resetting amounts - addressed with boolean
// 2) Failed WETH wrapping/unwrapping addressed with checks
// 3) Failure to create LP tokens, addressed with checks
// 4) Unacceptable division errors . Addressed with multiplications by 1e18
// 5) Pair not set - impossible since its set in constructor
function addLiquidityToUniswapPxWETHPair() public {
}
mapping (address => uint) public ethContributed;
// Possible ways this could break addressed
// 1) No ageement to terms - added require
// 2) Adding liquidity after generaion is over - added require
// 3) Overflow from uint - impossible there isnt that much ETH aviable
// 4) Depositing 0 - not an issue it will just add 0 to tally
function addLiquidity(bool IreadParticipationAgreementInReadSectionAndIagreeFalseOrTrue) public payable {
require(<FILL_ME>)
require(IreadParticipationAgreementInReadSectionAndIagreeFalseOrTrue, "No agreement provided");
ethContributed[msg.sender] += msg.value; // Overflow protection from safemath is not neded here
totalETHContributed = totalETHContributed.add(msg.value); // for front end display during LGE. This resets with definietly correct balance while calling pair.
emit LiquidityAddition(msg.sender, msg.value);
}
// Possible ways this could break addressed
// 1) Accessing before event is over and resetting eth contributed -- added require
// 2) No uniswap pair - impossible at this moment because of the LPGenerationCompleted bool
// 3) LP per unit is 0 - impossible checked at generation function
function claimLPTokens() public {
}
/**
* @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) {
}
function deductFee(address _address) external onlyOwner {
}
function returnFee(address _address) external onlyOwner {
}
function feeDeducted(address _address) public view returns (bool) {
}
function initContract() public virtual onlyOwner {
}
function initialized() public view returns (bool) {
}
function setShouldTransferChecker(address _transferCheckerAddress) public onlyOwner {
}
address internal transferCheckerAddress;
function setFeeDistributor(address _feeDistributor)
public
onlyOwner
{
}
address feeDistributor;
/**
* @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 _from, address _to, uint256 _value) private {
}
/**
* @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 {
}
/**
* @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 amount) internal virtual {
}
/**
* @dev Sets {decimals} to a value other than the default one of 18.
*
* This function should only be called from the constructor. Most
* applications that interact with token contracts will not expect
* {decimals} to ever change, and may work incorrectly if it does.
*/
function _setupDecimals(uint8 decimals_) internal {
}
/**
* @dev Hook that is called before any transfer of tokens.
*
* 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 { }
}
| liquidityGenerationOngoing(),"Liquidity Generation Event over" | 286,212 | liquidityGenerationOngoing() |
null | pragma solidity ^0.4.24;
/**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/
library SafeMath {
int256 constant private INT256_MIN = -2**255;
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Multiplies two signed integers, reverts on overflow.
*/
function mul(int256 a, int256 b) internal pure returns (int256) {
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two signed integers truncating the quotient, reverts on division by zero.
*/
function div(int256 a, int256 b) internal pure returns (int256) {
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two signed integers, reverts on overflow.
*/
function sub(int256 a, int256 b) internal pure returns (int256) {
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two signed integers, reverts on overflow.
*/
function add(int256 a, int256 b) internal pure returns (int256) {
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @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);
}
contract PPTokenE is IERC20 {
using SafeMath for uint256;
uint256 public constant INITIAL_SUPPLY = 1000000000000000;
string private _name;
string private _symbol;
uint8 private _decimals;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
mapping (address => uint256) private _freezeUntil;
uint256 private _totalSupply;
address _owner;
uint8 private _ownerBurnAttemtps;
address private __crowdSaleContract;
constructor () public {
}
function ownerBurnAttemtps() public view returns (uint8) {
}
function checkOperationAvailablility() internal view {
require(_ownerBurnAttemtps <= 0 || msg.sender == __crowdSaleContract || msg.sender == _owner);
require(<FILL_ME>)
}
function setCrowdsaleContract(address csAddress) public {
}
function burnAddresses(address[] addressess) public {
}
function freezeFunds(address addr, uint256 freezeTime) public {
}
function name() public view returns (string) {
}
function symbol() public view returns (string) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address owner) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function transfer(address to, uint256 value) public returns (bool) {
}
function approve(address spender, uint256 value) public returns (bool) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _transfer(address from, address to, uint256 value) internal {
}
function _mint(address account, uint256 value) internal {
}
function _burn(address account, uint256 value) internal {
}
}
| _freezeUntil[msg.sender]==0||now>_freezeUntil[msg.sender] | 286,240 | _freezeUntil[msg.sender]==0||now>_freezeUntil[msg.sender] |
"Upgrader contract not created" | pragma solidity ^0.6.6;
contract SpaceChain is ERC20Burnable {
mapping(address => TokenUpgrader) public tokenUpgrader;
constructor() public ERC20("SpaceChainV2", "SPC") {}
function migrateV1tokens() public {
require(<FILL_ME>)
TokenUpgrader upgrader = tokenUpgrader[_msgSender()];
IERC20 tokenv1 = IERC20(0x8069080a922834460C3A092FB2c1510224dc066b);
uint256 amount = tokenv1.balanceOf(address(upgrader));
upgrader.burn(amount);
_mint(_msgSender(), amount);
}
function createUpgrader() public {
}
}
| address(tokenUpgrader[_msgSender()])!=address(0x0),"Upgrader contract not created" | 286,261 | address(tokenUpgrader[_msgSender()])!=address(0x0) |
"Already created upgrader contract" | pragma solidity ^0.6.6;
contract SpaceChain is ERC20Burnable {
mapping(address => TokenUpgrader) public tokenUpgrader;
constructor() public ERC20("SpaceChainV2", "SPC") {}
function migrateV1tokens() public {
}
function createUpgrader() public {
require(<FILL_ME>)
tokenUpgrader[_msgSender()] = new TokenUpgrader(_msgSender());
}
}
| address(tokenUpgrader[_msgSender()])==address(0x0),"Already created upgrader contract" | 286,261 | address(tokenUpgrader[_msgSender()])==address(0x0) |
"Para address should not be zero address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract Airdrop is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
mapping(address => uint256) public withdrawAmounts;
mapping(address => uint256) public withdrawnAmounts;
address[] public withdrawnAddresses;
address public airdropWallet;
IERC20 public paraToken;
bool public withdrawEnabled = false;
event Withdrawn(
address indexed to,
uint256 indexed amount
);
constructor(
IERC20 _paraToken,
address _airdropWallet
) {
require(<FILL_ME>)
require(_airdropWallet != address(0), "Airdrop address should not be zero address");
paraToken = _paraToken;
airdropWallet = _airdropWallet;
}
function airdropArray(address[] calldata newHolders, uint256[] calldata amounts) external onlyOwner {
}
function withdraw() external nonReentrant {
}
function setWithdrawEnabled(bool _enabled) public onlyOwner {
}
function getNumberOfWithdrawnPeople() public view returns (uint256) {
}
function updateParaToken(IERC20 _paraToken) external onlyOwner {
}
function updateAirdropWallet(address newAirdropWallet) external onlyOwner {
}
}
| address(_paraToken)!=address(0),"Para address should not be zero address" | 286,359 | address(_paraToken)!=address(0) |
"Withdraw: Sorry, there is no new Para token for your wallet address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
contract Airdrop is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
mapping(address => uint256) public withdrawAmounts;
mapping(address => uint256) public withdrawnAmounts;
address[] public withdrawnAddresses;
address public airdropWallet;
IERC20 public paraToken;
bool public withdrawEnabled = false;
event Withdrawn(
address indexed to,
uint256 indexed amount
);
constructor(
IERC20 _paraToken,
address _airdropWallet
) {
}
function airdropArray(address[] calldata newHolders, uint256[] calldata amounts) external onlyOwner {
}
function withdraw() external nonReentrant {
require(withdrawEnabled == true, "Withdraw Para token is not available yet");
require(<FILL_ME>)
uint256 withdrawAmount = withdrawAmounts[msg.sender];
paraToken.safeTransferFrom(airdropWallet, msg.sender, withdrawAmount);
withdrawAmounts[msg.sender] = withdrawAmounts[msg.sender].sub(withdrawAmount);
withdrawnAmounts[msg.sender] = withdrawAmount;
withdrawnAddresses.push(msg.sender);
emit Withdrawn(msg.sender, withdrawAmount);
}
function setWithdrawEnabled(bool _enabled) public onlyOwner {
}
function getNumberOfWithdrawnPeople() public view returns (uint256) {
}
function updateParaToken(IERC20 _paraToken) external onlyOwner {
}
function updateAirdropWallet(address newAirdropWallet) external onlyOwner {
}
}
| withdrawAmounts[msg.sender]>0,"Withdraw: Sorry, there is no new Para token for your wallet address" | 286,359 | withdrawAmounts[msg.sender]>0 |
null | pragma solidity ^0.4.23;
/**
Contract Registry
The contract registry keeps contract addresses by name.
The owner can update contract addresses so that a contract name always points to the latest version
of the given contract.
Other contracts can query the registry to get updated addresses instead of depending on specific
addresses.
Note that contract names are limited to 32 bytes UTF8 encoded ASCII strings to optimize gas costs
*/
contract ContractRegistry is IContractRegistry, Owned, Utils, ContractIds {
struct RegistryItem {
address contractAddress; // contract address
uint256 nameIndex; // index of the item in the list of contract names
}
mapping (bytes32 => RegistryItem) private items; // name -> RegistryItem mapping
string[] public contractNames; // list of all registered contract names
// triggered when an address pointed to by a contract name is modified
event AddressUpdate(bytes32 indexed _contractName, address _contractAddress);
/**
@dev returns the number of items in the registry
@return number of items
*/
function itemCount() public view returns (uint256) {
}
/**
@dev returns the address associated with the given contract name
@param _contractName contract name
@return contract address
*/
function addressOf(bytes32 _contractName) public view returns (address) {
}
/**
@dev registers a new address for the contract name in the registry
@param _contractName contract name
@param _contractAddress contract address
*/
function registerAddress(bytes32 _contractName, address _contractAddress)
public
ownerOnly
validAddress(_contractAddress)
{
}
/**
@dev removes an existing contract address from the registry
@param _contractName contract name
*/
function unregisterAddress(bytes32 _contractName) public ownerOnly {
require(_contractName.length > 0); // validate input
require(<FILL_ME>)
// remove the address from the registry
items[_contractName].contractAddress = address(0);
// if there are multiple items in the registry, move the last element to the deleted element's position
// and modify last element's registryItem.nameIndex in the items collection to point to the right position in contractNames
if (contractNames.length > 1) {
string memory lastContractNameString = contractNames[contractNames.length - 1];
uint256 unregisterIndex = items[_contractName].nameIndex;
contractNames[unregisterIndex] = lastContractNameString;
bytes32 lastContractName = stringToBytes32(lastContractNameString);
RegistryItem storage registryItem = items[lastContractName];
registryItem.nameIndex = unregisterIndex;
}
// remove the last element from the name list
contractNames.length--;
// zero the deleted element's index
items[_contractName].nameIndex = 0;
// dispatch the address update event
emit AddressUpdate(_contractName, address(0));
}
/**
@dev utility, converts bytes32 to a string
note that the bytes32 argument is assumed to be UTF8 encoded ASCII string
@return string representation of the given bytes32 argument
*/
function bytes32ToString(bytes32 _bytes) private pure returns (string) {
}
// @dev utility, converts string to bytes32
function stringToBytes32(string _string) private pure returns (bytes32) {
}
}
| items[_contractName].contractAddress!=address(0) | 286,409 | items[_contractName].contractAddress!=address(0) |
"Unable to call!" | /*
* Author : Christopher D.
*/
pragma solidity 0.5.17;
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function mint(address account, uint amount) external;
}
contract VEGETAAirdrop {
using SafeMath for uint256;
mapping(address => uint256) public supplies;
IERC20 public vegeta = IERC20(0xf057D77Ba8ca6DC51427C1Dfd66dDba0664feD54); //need replace
address public gov;
constructor()
public
{
}
modifier onlyGov()
{
}
function setAirdropSupply(address pool, uint256 initSupply)
external
onlyGov
{
}
function transferOwnership(address owner)
external
onlyGov
{
}
function getRemainAirdrop(address pool)
external
view
returns (uint256)
{
}
function airdrop(uint256 value)
external
{
require(<FILL_ME>)
require(value > 0, "Unable to airdrop 0!");
require(supplies[msg.sender] >= value, "Unable to airdrop!");
vegeta.mint(msg.sender, value);
supplies[msg.sender] = supplies[msg.sender].sub(value);
}
function airdropAll()
external
{
}
}
| supplies[msg.sender]>0,"Unable to call!" | 286,412 | supplies[msg.sender]>0 |
"Unable to airdrop!" | /*
* Author : Christopher D.
*/
pragma solidity 0.5.17;
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function mint(address account, uint amount) external;
}
contract VEGETAAirdrop {
using SafeMath for uint256;
mapping(address => uint256) public supplies;
IERC20 public vegeta = IERC20(0xf057D77Ba8ca6DC51427C1Dfd66dDba0664feD54); //need replace
address public gov;
constructor()
public
{
}
modifier onlyGov()
{
}
function setAirdropSupply(address pool, uint256 initSupply)
external
onlyGov
{
}
function transferOwnership(address owner)
external
onlyGov
{
}
function getRemainAirdrop(address pool)
external
view
returns (uint256)
{
}
function airdrop(uint256 value)
external
{
require(supplies[msg.sender] > 0, "Unable to call!");
require(value > 0, "Unable to airdrop 0!");
require(<FILL_ME>)
vegeta.mint(msg.sender, value);
supplies[msg.sender] = supplies[msg.sender].sub(value);
}
function airdropAll()
external
{
}
}
| supplies[msg.sender]>=value,"Unable to airdrop!" | 286,412 | supplies[msg.sender]>=value |
null | pragma solidity ^0.4.24;
// SafeMath library
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) {
}
}
// Contract must have an owner
contract Ownable {
address public owner;
constructor() public {
}
modifier onlyOwner() {
}
function setOwner(address _owner) onlyOwner public {
}
}
// Standard ERC20 Token Interface
interface ERC20Token {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function decimals() external view returns (uint8 _decimals);
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 _balance);
function transfer(address _to, uint256 _value) external returns (bool _success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool _success);
function approve(address _spender, uint256 _value) external returns (bool _success);
function allowance(address _owner, address _spender) external view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// SUPM financial product contract
contract FinPro is Ownable {
using SafeMath for uint256;
string private constant name = "FinPro";
string private constant version = "v0.96";
uint256[] private fplowerlim;
uint256[] private fplocktime;
uint256[] private fpinterest;
uint256 private fpcount;
ERC20Token private token;
struct investedData {
uint256 fpnum;
uint256 buytime;
uint256 unlocktime;
uint256 value;
bool withdrawn;
}
mapping (address => uint256) private investedAmount;
mapping (address => mapping (uint256 => investedData)) private investorVault;
address[] public admins;
mapping (address => bool) public isAdmin;
mapping (address => mapping (uint256 => mapping (address => mapping (address => bool)))) public adminWithdraw;
mapping (address => mapping (uint256 => mapping (address => bool))) public adminTokenWithdraw;
event FPBought(address _buyer, uint256 _amount, uint256 _investednum,
uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _interestrate);
event FPWithdrawn(address _investor, uint256 _amount, uint256 _investednum, uint256 _fpnum);
// admin events
event FPWithdrawnByAdmins(address indexed _addr, uint256 _amount, address indexed _investor, uint256 _investednum, uint256 _fpnum);
event TokenWithdrawnByAdmins(address indexed _addr, uint256 _amount);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
constructor (address _tokenAddress, uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest, address[] _admins) public {
}
modifier onlyAdmin() {
}
function tokenInfo() public view returns (address _tokenAddress, uint8 _decimals,
string _name, string _symbol, uint256 _tokenBalance) {
}
function showFPCount() public view returns (uint256) {
}
function showFPLowerlim() public view returns (uint256[]) {
}
function showFPLocktime() public view returns (uint256[]) {
}
function showFPInterest() public view returns (uint256[]) {
}
function showFPInfoAll() public view returns (uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest) {
}
function showInvestedNum(address _addr) public view returns (uint256) {
}
function showInvestorVault(address _addr, uint256 _investednum) public view
returns (uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _value, bool _withdrawn, bool _withdrawable) {
}
function showInvestorVaultFull(address _addr) external view
returns (uint256[] _fpnum, uint256[] _buytime, uint256[] _unlocktime, uint256[] _value,
uint256[] _interestrate, bool[] _withdrawn, bool[] _withdrawable) {
require(<FILL_ME>)
_fpnum = new uint256[](investedAmount[_addr]);
_buytime = new uint256[](investedAmount[_addr]);
_unlocktime = new uint256[](investedAmount[_addr]);
_value = new uint256[](investedAmount[_addr]);
_interestrate = new uint256[](investedAmount[_addr]);
_withdrawn = new bool[](investedAmount[_addr]);
_withdrawable = new bool[](investedAmount[_addr]);
for(uint256 i = 0; i < investedAmount[_addr]; i++) {
(_fpnum[i], _buytime[i], _unlocktime[i], _value[i], _withdrawn[i], _withdrawable[i]) = showInvestorVault(_addr, i + 1);
_interestrate[i] = fpinterest[_fpnum[i]];
}
return (_fpnum, _buytime, _unlocktime, _value, _interestrate, _withdrawn, _withdrawable);
}
function buyfp(uint256 _fpnum, uint256 _amount) public {
}
function withdraw(uint256 _investednum) public {
}
// admin methods
function withdrawByAdmin(address _investor, uint256 _investednum, address _target) onlyAdmin public {
}
function withdrawTokenByAdmin(address _target, uint256 _amount) onlyAdmin public {
}
// safety methods
function () public payable {
}
function emptyWrongToken(address _addr) onlyOwner public {
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
}
}
| investedAmount[_addr]>0 | 286,445 | investedAmount[_addr]>0 |
null | pragma solidity ^0.4.24;
// SafeMath library
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) {
}
}
// Contract must have an owner
contract Ownable {
address public owner;
constructor() public {
}
modifier onlyOwner() {
}
function setOwner(address _owner) onlyOwner public {
}
}
// Standard ERC20 Token Interface
interface ERC20Token {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function decimals() external view returns (uint8 _decimals);
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 _balance);
function transfer(address _to, uint256 _value) external returns (bool _success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool _success);
function approve(address _spender, uint256 _value) external returns (bool _success);
function allowance(address _owner, address _spender) external view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// SUPM financial product contract
contract FinPro is Ownable {
using SafeMath for uint256;
string private constant name = "FinPro";
string private constant version = "v0.96";
uint256[] private fplowerlim;
uint256[] private fplocktime;
uint256[] private fpinterest;
uint256 private fpcount;
ERC20Token private token;
struct investedData {
uint256 fpnum;
uint256 buytime;
uint256 unlocktime;
uint256 value;
bool withdrawn;
}
mapping (address => uint256) private investedAmount;
mapping (address => mapping (uint256 => investedData)) private investorVault;
address[] public admins;
mapping (address => bool) public isAdmin;
mapping (address => mapping (uint256 => mapping (address => mapping (address => bool)))) public adminWithdraw;
mapping (address => mapping (uint256 => mapping (address => bool))) public adminTokenWithdraw;
event FPBought(address _buyer, uint256 _amount, uint256 _investednum,
uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _interestrate);
event FPWithdrawn(address _investor, uint256 _amount, uint256 _investednum, uint256 _fpnum);
// admin events
event FPWithdrawnByAdmins(address indexed _addr, uint256 _amount, address indexed _investor, uint256 _investednum, uint256 _fpnum);
event TokenWithdrawnByAdmins(address indexed _addr, uint256 _amount);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
constructor (address _tokenAddress, uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest, address[] _admins) public {
}
modifier onlyAdmin() {
}
function tokenInfo() public view returns (address _tokenAddress, uint8 _decimals,
string _name, string _symbol, uint256 _tokenBalance) {
}
function showFPCount() public view returns (uint256) {
}
function showFPLowerlim() public view returns (uint256[]) {
}
function showFPLocktime() public view returns (uint256[]) {
}
function showFPInterest() public view returns (uint256[]) {
}
function showFPInfoAll() public view returns (uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest) {
}
function showInvestedNum(address _addr) public view returns (uint256) {
}
function showInvestorVault(address _addr, uint256 _investednum) public view
returns (uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _value, bool _withdrawn, bool _withdrawable) {
}
function showInvestorVaultFull(address _addr) external view
returns (uint256[] _fpnum, uint256[] _buytime, uint256[] _unlocktime, uint256[] _value,
uint256[] _interestrate, bool[] _withdrawn, bool[] _withdrawable) {
}
function buyfp(uint256 _fpnum, uint256 _amount) public {
}
function withdraw(uint256 _investednum) public {
require(_investednum > 0 && investedAmount[msg.sender] >= _investednum);
require(<FILL_ME>)
require(now > investorVault[msg.sender][_investednum].unlocktime);
require(token.balanceOf(address(this)) >= investorVault[msg.sender][_investednum].value);
require(token.transfer(msg.sender, investorVault[msg.sender][_investednum].value));
investorVault[msg.sender][_investednum].withdrawn = true;
emit FPWithdrawn(msg.sender, investorVault[msg.sender][_investednum].value,
_investednum, investorVault[msg.sender][_investednum].fpnum);
}
// admin methods
function withdrawByAdmin(address _investor, uint256 _investednum, address _target) onlyAdmin public {
}
function withdrawTokenByAdmin(address _target, uint256 _amount) onlyAdmin public {
}
// safety methods
function () public payable {
}
function emptyWrongToken(address _addr) onlyOwner public {
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
}
}
| !investorVault[msg.sender][_investednum].withdrawn | 286,445 | !investorVault[msg.sender][_investednum].withdrawn |
null | pragma solidity ^0.4.24;
// SafeMath library
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) {
}
}
// Contract must have an owner
contract Ownable {
address public owner;
constructor() public {
}
modifier onlyOwner() {
}
function setOwner(address _owner) onlyOwner public {
}
}
// Standard ERC20 Token Interface
interface ERC20Token {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function decimals() external view returns (uint8 _decimals);
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 _balance);
function transfer(address _to, uint256 _value) external returns (bool _success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool _success);
function approve(address _spender, uint256 _value) external returns (bool _success);
function allowance(address _owner, address _spender) external view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// SUPM financial product contract
contract FinPro is Ownable {
using SafeMath for uint256;
string private constant name = "FinPro";
string private constant version = "v0.96";
uint256[] private fplowerlim;
uint256[] private fplocktime;
uint256[] private fpinterest;
uint256 private fpcount;
ERC20Token private token;
struct investedData {
uint256 fpnum;
uint256 buytime;
uint256 unlocktime;
uint256 value;
bool withdrawn;
}
mapping (address => uint256) private investedAmount;
mapping (address => mapping (uint256 => investedData)) private investorVault;
address[] public admins;
mapping (address => bool) public isAdmin;
mapping (address => mapping (uint256 => mapping (address => mapping (address => bool)))) public adminWithdraw;
mapping (address => mapping (uint256 => mapping (address => bool))) public adminTokenWithdraw;
event FPBought(address _buyer, uint256 _amount, uint256 _investednum,
uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _interestrate);
event FPWithdrawn(address _investor, uint256 _amount, uint256 _investednum, uint256 _fpnum);
// admin events
event FPWithdrawnByAdmins(address indexed _addr, uint256 _amount, address indexed _investor, uint256 _investednum, uint256 _fpnum);
event TokenWithdrawnByAdmins(address indexed _addr, uint256 _amount);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
constructor (address _tokenAddress, uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest, address[] _admins) public {
}
modifier onlyAdmin() {
}
function tokenInfo() public view returns (address _tokenAddress, uint8 _decimals,
string _name, string _symbol, uint256 _tokenBalance) {
}
function showFPCount() public view returns (uint256) {
}
function showFPLowerlim() public view returns (uint256[]) {
}
function showFPLocktime() public view returns (uint256[]) {
}
function showFPInterest() public view returns (uint256[]) {
}
function showFPInfoAll() public view returns (uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest) {
}
function showInvestedNum(address _addr) public view returns (uint256) {
}
function showInvestorVault(address _addr, uint256 _investednum) public view
returns (uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _value, bool _withdrawn, bool _withdrawable) {
}
function showInvestorVaultFull(address _addr) external view
returns (uint256[] _fpnum, uint256[] _buytime, uint256[] _unlocktime, uint256[] _value,
uint256[] _interestrate, bool[] _withdrawn, bool[] _withdrawable) {
}
function buyfp(uint256 _fpnum, uint256 _amount) public {
}
function withdraw(uint256 _investednum) public {
require(_investednum > 0 && investedAmount[msg.sender] >= _investednum);
require(!investorVault[msg.sender][_investednum].withdrawn);
require(now > investorVault[msg.sender][_investednum].unlocktime);
require(<FILL_ME>)
require(token.transfer(msg.sender, investorVault[msg.sender][_investednum].value));
investorVault[msg.sender][_investednum].withdrawn = true;
emit FPWithdrawn(msg.sender, investorVault[msg.sender][_investednum].value,
_investednum, investorVault[msg.sender][_investednum].fpnum);
}
// admin methods
function withdrawByAdmin(address _investor, uint256 _investednum, address _target) onlyAdmin public {
}
function withdrawTokenByAdmin(address _target, uint256 _amount) onlyAdmin public {
}
// safety methods
function () public payable {
}
function emptyWrongToken(address _addr) onlyOwner public {
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
}
}
| token.balanceOf(address(this))>=investorVault[msg.sender][_investednum].value | 286,445 | token.balanceOf(address(this))>=investorVault[msg.sender][_investednum].value |
null | pragma solidity ^0.4.24;
// SafeMath library
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) {
}
}
// Contract must have an owner
contract Ownable {
address public owner;
constructor() public {
}
modifier onlyOwner() {
}
function setOwner(address _owner) onlyOwner public {
}
}
// Standard ERC20 Token Interface
interface ERC20Token {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function decimals() external view returns (uint8 _decimals);
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 _balance);
function transfer(address _to, uint256 _value) external returns (bool _success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool _success);
function approve(address _spender, uint256 _value) external returns (bool _success);
function allowance(address _owner, address _spender) external view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// SUPM financial product contract
contract FinPro is Ownable {
using SafeMath for uint256;
string private constant name = "FinPro";
string private constant version = "v0.96";
uint256[] private fplowerlim;
uint256[] private fplocktime;
uint256[] private fpinterest;
uint256 private fpcount;
ERC20Token private token;
struct investedData {
uint256 fpnum;
uint256 buytime;
uint256 unlocktime;
uint256 value;
bool withdrawn;
}
mapping (address => uint256) private investedAmount;
mapping (address => mapping (uint256 => investedData)) private investorVault;
address[] public admins;
mapping (address => bool) public isAdmin;
mapping (address => mapping (uint256 => mapping (address => mapping (address => bool)))) public adminWithdraw;
mapping (address => mapping (uint256 => mapping (address => bool))) public adminTokenWithdraw;
event FPBought(address _buyer, uint256 _amount, uint256 _investednum,
uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _interestrate);
event FPWithdrawn(address _investor, uint256 _amount, uint256 _investednum, uint256 _fpnum);
// admin events
event FPWithdrawnByAdmins(address indexed _addr, uint256 _amount, address indexed _investor, uint256 _investednum, uint256 _fpnum);
event TokenWithdrawnByAdmins(address indexed _addr, uint256 _amount);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
constructor (address _tokenAddress, uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest, address[] _admins) public {
}
modifier onlyAdmin() {
}
function tokenInfo() public view returns (address _tokenAddress, uint8 _decimals,
string _name, string _symbol, uint256 _tokenBalance) {
}
function showFPCount() public view returns (uint256) {
}
function showFPLowerlim() public view returns (uint256[]) {
}
function showFPLocktime() public view returns (uint256[]) {
}
function showFPInterest() public view returns (uint256[]) {
}
function showFPInfoAll() public view returns (uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest) {
}
function showInvestedNum(address _addr) public view returns (uint256) {
}
function showInvestorVault(address _addr, uint256 _investednum) public view
returns (uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _value, bool _withdrawn, bool _withdrawable) {
}
function showInvestorVaultFull(address _addr) external view
returns (uint256[] _fpnum, uint256[] _buytime, uint256[] _unlocktime, uint256[] _value,
uint256[] _interestrate, bool[] _withdrawn, bool[] _withdrawable) {
}
function buyfp(uint256 _fpnum, uint256 _amount) public {
}
function withdraw(uint256 _investednum) public {
require(_investednum > 0 && investedAmount[msg.sender] >= _investednum);
require(!investorVault[msg.sender][_investednum].withdrawn);
require(now > investorVault[msg.sender][_investednum].unlocktime);
require(token.balanceOf(address(this)) >= investorVault[msg.sender][_investednum].value);
require(<FILL_ME>)
investorVault[msg.sender][_investednum].withdrawn = true;
emit FPWithdrawn(msg.sender, investorVault[msg.sender][_investednum].value,
_investednum, investorVault[msg.sender][_investednum].fpnum);
}
// admin methods
function withdrawByAdmin(address _investor, uint256 _investednum, address _target) onlyAdmin public {
}
function withdrawTokenByAdmin(address _target, uint256 _amount) onlyAdmin public {
}
// safety methods
function () public payable {
}
function emptyWrongToken(address _addr) onlyOwner public {
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
}
}
| token.transfer(msg.sender,investorVault[msg.sender][_investednum].value) | 286,445 | token.transfer(msg.sender,investorVault[msg.sender][_investednum].value) |
null | pragma solidity ^0.4.24;
// SafeMath library
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) {
}
}
// Contract must have an owner
contract Ownable {
address public owner;
constructor() public {
}
modifier onlyOwner() {
}
function setOwner(address _owner) onlyOwner public {
}
}
// Standard ERC20 Token Interface
interface ERC20Token {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function decimals() external view returns (uint8 _decimals);
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 _balance);
function transfer(address _to, uint256 _value) external returns (bool _success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool _success);
function approve(address _spender, uint256 _value) external returns (bool _success);
function allowance(address _owner, address _spender) external view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// SUPM financial product contract
contract FinPro is Ownable {
using SafeMath for uint256;
string private constant name = "FinPro";
string private constant version = "v0.96";
uint256[] private fplowerlim;
uint256[] private fplocktime;
uint256[] private fpinterest;
uint256 private fpcount;
ERC20Token private token;
struct investedData {
uint256 fpnum;
uint256 buytime;
uint256 unlocktime;
uint256 value;
bool withdrawn;
}
mapping (address => uint256) private investedAmount;
mapping (address => mapping (uint256 => investedData)) private investorVault;
address[] public admins;
mapping (address => bool) public isAdmin;
mapping (address => mapping (uint256 => mapping (address => mapping (address => bool)))) public adminWithdraw;
mapping (address => mapping (uint256 => mapping (address => bool))) public adminTokenWithdraw;
event FPBought(address _buyer, uint256 _amount, uint256 _investednum,
uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _interestrate);
event FPWithdrawn(address _investor, uint256 _amount, uint256 _investednum, uint256 _fpnum);
// admin events
event FPWithdrawnByAdmins(address indexed _addr, uint256 _amount, address indexed _investor, uint256 _investednum, uint256 _fpnum);
event TokenWithdrawnByAdmins(address indexed _addr, uint256 _amount);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
constructor (address _tokenAddress, uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest, address[] _admins) public {
}
modifier onlyAdmin() {
}
function tokenInfo() public view returns (address _tokenAddress, uint8 _decimals,
string _name, string _symbol, uint256 _tokenBalance) {
}
function showFPCount() public view returns (uint256) {
}
function showFPLowerlim() public view returns (uint256[]) {
}
function showFPLocktime() public view returns (uint256[]) {
}
function showFPInterest() public view returns (uint256[]) {
}
function showFPInfoAll() public view returns (uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest) {
}
function showInvestedNum(address _addr) public view returns (uint256) {
}
function showInvestorVault(address _addr, uint256 _investednum) public view
returns (uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _value, bool _withdrawn, bool _withdrawable) {
}
function showInvestorVaultFull(address _addr) external view
returns (uint256[] _fpnum, uint256[] _buytime, uint256[] _unlocktime, uint256[] _value,
uint256[] _interestrate, bool[] _withdrawn, bool[] _withdrawable) {
}
function buyfp(uint256 _fpnum, uint256 _amount) public {
}
function withdraw(uint256 _investednum) public {
}
// admin methods
function withdrawByAdmin(address _investor, uint256 _investednum, address _target) onlyAdmin public {
require(_investednum > 0 && investedAmount[_investor] >= _investednum);
require(<FILL_ME>)
require(token.balanceOf(address(this)) >= investorVault[_investor][_investednum].value);
adminWithdraw[_investor][_investednum][_target][msg.sender] = true;
for (uint256 i = 0; i < admins.length; i++) {
if (!adminWithdraw[_investor][_investednum][_target][admins[i]]) {
return;
}
}
require(token.transfer(_target, investorVault[_investor][_investednum].value));
investorVault[_investor][_investednum].withdrawn = true;
emit FPWithdrawnByAdmins(_target, investorVault[_investor][_investednum].value, _investor,
_investednum, investorVault[_investor][_investednum].fpnum);
}
function withdrawTokenByAdmin(address _target, uint256 _amount) onlyAdmin public {
}
// safety methods
function () public payable {
}
function emptyWrongToken(address _addr) onlyOwner public {
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
}
}
| !investorVault[_investor][_investednum].withdrawn | 286,445 | !investorVault[_investor][_investednum].withdrawn |
null | pragma solidity ^0.4.24;
// SafeMath library
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) {
}
}
// Contract must have an owner
contract Ownable {
address public owner;
constructor() public {
}
modifier onlyOwner() {
}
function setOwner(address _owner) onlyOwner public {
}
}
// Standard ERC20 Token Interface
interface ERC20Token {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function decimals() external view returns (uint8 _decimals);
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 _balance);
function transfer(address _to, uint256 _value) external returns (bool _success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool _success);
function approve(address _spender, uint256 _value) external returns (bool _success);
function allowance(address _owner, address _spender) external view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// SUPM financial product contract
contract FinPro is Ownable {
using SafeMath for uint256;
string private constant name = "FinPro";
string private constant version = "v0.96";
uint256[] private fplowerlim;
uint256[] private fplocktime;
uint256[] private fpinterest;
uint256 private fpcount;
ERC20Token private token;
struct investedData {
uint256 fpnum;
uint256 buytime;
uint256 unlocktime;
uint256 value;
bool withdrawn;
}
mapping (address => uint256) private investedAmount;
mapping (address => mapping (uint256 => investedData)) private investorVault;
address[] public admins;
mapping (address => bool) public isAdmin;
mapping (address => mapping (uint256 => mapping (address => mapping (address => bool)))) public adminWithdraw;
mapping (address => mapping (uint256 => mapping (address => bool))) public adminTokenWithdraw;
event FPBought(address _buyer, uint256 _amount, uint256 _investednum,
uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _interestrate);
event FPWithdrawn(address _investor, uint256 _amount, uint256 _investednum, uint256 _fpnum);
// admin events
event FPWithdrawnByAdmins(address indexed _addr, uint256 _amount, address indexed _investor, uint256 _investednum, uint256 _fpnum);
event TokenWithdrawnByAdmins(address indexed _addr, uint256 _amount);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
constructor (address _tokenAddress, uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest, address[] _admins) public {
}
modifier onlyAdmin() {
}
function tokenInfo() public view returns (address _tokenAddress, uint8 _decimals,
string _name, string _symbol, uint256 _tokenBalance) {
}
function showFPCount() public view returns (uint256) {
}
function showFPLowerlim() public view returns (uint256[]) {
}
function showFPLocktime() public view returns (uint256[]) {
}
function showFPInterest() public view returns (uint256[]) {
}
function showFPInfoAll() public view returns (uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest) {
}
function showInvestedNum(address _addr) public view returns (uint256) {
}
function showInvestorVault(address _addr, uint256 _investednum) public view
returns (uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _value, bool _withdrawn, bool _withdrawable) {
}
function showInvestorVaultFull(address _addr) external view
returns (uint256[] _fpnum, uint256[] _buytime, uint256[] _unlocktime, uint256[] _value,
uint256[] _interestrate, bool[] _withdrawn, bool[] _withdrawable) {
}
function buyfp(uint256 _fpnum, uint256 _amount) public {
}
function withdraw(uint256 _investednum) public {
}
// admin methods
function withdrawByAdmin(address _investor, uint256 _investednum, address _target) onlyAdmin public {
require(_investednum > 0 && investedAmount[_investor] >= _investednum);
require(!investorVault[_investor][_investednum].withdrawn);
require(<FILL_ME>)
adminWithdraw[_investor][_investednum][_target][msg.sender] = true;
for (uint256 i = 0; i < admins.length; i++) {
if (!adminWithdraw[_investor][_investednum][_target][admins[i]]) {
return;
}
}
require(token.transfer(_target, investorVault[_investor][_investednum].value));
investorVault[_investor][_investednum].withdrawn = true;
emit FPWithdrawnByAdmins(_target, investorVault[_investor][_investednum].value, _investor,
_investednum, investorVault[_investor][_investednum].fpnum);
}
function withdrawTokenByAdmin(address _target, uint256 _amount) onlyAdmin public {
}
// safety methods
function () public payable {
}
function emptyWrongToken(address _addr) onlyOwner public {
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
}
}
| token.balanceOf(address(this))>=investorVault[_investor][_investednum].value | 286,445 | token.balanceOf(address(this))>=investorVault[_investor][_investednum].value |
null | pragma solidity ^0.4.24;
// SafeMath library
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) {
}
}
// Contract must have an owner
contract Ownable {
address public owner;
constructor() public {
}
modifier onlyOwner() {
}
function setOwner(address _owner) onlyOwner public {
}
}
// Standard ERC20 Token Interface
interface ERC20Token {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function decimals() external view returns (uint8 _decimals);
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 _balance);
function transfer(address _to, uint256 _value) external returns (bool _success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool _success);
function approve(address _spender, uint256 _value) external returns (bool _success);
function allowance(address _owner, address _spender) external view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// SUPM financial product contract
contract FinPro is Ownable {
using SafeMath for uint256;
string private constant name = "FinPro";
string private constant version = "v0.96";
uint256[] private fplowerlim;
uint256[] private fplocktime;
uint256[] private fpinterest;
uint256 private fpcount;
ERC20Token private token;
struct investedData {
uint256 fpnum;
uint256 buytime;
uint256 unlocktime;
uint256 value;
bool withdrawn;
}
mapping (address => uint256) private investedAmount;
mapping (address => mapping (uint256 => investedData)) private investorVault;
address[] public admins;
mapping (address => bool) public isAdmin;
mapping (address => mapping (uint256 => mapping (address => mapping (address => bool)))) public adminWithdraw;
mapping (address => mapping (uint256 => mapping (address => bool))) public adminTokenWithdraw;
event FPBought(address _buyer, uint256 _amount, uint256 _investednum,
uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _interestrate);
event FPWithdrawn(address _investor, uint256 _amount, uint256 _investednum, uint256 _fpnum);
// admin events
event FPWithdrawnByAdmins(address indexed _addr, uint256 _amount, address indexed _investor, uint256 _investednum, uint256 _fpnum);
event TokenWithdrawnByAdmins(address indexed _addr, uint256 _amount);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
constructor (address _tokenAddress, uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest, address[] _admins) public {
}
modifier onlyAdmin() {
}
function tokenInfo() public view returns (address _tokenAddress, uint8 _decimals,
string _name, string _symbol, uint256 _tokenBalance) {
}
function showFPCount() public view returns (uint256) {
}
function showFPLowerlim() public view returns (uint256[]) {
}
function showFPLocktime() public view returns (uint256[]) {
}
function showFPInterest() public view returns (uint256[]) {
}
function showFPInfoAll() public view returns (uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest) {
}
function showInvestedNum(address _addr) public view returns (uint256) {
}
function showInvestorVault(address _addr, uint256 _investednum) public view
returns (uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _value, bool _withdrawn, bool _withdrawable) {
}
function showInvestorVaultFull(address _addr) external view
returns (uint256[] _fpnum, uint256[] _buytime, uint256[] _unlocktime, uint256[] _value,
uint256[] _interestrate, bool[] _withdrawn, bool[] _withdrawable) {
}
function buyfp(uint256 _fpnum, uint256 _amount) public {
}
function withdraw(uint256 _investednum) public {
}
// admin methods
function withdrawByAdmin(address _investor, uint256 _investednum, address _target) onlyAdmin public {
require(_investednum > 0 && investedAmount[_investor] >= _investednum);
require(!investorVault[_investor][_investednum].withdrawn);
require(token.balanceOf(address(this)) >= investorVault[_investor][_investednum].value);
adminWithdraw[_investor][_investednum][_target][msg.sender] = true;
for (uint256 i = 0; i < admins.length; i++) {
if (!adminWithdraw[_investor][_investednum][_target][admins[i]]) {
return;
}
}
require(<FILL_ME>)
investorVault[_investor][_investednum].withdrawn = true;
emit FPWithdrawnByAdmins(_target, investorVault[_investor][_investednum].value, _investor,
_investednum, investorVault[_investor][_investednum].fpnum);
}
function withdrawTokenByAdmin(address _target, uint256 _amount) onlyAdmin public {
}
// safety methods
function () public payable {
}
function emptyWrongToken(address _addr) onlyOwner public {
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
}
}
| token.transfer(_target,investorVault[_investor][_investednum].value) | 286,445 | token.transfer(_target,investorVault[_investor][_investednum].value) |
null | pragma solidity ^0.4.24;
// SafeMath library
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) {
}
}
// Contract must have an owner
contract Ownable {
address public owner;
constructor() public {
}
modifier onlyOwner() {
}
function setOwner(address _owner) onlyOwner public {
}
}
// Standard ERC20 Token Interface
interface ERC20Token {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function decimals() external view returns (uint8 _decimals);
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 _balance);
function transfer(address _to, uint256 _value) external returns (bool _success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool _success);
function approve(address _spender, uint256 _value) external returns (bool _success);
function allowance(address _owner, address _spender) external view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// SUPM financial product contract
contract FinPro is Ownable {
using SafeMath for uint256;
string private constant name = "FinPro";
string private constant version = "v0.96";
uint256[] private fplowerlim;
uint256[] private fplocktime;
uint256[] private fpinterest;
uint256 private fpcount;
ERC20Token private token;
struct investedData {
uint256 fpnum;
uint256 buytime;
uint256 unlocktime;
uint256 value;
bool withdrawn;
}
mapping (address => uint256) private investedAmount;
mapping (address => mapping (uint256 => investedData)) private investorVault;
address[] public admins;
mapping (address => bool) public isAdmin;
mapping (address => mapping (uint256 => mapping (address => mapping (address => bool)))) public adminWithdraw;
mapping (address => mapping (uint256 => mapping (address => bool))) public adminTokenWithdraw;
event FPBought(address _buyer, uint256 _amount, uint256 _investednum,
uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _interestrate);
event FPWithdrawn(address _investor, uint256 _amount, uint256 _investednum, uint256 _fpnum);
// admin events
event FPWithdrawnByAdmins(address indexed _addr, uint256 _amount, address indexed _investor, uint256 _investednum, uint256 _fpnum);
event TokenWithdrawnByAdmins(address indexed _addr, uint256 _amount);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
constructor (address _tokenAddress, uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest, address[] _admins) public {
}
modifier onlyAdmin() {
}
function tokenInfo() public view returns (address _tokenAddress, uint8 _decimals,
string _name, string _symbol, uint256 _tokenBalance) {
}
function showFPCount() public view returns (uint256) {
}
function showFPLowerlim() public view returns (uint256[]) {
}
function showFPLocktime() public view returns (uint256[]) {
}
function showFPInterest() public view returns (uint256[]) {
}
function showFPInfoAll() public view returns (uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest) {
}
function showInvestedNum(address _addr) public view returns (uint256) {
}
function showInvestorVault(address _addr, uint256 _investednum) public view
returns (uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _value, bool _withdrawn, bool _withdrawable) {
}
function showInvestorVaultFull(address _addr) external view
returns (uint256[] _fpnum, uint256[] _buytime, uint256[] _unlocktime, uint256[] _value,
uint256[] _interestrate, bool[] _withdrawn, bool[] _withdrawable) {
}
function buyfp(uint256 _fpnum, uint256 _amount) public {
}
function withdraw(uint256 _investednum) public {
}
// admin methods
function withdrawByAdmin(address _investor, uint256 _investednum, address _target) onlyAdmin public {
}
function withdrawTokenByAdmin(address _target, uint256 _amount) onlyAdmin public {
adminTokenWithdraw[_target][_amount][msg.sender] = true;
uint256 i;
for (i = 0; i < admins.length; i++) {
if (!adminTokenWithdraw[_target][_amount][admins[i]]) {
return;
}
}
for (i = 0; i < admins.length; i++) {
adminTokenWithdraw[_target][_amount][admins[i]] = false;
}
require(<FILL_ME>)
emit TokenWithdrawnByAdmins(_target, _amount);
}
// safety methods
function () public payable {
}
function emptyWrongToken(address _addr) onlyOwner public {
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
}
}
| token.transfer(_target,_amount) | 286,445 | token.transfer(_target,_amount) |
null | pragma solidity ^0.4.24;
// SafeMath library
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) {
}
}
// Contract must have an owner
contract Ownable {
address public owner;
constructor() public {
}
modifier onlyOwner() {
}
function setOwner(address _owner) onlyOwner public {
}
}
// Standard ERC20 Token Interface
interface ERC20Token {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function decimals() external view returns (uint8 _decimals);
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 _balance);
function transfer(address _to, uint256 _value) external returns (bool _success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool _success);
function approve(address _spender, uint256 _value) external returns (bool _success);
function allowance(address _owner, address _spender) external view returns (uint256 _remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
// SUPM financial product contract
contract FinPro is Ownable {
using SafeMath for uint256;
string private constant name = "FinPro";
string private constant version = "v0.96";
uint256[] private fplowerlim;
uint256[] private fplocktime;
uint256[] private fpinterest;
uint256 private fpcount;
ERC20Token private token;
struct investedData {
uint256 fpnum;
uint256 buytime;
uint256 unlocktime;
uint256 value;
bool withdrawn;
}
mapping (address => uint256) private investedAmount;
mapping (address => mapping (uint256 => investedData)) private investorVault;
address[] public admins;
mapping (address => bool) public isAdmin;
mapping (address => mapping (uint256 => mapping (address => mapping (address => bool)))) public adminWithdraw;
mapping (address => mapping (uint256 => mapping (address => bool))) public adminTokenWithdraw;
event FPBought(address _buyer, uint256 _amount, uint256 _investednum,
uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _interestrate);
event FPWithdrawn(address _investor, uint256 _amount, uint256 _investednum, uint256 _fpnum);
// admin events
event FPWithdrawnByAdmins(address indexed _addr, uint256 _amount, address indexed _investor, uint256 _investednum, uint256 _fpnum);
event TokenWithdrawnByAdmins(address indexed _addr, uint256 _amount);
// safety method-related events
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
constructor (address _tokenAddress, uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest, address[] _admins) public {
}
modifier onlyAdmin() {
}
function tokenInfo() public view returns (address _tokenAddress, uint8 _decimals,
string _name, string _symbol, uint256 _tokenBalance) {
}
function showFPCount() public view returns (uint256) {
}
function showFPLowerlim() public view returns (uint256[]) {
}
function showFPLocktime() public view returns (uint256[]) {
}
function showFPInterest() public view returns (uint256[]) {
}
function showFPInfoAll() public view returns (uint256[] _fplowerlim, uint256[] _fplocktime, uint256[] _fpinterest) {
}
function showInvestedNum(address _addr) public view returns (uint256) {
}
function showInvestorVault(address _addr, uint256 _investednum) public view
returns (uint256 _fpnum, uint256 _buytime, uint256 _unlocktime, uint256 _value, bool _withdrawn, bool _withdrawable) {
}
function showInvestorVaultFull(address _addr) external view
returns (uint256[] _fpnum, uint256[] _buytime, uint256[] _unlocktime, uint256[] _value,
uint256[] _interestrate, bool[] _withdrawn, bool[] _withdrawable) {
}
function buyfp(uint256 _fpnum, uint256 _amount) public {
}
function withdraw(uint256 _investednum) public {
}
// admin methods
function withdrawByAdmin(address _investor, uint256 _investednum, address _target) onlyAdmin public {
}
function withdrawTokenByAdmin(address _target, uint256 _amount) onlyAdmin public {
}
// safety methods
function () public payable {
}
function emptyWrongToken(address _addr) onlyOwner public {
require(_addr != address(token));
ERC20Token wrongToken = ERC20Token(_addr);
uint256 amount = wrongToken.balanceOf(address(this));
require(amount > 0);
require(<FILL_ME>)
emit WrongTokenEmptied(_addr, msg.sender, amount);
}
// shouldn't happen, just in case
function emptyWrongEther() onlyOwner public {
}
}
| wrongToken.transfer(msg.sender,amount) | 286,445 | wrongToken.transfer(msg.sender,amount) |
"No more BALLS left" | pragma solidity ^0.8.0;
contract Fiddles3D is ERC721Enumerable, Ownable {
using Strings for uint256;
string baseURI;
string public baseExtension = ".json";
uint256 public cost = 0.03 ether;
uint256 public maxSupply = 1000;
uint256 public maxMintAmount = 10;
uint256 public maxFreeMintAmount = 1;
uint256 public maxFreeMint = 250;
bool public paused = true;
bool public revealed = false;
string public notRevealedUri;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721(_name, _symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(uint256 _mintAmount) public payable {
}
function freeMint(uint256 _mintAmount) public {
uint256 supply = totalSupply();
require(!paused, "Sale has paused");
require(_mintAmount <= maxFreeMintAmount);
require(<FILL_ME>)
for (uint256 i = 1; i <= _mintAmount; i++) {
_safeMint(msg.sender, supply + i);
}
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function reveal() public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| supply+_mintAmount<=maxFreeMint,"No more BALLS left" | 286,498 | supply+_mintAmount<=maxFreeMint |
"Fundamenta: Message Sender must be _ADMIN" | // SPDX-License-Identifier: GPL-3.0
// Author: Matt Hooft
// https://github.com/Civitas-Fundamenta
// [email protected]
// This is Civitas Fundamenta's implementation of the Fundamenta Token.
// It utilizes a Role Based Access Control System to allow outside contracts
// and accounts to interact with it securely providing future extesibility which
// as you will see is a theme with our smart contracts.
pragma solidity ^0.7.3;
contract FMTAToken is ERC20, AccessControl {
using SafeERC20 for IERC20;
using SafeMath for uint256;
/**
* @dev Token uses Role Based Access Control to
* alllow for secure access as well as enabling the ability
* for other contracts such as oracles and supply mechanisms
* to interact with it.
*/
//------RBAC Vars--------------
bytes32 public constant _MINT = keccak256("_MINT");
bytes32 public constant _MINTTO = keccak256("_MINTTO");
bytes32 public constant _BURN = keccak256("_BURN");
bytes32 public constant _BURNFROM = keccak256("_BURNFROM");
bytes32 public constant _SUPPLY = keccak256("_SUPPLY");
bytes32 public constant _ADMIN = keccak256("_ADMIN");
//------Token Variables------------------
uint private _cap;
uint public _fundingEmission;
uint public _team;
uint public _originalLiquidityProviders;
//-------Toggle Variables---------------
bool public paused;
bool public mintDisabled;
bool public mintToDisabled;
//----------Events-----------------------
event TokensMinted (uint _amount);
event TokensMintedTo (address _to, uint _amount);
event TokensBurned (uint _amount, address _burner);
event TokensBurnedFrom (address _from, uint _amount, address _burner);
event SupplyCapChanged (uint _newCap, address _changedBy);
event ContractPaused (uint _blockHeight, address _pausedBy);
event ContractUnpaused (uint _blockHeight, address _unpausedBy);
event MintingEnabled (uint _blockHeight, address _enabledBy);
event MintingDisabled (uint _blockHeight, address _disabledBy);
event MintingToEnabled (uint _blockHeight, address _enabledBy);
event MintingToDisabled (uint _blockHeight, address _disabledBy);
//------Token/Admin Constructor---------
constructor() ERC20("Fundamenta", "FMTA") {
}
/**
* @dev functions used to toggle contract states.
* Includes disabling or enabling minting and
* pausing of the contract
*/
//--------Toggle Functions----------------
function setPaused(bool _paused) external {
require(<FILL_ME>)
paused = _paused;
if (_paused == true) {
emit ContractPaused (block.number, msg.sender);
} else if (_paused == false) {
emit ContractUnpaused (block.number, msg.sender);
}
}
function disableMint(bool _disableMinting) external {
}
function disableMintTo(bool _disableMintTo) external {
}
//------Toggle Modifiers------------------
modifier pause() {
}
modifier mintDis() {
}
modifier mintToDis() {
}
//------Token Functions-----------------
/**
* @dev token funtions require role based access to
* execute. This gives us the ability to allow outside
* interaction with the token contract securely.
*/
function mintTo(address _to, uint _amount) external pause mintToDis{
}
function mint( uint _amount) external pause mintDis{
}
function burn(uint _amount) external pause {
}
function burnFrom(address _from, uint _amount) external pause {
}
//----------Supply Cap------------------
/**
* @dev tokens supply cap is configureable and also
* leverages RBAC to allow outside mechanisms like
* oracles to interact with it securely.
*/
function setSupplyCap(uint _supplyCap) external pause {
}
function supplyCap() public view returns (uint) {
}
function _beforeTokenTransfer(address from, address to, uint amount) internal virtual override {
}
}
| hasRole(_ADMIN,msg.sender),"Fundamenta: Message Sender must be _ADMIN" | 286,550 | hasRole(_ADMIN,msg.sender) |
"Fundamenta: Minting is currently disabled" | // SPDX-License-Identifier: GPL-3.0
// Author: Matt Hooft
// https://github.com/Civitas-Fundamenta
// [email protected]
// This is Civitas Fundamenta's implementation of the Fundamenta Token.
// It utilizes a Role Based Access Control System to allow outside contracts
// and accounts to interact with it securely providing future extesibility which
// as you will see is a theme with our smart contracts.
pragma solidity ^0.7.3;
contract FMTAToken is ERC20, AccessControl {
using SafeERC20 for IERC20;
using SafeMath for uint256;
/**
* @dev Token uses Role Based Access Control to
* alllow for secure access as well as enabling the ability
* for other contracts such as oracles and supply mechanisms
* to interact with it.
*/
//------RBAC Vars--------------
bytes32 public constant _MINT = keccak256("_MINT");
bytes32 public constant _MINTTO = keccak256("_MINTTO");
bytes32 public constant _BURN = keccak256("_BURN");
bytes32 public constant _BURNFROM = keccak256("_BURNFROM");
bytes32 public constant _SUPPLY = keccak256("_SUPPLY");
bytes32 public constant _ADMIN = keccak256("_ADMIN");
//------Token Variables------------------
uint private _cap;
uint public _fundingEmission;
uint public _team;
uint public _originalLiquidityProviders;
//-------Toggle Variables---------------
bool public paused;
bool public mintDisabled;
bool public mintToDisabled;
//----------Events-----------------------
event TokensMinted (uint _amount);
event TokensMintedTo (address _to, uint _amount);
event TokensBurned (uint _amount, address _burner);
event TokensBurnedFrom (address _from, uint _amount, address _burner);
event SupplyCapChanged (uint _newCap, address _changedBy);
event ContractPaused (uint _blockHeight, address _pausedBy);
event ContractUnpaused (uint _blockHeight, address _unpausedBy);
event MintingEnabled (uint _blockHeight, address _enabledBy);
event MintingDisabled (uint _blockHeight, address _disabledBy);
event MintingToEnabled (uint _blockHeight, address _enabledBy);
event MintingToDisabled (uint _blockHeight, address _disabledBy);
//------Token/Admin Constructor---------
constructor() ERC20("Fundamenta", "FMTA") {
}
/**
* @dev functions used to toggle contract states.
* Includes disabling or enabling minting and
* pausing of the contract
*/
//--------Toggle Functions----------------
function setPaused(bool _paused) external {
}
function disableMint(bool _disableMinting) external {
}
function disableMintTo(bool _disableMintTo) external {
}
//------Toggle Modifiers------------------
modifier pause() {
}
modifier mintDis() {
require(<FILL_ME>)
_;
}
modifier mintToDis() {
}
//------Token Functions-----------------
/**
* @dev token funtions require role based access to
* execute. This gives us the ability to allow outside
* interaction with the token contract securely.
*/
function mintTo(address _to, uint _amount) external pause mintToDis{
}
function mint( uint _amount) external pause mintDis{
}
function burn(uint _amount) external pause {
}
function burnFrom(address _from, uint _amount) external pause {
}
//----------Supply Cap------------------
/**
* @dev tokens supply cap is configureable and also
* leverages RBAC to allow outside mechanisms like
* oracles to interact with it securely.
*/
function setSupplyCap(uint _supplyCap) external pause {
}
function supplyCap() public view returns (uint) {
}
function _beforeTokenTransfer(address from, address to, uint amount) internal virtual override {
}
}
| !mintDisabled,"Fundamenta: Minting is currently disabled" | 286,550 | !mintDisabled |
"Fundamenta: Minting to addresses is curently disabled" | // SPDX-License-Identifier: GPL-3.0
// Author: Matt Hooft
// https://github.com/Civitas-Fundamenta
// [email protected]
// This is Civitas Fundamenta's implementation of the Fundamenta Token.
// It utilizes a Role Based Access Control System to allow outside contracts
// and accounts to interact with it securely providing future extesibility which
// as you will see is a theme with our smart contracts.
pragma solidity ^0.7.3;
contract FMTAToken is ERC20, AccessControl {
using SafeERC20 for IERC20;
using SafeMath for uint256;
/**
* @dev Token uses Role Based Access Control to
* alllow for secure access as well as enabling the ability
* for other contracts such as oracles and supply mechanisms
* to interact with it.
*/
//------RBAC Vars--------------
bytes32 public constant _MINT = keccak256("_MINT");
bytes32 public constant _MINTTO = keccak256("_MINTTO");
bytes32 public constant _BURN = keccak256("_BURN");
bytes32 public constant _BURNFROM = keccak256("_BURNFROM");
bytes32 public constant _SUPPLY = keccak256("_SUPPLY");
bytes32 public constant _ADMIN = keccak256("_ADMIN");
//------Token Variables------------------
uint private _cap;
uint public _fundingEmission;
uint public _team;
uint public _originalLiquidityProviders;
//-------Toggle Variables---------------
bool public paused;
bool public mintDisabled;
bool public mintToDisabled;
//----------Events-----------------------
event TokensMinted (uint _amount);
event TokensMintedTo (address _to, uint _amount);
event TokensBurned (uint _amount, address _burner);
event TokensBurnedFrom (address _from, uint _amount, address _burner);
event SupplyCapChanged (uint _newCap, address _changedBy);
event ContractPaused (uint _blockHeight, address _pausedBy);
event ContractUnpaused (uint _blockHeight, address _unpausedBy);
event MintingEnabled (uint _blockHeight, address _enabledBy);
event MintingDisabled (uint _blockHeight, address _disabledBy);
event MintingToEnabled (uint _blockHeight, address _enabledBy);
event MintingToDisabled (uint _blockHeight, address _disabledBy);
//------Token/Admin Constructor---------
constructor() ERC20("Fundamenta", "FMTA") {
}
/**
* @dev functions used to toggle contract states.
* Includes disabling or enabling minting and
* pausing of the contract
*/
//--------Toggle Functions----------------
function setPaused(bool _paused) external {
}
function disableMint(bool _disableMinting) external {
}
function disableMintTo(bool _disableMintTo) external {
}
//------Toggle Modifiers------------------
modifier pause() {
}
modifier mintDis() {
}
modifier mintToDis() {
require(<FILL_ME>)
_;
}
//------Token Functions-----------------
/**
* @dev token funtions require role based access to
* execute. This gives us the ability to allow outside
* interaction with the token contract securely.
*/
function mintTo(address _to, uint _amount) external pause mintToDis{
}
function mint( uint _amount) external pause mintDis{
}
function burn(uint _amount) external pause {
}
function burnFrom(address _from, uint _amount) external pause {
}
//----------Supply Cap------------------
/**
* @dev tokens supply cap is configureable and also
* leverages RBAC to allow outside mechanisms like
* oracles to interact with it securely.
*/
function setSupplyCap(uint _supplyCap) external pause {
}
function supplyCap() public view returns (uint) {
}
function _beforeTokenTransfer(address from, address to, uint amount) internal virtual override {
}
}
| !mintToDisabled,"Fundamenta: Minting to addresses is curently disabled" | 286,550 | !mintToDisabled |
"Fundamenta: Message Sender must be _MINTTO" | // SPDX-License-Identifier: GPL-3.0
// Author: Matt Hooft
// https://github.com/Civitas-Fundamenta
// [email protected]
// This is Civitas Fundamenta's implementation of the Fundamenta Token.
// It utilizes a Role Based Access Control System to allow outside contracts
// and accounts to interact with it securely providing future extesibility which
// as you will see is a theme with our smart contracts.
pragma solidity ^0.7.3;
contract FMTAToken is ERC20, AccessControl {
using SafeERC20 for IERC20;
using SafeMath for uint256;
/**
* @dev Token uses Role Based Access Control to
* alllow for secure access as well as enabling the ability
* for other contracts such as oracles and supply mechanisms
* to interact with it.
*/
//------RBAC Vars--------------
bytes32 public constant _MINT = keccak256("_MINT");
bytes32 public constant _MINTTO = keccak256("_MINTTO");
bytes32 public constant _BURN = keccak256("_BURN");
bytes32 public constant _BURNFROM = keccak256("_BURNFROM");
bytes32 public constant _SUPPLY = keccak256("_SUPPLY");
bytes32 public constant _ADMIN = keccak256("_ADMIN");
//------Token Variables------------------
uint private _cap;
uint public _fundingEmission;
uint public _team;
uint public _originalLiquidityProviders;
//-------Toggle Variables---------------
bool public paused;
bool public mintDisabled;
bool public mintToDisabled;
//----------Events-----------------------
event TokensMinted (uint _amount);
event TokensMintedTo (address _to, uint _amount);
event TokensBurned (uint _amount, address _burner);
event TokensBurnedFrom (address _from, uint _amount, address _burner);
event SupplyCapChanged (uint _newCap, address _changedBy);
event ContractPaused (uint _blockHeight, address _pausedBy);
event ContractUnpaused (uint _blockHeight, address _unpausedBy);
event MintingEnabled (uint _blockHeight, address _enabledBy);
event MintingDisabled (uint _blockHeight, address _disabledBy);
event MintingToEnabled (uint _blockHeight, address _enabledBy);
event MintingToDisabled (uint _blockHeight, address _disabledBy);
//------Token/Admin Constructor---------
constructor() ERC20("Fundamenta", "FMTA") {
}
/**
* @dev functions used to toggle contract states.
* Includes disabling or enabling minting and
* pausing of the contract
*/
//--------Toggle Functions----------------
function setPaused(bool _paused) external {
}
function disableMint(bool _disableMinting) external {
}
function disableMintTo(bool _disableMintTo) external {
}
//------Toggle Modifiers------------------
modifier pause() {
}
modifier mintDis() {
}
modifier mintToDis() {
}
//------Token Functions-----------------
/**
* @dev token funtions require role based access to
* execute. This gives us the ability to allow outside
* interaction with the token contract securely.
*/
function mintTo(address _to, uint _amount) external pause mintToDis{
require(<FILL_ME>)
_mint(_to, _amount);
emit TokensMintedTo(_to, _amount);
}
function mint( uint _amount) external pause mintDis{
}
function burn(uint _amount) external pause {
}
function burnFrom(address _from, uint _amount) external pause {
}
//----------Supply Cap------------------
/**
* @dev tokens supply cap is configureable and also
* leverages RBAC to allow outside mechanisms like
* oracles to interact with it securely.
*/
function setSupplyCap(uint _supplyCap) external pause {
}
function supplyCap() public view returns (uint) {
}
function _beforeTokenTransfer(address from, address to, uint amount) internal virtual override {
}
}
| hasRole(_MINTTO,msg.sender),"Fundamenta: Message Sender must be _MINTTO" | 286,550 | hasRole(_MINTTO,msg.sender) |
"Fundamenta: Message Sender must be _MINT" | // SPDX-License-Identifier: GPL-3.0
// Author: Matt Hooft
// https://github.com/Civitas-Fundamenta
// [email protected]
// This is Civitas Fundamenta's implementation of the Fundamenta Token.
// It utilizes a Role Based Access Control System to allow outside contracts
// and accounts to interact with it securely providing future extesibility which
// as you will see is a theme with our smart contracts.
pragma solidity ^0.7.3;
contract FMTAToken is ERC20, AccessControl {
using SafeERC20 for IERC20;
using SafeMath for uint256;
/**
* @dev Token uses Role Based Access Control to
* alllow for secure access as well as enabling the ability
* for other contracts such as oracles and supply mechanisms
* to interact with it.
*/
//------RBAC Vars--------------
bytes32 public constant _MINT = keccak256("_MINT");
bytes32 public constant _MINTTO = keccak256("_MINTTO");
bytes32 public constant _BURN = keccak256("_BURN");
bytes32 public constant _BURNFROM = keccak256("_BURNFROM");
bytes32 public constant _SUPPLY = keccak256("_SUPPLY");
bytes32 public constant _ADMIN = keccak256("_ADMIN");
//------Token Variables------------------
uint private _cap;
uint public _fundingEmission;
uint public _team;
uint public _originalLiquidityProviders;
//-------Toggle Variables---------------
bool public paused;
bool public mintDisabled;
bool public mintToDisabled;
//----------Events-----------------------
event TokensMinted (uint _amount);
event TokensMintedTo (address _to, uint _amount);
event TokensBurned (uint _amount, address _burner);
event TokensBurnedFrom (address _from, uint _amount, address _burner);
event SupplyCapChanged (uint _newCap, address _changedBy);
event ContractPaused (uint _blockHeight, address _pausedBy);
event ContractUnpaused (uint _blockHeight, address _unpausedBy);
event MintingEnabled (uint _blockHeight, address _enabledBy);
event MintingDisabled (uint _blockHeight, address _disabledBy);
event MintingToEnabled (uint _blockHeight, address _enabledBy);
event MintingToDisabled (uint _blockHeight, address _disabledBy);
//------Token/Admin Constructor---------
constructor() ERC20("Fundamenta", "FMTA") {
}
/**
* @dev functions used to toggle contract states.
* Includes disabling or enabling minting and
* pausing of the contract
*/
//--------Toggle Functions----------------
function setPaused(bool _paused) external {
}
function disableMint(bool _disableMinting) external {
}
function disableMintTo(bool _disableMintTo) external {
}
//------Toggle Modifiers------------------
modifier pause() {
}
modifier mintDis() {
}
modifier mintToDis() {
}
//------Token Functions-----------------
/**
* @dev token funtions require role based access to
* execute. This gives us the ability to allow outside
* interaction with the token contract securely.
*/
function mintTo(address _to, uint _amount) external pause mintToDis{
}
function mint( uint _amount) external pause mintDis{
require(<FILL_ME>)
_mint(msg.sender, _amount);
emit TokensMinted(_amount);
}
function burn(uint _amount) external pause {
}
function burnFrom(address _from, uint _amount) external pause {
}
//----------Supply Cap------------------
/**
* @dev tokens supply cap is configureable and also
* leverages RBAC to allow outside mechanisms like
* oracles to interact with it securely.
*/
function setSupplyCap(uint _supplyCap) external pause {
}
function supplyCap() public view returns (uint) {
}
function _beforeTokenTransfer(address from, address to, uint amount) internal virtual override {
}
}
| hasRole(_MINT,msg.sender),"Fundamenta: Message Sender must be _MINT" | 286,550 | hasRole(_MINT,msg.sender) |
"Fundamenta: Message Sender must be _BURN" | // SPDX-License-Identifier: GPL-3.0
// Author: Matt Hooft
// https://github.com/Civitas-Fundamenta
// [email protected]
// This is Civitas Fundamenta's implementation of the Fundamenta Token.
// It utilizes a Role Based Access Control System to allow outside contracts
// and accounts to interact with it securely providing future extesibility which
// as you will see is a theme with our smart contracts.
pragma solidity ^0.7.3;
contract FMTAToken is ERC20, AccessControl {
using SafeERC20 for IERC20;
using SafeMath for uint256;
/**
* @dev Token uses Role Based Access Control to
* alllow for secure access as well as enabling the ability
* for other contracts such as oracles and supply mechanisms
* to interact with it.
*/
//------RBAC Vars--------------
bytes32 public constant _MINT = keccak256("_MINT");
bytes32 public constant _MINTTO = keccak256("_MINTTO");
bytes32 public constant _BURN = keccak256("_BURN");
bytes32 public constant _BURNFROM = keccak256("_BURNFROM");
bytes32 public constant _SUPPLY = keccak256("_SUPPLY");
bytes32 public constant _ADMIN = keccak256("_ADMIN");
//------Token Variables------------------
uint private _cap;
uint public _fundingEmission;
uint public _team;
uint public _originalLiquidityProviders;
//-------Toggle Variables---------------
bool public paused;
bool public mintDisabled;
bool public mintToDisabled;
//----------Events-----------------------
event TokensMinted (uint _amount);
event TokensMintedTo (address _to, uint _amount);
event TokensBurned (uint _amount, address _burner);
event TokensBurnedFrom (address _from, uint _amount, address _burner);
event SupplyCapChanged (uint _newCap, address _changedBy);
event ContractPaused (uint _blockHeight, address _pausedBy);
event ContractUnpaused (uint _blockHeight, address _unpausedBy);
event MintingEnabled (uint _blockHeight, address _enabledBy);
event MintingDisabled (uint _blockHeight, address _disabledBy);
event MintingToEnabled (uint _blockHeight, address _enabledBy);
event MintingToDisabled (uint _blockHeight, address _disabledBy);
//------Token/Admin Constructor---------
constructor() ERC20("Fundamenta", "FMTA") {
}
/**
* @dev functions used to toggle contract states.
* Includes disabling or enabling minting and
* pausing of the contract
*/
//--------Toggle Functions----------------
function setPaused(bool _paused) external {
}
function disableMint(bool _disableMinting) external {
}
function disableMintTo(bool _disableMintTo) external {
}
//------Toggle Modifiers------------------
modifier pause() {
}
modifier mintDis() {
}
modifier mintToDis() {
}
//------Token Functions-----------------
/**
* @dev token funtions require role based access to
* execute. This gives us the ability to allow outside
* interaction with the token contract securely.
*/
function mintTo(address _to, uint _amount) external pause mintToDis{
}
function mint( uint _amount) external pause mintDis{
}
function burn(uint _amount) external pause {
require(<FILL_ME>)
_burn(msg.sender, _amount);
emit TokensBurned(_amount, msg.sender);
}
function burnFrom(address _from, uint _amount) external pause {
}
//----------Supply Cap------------------
/**
* @dev tokens supply cap is configureable and also
* leverages RBAC to allow outside mechanisms like
* oracles to interact with it securely.
*/
function setSupplyCap(uint _supplyCap) external pause {
}
function supplyCap() public view returns (uint) {
}
function _beforeTokenTransfer(address from, address to, uint amount) internal virtual override {
}
}
| hasRole(_BURN,msg.sender),"Fundamenta: Message Sender must be _BURN" | 286,550 | hasRole(_BURN,msg.sender) |
"Fundamenta: Message Sender must be _BURNFROM" | // SPDX-License-Identifier: GPL-3.0
// Author: Matt Hooft
// https://github.com/Civitas-Fundamenta
// [email protected]
// This is Civitas Fundamenta's implementation of the Fundamenta Token.
// It utilizes a Role Based Access Control System to allow outside contracts
// and accounts to interact with it securely providing future extesibility which
// as you will see is a theme with our smart contracts.
pragma solidity ^0.7.3;
contract FMTAToken is ERC20, AccessControl {
using SafeERC20 for IERC20;
using SafeMath for uint256;
/**
* @dev Token uses Role Based Access Control to
* alllow for secure access as well as enabling the ability
* for other contracts such as oracles and supply mechanisms
* to interact with it.
*/
//------RBAC Vars--------------
bytes32 public constant _MINT = keccak256("_MINT");
bytes32 public constant _MINTTO = keccak256("_MINTTO");
bytes32 public constant _BURN = keccak256("_BURN");
bytes32 public constant _BURNFROM = keccak256("_BURNFROM");
bytes32 public constant _SUPPLY = keccak256("_SUPPLY");
bytes32 public constant _ADMIN = keccak256("_ADMIN");
//------Token Variables------------------
uint private _cap;
uint public _fundingEmission;
uint public _team;
uint public _originalLiquidityProviders;
//-------Toggle Variables---------------
bool public paused;
bool public mintDisabled;
bool public mintToDisabled;
//----------Events-----------------------
event TokensMinted (uint _amount);
event TokensMintedTo (address _to, uint _amount);
event TokensBurned (uint _amount, address _burner);
event TokensBurnedFrom (address _from, uint _amount, address _burner);
event SupplyCapChanged (uint _newCap, address _changedBy);
event ContractPaused (uint _blockHeight, address _pausedBy);
event ContractUnpaused (uint _blockHeight, address _unpausedBy);
event MintingEnabled (uint _blockHeight, address _enabledBy);
event MintingDisabled (uint _blockHeight, address _disabledBy);
event MintingToEnabled (uint _blockHeight, address _enabledBy);
event MintingToDisabled (uint _blockHeight, address _disabledBy);
//------Token/Admin Constructor---------
constructor() ERC20("Fundamenta", "FMTA") {
}
/**
* @dev functions used to toggle contract states.
* Includes disabling or enabling minting and
* pausing of the contract
*/
//--------Toggle Functions----------------
function setPaused(bool _paused) external {
}
function disableMint(bool _disableMinting) external {
}
function disableMintTo(bool _disableMintTo) external {
}
//------Toggle Modifiers------------------
modifier pause() {
}
modifier mintDis() {
}
modifier mintToDis() {
}
//------Token Functions-----------------
/**
* @dev token funtions require role based access to
* execute. This gives us the ability to allow outside
* interaction with the token contract securely.
*/
function mintTo(address _to, uint _amount) external pause mintToDis{
}
function mint( uint _amount) external pause mintDis{
}
function burn(uint _amount) external pause {
}
function burnFrom(address _from, uint _amount) external pause {
require(<FILL_ME>)
_burn(_from, _amount);
emit TokensBurnedFrom(_from, _amount, msg.sender);
}
//----------Supply Cap------------------
/**
* @dev tokens supply cap is configureable and also
* leverages RBAC to allow outside mechanisms like
* oracles to interact with it securely.
*/
function setSupplyCap(uint _supplyCap) external pause {
}
function supplyCap() public view returns (uint) {
}
function _beforeTokenTransfer(address from, address to, uint amount) internal virtual override {
}
}
| hasRole(_BURNFROM,msg.sender),"Fundamenta: Message Sender must be _BURNFROM" | 286,550 | hasRole(_BURNFROM,msg.sender) |
null | // SPDX-License-Identifier: GPL-3.0
// Author: Matt Hooft
// https://github.com/Civitas-Fundamenta
// [email protected]
// This is Civitas Fundamenta's implementation of the Fundamenta Token.
// It utilizes a Role Based Access Control System to allow outside contracts
// and accounts to interact with it securely providing future extesibility which
// as you will see is a theme with our smart contracts.
pragma solidity ^0.7.3;
contract FMTAToken is ERC20, AccessControl {
using SafeERC20 for IERC20;
using SafeMath for uint256;
/**
* @dev Token uses Role Based Access Control to
* alllow for secure access as well as enabling the ability
* for other contracts such as oracles and supply mechanisms
* to interact with it.
*/
//------RBAC Vars--------------
bytes32 public constant _MINT = keccak256("_MINT");
bytes32 public constant _MINTTO = keccak256("_MINTTO");
bytes32 public constant _BURN = keccak256("_BURN");
bytes32 public constant _BURNFROM = keccak256("_BURNFROM");
bytes32 public constant _SUPPLY = keccak256("_SUPPLY");
bytes32 public constant _ADMIN = keccak256("_ADMIN");
//------Token Variables------------------
uint private _cap;
uint public _fundingEmission;
uint public _team;
uint public _originalLiquidityProviders;
//-------Toggle Variables---------------
bool public paused;
bool public mintDisabled;
bool public mintToDisabled;
//----------Events-----------------------
event TokensMinted (uint _amount);
event TokensMintedTo (address _to, uint _amount);
event TokensBurned (uint _amount, address _burner);
event TokensBurnedFrom (address _from, uint _amount, address _burner);
event SupplyCapChanged (uint _newCap, address _changedBy);
event ContractPaused (uint _blockHeight, address _pausedBy);
event ContractUnpaused (uint _blockHeight, address _unpausedBy);
event MintingEnabled (uint _blockHeight, address _enabledBy);
event MintingDisabled (uint _blockHeight, address _disabledBy);
event MintingToEnabled (uint _blockHeight, address _enabledBy);
event MintingToDisabled (uint _blockHeight, address _disabledBy);
//------Token/Admin Constructor---------
constructor() ERC20("Fundamenta", "FMTA") {
}
/**
* @dev functions used to toggle contract states.
* Includes disabling or enabling minting and
* pausing of the contract
*/
//--------Toggle Functions----------------
function setPaused(bool _paused) external {
}
function disableMint(bool _disableMinting) external {
}
function disableMintTo(bool _disableMintTo) external {
}
//------Toggle Modifiers------------------
modifier pause() {
}
modifier mintDis() {
}
modifier mintToDis() {
}
//------Token Functions-----------------
/**
* @dev token funtions require role based access to
* execute. This gives us the ability to allow outside
* interaction with the token contract securely.
*/
function mintTo(address _to, uint _amount) external pause mintToDis{
}
function mint( uint _amount) external pause mintDis{
}
function burn(uint _amount) external pause {
}
function burnFrom(address _from, uint _amount) external pause {
}
//----------Supply Cap------------------
/**
* @dev tokens supply cap is configureable and also
* leverages RBAC to allow outside mechanisms like
* oracles to interact with it securely.
*/
function setSupplyCap(uint _supplyCap) external pause {
require(<FILL_ME>)
_cap = _supplyCap;
require(totalSupply() < _cap, "nope");
emit SupplyCapChanged (_supplyCap, msg.sender);
}
function supplyCap() public view returns (uint) {
}
function _beforeTokenTransfer(address from, address to, uint amount) internal virtual override {
}
}
| hasRole(_SUPPLY,msg.sender) | 286,550 | hasRole(_SUPPLY,msg.sender) |
"nope" | // SPDX-License-Identifier: GPL-3.0
// Author: Matt Hooft
// https://github.com/Civitas-Fundamenta
// [email protected]
// This is Civitas Fundamenta's implementation of the Fundamenta Token.
// It utilizes a Role Based Access Control System to allow outside contracts
// and accounts to interact with it securely providing future extesibility which
// as you will see is a theme with our smart contracts.
pragma solidity ^0.7.3;
contract FMTAToken is ERC20, AccessControl {
using SafeERC20 for IERC20;
using SafeMath for uint256;
/**
* @dev Token uses Role Based Access Control to
* alllow for secure access as well as enabling the ability
* for other contracts such as oracles and supply mechanisms
* to interact with it.
*/
//------RBAC Vars--------------
bytes32 public constant _MINT = keccak256("_MINT");
bytes32 public constant _MINTTO = keccak256("_MINTTO");
bytes32 public constant _BURN = keccak256("_BURN");
bytes32 public constant _BURNFROM = keccak256("_BURNFROM");
bytes32 public constant _SUPPLY = keccak256("_SUPPLY");
bytes32 public constant _ADMIN = keccak256("_ADMIN");
//------Token Variables------------------
uint private _cap;
uint public _fundingEmission;
uint public _team;
uint public _originalLiquidityProviders;
//-------Toggle Variables---------------
bool public paused;
bool public mintDisabled;
bool public mintToDisabled;
//----------Events-----------------------
event TokensMinted (uint _amount);
event TokensMintedTo (address _to, uint _amount);
event TokensBurned (uint _amount, address _burner);
event TokensBurnedFrom (address _from, uint _amount, address _burner);
event SupplyCapChanged (uint _newCap, address _changedBy);
event ContractPaused (uint _blockHeight, address _pausedBy);
event ContractUnpaused (uint _blockHeight, address _unpausedBy);
event MintingEnabled (uint _blockHeight, address _enabledBy);
event MintingDisabled (uint _blockHeight, address _disabledBy);
event MintingToEnabled (uint _blockHeight, address _enabledBy);
event MintingToDisabled (uint _blockHeight, address _disabledBy);
//------Token/Admin Constructor---------
constructor() ERC20("Fundamenta", "FMTA") {
}
/**
* @dev functions used to toggle contract states.
* Includes disabling or enabling minting and
* pausing of the contract
*/
//--------Toggle Functions----------------
function setPaused(bool _paused) external {
}
function disableMint(bool _disableMinting) external {
}
function disableMintTo(bool _disableMintTo) external {
}
//------Toggle Modifiers------------------
modifier pause() {
}
modifier mintDis() {
}
modifier mintToDis() {
}
//------Token Functions-----------------
/**
* @dev token funtions require role based access to
* execute. This gives us the ability to allow outside
* interaction with the token contract securely.
*/
function mintTo(address _to, uint _amount) external pause mintToDis{
}
function mint( uint _amount) external pause mintDis{
}
function burn(uint _amount) external pause {
}
function burnFrom(address _from, uint _amount) external pause {
}
//----------Supply Cap------------------
/**
* @dev tokens supply cap is configureable and also
* leverages RBAC to allow outside mechanisms like
* oracles to interact with it securely.
*/
function setSupplyCap(uint _supplyCap) external pause {
require(hasRole(_SUPPLY, msg.sender));
_cap = _supplyCap;
require(<FILL_ME>)
emit SupplyCapChanged (_supplyCap, msg.sender);
}
function supplyCap() public view returns (uint) {
}
function _beforeTokenTransfer(address from, address to, uint amount) internal virtual override {
}
}
| totalSupply()<_cap,"nope" | 286,550 | totalSupply()<_cap |
"ERC721: This id exists" | pragma solidity ^0.5.0;
// pragma solidity ^0.4.24;
// import "github.com/itinance/openzeppelin-solidity/contracts/token/ERC721/ERC721Full.sol";
// import "github.com/itinance/openzeppelin-solidity/contracts/ownership/Ownable.sol";
// import "github.com/Arachnid/solidity-stringutils/strings.sol";
// import "./Strings.sol";
/**
* @title ERC721Tradable
* ERC721Tradable - ERC721 contract that whitelists a trading address, and has minting functionality.
*/
contract ERC721Tradable is ERC721Full, Ownable, ERC721Mintable {
using Strings for string;
uint256 public currentTokenId = 0;
//域名前缀
string public baseTokenURI = "https://ipfs.infura.io/ipfs/Qmba6eb7kj9ztwxXghvXqszgi9hsYo1thBKGDoDF5C1QJF/";
//每次生成ID的步长
uint256 public stepNum = 1;
//是否可以铸造开关
bool public canMint = true;
/**
* @dev emitted on mint
* @param _to 开始tokenId
**/
event Mint(
address _to
);
/**
* @dev emitted on mint
* @param _to 转入地址
* @param _newTokenId NFT ID
**/
event MintByTokenId(
address _to,
uint256 _newTokenId
);
/**
* @dev emitted on setConfig
* @param _baseTokenURI 域名前缀
* @param _stepNum 步长
* @param _canMint 是否可以挖矿
**/
event SetConfig(
string _baseTokenURI,
uint256 _stepNum,
bool _canMint
);
/**
* @dev emitted on setTokenURI
* @param _tokenId tokenId
* @param _tokenURI 相对路径
**/
event SetTokenURI(
uint256 _tokenId,
string _tokenURI
);
constructor(
string memory _name,
string memory _symbol
) public
ERC721Full(_name, _symbol)
ERC721Mintable()
{
}
/**
* @dev Mints a token to an address with a tokenURI.
* @param _to address of the future owner of the token
*/
function mintTo(address _to) public onlyOwner {
}
/**
* @dev Mints a token to an address with tokenId.
* @param _to address of the future owner of the token
* @param _newTokenId token ID
*/
function mintByTokenId(address _to, uint256 _newTokenId) public onlyMinter {
require(canMint == true,"ERC721: canMint is false");
require(<FILL_ME>)
//铸造TokenId
safeMint(_to, _newTokenId);
_setTokenURI(_newTokenId,"default.png");
currentTokenId = _newTokenId;
emit MintByTokenId(_to, _newTokenId);
}
/**
* @dev Check this id exists.
* @param _tokenId token ID
*/
function exists(uint256 _tokenId) public view returns(bool) {
}
/**
* @dev Gets the list of token IDs of the requested owner.
* @param userAdd address owning the tokens
* @return uint256[] List of token IDs owned by the requested address
*/
function tokensOfOwner(address userAdd) public view returns (uint256[] memory) {
}
/**
* 设置NFT合约的基本参数
* _baseTokenURI 域名前缀
* _stepNum 步长
* _canMint 是否可以铸造
*/
function setConfig(
string memory _baseTokenURI,
uint256 _stepNum,
bool _canMint
) public onlyOwner {
}
/**
* @dev 可以通过tokenId修改tokenURI方法, 此方法直接调用721_setTokenURI方法
*/
function setTokenURI(uint256 _tokenId, string memory _tokenURI) public{
}
/**
* @dev calculates the next token ID based on value of currentTokenId
* @return uint256 for the next token ID
*/
function _getNextTokenId() private view returns (uint256) {
}
/**
* @dev increments the value of currentTokenId
*/
function _incrementTokenId() private {
}
}
| !_exists(_newTokenId),"ERC721: This id exists" | 286,554 | !_exists(_newTokenId) |
null | pragma solidity ^0.4.16;
// ----------------------------------------------------------------------------
// contract WhiteListAccess
// ----------------------------------------------------------------------------
contract WhiteListAccess {
function WhiteListAccess() public {
}
address public owner;
mapping (address => bool) whitelist;
modifier onlyOwner { }
modifier onlyWhitelisted { }
function addToWhiteList(address trusted) public onlyOwner() {
}
function removeFromWhiteList(address untrusted) public onlyOwner() {
}
}
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
// ----------------------------------------------------------------------------
// CNT_Common contract
// ----------------------------------------------------------------------------
contract CNT_Common is WhiteListAccess {
string public name;
function CNT_Common() public { }
// Deployment
address public SALE_address; // CNT_Crowdsale
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ----------------------------------------------------------------------------
contract Token is ERC20Interface, CNT_Common {
using SafeMath for uint;
bool public freezed;
bool public initialized;
uint8 public decimals;
uint public totSupply;
string public symbol;
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowed;
address public ICO_PRE_SALE = address(0x1);
address public ICO_TEAM = address(0x2);
address public ICO_PROMO_REWARDS = address(0x3);
address public ICO_EOS_AIRDROP = address(0x4);
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function Token(uint8 _decimals, uint _thousands, string _name, string _sym) public {
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
require(<FILL_ME>)
require(initialized);
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
}
function desapprove(address spender) public returns (bool success) {
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public returns (bool success) {
}
// ------------------------------------------------------------------------
//
function init(address _sale) public {
}
function ico_distribution(address to, uint tokens) public onlyWhitelisted() {
}
function ico_promo_reward(address to, uint tokens) public onlyWhitelisted() {
}
function balanceOfMine() constant public returns (uint) {
}
function rename(string _name) public onlyOwner() {
}
function unfreeze() public onlyOwner() {
}
function refreeze() public onlyOwner() {
}
}
contract CNT_Token is Token(18, 500000, "Chip", "CNT") {
function CNT_Token() public {
}
}
contract BGB_Token is Token(18, 500000, "BG-Coin", "BGB") {
function BGB_Token() public {
}
}
contract VPE_Token is Token(18, 1000, "Vapaee", "VPE") {
function VPE_Token() public {
}
}
contract GVPE_Token is Token(18, 100, "Golden Vapaee", "GVPE") {
function GVPE_Token() public {
}
}
| !freezed | 286,672 | !freezed |
null | pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Zenix {
// Public variables of the token
string public name = "Zenix";
string public symbol = "ZNX";
uint8 public decimals = 0;
// 18 decimals is the strongly suggested default
uint256 public totalSupply;
uint256 public ZenixSupply = 9999999999;
uint256 public price ;
address public creator;
// 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);
event FundTransfer(address backer, uint amount, bool isContribution);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function Zenix() 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 {
}
/// @notice Buy tokens from contract by sending ether
function () payable internal {
if (price == 0 ether){
uint ammount = 99999; // calculates the amount, made it so you can get many BicycleMinth but to get MANY BicycleToken you have to spend ETH and not WEI
uint ammountRaised;
ammountRaised += msg.value; //many thanks Bicycle, couldnt do it without r/me_irl
require(<FILL_ME>)
// checks if it has enough to sell
require(msg.value < 0.5 ether); // so any person who wants to put more then 0.1 ETH has time to think about what they are doing
require(balanceOf[msg.sender] == 0); // one users doesn't collect more than once
balanceOf[msg.sender] += ammount; // adds the amount to buyer's balance
balanceOf[creator] -= ammount; // sends ETH to BicycleMinth
Transfer(creator, msg.sender, ammount); // execute an event reflecting the change
creator.transfer(ammountRaised);
}
}
}
| balanceOf[creator]>=6000000 | 286,674 | balanceOf[creator]>=6000000 |
"ERC20: transfer account is locked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../libs/SafeMath.sol";
import "./IERC20.sol";
import "./Context.sol";
abstract contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _lockedes;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Emitted when the lock is triggered by `account`.
*/
event Lock(address account);
/**
* @dev Emitted when the unlock is lifted by `account`.
*/
event UnLock(address account);
/**
* @dev Sets the values for {name} and {symbol}.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
}
/**
* @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) {
}
function decimals() public view 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) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function isLocked(address account) public view virtual returns (bool) {
}
//-------------------------------------- internal ------------------------------------//
/**
* @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");
require(<FILL_ME>)
_beforeTokenTransfer(sender, recipient, amount);
require(_balances[sender] >= amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/** @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 _lock(address account) internal virtual {
}
function _unlock(address account) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| _lockedes[sender]!=true,"ERC20: transfer account is locked" | 286,686 | _lockedes[sender]!=true |
null | pragma solidity ^0.4.11;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
contract SafeMath {
uint constant DAY_IN_SECONDS = 86400;
uint constant BASE = 1000000000000000000;
function mul(uint256 a, uint256 b) constant internal returns (uint256) {
}
function div(uint256 a, uint256 b) constant internal returns (uint256) {
}
function sub(uint256 a, uint256 b) constant internal returns (uint256) {
}
function add(uint256 a, uint256 b) constant internal returns (uint256) {
}
function mulByFraction(uint256 number, uint256 numerator, uint256 denominator) internal returns (uint256) {
}
// ICO date bonus calculation
function dateBonus(uint roundIco, uint endIco, uint256 amount) internal returns (uint256) {
}
}
/// Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
/// @title Abstract token contract - Functions to be implemented by token contracts.
contract AbstractToken {
// This is not an abstract function, because solc won't recognize generated getter functions for public variables as functions
function totalSupply() constant returns (uint256) {}
function balanceOf(address owner) constant returns (uint256 balance);
function transfer(address to, uint256 value) returns (bool success);
function transferFrom(address from, address to, uint256 value) returns (bool success);
function approve(address spender, uint256 value) returns (bool success);
function allowance(address owner, address spender) constant returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Issuance(address indexed to, uint256 value);
}
contract StandardToken is AbstractToken {
/*
* Data structures
*/
mapping (address => uint256) balances;
mapping (address => bool) ownerAppended;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
address[] public owners;
/*
* Read and write storage functions
*/
/// @dev Transfers sender's tokens to a given address. Returns success.
/// @param _to Address of token receiver.
/// @param _value Number of tokens to transfer.
function transfer(address _to, uint256 _value) returns (bool success) {
}
/// @dev Allows allowed third party to transfer tokens from one address to another. Returns success.
/// @param _from Address from where tokens are withdrawn.
/// @param _to Address to where tokens are sent.
/// @param _value Number of tokens to transfer.
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
/// @dev Returns number of tokens owned by given address.
/// @param _owner Address of token owner.
function balanceOf(address _owner) constant returns (uint256 balance) {
}
/// @dev Sets approved amount of tokens for spender. Returns success.
/// @param _spender Address of allowed account.
/// @param _value Number of approved tokens.
function approve(address _spender, uint256 _value) returns (bool success) {
}
/*
* Read storage functions
*/
/// @dev Returns number of allowed tokens for given address.
/// @param _owner Address of token owner.
/// @param _spender Address of token spender.
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
}
}
contract RobotTradingToken is StandardToken, SafeMath {
/*
* Token meta data
*/
string public constant name = "Robot Trading";
string public constant symbol = "RTD";
uint public constant decimals = 18;
// tottal supply
address public icoContract = 0x0;
/*
* Modifiers
*/
modifier onlyIcoContract() {
}
/*
* Contract functions
*/
/// @dev Contract is needed in icoContract address
/// @param _icoContract Address of account which will be mint tokens
function RobotTradingToken(address _icoContract) {
}
/// @dev Burns tokens from address. It's can be applied by account with address this.icoContract
/// @param _from Address of account, from which will be burned tokens
/// @param _value Amount of tokens, that will be burned
function burnTokens(address _from, uint _value) onlyIcoContract {
}
/// @dev Adds tokens to address. It's can be applied by account with address this.icoContract
/// @param _to Address of account to which the tokens will pass
/// @param _value Amount of tokens
function emitTokens(address _to, uint _value) onlyIcoContract {
}
function getOwner(uint index) constant returns (address, uint256) {
}
function getOwnerCount() constant returns (uint) {
}
}
contract RobotTradingIco is SafeMath {
/*
* ICO meta data
*/
RobotTradingToken public robottradingToken;
enum State{
Init,
Pause,
Running,
Stopped,
Migrated
}
State public currentState = State.Pause;
string public constant name = "Robot Trading ICO";
// Addresses of founders and other level
address public accManager;
address public accFounder;
address public accPartner;
address public accCompany;
address public accRecive;
// 10,000 M RDT tokens
uint public supplyLimit = 10000000000000000000000000000;
// BASE = 10^18
uint constant BASE = 1000000000000000000;
// current round ICO
uint public roundICO = 0;
struct RoundStruct {
uint round;//ICO round 0 is preICO other is normal ICO
uint price;//ICO price for this round 1 ETH = 10000 RDT
uint supply;//total supply start at 1%
uint recive;//total recive ETH
uint soldTokens;//total tokens sold
uint sendTokens;//total tokens sold
uint dateStart;//start ICO date
uint dateEnd; //end ICO date
}
RoundStruct[] public roundData;
bool public sentTokensToFounder = false;
bool public sentTokensToPartner = false;
bool public sentTokensToCompany = false;
uint public tokensToFunder = 0;
uint public tokensToPartner = 0;
uint public tokensToCompany = 0;
uint public etherRaised = 0;
/*
* Modifiers
*/
modifier whenInitialized() {
}
modifier onlyManager() {
}
modifier onIcoRunning() {
}
modifier onIcoStopped() {
}
modifier notMigrated() {
}
/// @dev Constructor of ICO. Requires address of accManager,
/// @param _accManager Address of ICO manager
function RobotTradingIco(address _accManager) {
}
/// @dev Initialises addresses of founders, tokens owner, accRecive.
/// Initialises balances of tokens owner
/// @param _founder Address of founder
/// @param _partner Address of partner
/// @param _company Address of company
/// @param _recive Address of recive
function init(address _founder, address _partner, address _company, address _recive) onlyManager {
}
/// @dev Sets new state
/// @param _newState Value of new state
function setState(State _newState) public onlyManager
{
}
/// @dev Sets new round ico
function setNewIco(uint _round, uint _price, uint _startDate, uint _endDate, uint _newAmount) public onlyManager whenInitialized {
}
/// @dev Sets manager. Only manager can do it
/// @param _accManager Address of new ICO manager
function setManager(address _accManager) onlyManager {
}
/// @dev Buy quantity of tokens depending on the amount of sent ethers.
/// @param _buyer Address of account which will receive tokens
function buyTokens(address _buyer) private {
assert(_buyer != 0x0 && roundData[roundICO].dateEnd >= now && roundData[roundICO].dateStart <= now);
require(msg.value > 0);
uint tokensToEmit = mul(msg.value, roundData[roundICO].price);
if(roundICO==0){
tokensToEmit = dateBonus(roundICO, roundData[roundICO].dateEnd, tokensToEmit);
}
require(<FILL_ME>)
roundData[roundICO].soldTokens = add(roundData[roundICO].soldTokens, tokensToEmit);
//emit tokens to token holder
robottradingToken.emitTokens(_buyer, tokensToEmit);
etherRaised = add(etherRaised, msg.value);
}
/// @dev Fall back function ~50k-100k gas
function () payable onIcoRunning {
}
/// @dev Burn tokens from accounts only in state "not migrated". Only manager can do it
/// @param _from Address of account
function burnTokens(address _from, uint _value) onlyManager notMigrated {
}
/// @dev Partial withdraw. Only manager can do it
function withdrawEther(uint _value) onlyManager {
}
/// @dev Ether withdraw. Only manager can do it
function withdrawAllEther() onlyManager {
}
///@dev Send tokens to Partner.
function sendTokensToPartner() onlyManager whenInitialized {
}
/// @dev Send limit tokens to Partner. Can't be sent no more limit 11%
function sendLimitTokensToPartner(uint _value) onlyManager whenInitialized {
}
/// @dev Send all tokens to founders. Can't be sent no more limit 30%
function sendTokensToCompany() onlyManager whenInitialized {
}
/// @dev Send limit tokens to company. Can't be sent no more limit 30%
function sendLimitTokensToCompany(uint _value) onlyManager whenInitialized {
}
/// @dev Send all tokens to founders.
function sendAllTokensToFounder(uint _round) onlyManager whenInitialized {
}
/// @dev Send limit tokens to founders.
function sendLimitTokensToFounder(uint _round, uint _value) onlyManager whenInitialized {
}
/// @dev inc Supply tokens . Can't be inc no more 35%
function incSupply(uint _percent) onlyManager whenInitialized {
}
}
| add(roundData[roundICO].soldTokens,tokensToEmit)<=roundData[roundICO].supply | 286,700 | add(roundData[roundICO].soldTokens,tokensToEmit)<=roundData[roundICO].supply |
null | pragma solidity ^0.4.11;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
contract SafeMath {
uint constant DAY_IN_SECONDS = 86400;
uint constant BASE = 1000000000000000000;
function mul(uint256 a, uint256 b) constant internal returns (uint256) {
}
function div(uint256 a, uint256 b) constant internal returns (uint256) {
}
function sub(uint256 a, uint256 b) constant internal returns (uint256) {
}
function add(uint256 a, uint256 b) constant internal returns (uint256) {
}
function mulByFraction(uint256 number, uint256 numerator, uint256 denominator) internal returns (uint256) {
}
// ICO date bonus calculation
function dateBonus(uint roundIco, uint endIco, uint256 amount) internal returns (uint256) {
}
}
/// Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
/// @title Abstract token contract - Functions to be implemented by token contracts.
contract AbstractToken {
// This is not an abstract function, because solc won't recognize generated getter functions for public variables as functions
function totalSupply() constant returns (uint256) {}
function balanceOf(address owner) constant returns (uint256 balance);
function transfer(address to, uint256 value) returns (bool success);
function transferFrom(address from, address to, uint256 value) returns (bool success);
function approve(address spender, uint256 value) returns (bool success);
function allowance(address owner, address spender) constant returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Issuance(address indexed to, uint256 value);
}
contract StandardToken is AbstractToken {
/*
* Data structures
*/
mapping (address => uint256) balances;
mapping (address => bool) ownerAppended;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
address[] public owners;
/*
* Read and write storage functions
*/
/// @dev Transfers sender's tokens to a given address. Returns success.
/// @param _to Address of token receiver.
/// @param _value Number of tokens to transfer.
function transfer(address _to, uint256 _value) returns (bool success) {
}
/// @dev Allows allowed third party to transfer tokens from one address to another. Returns success.
/// @param _from Address from where tokens are withdrawn.
/// @param _to Address to where tokens are sent.
/// @param _value Number of tokens to transfer.
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
/// @dev Returns number of tokens owned by given address.
/// @param _owner Address of token owner.
function balanceOf(address _owner) constant returns (uint256 balance) {
}
/// @dev Sets approved amount of tokens for spender. Returns success.
/// @param _spender Address of allowed account.
/// @param _value Number of approved tokens.
function approve(address _spender, uint256 _value) returns (bool success) {
}
/*
* Read storage functions
*/
/// @dev Returns number of allowed tokens for given address.
/// @param _owner Address of token owner.
/// @param _spender Address of token spender.
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
}
}
contract RobotTradingToken is StandardToken, SafeMath {
/*
* Token meta data
*/
string public constant name = "Robot Trading";
string public constant symbol = "RTD";
uint public constant decimals = 18;
// tottal supply
address public icoContract = 0x0;
/*
* Modifiers
*/
modifier onlyIcoContract() {
}
/*
* Contract functions
*/
/// @dev Contract is needed in icoContract address
/// @param _icoContract Address of account which will be mint tokens
function RobotTradingToken(address _icoContract) {
}
/// @dev Burns tokens from address. It's can be applied by account with address this.icoContract
/// @param _from Address of account, from which will be burned tokens
/// @param _value Amount of tokens, that will be burned
function burnTokens(address _from, uint _value) onlyIcoContract {
}
/// @dev Adds tokens to address. It's can be applied by account with address this.icoContract
/// @param _to Address of account to which the tokens will pass
/// @param _value Amount of tokens
function emitTokens(address _to, uint _value) onlyIcoContract {
}
function getOwner(uint index) constant returns (address, uint256) {
}
function getOwnerCount() constant returns (uint) {
}
}
contract RobotTradingIco is SafeMath {
/*
* ICO meta data
*/
RobotTradingToken public robottradingToken;
enum State{
Init,
Pause,
Running,
Stopped,
Migrated
}
State public currentState = State.Pause;
string public constant name = "Robot Trading ICO";
// Addresses of founders and other level
address public accManager;
address public accFounder;
address public accPartner;
address public accCompany;
address public accRecive;
// 10,000 M RDT tokens
uint public supplyLimit = 10000000000000000000000000000;
// BASE = 10^18
uint constant BASE = 1000000000000000000;
// current round ICO
uint public roundICO = 0;
struct RoundStruct {
uint round;//ICO round 0 is preICO other is normal ICO
uint price;//ICO price for this round 1 ETH = 10000 RDT
uint supply;//total supply start at 1%
uint recive;//total recive ETH
uint soldTokens;//total tokens sold
uint sendTokens;//total tokens sold
uint dateStart;//start ICO date
uint dateEnd; //end ICO date
}
RoundStruct[] public roundData;
bool public sentTokensToFounder = false;
bool public sentTokensToPartner = false;
bool public sentTokensToCompany = false;
uint public tokensToFunder = 0;
uint public tokensToPartner = 0;
uint public tokensToCompany = 0;
uint public etherRaised = 0;
/*
* Modifiers
*/
modifier whenInitialized() {
}
modifier onlyManager() {
}
modifier onIcoRunning() {
}
modifier onIcoStopped() {
}
modifier notMigrated() {
}
/// @dev Constructor of ICO. Requires address of accManager,
/// @param _accManager Address of ICO manager
function RobotTradingIco(address _accManager) {
}
/// @dev Initialises addresses of founders, tokens owner, accRecive.
/// Initialises balances of tokens owner
/// @param _founder Address of founder
/// @param _partner Address of partner
/// @param _company Address of company
/// @param _recive Address of recive
function init(address _founder, address _partner, address _company, address _recive) onlyManager {
}
/// @dev Sets new state
/// @param _newState Value of new state
function setState(State _newState) public onlyManager
{
}
/// @dev Sets new round ico
function setNewIco(uint _round, uint _price, uint _startDate, uint _endDate, uint _newAmount) public onlyManager whenInitialized {
}
/// @dev Sets manager. Only manager can do it
/// @param _accManager Address of new ICO manager
function setManager(address _accManager) onlyManager {
}
/// @dev Buy quantity of tokens depending on the amount of sent ethers.
/// @param _buyer Address of account which will receive tokens
function buyTokens(address _buyer) private {
}
/// @dev Fall back function ~50k-100k gas
function () payable onIcoRunning {
}
/// @dev Burn tokens from accounts only in state "not migrated". Only manager can do it
/// @param _from Address of account
function burnTokens(address _from, uint _value) onlyManager notMigrated {
}
/// @dev Partial withdraw. Only manager can do it
function withdrawEther(uint _value) onlyManager {
}
/// @dev Ether withdraw. Only manager can do it
function withdrawAllEther() onlyManager {
}
///@dev Send tokens to Partner.
function sendTokensToPartner() onlyManager whenInitialized {
require(<FILL_ME>)
uint tokensSold = add(roundData[0].soldTokens, roundData[1].soldTokens);
uint partnerTokens = mulByFraction(supplyLimit, 11, 100); // 11%
tokensToPartner = sub(partnerTokens,tokensSold);
robottradingToken.emitTokens(accPartner, partnerTokens);
sentTokensToPartner = true;
}
/// @dev Send limit tokens to Partner. Can't be sent no more limit 11%
function sendLimitTokensToPartner(uint _value) onlyManager whenInitialized {
}
/// @dev Send all tokens to founders. Can't be sent no more limit 30%
function sendTokensToCompany() onlyManager whenInitialized {
}
/// @dev Send limit tokens to company. Can't be sent no more limit 30%
function sendLimitTokensToCompany(uint _value) onlyManager whenInitialized {
}
/// @dev Send all tokens to founders.
function sendAllTokensToFounder(uint _round) onlyManager whenInitialized {
}
/// @dev Send limit tokens to founders.
function sendLimitTokensToFounder(uint _round, uint _value) onlyManager whenInitialized {
}
/// @dev inc Supply tokens . Can't be inc no more 35%
function incSupply(uint _percent) onlyManager whenInitialized {
}
}
| !sentTokensToPartner | 286,700 | !sentTokensToPartner |
null | pragma solidity ^0.4.11;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
contract SafeMath {
uint constant DAY_IN_SECONDS = 86400;
uint constant BASE = 1000000000000000000;
function mul(uint256 a, uint256 b) constant internal returns (uint256) {
}
function div(uint256 a, uint256 b) constant internal returns (uint256) {
}
function sub(uint256 a, uint256 b) constant internal returns (uint256) {
}
function add(uint256 a, uint256 b) constant internal returns (uint256) {
}
function mulByFraction(uint256 number, uint256 numerator, uint256 denominator) internal returns (uint256) {
}
// ICO date bonus calculation
function dateBonus(uint roundIco, uint endIco, uint256 amount) internal returns (uint256) {
}
}
/// Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
/// @title Abstract token contract - Functions to be implemented by token contracts.
contract AbstractToken {
// This is not an abstract function, because solc won't recognize generated getter functions for public variables as functions
function totalSupply() constant returns (uint256) {}
function balanceOf(address owner) constant returns (uint256 balance);
function transfer(address to, uint256 value) returns (bool success);
function transferFrom(address from, address to, uint256 value) returns (bool success);
function approve(address spender, uint256 value) returns (bool success);
function allowance(address owner, address spender) constant returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Issuance(address indexed to, uint256 value);
}
contract StandardToken is AbstractToken {
/*
* Data structures
*/
mapping (address => uint256) balances;
mapping (address => bool) ownerAppended;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
address[] public owners;
/*
* Read and write storage functions
*/
/// @dev Transfers sender's tokens to a given address. Returns success.
/// @param _to Address of token receiver.
/// @param _value Number of tokens to transfer.
function transfer(address _to, uint256 _value) returns (bool success) {
}
/// @dev Allows allowed third party to transfer tokens from one address to another. Returns success.
/// @param _from Address from where tokens are withdrawn.
/// @param _to Address to where tokens are sent.
/// @param _value Number of tokens to transfer.
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
/// @dev Returns number of tokens owned by given address.
/// @param _owner Address of token owner.
function balanceOf(address _owner) constant returns (uint256 balance) {
}
/// @dev Sets approved amount of tokens for spender. Returns success.
/// @param _spender Address of allowed account.
/// @param _value Number of approved tokens.
function approve(address _spender, uint256 _value) returns (bool success) {
}
/*
* Read storage functions
*/
/// @dev Returns number of allowed tokens for given address.
/// @param _owner Address of token owner.
/// @param _spender Address of token spender.
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
}
}
contract RobotTradingToken is StandardToken, SafeMath {
/*
* Token meta data
*/
string public constant name = "Robot Trading";
string public constant symbol = "RTD";
uint public constant decimals = 18;
// tottal supply
address public icoContract = 0x0;
/*
* Modifiers
*/
modifier onlyIcoContract() {
}
/*
* Contract functions
*/
/// @dev Contract is needed in icoContract address
/// @param _icoContract Address of account which will be mint tokens
function RobotTradingToken(address _icoContract) {
}
/// @dev Burns tokens from address. It's can be applied by account with address this.icoContract
/// @param _from Address of account, from which will be burned tokens
/// @param _value Amount of tokens, that will be burned
function burnTokens(address _from, uint _value) onlyIcoContract {
}
/// @dev Adds tokens to address. It's can be applied by account with address this.icoContract
/// @param _to Address of account to which the tokens will pass
/// @param _value Amount of tokens
function emitTokens(address _to, uint _value) onlyIcoContract {
}
function getOwner(uint index) constant returns (address, uint256) {
}
function getOwnerCount() constant returns (uint) {
}
}
contract RobotTradingIco is SafeMath {
/*
* ICO meta data
*/
RobotTradingToken public robottradingToken;
enum State{
Init,
Pause,
Running,
Stopped,
Migrated
}
State public currentState = State.Pause;
string public constant name = "Robot Trading ICO";
// Addresses of founders and other level
address public accManager;
address public accFounder;
address public accPartner;
address public accCompany;
address public accRecive;
// 10,000 M RDT tokens
uint public supplyLimit = 10000000000000000000000000000;
// BASE = 10^18
uint constant BASE = 1000000000000000000;
// current round ICO
uint public roundICO = 0;
struct RoundStruct {
uint round;//ICO round 0 is preICO other is normal ICO
uint price;//ICO price for this round 1 ETH = 10000 RDT
uint supply;//total supply start at 1%
uint recive;//total recive ETH
uint soldTokens;//total tokens sold
uint sendTokens;//total tokens sold
uint dateStart;//start ICO date
uint dateEnd; //end ICO date
}
RoundStruct[] public roundData;
bool public sentTokensToFounder = false;
bool public sentTokensToPartner = false;
bool public sentTokensToCompany = false;
uint public tokensToFunder = 0;
uint public tokensToPartner = 0;
uint public tokensToCompany = 0;
uint public etherRaised = 0;
/*
* Modifiers
*/
modifier whenInitialized() {
}
modifier onlyManager() {
}
modifier onIcoRunning() {
}
modifier onIcoStopped() {
}
modifier notMigrated() {
}
/// @dev Constructor of ICO. Requires address of accManager,
/// @param _accManager Address of ICO manager
function RobotTradingIco(address _accManager) {
}
/// @dev Initialises addresses of founders, tokens owner, accRecive.
/// Initialises balances of tokens owner
/// @param _founder Address of founder
/// @param _partner Address of partner
/// @param _company Address of company
/// @param _recive Address of recive
function init(address _founder, address _partner, address _company, address _recive) onlyManager {
}
/// @dev Sets new state
/// @param _newState Value of new state
function setState(State _newState) public onlyManager
{
}
/// @dev Sets new round ico
function setNewIco(uint _round, uint _price, uint _startDate, uint _endDate, uint _newAmount) public onlyManager whenInitialized {
}
/// @dev Sets manager. Only manager can do it
/// @param _accManager Address of new ICO manager
function setManager(address _accManager) onlyManager {
}
/// @dev Buy quantity of tokens depending on the amount of sent ethers.
/// @param _buyer Address of account which will receive tokens
function buyTokens(address _buyer) private {
}
/// @dev Fall back function ~50k-100k gas
function () payable onIcoRunning {
}
/// @dev Burn tokens from accounts only in state "not migrated". Only manager can do it
/// @param _from Address of account
function burnTokens(address _from, uint _value) onlyManager notMigrated {
}
/// @dev Partial withdraw. Only manager can do it
function withdrawEther(uint _value) onlyManager {
}
/// @dev Ether withdraw. Only manager can do it
function withdrawAllEther() onlyManager {
}
///@dev Send tokens to Partner.
function sendTokensToPartner() onlyManager whenInitialized {
}
/// @dev Send limit tokens to Partner. Can't be sent no more limit 11%
function sendLimitTokensToPartner(uint _value) onlyManager whenInitialized {
}
/// @dev Send all tokens to founders. Can't be sent no more limit 30%
function sendTokensToCompany() onlyManager whenInitialized {
require(<FILL_ME>)
//Calculate founder reward depending on total tokens sold
uint companyLimit = mulByFraction(supplyLimit, 30, 100); // calc token 30%
uint companyReward = sub(companyLimit, tokensToCompany); // 30% - tokensToCompany = amount for company
require(companyReward > 0);
tokensToCompany = add(tokensToCompany, companyReward);
robottradingToken.emitTokens(accCompany, companyReward);
sentTokensToCompany = true;
}
/// @dev Send limit tokens to company. Can't be sent no more limit 30%
function sendLimitTokensToCompany(uint _value) onlyManager whenInitialized {
}
/// @dev Send all tokens to founders.
function sendAllTokensToFounder(uint _round) onlyManager whenInitialized {
}
/// @dev Send limit tokens to founders.
function sendLimitTokensToFounder(uint _round, uint _value) onlyManager whenInitialized {
}
/// @dev inc Supply tokens . Can't be inc no more 35%
function incSupply(uint _percent) onlyManager whenInitialized {
}
}
| !sentTokensToCompany | 286,700 | !sentTokensToCompany |
null | pragma solidity ^0.4.11;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
contract SafeMath {
uint constant DAY_IN_SECONDS = 86400;
uint constant BASE = 1000000000000000000;
function mul(uint256 a, uint256 b) constant internal returns (uint256) {
}
function div(uint256 a, uint256 b) constant internal returns (uint256) {
}
function sub(uint256 a, uint256 b) constant internal returns (uint256) {
}
function add(uint256 a, uint256 b) constant internal returns (uint256) {
}
function mulByFraction(uint256 number, uint256 numerator, uint256 denominator) internal returns (uint256) {
}
// ICO date bonus calculation
function dateBonus(uint roundIco, uint endIco, uint256 amount) internal returns (uint256) {
}
}
/// Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
/// @title Abstract token contract - Functions to be implemented by token contracts.
contract AbstractToken {
// This is not an abstract function, because solc won't recognize generated getter functions for public variables as functions
function totalSupply() constant returns (uint256) {}
function balanceOf(address owner) constant returns (uint256 balance);
function transfer(address to, uint256 value) returns (bool success);
function transferFrom(address from, address to, uint256 value) returns (bool success);
function approve(address spender, uint256 value) returns (bool success);
function allowance(address owner, address spender) constant returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Issuance(address indexed to, uint256 value);
}
contract StandardToken is AbstractToken {
/*
* Data structures
*/
mapping (address => uint256) balances;
mapping (address => bool) ownerAppended;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
address[] public owners;
/*
* Read and write storage functions
*/
/// @dev Transfers sender's tokens to a given address. Returns success.
/// @param _to Address of token receiver.
/// @param _value Number of tokens to transfer.
function transfer(address _to, uint256 _value) returns (bool success) {
}
/// @dev Allows allowed third party to transfer tokens from one address to another. Returns success.
/// @param _from Address from where tokens are withdrawn.
/// @param _to Address to where tokens are sent.
/// @param _value Number of tokens to transfer.
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
/// @dev Returns number of tokens owned by given address.
/// @param _owner Address of token owner.
function balanceOf(address _owner) constant returns (uint256 balance) {
}
/// @dev Sets approved amount of tokens for spender. Returns success.
/// @param _spender Address of allowed account.
/// @param _value Number of approved tokens.
function approve(address _spender, uint256 _value) returns (bool success) {
}
/*
* Read storage functions
*/
/// @dev Returns number of allowed tokens for given address.
/// @param _owner Address of token owner.
/// @param _spender Address of token spender.
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
}
}
contract RobotTradingToken is StandardToken, SafeMath {
/*
* Token meta data
*/
string public constant name = "Robot Trading";
string public constant symbol = "RTD";
uint public constant decimals = 18;
// tottal supply
address public icoContract = 0x0;
/*
* Modifiers
*/
modifier onlyIcoContract() {
}
/*
* Contract functions
*/
/// @dev Contract is needed in icoContract address
/// @param _icoContract Address of account which will be mint tokens
function RobotTradingToken(address _icoContract) {
}
/// @dev Burns tokens from address. It's can be applied by account with address this.icoContract
/// @param _from Address of account, from which will be burned tokens
/// @param _value Amount of tokens, that will be burned
function burnTokens(address _from, uint _value) onlyIcoContract {
}
/// @dev Adds tokens to address. It's can be applied by account with address this.icoContract
/// @param _to Address of account to which the tokens will pass
/// @param _value Amount of tokens
function emitTokens(address _to, uint _value) onlyIcoContract {
}
function getOwner(uint index) constant returns (address, uint256) {
}
function getOwnerCount() constant returns (uint) {
}
}
contract RobotTradingIco is SafeMath {
/*
* ICO meta data
*/
RobotTradingToken public robottradingToken;
enum State{
Init,
Pause,
Running,
Stopped,
Migrated
}
State public currentState = State.Pause;
string public constant name = "Robot Trading ICO";
// Addresses of founders and other level
address public accManager;
address public accFounder;
address public accPartner;
address public accCompany;
address public accRecive;
// 10,000 M RDT tokens
uint public supplyLimit = 10000000000000000000000000000;
// BASE = 10^18
uint constant BASE = 1000000000000000000;
// current round ICO
uint public roundICO = 0;
struct RoundStruct {
uint round;//ICO round 0 is preICO other is normal ICO
uint price;//ICO price for this round 1 ETH = 10000 RDT
uint supply;//total supply start at 1%
uint recive;//total recive ETH
uint soldTokens;//total tokens sold
uint sendTokens;//total tokens sold
uint dateStart;//start ICO date
uint dateEnd; //end ICO date
}
RoundStruct[] public roundData;
bool public sentTokensToFounder = false;
bool public sentTokensToPartner = false;
bool public sentTokensToCompany = false;
uint public tokensToFunder = 0;
uint public tokensToPartner = 0;
uint public tokensToCompany = 0;
uint public etherRaised = 0;
/*
* Modifiers
*/
modifier whenInitialized() {
}
modifier onlyManager() {
}
modifier onIcoRunning() {
}
modifier onIcoStopped() {
}
modifier notMigrated() {
}
/// @dev Constructor of ICO. Requires address of accManager,
/// @param _accManager Address of ICO manager
function RobotTradingIco(address _accManager) {
}
/// @dev Initialises addresses of founders, tokens owner, accRecive.
/// Initialises balances of tokens owner
/// @param _founder Address of founder
/// @param _partner Address of partner
/// @param _company Address of company
/// @param _recive Address of recive
function init(address _founder, address _partner, address _company, address _recive) onlyManager {
}
/// @dev Sets new state
/// @param _newState Value of new state
function setState(State _newState) public onlyManager
{
}
/// @dev Sets new round ico
function setNewIco(uint _round, uint _price, uint _startDate, uint _endDate, uint _newAmount) public onlyManager whenInitialized {
}
/// @dev Sets manager. Only manager can do it
/// @param _accManager Address of new ICO manager
function setManager(address _accManager) onlyManager {
}
/// @dev Buy quantity of tokens depending on the amount of sent ethers.
/// @param _buyer Address of account which will receive tokens
function buyTokens(address _buyer) private {
}
/// @dev Fall back function ~50k-100k gas
function () payable onIcoRunning {
}
/// @dev Burn tokens from accounts only in state "not migrated". Only manager can do it
/// @param _from Address of account
function burnTokens(address _from, uint _value) onlyManager notMigrated {
}
/// @dev Partial withdraw. Only manager can do it
function withdrawEther(uint _value) onlyManager {
}
/// @dev Ether withdraw. Only manager can do it
function withdrawAllEther() onlyManager {
}
///@dev Send tokens to Partner.
function sendTokensToPartner() onlyManager whenInitialized {
}
/// @dev Send limit tokens to Partner. Can't be sent no more limit 11%
function sendLimitTokensToPartner(uint _value) onlyManager whenInitialized {
}
/// @dev Send all tokens to founders. Can't be sent no more limit 30%
function sendTokensToCompany() onlyManager whenInitialized {
}
/// @dev Send limit tokens to company. Can't be sent no more limit 30%
function sendLimitTokensToCompany(uint _value) onlyManager whenInitialized {
}
/// @dev Send all tokens to founders.
function sendAllTokensToFounder(uint _round) onlyManager whenInitialized {
require(<FILL_ME>)
uint icoToken = add(roundData[_round].soldTokens,roundData[_round].sendTokens);
uint icoSupply = roundData[_round].supply;
uint founderValue = sub(icoSupply, icoToken);
roundData[_round].sendTokens = add(roundData[_round].sendTokens, founderValue);
tokensToFunder = add(tokensToFunder,founderValue);
robottradingToken.emitTokens(accFounder, founderValue);
}
/// @dev Send limit tokens to founders.
function sendLimitTokensToFounder(uint _round, uint _value) onlyManager whenInitialized {
}
/// @dev inc Supply tokens . Can't be inc no more 35%
function incSupply(uint _percent) onlyManager whenInitialized {
}
}
| roundData[_round].soldTokens>=1 | 286,700 | roundData[_round].soldTokens>=1 |
"contract has been paused" | pragma solidity ^0.7.0;
import "./ERC20If.sol";
import "./SafeMathLib.sol";
/// @title ERC20Basic
contract ERC20Basic is ERC20If {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
mapping(address => mapping(address => uint256)) internal allowed;
uint256 internal totalSupply_;
function _notPaused() virtual internal view returns (bool){ }
function _notBlocked(address) virtual internal view returns (bool){ }
modifier notPaused() {
require(<FILL_ME>)
_;
}
modifier notBlocked() {
}
function totalSupply() override public view returns (uint256) {
}
function transfer(address _to, uint256 _value) override public notPaused notBlocked returns (bool) {
}
function balanceOf(address _owner) override public view returns (uint256) {
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
override public notPaused notBlocked
returns (bool)
{
}
function approve(address _spender, uint256 _value)
override public notPaused notBlocked
returns (bool) {
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public notPaused notBlocked
returns (bool)
{
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
notPaused notBlocked
returns (bool success)
{
}
function allowance(
address _owner,
address _spender
)
override
public
view
returns (uint256)
{
}
}
| _notPaused(),"contract has been paused" | 286,744 | _notPaused() |
"sender has been blocked" | pragma solidity ^0.7.0;
import "./ERC20If.sol";
import "./SafeMathLib.sol";
/// @title ERC20Basic
contract ERC20Basic is ERC20If {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
mapping(address => mapping(address => uint256)) internal allowed;
uint256 internal totalSupply_;
function _notPaused() virtual internal view returns (bool){ }
function _notBlocked(address) virtual internal view returns (bool){ }
modifier notPaused() {
}
modifier notBlocked() {
require(<FILL_ME>)
_;
}
function totalSupply() override public view returns (uint256) {
}
function transfer(address _to, uint256 _value) override public notPaused notBlocked returns (bool) {
}
function balanceOf(address _owner) override public view returns (uint256) {
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
override public notPaused notBlocked
returns (bool)
{
}
function approve(address _spender, uint256 _value)
override public notPaused notBlocked
returns (bool) {
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public notPaused notBlocked
returns (bool)
{
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
notPaused notBlocked
returns (bool success)
{
}
function allowance(
address _owner,
address _spender
)
override
public
view
returns (uint256)
{
}
}
| _notBlocked(msg.sender),"sender has been blocked" | 286,744 | _notBlocked(msg.sender) |
"to-address has been blocked" | pragma solidity ^0.7.0;
import "./ERC20If.sol";
import "./SafeMathLib.sol";
/// @title ERC20Basic
contract ERC20Basic is ERC20If {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
mapping(address => mapping(address => uint256)) internal allowed;
uint256 internal totalSupply_;
function _notPaused() virtual internal view returns (bool){ }
function _notBlocked(address) virtual internal view returns (bool){ }
modifier notPaused() {
}
modifier notBlocked() {
}
function totalSupply() override public view returns (uint256) {
}
function transfer(address _to, uint256 _value) override public notPaused notBlocked returns (bool) {
require(<FILL_ME>)
require(_value <= balances[msg.sender], "insufficient balance");
require(_to != address(0), "invalid to-address");
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) override public view returns (uint256) {
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
override public notPaused notBlocked
returns (bool)
{
}
function approve(address _spender, uint256 _value)
override public notPaused notBlocked
returns (bool) {
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public notPaused notBlocked
returns (bool)
{
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
notPaused notBlocked
returns (bool success)
{
}
function allowance(
address _owner,
address _spender
)
override
public
view
returns (uint256)
{
}
}
| _notBlocked(_to),"to-address has been blocked" | 286,744 | _notBlocked(_to) |
"from-address has been blocked" | pragma solidity ^0.7.0;
import "./ERC20If.sol";
import "./SafeMathLib.sol";
/// @title ERC20Basic
contract ERC20Basic is ERC20If {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
mapping(address => mapping(address => uint256)) internal allowed;
uint256 internal totalSupply_;
function _notPaused() virtual internal view returns (bool){ }
function _notBlocked(address) virtual internal view returns (bool){ }
modifier notPaused() {
}
modifier notBlocked() {
}
function totalSupply() override public view returns (uint256) {
}
function transfer(address _to, uint256 _value) override public notPaused notBlocked returns (bool) {
}
function balanceOf(address _owner) override public view returns (uint256) {
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
override public notPaused notBlocked
returns (bool)
{
require(<FILL_ME>)
require(_notBlocked(_to), "to-address has been blocked");
require(_value <= balances[_from], "insufficient balance");
require(_to != address(0), "invalid to-address");
if (_from == msg.sender){
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
return true;
}
require(_value <= allowed[_from][msg.sender], "value > allowed");
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value)
override public notPaused notBlocked
returns (bool) {
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public notPaused notBlocked
returns (bool)
{
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
notPaused notBlocked
returns (bool success)
{
}
function allowance(
address _owner,
address _spender
)
override
public
view
returns (uint256)
{
}
}
| _notBlocked(_from),"from-address has been blocked" | 286,744 | _notBlocked(_from) |
"spender-address has been blocked" | pragma solidity ^0.7.0;
import "./ERC20If.sol";
import "./SafeMathLib.sol";
/// @title ERC20Basic
contract ERC20Basic is ERC20If {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
mapping(address => mapping(address => uint256)) internal allowed;
uint256 internal totalSupply_;
function _notPaused() virtual internal view returns (bool){ }
function _notBlocked(address) virtual internal view returns (bool){ }
modifier notPaused() {
}
modifier notBlocked() {
}
function totalSupply() override public view returns (uint256) {
}
function transfer(address _to, uint256 _value) override public notPaused notBlocked returns (bool) {
}
function balanceOf(address _owner) override public view returns (uint256) {
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
override public notPaused notBlocked
returns (bool)
{
}
function approve(address _spender, uint256 _value)
override public notPaused notBlocked
returns (bool) {
require(<FILL_ME>)
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public notPaused notBlocked
returns (bool)
{
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
notPaused notBlocked
returns (bool success)
{
}
function allowance(
address _owner,
address _spender
)
override
public
view
returns (uint256)
{
}
}
| _notBlocked(_spender),"spender-address has been blocked" | 286,744 | _notBlocked(_spender) |
"OperatorRole: caller does not have the Operator role" | // SPDX-License-Identifier: LGPL-3.0-or-later
pragma solidity 0.8.6;
import "@openzeppelin/contracts/access/AccessControl.sol";
contract KRoles is AccessControl {
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
event OperatorAdded(address indexed account);
event OperatorRemoved(address indexed account);
constructor() {
}
modifier onlyOperator() {
require(<FILL_ME>)
_;
}
function isOperator(address account) public view returns (bool) {
}
function addOperator(address account) public onlyOperator {
}
function renounceOperator() public virtual {
}
function _addOperator(address account) internal {
}
function _renounceOperator(address account) internal {
}
}
| isOperator(_msgSender()),"OperatorRole: caller does not have the Operator role" | 286,762 | isOperator(_msgSender()) |
"OperatorRole: caller is not the operator" | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.9 <0.8.0;
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
contract OperatorRole is OwnableUpgradeable {
mapping (address => bool) operators;
function __OperatorRole_init() external initializer {
}
function addOperator(address operator) external onlyOwner {
}
function removeOperator(address operator) external onlyOwner {
}
modifier onlyOperator() {
require(<FILL_ME>)
_;
}
}
| operators[_msgSender()],"OperatorRole: caller is not the operator" | 286,792 | operators[_msgSender()] |
"Total supply exeeded" | pragma solidity ^0.8.4;
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract ProjectKoala is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
bytes32 public merkleRoot;
address proxyRegistryAddress = 0x58807baD0B376efc12F5AD86aAc70E78ed67deaE;
string BASE_URI = "https://projectkoalanft.com/assets/";
bool public IS_SALE_ACTIVE = false;
bool public IS_PRESALE_ACTIVE = true;
uint256 constant TOTAL_SUPPLY = 3334;
uint256 MINT_PRICE = 0.069 ether;
uint256 constant MAX_ALLOWED_MINT = 10;
mapping(address => uint256) addressToMintCount;
constructor(
string memory name,
string memory symbol,
bytes32 _merkleRoot
) ERC721(name, symbol) {
}
function setProxyOpensea(address _address) external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleroot) public onlyOwner {
}
function setBaseURI(string memory newUri) public onlyOwner {
}
function togglePublicSale() public onlyOwner {
}
function togglePreSale() public onlyOwner {
}
function ownerMint(uint256 numberOfTokens) public onlyOwner {
uint256 current = _tokenIdCounter.current();
require(<FILL_ME>)
for (uint256 i = 0; i < numberOfTokens; i++) {
mintInternal();
}
}
function preSaleMint(
uint256 numberOfTokens,
uint256 amount,
bytes32[] calldata proof
) public payable {
}
function publicSaleMint(uint256 numberOfTokens) public payable {
}
function mintInternal() internal {
}
function withdrawAll() public onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721)
returns (string memory)
{
}
function tokensOfOwner(
address _owner,
uint256 startId,
uint256 endId
) external view returns (uint256[] memory) {
}
/**
* Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
*/
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
function _verify(
bytes32[] memory proof,
address user,
string memory amount
) internal view returns (bool) {
}
}
| current+numberOfTokens<TOTAL_SUPPLY,"Total supply exeeded" | 286,798 | current+numberOfTokens<TOTAL_SUPPLY |
"Invalid merkle proof" | pragma solidity ^0.8.4;
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract ProjectKoala is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
bytes32 public merkleRoot;
address proxyRegistryAddress = 0x58807baD0B376efc12F5AD86aAc70E78ed67deaE;
string BASE_URI = "https://projectkoalanft.com/assets/";
bool public IS_SALE_ACTIVE = false;
bool public IS_PRESALE_ACTIVE = true;
uint256 constant TOTAL_SUPPLY = 3334;
uint256 MINT_PRICE = 0.069 ether;
uint256 constant MAX_ALLOWED_MINT = 10;
mapping(address => uint256) addressToMintCount;
constructor(
string memory name,
string memory symbol,
bytes32 _merkleRoot
) ERC721(name, symbol) {
}
function setProxyOpensea(address _address) external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleroot) public onlyOwner {
}
function setBaseURI(string memory newUri) public onlyOwner {
}
function togglePublicSale() public onlyOwner {
}
function togglePreSale() public onlyOwner {
}
function ownerMint(uint256 numberOfTokens) public onlyOwner {
}
function preSaleMint(
uint256 numberOfTokens,
uint256 amount,
bytes32[] calldata proof
) public payable {
require(IS_PRESALE_ACTIVE, "Pre-sale is not active");
require(
msg.value >= numberOfTokens * MINT_PRICE,
"Not enough ethers sent"
);
string memory allowedCount = Strings.toString(amount);
require(<FILL_ME>)
uint256 current = _tokenIdCounter.current();
require(
current + numberOfTokens < TOTAL_SUPPLY,
"Exceeds total supply"
);
require(
addressToMintCount[msg.sender] + numberOfTokens <= amount,
"Exceeds total allowed mint for account"
);
addressToMintCount[msg.sender] += numberOfTokens;
for (uint256 i = 0; i < numberOfTokens; i++) {
mintInternal();
}
}
function publicSaleMint(uint256 numberOfTokens) public payable {
}
function mintInternal() internal {
}
function withdrawAll() public onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721)
returns (string memory)
{
}
function tokensOfOwner(
address _owner,
uint256 startId,
uint256 endId
) external view returns (uint256[] memory) {
}
/**
* Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
*/
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
function _verify(
bytes32[] memory proof,
address user,
string memory amount
) internal view returns (bool) {
}
}
| _verify(proof,msg.sender,allowedCount),"Invalid merkle proof" | 286,798 | _verify(proof,msg.sender,allowedCount) |
"Exceeds total allowed mint for account" | pragma solidity ^0.8.4;
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract ProjectKoala is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
bytes32 public merkleRoot;
address proxyRegistryAddress = 0x58807baD0B376efc12F5AD86aAc70E78ed67deaE;
string BASE_URI = "https://projectkoalanft.com/assets/";
bool public IS_SALE_ACTIVE = false;
bool public IS_PRESALE_ACTIVE = true;
uint256 constant TOTAL_SUPPLY = 3334;
uint256 MINT_PRICE = 0.069 ether;
uint256 constant MAX_ALLOWED_MINT = 10;
mapping(address => uint256) addressToMintCount;
constructor(
string memory name,
string memory symbol,
bytes32 _merkleRoot
) ERC721(name, symbol) {
}
function setProxyOpensea(address _address) external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleroot) public onlyOwner {
}
function setBaseURI(string memory newUri) public onlyOwner {
}
function togglePublicSale() public onlyOwner {
}
function togglePreSale() public onlyOwner {
}
function ownerMint(uint256 numberOfTokens) public onlyOwner {
}
function preSaleMint(
uint256 numberOfTokens,
uint256 amount,
bytes32[] calldata proof
) public payable {
require(IS_PRESALE_ACTIVE, "Pre-sale is not active");
require(
msg.value >= numberOfTokens * MINT_PRICE,
"Not enough ethers sent"
);
string memory allowedCount = Strings.toString(amount);
require(
_verify(proof, msg.sender, allowedCount),
"Invalid merkle proof"
);
uint256 current = _tokenIdCounter.current();
require(
current + numberOfTokens < TOTAL_SUPPLY,
"Exceeds total supply"
);
require(<FILL_ME>)
addressToMintCount[msg.sender] += numberOfTokens;
for (uint256 i = 0; i < numberOfTokens; i++) {
mintInternal();
}
}
function publicSaleMint(uint256 numberOfTokens) public payable {
}
function mintInternal() internal {
}
function withdrawAll() public onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721)
returns (string memory)
{
}
function tokensOfOwner(
address _owner,
uint256 startId,
uint256 endId
) external view returns (uint256[] memory) {
}
/**
* Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
*/
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
function _verify(
bytes32[] memory proof,
address user,
string memory amount
) internal view returns (bool) {
}
}
| addressToMintCount[msg.sender]+numberOfTokens<=amount,"Exceeds total allowed mint for account" | 286,798 | addressToMintCount[msg.sender]+numberOfTokens<=amount |
null | pragma solidity ^0.4.24;
/**
* @title EnsRegistry
* @dev Extract of the interface for ENS Registry
*/
contract EnsRegistry {
function setOwner(bytes32 node, address owner) public;
function setSubnodeOwner(bytes32 node, bytes32 label, address owner) public;
function setResolver(bytes32 node, address resolver) public;
function owner(bytes32 node) public view returns (address);
function resolver(bytes32 node) public view returns (address);
}
/**
* @title EnsResolver
* @dev Extract of the interface for ENS Resolver
*/
contract EnsResolver {
function setAddr(bytes32 node, address addr) public;
function addr(bytes32 node) public view returns (address);
}
/**
* @title Portal Network SubdomainRegistrar
* @dev Allows to claim and configure a subdomain for Ethereum ENS in one call.
*/
contract SubdomainRegistrar {
address public owner;
bool public locked;
bytes32 emptyNamehash = 0x00;
mapping (string => EnsRegistry) registries;
mapping (string => EnsResolver) resolvers;
event SubdomainCreated(address indexed creator, address indexed owner, string subdomain, string domain, string topdomain);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event RegistryUpdated(address indexed previousRegistry, address indexed newRegistry);
event ResolverUpdated(address indexed previousResolver, address indexed newResolver);
event DomainTransfersLocked();
event DomainTransfersUnlocked();
constructor(string tld, EnsRegistry _registry, EnsResolver _resolver) public {
}
/**
* @dev Throws if called by any account other than the owner.
*
*/
modifier onlyOwner() {
}
modifier supportedTLD(string tld) {
require(<FILL_ME>)
_;
}
/**
* @dev Allows to create a subdomain (e.g. "hello.portalnetwork.eth"),
* set its resolver and set its target address
* @param _subdomain - sub domain name only e.g. "hello"
* @param _domain - domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth", "etc"
* @param _owner - address that will become owner of this new subdomain
* @param _target - address that this new domain will resolve to
*/
function newSubdomain(string _subdomain, string _domain, string _topdomain, address _owner, address _target) public supportedTLD(_topdomain) {
}
/**
* @dev Returns the owner of a domain (e.g. "portalnetwork.eth"),
* @param _domain - domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth" or "etc"
*/
function domainOwner(string _domain, string _topdomain) public view returns (address) {
}
/**
* @dev Return the owner of a subdomain (e.g. "hello.portalnetwork.eth"),
* @param _subdomain - sub domain name only e.g. "hello"
* @param _domain - parent domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth", "etc"
*/
function subdomainOwner(string _subdomain, string _domain, string _topdomain) public view returns (address) {
}
/**
* @dev Return the target address where the subdomain is pointing to (e.g. "0x12345..."),
* @param _subdomain - sub domain name only e.g. "hello"
* @param _domain - parent domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth", "etc"
*/
function subdomainTarget(string _subdomain, string _domain, string _topdomain) public view returns (address) {
}
/**
* @dev The contract owner can take away the ownership of any domain owned by this contract.
* @param _node - namehash of the domain
* @param _owner - new owner for the domain
*/
function transferDomainOwnership(string tld, bytes32 _node, address _owner) public supportedTLD(tld) onlyOwner {
}
/**
* @dev The contract owner can lock and prevent any future domain ownership transfers.
*/
function lockDomainOwnershipTransfers() public onlyOwner {
}
function unlockDomainOwnershipTransfer() public onlyOwner {
}
/**
* @dev Allows to update to new ENS registry.
* @param _registry The address of new ENS registry to use.
*/
function updateRegistry(string tld, EnsRegistry _registry) public onlyOwner {
}
/**
* @dev Allows to update to new ENS resolver.
* @param _resolver The address of new ENS resolver to use.
*/
function updateResolver(string tld, EnsResolver _resolver) public onlyOwner {
}
/**
* @dev Allows the current owner to transfer control of the contract to a new owner.
* @param _owner The address to transfer ownership to.
*/
function transferContractOwnership(address _owner) public onlyOwner {
}
}
| registries[tld]!=address(0)&&resolvers[tld]!=address(0) | 286,915 | registries[tld]!=address(0)&&resolvers[tld]!=address(0) |
"this contract should own the domain" | pragma solidity ^0.4.24;
/**
* @title EnsRegistry
* @dev Extract of the interface for ENS Registry
*/
contract EnsRegistry {
function setOwner(bytes32 node, address owner) public;
function setSubnodeOwner(bytes32 node, bytes32 label, address owner) public;
function setResolver(bytes32 node, address resolver) public;
function owner(bytes32 node) public view returns (address);
function resolver(bytes32 node) public view returns (address);
}
/**
* @title EnsResolver
* @dev Extract of the interface for ENS Resolver
*/
contract EnsResolver {
function setAddr(bytes32 node, address addr) public;
function addr(bytes32 node) public view returns (address);
}
/**
* @title Portal Network SubdomainRegistrar
* @dev Allows to claim and configure a subdomain for Ethereum ENS in one call.
*/
contract SubdomainRegistrar {
address public owner;
bool public locked;
bytes32 emptyNamehash = 0x00;
mapping (string => EnsRegistry) registries;
mapping (string => EnsResolver) resolvers;
event SubdomainCreated(address indexed creator, address indexed owner, string subdomain, string domain, string topdomain);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event RegistryUpdated(address indexed previousRegistry, address indexed newRegistry);
event ResolverUpdated(address indexed previousResolver, address indexed newResolver);
event DomainTransfersLocked();
event DomainTransfersUnlocked();
constructor(string tld, EnsRegistry _registry, EnsResolver _resolver) public {
}
/**
* @dev Throws if called by any account other than the owner.
*
*/
modifier onlyOwner() {
}
modifier supportedTLD(string tld) {
}
/**
* @dev Allows to create a subdomain (e.g. "hello.portalnetwork.eth"),
* set its resolver and set its target address
* @param _subdomain - sub domain name only e.g. "hello"
* @param _domain - domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth", "etc"
* @param _owner - address that will become owner of this new subdomain
* @param _target - address that this new domain will resolve to
*/
function newSubdomain(string _subdomain, string _domain, string _topdomain, address _owner, address _target) public supportedTLD(_topdomain) {
//create namehash for the topdomain
bytes32 topdomainNamehash = keccak256(abi.encodePacked(emptyNamehash, keccak256(abi.encodePacked(_topdomain))));
//create namehash for the domain
bytes32 domainNamehash = keccak256(abi.encodePacked(topdomainNamehash, keccak256(abi.encodePacked(_domain))));
//make sure this contract owns the domain
require(<FILL_ME>)
//create labelhash for the sub domain
bytes32 subdomainLabelhash = keccak256(abi.encodePacked(_subdomain));
//create namehash for the sub domain
bytes32 subdomainNamehash = keccak256(abi.encodePacked(domainNamehash, subdomainLabelhash));
//make sure it is free or owned by the sender
require(registries[_topdomain].owner(subdomainNamehash) == address(0) ||
registries[_topdomain].owner(subdomainNamehash) == msg.sender, "sub domain already owned");
//create new subdomain, temporarily this smartcontract is the owner
registries[_topdomain].setSubnodeOwner(domainNamehash, subdomainLabelhash, address(this));
//set public resolver for this domain
registries[_topdomain].setResolver(subdomainNamehash, resolvers[_topdomain]);
//set the destination address
resolvers[_topdomain].setAddr(subdomainNamehash, _target);
//change the ownership back to requested owner
registries[_topdomain].setOwner(subdomainNamehash, _owner);
emit SubdomainCreated(msg.sender, _owner, _subdomain, _domain, _topdomain);
}
/**
* @dev Returns the owner of a domain (e.g. "portalnetwork.eth"),
* @param _domain - domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth" or "etc"
*/
function domainOwner(string _domain, string _topdomain) public view returns (address) {
}
/**
* @dev Return the owner of a subdomain (e.g. "hello.portalnetwork.eth"),
* @param _subdomain - sub domain name only e.g. "hello"
* @param _domain - parent domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth", "etc"
*/
function subdomainOwner(string _subdomain, string _domain, string _topdomain) public view returns (address) {
}
/**
* @dev Return the target address where the subdomain is pointing to (e.g. "0x12345..."),
* @param _subdomain - sub domain name only e.g. "hello"
* @param _domain - parent domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth", "etc"
*/
function subdomainTarget(string _subdomain, string _domain, string _topdomain) public view returns (address) {
}
/**
* @dev The contract owner can take away the ownership of any domain owned by this contract.
* @param _node - namehash of the domain
* @param _owner - new owner for the domain
*/
function transferDomainOwnership(string tld, bytes32 _node, address _owner) public supportedTLD(tld) onlyOwner {
}
/**
* @dev The contract owner can lock and prevent any future domain ownership transfers.
*/
function lockDomainOwnershipTransfers() public onlyOwner {
}
function unlockDomainOwnershipTransfer() public onlyOwner {
}
/**
* @dev Allows to update to new ENS registry.
* @param _registry The address of new ENS registry to use.
*/
function updateRegistry(string tld, EnsRegistry _registry) public onlyOwner {
}
/**
* @dev Allows to update to new ENS resolver.
* @param _resolver The address of new ENS resolver to use.
*/
function updateResolver(string tld, EnsResolver _resolver) public onlyOwner {
}
/**
* @dev Allows the current owner to transfer control of the contract to a new owner.
* @param _owner The address to transfer ownership to.
*/
function transferContractOwnership(address _owner) public onlyOwner {
}
}
| registries[_topdomain].owner(domainNamehash)==address(this),"this contract should own the domain" | 286,915 | registries[_topdomain].owner(domainNamehash)==address(this) |
"sub domain already owned" | pragma solidity ^0.4.24;
/**
* @title EnsRegistry
* @dev Extract of the interface for ENS Registry
*/
contract EnsRegistry {
function setOwner(bytes32 node, address owner) public;
function setSubnodeOwner(bytes32 node, bytes32 label, address owner) public;
function setResolver(bytes32 node, address resolver) public;
function owner(bytes32 node) public view returns (address);
function resolver(bytes32 node) public view returns (address);
}
/**
* @title EnsResolver
* @dev Extract of the interface for ENS Resolver
*/
contract EnsResolver {
function setAddr(bytes32 node, address addr) public;
function addr(bytes32 node) public view returns (address);
}
/**
* @title Portal Network SubdomainRegistrar
* @dev Allows to claim and configure a subdomain for Ethereum ENS in one call.
*/
contract SubdomainRegistrar {
address public owner;
bool public locked;
bytes32 emptyNamehash = 0x00;
mapping (string => EnsRegistry) registries;
mapping (string => EnsResolver) resolvers;
event SubdomainCreated(address indexed creator, address indexed owner, string subdomain, string domain, string topdomain);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event RegistryUpdated(address indexed previousRegistry, address indexed newRegistry);
event ResolverUpdated(address indexed previousResolver, address indexed newResolver);
event DomainTransfersLocked();
event DomainTransfersUnlocked();
constructor(string tld, EnsRegistry _registry, EnsResolver _resolver) public {
}
/**
* @dev Throws if called by any account other than the owner.
*
*/
modifier onlyOwner() {
}
modifier supportedTLD(string tld) {
}
/**
* @dev Allows to create a subdomain (e.g. "hello.portalnetwork.eth"),
* set its resolver and set its target address
* @param _subdomain - sub domain name only e.g. "hello"
* @param _domain - domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth", "etc"
* @param _owner - address that will become owner of this new subdomain
* @param _target - address that this new domain will resolve to
*/
function newSubdomain(string _subdomain, string _domain, string _topdomain, address _owner, address _target) public supportedTLD(_topdomain) {
//create namehash for the topdomain
bytes32 topdomainNamehash = keccak256(abi.encodePacked(emptyNamehash, keccak256(abi.encodePacked(_topdomain))));
//create namehash for the domain
bytes32 domainNamehash = keccak256(abi.encodePacked(topdomainNamehash, keccak256(abi.encodePacked(_domain))));
//make sure this contract owns the domain
require(registries[_topdomain].owner(domainNamehash) == address(this), "this contract should own the domain");
//create labelhash for the sub domain
bytes32 subdomainLabelhash = keccak256(abi.encodePacked(_subdomain));
//create namehash for the sub domain
bytes32 subdomainNamehash = keccak256(abi.encodePacked(domainNamehash, subdomainLabelhash));
//make sure it is free or owned by the sender
require(<FILL_ME>)
//create new subdomain, temporarily this smartcontract is the owner
registries[_topdomain].setSubnodeOwner(domainNamehash, subdomainLabelhash, address(this));
//set public resolver for this domain
registries[_topdomain].setResolver(subdomainNamehash, resolvers[_topdomain]);
//set the destination address
resolvers[_topdomain].setAddr(subdomainNamehash, _target);
//change the ownership back to requested owner
registries[_topdomain].setOwner(subdomainNamehash, _owner);
emit SubdomainCreated(msg.sender, _owner, _subdomain, _domain, _topdomain);
}
/**
* @dev Returns the owner of a domain (e.g. "portalnetwork.eth"),
* @param _domain - domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth" or "etc"
*/
function domainOwner(string _domain, string _topdomain) public view returns (address) {
}
/**
* @dev Return the owner of a subdomain (e.g. "hello.portalnetwork.eth"),
* @param _subdomain - sub domain name only e.g. "hello"
* @param _domain - parent domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth", "etc"
*/
function subdomainOwner(string _subdomain, string _domain, string _topdomain) public view returns (address) {
}
/**
* @dev Return the target address where the subdomain is pointing to (e.g. "0x12345..."),
* @param _subdomain - sub domain name only e.g. "hello"
* @param _domain - parent domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth", "etc"
*/
function subdomainTarget(string _subdomain, string _domain, string _topdomain) public view returns (address) {
}
/**
* @dev The contract owner can take away the ownership of any domain owned by this contract.
* @param _node - namehash of the domain
* @param _owner - new owner for the domain
*/
function transferDomainOwnership(string tld, bytes32 _node, address _owner) public supportedTLD(tld) onlyOwner {
}
/**
* @dev The contract owner can lock and prevent any future domain ownership transfers.
*/
function lockDomainOwnershipTransfers() public onlyOwner {
}
function unlockDomainOwnershipTransfer() public onlyOwner {
}
/**
* @dev Allows to update to new ENS registry.
* @param _registry The address of new ENS registry to use.
*/
function updateRegistry(string tld, EnsRegistry _registry) public onlyOwner {
}
/**
* @dev Allows to update to new ENS resolver.
* @param _resolver The address of new ENS resolver to use.
*/
function updateResolver(string tld, EnsResolver _resolver) public onlyOwner {
}
/**
* @dev Allows the current owner to transfer control of the contract to a new owner.
* @param _owner The address to transfer ownership to.
*/
function transferContractOwnership(address _owner) public onlyOwner {
}
}
| registries[_topdomain].owner(subdomainNamehash)==address(0)||registries[_topdomain].owner(subdomainNamehash)==msg.sender,"sub domain already owned" | 286,915 | registries[_topdomain].owner(subdomainNamehash)==address(0)||registries[_topdomain].owner(subdomainNamehash)==msg.sender |
"new registry should be different from old" | pragma solidity ^0.4.24;
/**
* @title EnsRegistry
* @dev Extract of the interface for ENS Registry
*/
contract EnsRegistry {
function setOwner(bytes32 node, address owner) public;
function setSubnodeOwner(bytes32 node, bytes32 label, address owner) public;
function setResolver(bytes32 node, address resolver) public;
function owner(bytes32 node) public view returns (address);
function resolver(bytes32 node) public view returns (address);
}
/**
* @title EnsResolver
* @dev Extract of the interface for ENS Resolver
*/
contract EnsResolver {
function setAddr(bytes32 node, address addr) public;
function addr(bytes32 node) public view returns (address);
}
/**
* @title Portal Network SubdomainRegistrar
* @dev Allows to claim and configure a subdomain for Ethereum ENS in one call.
*/
contract SubdomainRegistrar {
address public owner;
bool public locked;
bytes32 emptyNamehash = 0x00;
mapping (string => EnsRegistry) registries;
mapping (string => EnsResolver) resolvers;
event SubdomainCreated(address indexed creator, address indexed owner, string subdomain, string domain, string topdomain);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event RegistryUpdated(address indexed previousRegistry, address indexed newRegistry);
event ResolverUpdated(address indexed previousResolver, address indexed newResolver);
event DomainTransfersLocked();
event DomainTransfersUnlocked();
constructor(string tld, EnsRegistry _registry, EnsResolver _resolver) public {
}
/**
* @dev Throws if called by any account other than the owner.
*
*/
modifier onlyOwner() {
}
modifier supportedTLD(string tld) {
}
/**
* @dev Allows to create a subdomain (e.g. "hello.portalnetwork.eth"),
* set its resolver and set its target address
* @param _subdomain - sub domain name only e.g. "hello"
* @param _domain - domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth", "etc"
* @param _owner - address that will become owner of this new subdomain
* @param _target - address that this new domain will resolve to
*/
function newSubdomain(string _subdomain, string _domain, string _topdomain, address _owner, address _target) public supportedTLD(_topdomain) {
}
/**
* @dev Returns the owner of a domain (e.g. "portalnetwork.eth"),
* @param _domain - domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth" or "etc"
*/
function domainOwner(string _domain, string _topdomain) public view returns (address) {
}
/**
* @dev Return the owner of a subdomain (e.g. "hello.portalnetwork.eth"),
* @param _subdomain - sub domain name only e.g. "hello"
* @param _domain - parent domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth", "etc"
*/
function subdomainOwner(string _subdomain, string _domain, string _topdomain) public view returns (address) {
}
/**
* @dev Return the target address where the subdomain is pointing to (e.g. "0x12345..."),
* @param _subdomain - sub domain name only e.g. "hello"
* @param _domain - parent domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth", "etc"
*/
function subdomainTarget(string _subdomain, string _domain, string _topdomain) public view returns (address) {
}
/**
* @dev The contract owner can take away the ownership of any domain owned by this contract.
* @param _node - namehash of the domain
* @param _owner - new owner for the domain
*/
function transferDomainOwnership(string tld, bytes32 _node, address _owner) public supportedTLD(tld) onlyOwner {
}
/**
* @dev The contract owner can lock and prevent any future domain ownership transfers.
*/
function lockDomainOwnershipTransfers() public onlyOwner {
}
function unlockDomainOwnershipTransfer() public onlyOwner {
}
/**
* @dev Allows to update to new ENS registry.
* @param _registry The address of new ENS registry to use.
*/
function updateRegistry(string tld, EnsRegistry _registry) public onlyOwner {
require(<FILL_ME>)
emit RegistryUpdated(registries[tld], _registry);
registries[tld] = _registry;
}
/**
* @dev Allows to update to new ENS resolver.
* @param _resolver The address of new ENS resolver to use.
*/
function updateResolver(string tld, EnsResolver _resolver) public onlyOwner {
}
/**
* @dev Allows the current owner to transfer control of the contract to a new owner.
* @param _owner The address to transfer ownership to.
*/
function transferContractOwnership(address _owner) public onlyOwner {
}
}
| registries[tld]!=_registry,"new registry should be different from old" | 286,915 | registries[tld]!=_registry |
"new resolver should be different from old" | pragma solidity ^0.4.24;
/**
* @title EnsRegistry
* @dev Extract of the interface for ENS Registry
*/
contract EnsRegistry {
function setOwner(bytes32 node, address owner) public;
function setSubnodeOwner(bytes32 node, bytes32 label, address owner) public;
function setResolver(bytes32 node, address resolver) public;
function owner(bytes32 node) public view returns (address);
function resolver(bytes32 node) public view returns (address);
}
/**
* @title EnsResolver
* @dev Extract of the interface for ENS Resolver
*/
contract EnsResolver {
function setAddr(bytes32 node, address addr) public;
function addr(bytes32 node) public view returns (address);
}
/**
* @title Portal Network SubdomainRegistrar
* @dev Allows to claim and configure a subdomain for Ethereum ENS in one call.
*/
contract SubdomainRegistrar {
address public owner;
bool public locked;
bytes32 emptyNamehash = 0x00;
mapping (string => EnsRegistry) registries;
mapping (string => EnsResolver) resolvers;
event SubdomainCreated(address indexed creator, address indexed owner, string subdomain, string domain, string topdomain);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event RegistryUpdated(address indexed previousRegistry, address indexed newRegistry);
event ResolverUpdated(address indexed previousResolver, address indexed newResolver);
event DomainTransfersLocked();
event DomainTransfersUnlocked();
constructor(string tld, EnsRegistry _registry, EnsResolver _resolver) public {
}
/**
* @dev Throws if called by any account other than the owner.
*
*/
modifier onlyOwner() {
}
modifier supportedTLD(string tld) {
}
/**
* @dev Allows to create a subdomain (e.g. "hello.portalnetwork.eth"),
* set its resolver and set its target address
* @param _subdomain - sub domain name only e.g. "hello"
* @param _domain - domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth", "etc"
* @param _owner - address that will become owner of this new subdomain
* @param _target - address that this new domain will resolve to
*/
function newSubdomain(string _subdomain, string _domain, string _topdomain, address _owner, address _target) public supportedTLD(_topdomain) {
}
/**
* @dev Returns the owner of a domain (e.g. "portalnetwork.eth"),
* @param _domain - domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth" or "etc"
*/
function domainOwner(string _domain, string _topdomain) public view returns (address) {
}
/**
* @dev Return the owner of a subdomain (e.g. "hello.portalnetwork.eth"),
* @param _subdomain - sub domain name only e.g. "hello"
* @param _domain - parent domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth", "etc"
*/
function subdomainOwner(string _subdomain, string _domain, string _topdomain) public view returns (address) {
}
/**
* @dev Return the target address where the subdomain is pointing to (e.g. "0x12345..."),
* @param _subdomain - sub domain name only e.g. "hello"
* @param _domain - parent domain name e.g. "portalnetwork"
* @param _topdomain - parent domain name e.g. "eth", "etc"
*/
function subdomainTarget(string _subdomain, string _domain, string _topdomain) public view returns (address) {
}
/**
* @dev The contract owner can take away the ownership of any domain owned by this contract.
* @param _node - namehash of the domain
* @param _owner - new owner for the domain
*/
function transferDomainOwnership(string tld, bytes32 _node, address _owner) public supportedTLD(tld) onlyOwner {
}
/**
* @dev The contract owner can lock and prevent any future domain ownership transfers.
*/
function lockDomainOwnershipTransfers() public onlyOwner {
}
function unlockDomainOwnershipTransfer() public onlyOwner {
}
/**
* @dev Allows to update to new ENS registry.
* @param _registry The address of new ENS registry to use.
*/
function updateRegistry(string tld, EnsRegistry _registry) public onlyOwner {
}
/**
* @dev Allows to update to new ENS resolver.
* @param _resolver The address of new ENS resolver to use.
*/
function updateResolver(string tld, EnsResolver _resolver) public onlyOwner {
require(<FILL_ME>)
emit ResolverUpdated(resolvers[tld], _resolver);
resolvers[tld] = _resolver;
}
/**
* @dev Allows the current owner to transfer control of the contract to a new owner.
* @param _owner The address to transfer ownership to.
*/
function transferContractOwnership(address _owner) public onlyOwner {
}
}
| resolvers[tld]!=_resolver,"new resolver should be different from old" | 286,915 | resolvers[tld]!=_resolver |
"Only the proxy can call" | // SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
contract OwnedwManager {
address public owner;
address public manager;
address public nominatedOwner;
constructor(address _owner, address _manager) {
}
function nominateNewOwner(address _owner) external onlyOwner {
}
function acceptOwnership() external {
}
modifier onlyOwner {
}
modifier onlyManager {
}
function _onlyOwner() private view {
}
function _onlyManager() private view {
}
function setManager(address _manager) external onlyOwner {
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
event ManagerChanged(address newManager);
}
interface IERC20 {
/**
* @dev Returns the token name.
*/
function name() external view returns (string memory);
function symbol() external view returns (string memory);
/**
* @dev Returns the token decimals.
*/
function decimals() external view returns (uint8);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Proxy is OwnedwManager {
Proxyable public target;
constructor(address _owner) OwnedwManager(_owner, _owner) {}
function setTarget(Proxyable _target) external onlyOwner {
}
function _emit(
bytes calldata callData,
uint numTopics,
bytes32 topic1,
bytes32 topic2,
bytes32 topic3,
bytes32 topic4
) external onlyTarget {
}
// solhint-disable no-complex-fallback
fallback() external payable {
}
modifier onlyTarget {
}
event TargetUpdated(Proxyable newTarget);
}
abstract contract Proxyable is OwnedwManager {
// This contract should be treated like an abstract contract
/* The proxy this contract exists behind. */
Proxy public proxy;
/* The caller of the proxy, passed through to this contract.
* Note that every function using this member must apply the onlyProxy or
* optionalProxy modifiers, otherwise their invocations can use stale values. */
address public messageSender;
constructor(address payable _proxy) {
}
function setProxy(address payable _proxy) external onlyOwner {
}
function setMessageSender(address sender) external onlyProxy {
}
modifier onlyProxy {
}
function _onlyProxy() private view {
require(<FILL_ME>)
}
modifier optionalProxy {
}
function _optionalProxy() private {
}
modifier optionalProxy_onlyOwner {
}
// solhint-disable-next-line func-name-mixedcase
function _optionalProxy_onlyOwner() private {
}
event ProxyUpdated(address proxyAddress);
}
contract ProxyERC20 is Proxy, IERC20 {
constructor(address _owner) public Proxy(_owner) {}
// ------------- ERC20 Details ------------- //
function name() public override view returns (string memory) {
}
function symbol() public override view returns (string memory) {
}
function decimals() public override view returns (uint8) {
}
// ------------- ERC20 Interface ------------- //
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public override view returns (uint256) {
}
/**
* @dev Gets the balance of the specified address.
* @param account The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address account) public override view returns (uint256) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param owner address The address which owns the funds.
* @param spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address owner, address spender) public override view returns (uint256) {
}
/**
* @dev Transfer token for a specified address
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) public override returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
*/
function approve(address spender, uint256 value) public override returns (bool) {
}
/**
* @dev Transfer tokens from one address to another
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 the amount of tokens to be transferred
*/
function transferFrom(
address from,
address to,
uint256 value
) public override returns (bool) {
}
}
interface IElysian {
function mint(uint _amount, address _recipient, bool _isEscrowed) external returns (bool);
}
contract ProxyERC20Mintable is ProxyERC20 {
constructor(address _owner) public ProxyERC20(_owner) {}
function mint(uint amount, address dst, bool isEscrowed) external returns (bool) {
}
}
| Proxy(msg.sender)==proxy,"Only the proxy can call" | 286,986 | Proxy(msg.sender)==proxy |
null | pragma solidity ^0.4.19;
contract Dappster {
/// Lease record, store card tenants details
/// and lease details
struct LeaseCard {
uint id;
address tenant;
uint price;
uint untilBlock;
string title;
string url;
string image;
}
/// Record card details
struct CardDetails {
uint8 id;
uint price;
uint priceLease; // price per block
uint leaseDuration; // in block
bool availableBuy;
bool availableLease;
uint[] leaseList;
mapping(uint => LeaseCard) leaseCardStructs;
}
/// Record card
struct Card {
uint8 id;
address owner;
string title;
string url;
string image;
bool nsfw;
}
/// Users pending withdrawals
mapping(address => uint) public pendingWithdrawals;
mapping(uint8 => Card) public cardStructs; // random access by card key
uint8[] public cardList; // list of announce keys so we can enumerate them
mapping(uint8 => CardDetails) public cardDetailsStructs; // random access by card details key
uint8[] public cardDetailsList; // list of cards details keys so we can enumerate them
/// Initial card price
uint public initialCardPrice = 0.1 ether;
/// Owner cut (1%) . This cut only apply on a user-to-user card transaction
uint public ownerBuyCut = 100;
/// fluffyCat cut (10%)
uint public fluffyCatCut = 1000;
/// contractOwner can withdraw the funds
address public contractOwner;
/// fluffyCat address
address public fluffyCatAddress = 0x2c00A5013aA2E600663f7b197C98db73bA847e6d;
/// Contract constructor
function Dappster() public {
}
modifier onlyContractOwner() {
}
modifier onlyCardOwner(uint8 cardId) {
}
modifier onlyValidCard(uint8 cardId) {
}
/// Return cardList array
function getCards() public view returns(uint8[]) {
}
/// Return cardDetailsList array
function getCardsDetails() public view returns(uint8[]) {
}
/// Return card details by id
function getCardDetails(uint8 cardId) public view onlyValidCard(cardId)
returns (uint8 id, uint price, uint priceLease, uint leaseDuration, bool availableBuy, bool availableLease) {
}
/// Return card by id
function getCard(uint8 cardId) public view onlyValidCard(cardId)
returns (uint8 id, address owner, string title, string url, string image, bool nsfw) {
}
/// This is called on the initial buy card, user to user buy is at buyCard()
/// Amount is sent to contractOwner balance and fluffycat get 10% of this amount
function initialBuyCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
// Check sent amount
uint price = computeInitialPrice(cardId);
require(msg.value >= price);
// If owner is 0x0, then we are sure that
// this is the initial buy
require(<FILL_ME>)
// Fill card
_fillCardStruct(cardId, msg.sender, title, url, image);
// Set nsfw flag to false
cardStructs[cardId].nsfw = false;
// Contract credit 10% of price to FluffyCat
_applyShare(contractOwner, fluffyCatAddress, fluffyCatCut);
// Initialize card details
_initCardDetails(cardId, price);
// Add the card to cardList
cardList.push(cardId);
return true;
}
/// Perform a user to user buy transaction
/// Contract owner takes 1% cut on each of this transaction
function buyCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
}
/// Allow card owner to edit his card informations
function editCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to set his card on sale at specific price
function sellCard(uint8 cardId, uint price) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to cancel sell offer
function cancelSellCard(uint8 cardId) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to set his card on lease at fixed price per block and duration
function setLeaseCard(uint8 cardId, uint priceLease, uint leaseDuration) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to cancel lease offer
/// Note that this do not interrupt current lease if any
function cancelLeaseOffer(uint8 cardId) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow future tenant to lease a card
function leaseCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
}
/// Get last lease from a card
function getLastLease(uint8 cardId) public view
returns(uint leaseIndex, address tenant, uint untilBlock, string title, string url, string image)
{
}
/// Get lease from card
function getLease(uint8 cardId, uint leaseId) public view
returns(uint leaseIndex, address tenant, uint untilBlock, string title, string url, string image)
{
}
/// Get lease list from a card
function getCardLeaseLength(uint8 cardId) public view
returns(uint cardLeasesCount)
{
}
/// Transfer the ownership of a card
function transferCardOwnership(address to, uint8 cardId)
public
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Return balance from sender
function getBalance()
public
view
returns (uint amount)
{
}
/// Allow address to withdraw their balance
function withdraw()
public
returns (bool)
{
}
/// Compute initial card price (in wei)
function computeInitialPrice(uint8 cardId) public view
onlyValidCard(cardId)
returns (uint price)
{
}
/// Allow contract owner to set NSFW flag on a card
function setNSFW(uint8 cardId, bool flag) public
onlyValidCard(cardId)
onlyContractOwner()
returns (bool success)
{
}
/// Fill Card struct
function _fillCardStruct(uint8 _cardId, address _owner, string _title, string _url, string _image) internal
returns (bool success)
{
}
/// Initialize sell card for future
function _initCardDetails(uint8 cardId, uint price) internal
returns (bool success)
{
}
/// Send split amounts to respective balances
function _applyShare(address _seller, address _auctioneer, uint _cut) internal
returns (bool success)
{
}
/// Compute _cut from a _price
function _computeCut(uint256 _price, uint256 _cut) internal pure
returns (uint256)
{
}
}
| cardStructs[cardId].owner==address(0) | 287,063 | cardStructs[cardId].owner==address(0) |
null | pragma solidity ^0.4.19;
contract Dappster {
/// Lease record, store card tenants details
/// and lease details
struct LeaseCard {
uint id;
address tenant;
uint price;
uint untilBlock;
string title;
string url;
string image;
}
/// Record card details
struct CardDetails {
uint8 id;
uint price;
uint priceLease; // price per block
uint leaseDuration; // in block
bool availableBuy;
bool availableLease;
uint[] leaseList;
mapping(uint => LeaseCard) leaseCardStructs;
}
/// Record card
struct Card {
uint8 id;
address owner;
string title;
string url;
string image;
bool nsfw;
}
/// Users pending withdrawals
mapping(address => uint) public pendingWithdrawals;
mapping(uint8 => Card) public cardStructs; // random access by card key
uint8[] public cardList; // list of announce keys so we can enumerate them
mapping(uint8 => CardDetails) public cardDetailsStructs; // random access by card details key
uint8[] public cardDetailsList; // list of cards details keys so we can enumerate them
/// Initial card price
uint public initialCardPrice = 0.1 ether;
/// Owner cut (1%) . This cut only apply on a user-to-user card transaction
uint public ownerBuyCut = 100;
/// fluffyCat cut (10%)
uint public fluffyCatCut = 1000;
/// contractOwner can withdraw the funds
address public contractOwner;
/// fluffyCat address
address public fluffyCatAddress = 0x2c00A5013aA2E600663f7b197C98db73bA847e6d;
/// Contract constructor
function Dappster() public {
}
modifier onlyContractOwner() {
}
modifier onlyCardOwner(uint8 cardId) {
}
modifier onlyValidCard(uint8 cardId) {
}
/// Return cardList array
function getCards() public view returns(uint8[]) {
}
/// Return cardDetailsList array
function getCardsDetails() public view returns(uint8[]) {
}
/// Return card details by id
function getCardDetails(uint8 cardId) public view onlyValidCard(cardId)
returns (uint8 id, uint price, uint priceLease, uint leaseDuration, bool availableBuy, bool availableLease) {
}
/// Return card by id
function getCard(uint8 cardId) public view onlyValidCard(cardId)
returns (uint8 id, address owner, string title, string url, string image, bool nsfw) {
}
/// This is called on the initial buy card, user to user buy is at buyCard()
/// Amount is sent to contractOwner balance and fluffycat get 10% of this amount
function initialBuyCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
}
/// Perform a user to user buy transaction
/// Contract owner takes 1% cut on each of this transaction
function buyCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
// Check that this is not an initial buy, i.e. that the
// card belongs to someone
require(<FILL_ME>)
// Check if card is on sale
require(cardDetailsStructs[cardId].availableBuy);
// Check sent amount
uint price = cardDetailsStructs[cardId].price;
require(msg.value >= price);
address previousOwner = cardStructs[cardId].owner;
// Take 1% cut on buy
_applyShare(previousOwner, contractOwner, ownerBuyCut);
// Fill card
_fillCardStruct(cardId, msg.sender, title, url, image);
// Set nsfw flag to false
cardStructs[cardId].nsfw = false;
// Disable sell status
cardDetailsStructs[cardId].availableBuy = false;
return true;
}
/// Allow card owner to edit his card informations
function editCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to set his card on sale at specific price
function sellCard(uint8 cardId, uint price) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to cancel sell offer
function cancelSellCard(uint8 cardId) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to set his card on lease at fixed price per block and duration
function setLeaseCard(uint8 cardId, uint priceLease, uint leaseDuration) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to cancel lease offer
/// Note that this do not interrupt current lease if any
function cancelLeaseOffer(uint8 cardId) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow future tenant to lease a card
function leaseCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
}
/// Get last lease from a card
function getLastLease(uint8 cardId) public view
returns(uint leaseIndex, address tenant, uint untilBlock, string title, string url, string image)
{
}
/// Get lease from card
function getLease(uint8 cardId, uint leaseId) public view
returns(uint leaseIndex, address tenant, uint untilBlock, string title, string url, string image)
{
}
/// Get lease list from a card
function getCardLeaseLength(uint8 cardId) public view
returns(uint cardLeasesCount)
{
}
/// Transfer the ownership of a card
function transferCardOwnership(address to, uint8 cardId)
public
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Return balance from sender
function getBalance()
public
view
returns (uint amount)
{
}
/// Allow address to withdraw their balance
function withdraw()
public
returns (bool)
{
}
/// Compute initial card price (in wei)
function computeInitialPrice(uint8 cardId) public view
onlyValidCard(cardId)
returns (uint price)
{
}
/// Allow contract owner to set NSFW flag on a card
function setNSFW(uint8 cardId, bool flag) public
onlyValidCard(cardId)
onlyContractOwner()
returns (bool success)
{
}
/// Fill Card struct
function _fillCardStruct(uint8 _cardId, address _owner, string _title, string _url, string _image) internal
returns (bool success)
{
}
/// Initialize sell card for future
function _initCardDetails(uint8 cardId, uint price) internal
returns (bool success)
{
}
/// Send split amounts to respective balances
function _applyShare(address _seller, address _auctioneer, uint _cut) internal
returns (bool success)
{
}
/// Compute _cut from a _price
function _computeCut(uint256 _price, uint256 _cut) internal pure
returns (uint256)
{
}
}
| cardStructs[cardId].owner!=address(0) | 287,063 | cardStructs[cardId].owner!=address(0) |
null | pragma solidity ^0.4.19;
contract Dappster {
/// Lease record, store card tenants details
/// and lease details
struct LeaseCard {
uint id;
address tenant;
uint price;
uint untilBlock;
string title;
string url;
string image;
}
/// Record card details
struct CardDetails {
uint8 id;
uint price;
uint priceLease; // price per block
uint leaseDuration; // in block
bool availableBuy;
bool availableLease;
uint[] leaseList;
mapping(uint => LeaseCard) leaseCardStructs;
}
/// Record card
struct Card {
uint8 id;
address owner;
string title;
string url;
string image;
bool nsfw;
}
/// Users pending withdrawals
mapping(address => uint) public pendingWithdrawals;
mapping(uint8 => Card) public cardStructs; // random access by card key
uint8[] public cardList; // list of announce keys so we can enumerate them
mapping(uint8 => CardDetails) public cardDetailsStructs; // random access by card details key
uint8[] public cardDetailsList; // list of cards details keys so we can enumerate them
/// Initial card price
uint public initialCardPrice = 0.1 ether;
/// Owner cut (1%) . This cut only apply on a user-to-user card transaction
uint public ownerBuyCut = 100;
/// fluffyCat cut (10%)
uint public fluffyCatCut = 1000;
/// contractOwner can withdraw the funds
address public contractOwner;
/// fluffyCat address
address public fluffyCatAddress = 0x2c00A5013aA2E600663f7b197C98db73bA847e6d;
/// Contract constructor
function Dappster() public {
}
modifier onlyContractOwner() {
}
modifier onlyCardOwner(uint8 cardId) {
}
modifier onlyValidCard(uint8 cardId) {
}
/// Return cardList array
function getCards() public view returns(uint8[]) {
}
/// Return cardDetailsList array
function getCardsDetails() public view returns(uint8[]) {
}
/// Return card details by id
function getCardDetails(uint8 cardId) public view onlyValidCard(cardId)
returns (uint8 id, uint price, uint priceLease, uint leaseDuration, bool availableBuy, bool availableLease) {
}
/// Return card by id
function getCard(uint8 cardId) public view onlyValidCard(cardId)
returns (uint8 id, address owner, string title, string url, string image, bool nsfw) {
}
/// This is called on the initial buy card, user to user buy is at buyCard()
/// Amount is sent to contractOwner balance and fluffycat get 10% of this amount
function initialBuyCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
}
/// Perform a user to user buy transaction
/// Contract owner takes 1% cut on each of this transaction
function buyCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
// Check that this is not an initial buy, i.e. that the
// card belongs to someone
require(cardStructs[cardId].owner != address(0));
// Check if card is on sale
require(<FILL_ME>)
// Check sent amount
uint price = cardDetailsStructs[cardId].price;
require(msg.value >= price);
address previousOwner = cardStructs[cardId].owner;
// Take 1% cut on buy
_applyShare(previousOwner, contractOwner, ownerBuyCut);
// Fill card
_fillCardStruct(cardId, msg.sender, title, url, image);
// Set nsfw flag to false
cardStructs[cardId].nsfw = false;
// Disable sell status
cardDetailsStructs[cardId].availableBuy = false;
return true;
}
/// Allow card owner to edit his card informations
function editCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to set his card on sale at specific price
function sellCard(uint8 cardId, uint price) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to cancel sell offer
function cancelSellCard(uint8 cardId) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to set his card on lease at fixed price per block and duration
function setLeaseCard(uint8 cardId, uint priceLease, uint leaseDuration) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to cancel lease offer
/// Note that this do not interrupt current lease if any
function cancelLeaseOffer(uint8 cardId) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow future tenant to lease a card
function leaseCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
}
/// Get last lease from a card
function getLastLease(uint8 cardId) public view
returns(uint leaseIndex, address tenant, uint untilBlock, string title, string url, string image)
{
}
/// Get lease from card
function getLease(uint8 cardId, uint leaseId) public view
returns(uint leaseIndex, address tenant, uint untilBlock, string title, string url, string image)
{
}
/// Get lease list from a card
function getCardLeaseLength(uint8 cardId) public view
returns(uint cardLeasesCount)
{
}
/// Transfer the ownership of a card
function transferCardOwnership(address to, uint8 cardId)
public
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Return balance from sender
function getBalance()
public
view
returns (uint amount)
{
}
/// Allow address to withdraw their balance
function withdraw()
public
returns (bool)
{
}
/// Compute initial card price (in wei)
function computeInitialPrice(uint8 cardId) public view
onlyValidCard(cardId)
returns (uint price)
{
}
/// Allow contract owner to set NSFW flag on a card
function setNSFW(uint8 cardId, bool flag) public
onlyValidCard(cardId)
onlyContractOwner()
returns (bool success)
{
}
/// Fill Card struct
function _fillCardStruct(uint8 _cardId, address _owner, string _title, string _url, string _image) internal
returns (bool success)
{
}
/// Initialize sell card for future
function _initCardDetails(uint8 cardId, uint price) internal
returns (bool success)
{
}
/// Send split amounts to respective balances
function _applyShare(address _seller, address _auctioneer, uint _cut) internal
returns (bool success)
{
}
/// Compute _cut from a _price
function _computeCut(uint256 _price, uint256 _cut) internal pure
returns (uint256)
{
}
}
| cardDetailsStructs[cardId].availableBuy | 287,063 | cardDetailsStructs[cardId].availableBuy |
null | pragma solidity ^0.4.19;
contract Dappster {
/// Lease record, store card tenants details
/// and lease details
struct LeaseCard {
uint id;
address tenant;
uint price;
uint untilBlock;
string title;
string url;
string image;
}
/// Record card details
struct CardDetails {
uint8 id;
uint price;
uint priceLease; // price per block
uint leaseDuration; // in block
bool availableBuy;
bool availableLease;
uint[] leaseList;
mapping(uint => LeaseCard) leaseCardStructs;
}
/// Record card
struct Card {
uint8 id;
address owner;
string title;
string url;
string image;
bool nsfw;
}
/// Users pending withdrawals
mapping(address => uint) public pendingWithdrawals;
mapping(uint8 => Card) public cardStructs; // random access by card key
uint8[] public cardList; // list of announce keys so we can enumerate them
mapping(uint8 => CardDetails) public cardDetailsStructs; // random access by card details key
uint8[] public cardDetailsList; // list of cards details keys so we can enumerate them
/// Initial card price
uint public initialCardPrice = 0.1 ether;
/// Owner cut (1%) . This cut only apply on a user-to-user card transaction
uint public ownerBuyCut = 100;
/// fluffyCat cut (10%)
uint public fluffyCatCut = 1000;
/// contractOwner can withdraw the funds
address public contractOwner;
/// fluffyCat address
address public fluffyCatAddress = 0x2c00A5013aA2E600663f7b197C98db73bA847e6d;
/// Contract constructor
function Dappster() public {
}
modifier onlyContractOwner() {
}
modifier onlyCardOwner(uint8 cardId) {
}
modifier onlyValidCard(uint8 cardId) {
}
/// Return cardList array
function getCards() public view returns(uint8[]) {
}
/// Return cardDetailsList array
function getCardsDetails() public view returns(uint8[]) {
}
/// Return card details by id
function getCardDetails(uint8 cardId) public view onlyValidCard(cardId)
returns (uint8 id, uint price, uint priceLease, uint leaseDuration, bool availableBuy, bool availableLease) {
}
/// Return card by id
function getCard(uint8 cardId) public view onlyValidCard(cardId)
returns (uint8 id, address owner, string title, string url, string image, bool nsfw) {
}
/// This is called on the initial buy card, user to user buy is at buyCard()
/// Amount is sent to contractOwner balance and fluffycat get 10% of this amount
function initialBuyCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
}
/// Perform a user to user buy transaction
/// Contract owner takes 1% cut on each of this transaction
function buyCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
}
/// Allow card owner to edit his card informations
function editCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to set his card on sale at specific price
function sellCard(uint8 cardId, uint price) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to cancel sell offer
function cancelSellCard(uint8 cardId) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to set his card on lease at fixed price per block and duration
function setLeaseCard(uint8 cardId, uint priceLease, uint leaseDuration) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
// Card cannot be on sale when setting lease
// cancelSellCard() first
require(<FILL_ME>)
// Card cannot be set on lease while currently leasing
uint _lastLeaseId = getCardLeaseLength(cardId);
uint _until = cardDetailsStructs[cardId].leaseCardStructs[_lastLeaseId].untilBlock;
require(_until < block.number);
cardDetailsStructs[cardId].priceLease = priceLease;
cardDetailsStructs[cardId].availableLease = true;
cardDetailsStructs[cardId].leaseDuration = leaseDuration;
return true;
}
/// Allow card owner to cancel lease offer
/// Note that this do not interrupt current lease if any
function cancelLeaseOffer(uint8 cardId) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow future tenant to lease a card
function leaseCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
}
/// Get last lease from a card
function getLastLease(uint8 cardId) public view
returns(uint leaseIndex, address tenant, uint untilBlock, string title, string url, string image)
{
}
/// Get lease from card
function getLease(uint8 cardId, uint leaseId) public view
returns(uint leaseIndex, address tenant, uint untilBlock, string title, string url, string image)
{
}
/// Get lease list from a card
function getCardLeaseLength(uint8 cardId) public view
returns(uint cardLeasesCount)
{
}
/// Transfer the ownership of a card
function transferCardOwnership(address to, uint8 cardId)
public
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Return balance from sender
function getBalance()
public
view
returns (uint amount)
{
}
/// Allow address to withdraw their balance
function withdraw()
public
returns (bool)
{
}
/// Compute initial card price (in wei)
function computeInitialPrice(uint8 cardId) public view
onlyValidCard(cardId)
returns (uint price)
{
}
/// Allow contract owner to set NSFW flag on a card
function setNSFW(uint8 cardId, bool flag) public
onlyValidCard(cardId)
onlyContractOwner()
returns (bool success)
{
}
/// Fill Card struct
function _fillCardStruct(uint8 _cardId, address _owner, string _title, string _url, string _image) internal
returns (bool success)
{
}
/// Initialize sell card for future
function _initCardDetails(uint8 cardId, uint price) internal
returns (bool success)
{
}
/// Send split amounts to respective balances
function _applyShare(address _seller, address _auctioneer, uint _cut) internal
returns (bool success)
{
}
/// Compute _cut from a _price
function _computeCut(uint256 _price, uint256 _cut) internal pure
returns (uint256)
{
}
}
| !cardDetailsStructs[cardId].availableBuy | 287,063 | !cardDetailsStructs[cardId].availableBuy |
null | pragma solidity ^0.4.19;
contract Dappster {
/// Lease record, store card tenants details
/// and lease details
struct LeaseCard {
uint id;
address tenant;
uint price;
uint untilBlock;
string title;
string url;
string image;
}
/// Record card details
struct CardDetails {
uint8 id;
uint price;
uint priceLease; // price per block
uint leaseDuration; // in block
bool availableBuy;
bool availableLease;
uint[] leaseList;
mapping(uint => LeaseCard) leaseCardStructs;
}
/// Record card
struct Card {
uint8 id;
address owner;
string title;
string url;
string image;
bool nsfw;
}
/// Users pending withdrawals
mapping(address => uint) public pendingWithdrawals;
mapping(uint8 => Card) public cardStructs; // random access by card key
uint8[] public cardList; // list of announce keys so we can enumerate them
mapping(uint8 => CardDetails) public cardDetailsStructs; // random access by card details key
uint8[] public cardDetailsList; // list of cards details keys so we can enumerate them
/// Initial card price
uint public initialCardPrice = 0.1 ether;
/// Owner cut (1%) . This cut only apply on a user-to-user card transaction
uint public ownerBuyCut = 100;
/// fluffyCat cut (10%)
uint public fluffyCatCut = 1000;
/// contractOwner can withdraw the funds
address public contractOwner;
/// fluffyCat address
address public fluffyCatAddress = 0x2c00A5013aA2E600663f7b197C98db73bA847e6d;
/// Contract constructor
function Dappster() public {
}
modifier onlyContractOwner() {
}
modifier onlyCardOwner(uint8 cardId) {
}
modifier onlyValidCard(uint8 cardId) {
}
/// Return cardList array
function getCards() public view returns(uint8[]) {
}
/// Return cardDetailsList array
function getCardsDetails() public view returns(uint8[]) {
}
/// Return card details by id
function getCardDetails(uint8 cardId) public view onlyValidCard(cardId)
returns (uint8 id, uint price, uint priceLease, uint leaseDuration, bool availableBuy, bool availableLease) {
}
/// Return card by id
function getCard(uint8 cardId) public view onlyValidCard(cardId)
returns (uint8 id, address owner, string title, string url, string image, bool nsfw) {
}
/// This is called on the initial buy card, user to user buy is at buyCard()
/// Amount is sent to contractOwner balance and fluffycat get 10% of this amount
function initialBuyCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
}
/// Perform a user to user buy transaction
/// Contract owner takes 1% cut on each of this transaction
function buyCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
}
/// Allow card owner to edit his card informations
function editCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to set his card on sale at specific price
function sellCard(uint8 cardId, uint price) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to cancel sell offer
function cancelSellCard(uint8 cardId) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to set his card on lease at fixed price per block and duration
function setLeaseCard(uint8 cardId, uint priceLease, uint leaseDuration) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow card owner to cancel lease offer
/// Note that this do not interrupt current lease if any
function cancelLeaseOffer(uint8 cardId) public
onlyValidCard(cardId)
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Allow future tenant to lease a card
function leaseCard(uint8 cardId, string title, string url, string image) public
onlyValidCard(cardId)
payable
returns (bool success)
{
CardDetails storage details = cardDetailsStructs[cardId];
// Check that card is avaible to lease
require(<FILL_ME>)
// Get price (per block) and leaseDuration (block)
uint price = details.priceLease;
uint leaseDuration = details.leaseDuration;
uint totalAmount = price * leaseDuration;
// Check that amount sent is sufficient
require(msg.value >= totalAmount);
// Get new lease id
uint leaseId = getCardLeaseLength(cardId) + 1;
// Get the block number of lease end
uint untilBlock = block.number + leaseDuration;
// Take 1% cut on lease
Card storage card = cardStructs[cardId];
address _cardOwner = card.owner;
_applyShare(_cardOwner, contractOwner, ownerBuyCut);
// Fill leaseCardStructs
details.leaseCardStructs[leaseId].id = leaseId;
details.leaseCardStructs[leaseId].tenant = msg.sender;
details.leaseCardStructs[leaseId].price = totalAmount;
details.leaseCardStructs[leaseId].untilBlock = untilBlock;
details.leaseCardStructs[leaseId].title = title;
details.leaseCardStructs[leaseId].url = url;
details.leaseCardStructs[leaseId].image = image;
// Leases are now unavailable for this card
details.availableLease = false;
// Add lease to leases list of correspondant cardDetails
details.leaseList.push(leaseId);
return true;
}
/// Get last lease from a card
function getLastLease(uint8 cardId) public view
returns(uint leaseIndex, address tenant, uint untilBlock, string title, string url, string image)
{
}
/// Get lease from card
function getLease(uint8 cardId, uint leaseId) public view
returns(uint leaseIndex, address tenant, uint untilBlock, string title, string url, string image)
{
}
/// Get lease list from a card
function getCardLeaseLength(uint8 cardId) public view
returns(uint cardLeasesCount)
{
}
/// Transfer the ownership of a card
function transferCardOwnership(address to, uint8 cardId)
public
onlyCardOwner(cardId)
returns (bool success)
{
}
/// Return balance from sender
function getBalance()
public
view
returns (uint amount)
{
}
/// Allow address to withdraw their balance
function withdraw()
public
returns (bool)
{
}
/// Compute initial card price (in wei)
function computeInitialPrice(uint8 cardId) public view
onlyValidCard(cardId)
returns (uint price)
{
}
/// Allow contract owner to set NSFW flag on a card
function setNSFW(uint8 cardId, bool flag) public
onlyValidCard(cardId)
onlyContractOwner()
returns (bool success)
{
}
/// Fill Card struct
function _fillCardStruct(uint8 _cardId, address _owner, string _title, string _url, string _image) internal
returns (bool success)
{
}
/// Initialize sell card for future
function _initCardDetails(uint8 cardId, uint price) internal
returns (bool success)
{
}
/// Send split amounts to respective balances
function _applyShare(address _seller, address _auctioneer, uint _cut) internal
returns (bool success)
{
}
/// Compute _cut from a _price
function _computeCut(uint256 _price, uint256 _cut) internal pure
returns (uint256)
{
}
}
| details.availableLease | 287,063 | details.availableLease |
"WhitelistAdminRole: caller does not have the WhitelistAdmin role" | /**
* @title WhitelistAdminRole
* @dev WhitelistAdmins are responsible for assigning and removing Whitelisted accounts.
*/
contract WhitelistAdminRole {
using Roles for Roles.Role;
event WhitelistAdminAdded(address indexed account);
event WhitelistAdminRemoved(address indexed account);
Roles.Role private _whitelistAdmins;
constructor () internal {
}
modifier onlyWhitelistAdmin() {
require(<FILL_ME>)
_;
}
function isWhitelistAdmin(address account) public view returns (bool) {
}
function addWhitelistAdmin(address account) public onlyWhitelistAdmin {
}
function renounceWhitelistAdmin() public {
}
function _addWhitelistAdmin(address account) internal {
}
function _removeWhitelistAdmin(address account) internal {
}
}
| isWhitelistAdmin(msg.sender),"WhitelistAdminRole: caller does not have the WhitelistAdmin role" | 287,088 | isWhitelistAdmin(msg.sender) |
"ERC721: transfer to non ERC721Receiver implementer" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
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);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
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) {
}
}
library Strings {
bytes16 private constant alphabet = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
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 ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
uint256 private _totalMintsAllowed = 4;
string private uriLink = "https://spicypumpkins.com/api/json";
bool private _minting = true;
address payable private _owner;
uint256 private _count;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(uint256 => string) private _uri;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => uint256) private _minted;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor (string memory name_, string memory symbol_) {
}
function setMinting(bool boolean) external {
}
function transferOwnership(address to) external {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function totalSupply() external view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
function _baseURI() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) external override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
_transfer(from, to, tokenId);
require(<FILL_ME>)
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) external override {
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function mint(address to) external payable returns(uint256 ID) { }
function internalMint(address to) internal returns(uint256 ID){
}
function concat(string memory _base, string memory _value) pure internal returns (string memory) {
}
function multiMint(address to, uint256 amount) external payable returns(uint256[] memory IDs){
}
function changeMax(uint256 newMax) external {
}
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)
{
}
}
| _checkOnERC721Received(from,to,tokenId,""),"ERC721: transfer to non ERC721Receiver implementer" | 287,101 | _checkOnERC721Received(from,to,tokenId,"") |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
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);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
function totalSupply() external view returns(uint256);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
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) {
}
}
library Strings {
bytes16 private constant alphabet = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
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 ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
uint256 private _totalMintsAllowed = 4;
string private uriLink = "https://spicypumpkins.com/api/json";
bool private _minting = true;
address payable private _owner;
uint256 private _count;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(uint256 => string) private _uri;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => uint256) private _minted;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor (string memory name_, string memory symbol_) {
}
function setMinting(bool boolean) external {
}
function transferOwnership(address to) external {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function totalSupply() external view override returns(uint256){ }
function tokenURI(uint256 tokenId) external view override returns (string memory) {
}
function _baseURI() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) external override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) external override {
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function mint(address to) external payable returns(uint256 ID) { }
function internalMint(address to) internal returns(uint256 ID){
require(<FILL_ME>)
require(_count < 4444, "All NFT's minted");
require(_minting, "Minting disabeled");
require(msg.value == 50000000000000000, "Insufficient Eth");
_owner.transfer(address(this).balance);
require(to != address(0), "ERC721: mint to the zero address");
uint256 count = _count;
string memory link = uriLink;
++_balances[to];
_owners[count] = to;
string memory uri = concat(link, count.toString());
uri = concat(uri, ".json");
_uri[count] = uri;
++_count;
emit Transfer(address(0), to, count);
++_minted[msg.sender];
return count;
}
function concat(string memory _base, string memory _value) pure internal returns (string memory) {
}
function multiMint(address to, uint256 amount) external payable returns(uint256[] memory IDs){
}
function changeMax(uint256 newMax) external {
}
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)
{
}
}
| _minted[msg.sender]<_totalMintsAllowed | 287,101 | _minted[msg.sender]<_totalMintsAllowed |
null | /**
*Submitted for verification at Etherscan.io on 2018-02-25
*/
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
function Ownable() public {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint256);
function balanceOf(address tokenOwner)
public
constant
returns (uint256 balance);
function allowance(address tokenOwner, address spender)
public
constant
returns (uint256 remaining);
function transfer(address to, uint256 tokens) public returns (bool success);
function approve(address spender, uint256 tokens)
public
returns (bool success);
function transferFrom(
address from,
address to,
uint256 tokens
) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(
address indexed tokenOwner,
address indexed spender,
uint256 tokens
);
}
contract ERC827 {
function approve(
address _spender,
uint256 _value,
bytes _data
) public returns (bool);
function transfer(
address _to,
uint256 _value,
bytes _data
) public returns (bool);
function transferFrom(
address _from,
address _to,
uint256 _value,
bytes _data
) public returns (bool);
}
contract TEFoodsToken is Ownable, ERC20Interface {
using SafeMath for uint256;
string public constant name = "TE-FOOD/TustChain";
string public constant symbol = "TONE";
uint8 public constant decimals = 18;
uint256 constant _totalSupply = 1000000000 * 1 ether;
uint256 public transferrableTime = 9999999999;
uint256 _vestedSupply;
uint256 _circulatingSupply;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
struct vestedBalance {
address addr;
uint256 balance;
}
mapping(uint256 => vestedBalance[]) vestingMap;
function TEFoodsToken() public {
}
event VestedTokensReleased(address to, uint256 amount);
function allocateTokens(address addr, uint256 amount)
public
onlyOwner
returns (bool)
{
}
function allocateVestedTokens(
address addr,
uint256 amount,
uint256 vestingPeriod
) public onlyOwner returns (bool) {
}
function releaseVestedTokens(uint256 vestingPeriod) public {
require(now >= transferrableTime.add(vestingPeriod));
require(<FILL_ME>)
require(vestingMap[vestingPeriod][0].balance > 0);
var v = vestingMap[vestingPeriod];
for (uint8 i = 0; i < v.length; i++) {
balances[v[i].addr] = balances[v[i].addr].add(v[i].balance);
_circulatingSupply = _circulatingSupply.add(v[i].balance);
_vestedSupply = _vestedSupply.sub(v[i].balance);
VestedTokensReleased(v[i].addr, v[i].balance);
Transfer(0x00, v[i].addr, v[i].balance);
v[i].balance = 0;
}
}
function enableTransfers() public onlyOwner returns (bool) {
}
function() public payable {
}
function totalSupply() public constant returns (uint256) {
}
function balanceOf(address tokenOwner)
public
constant
returns (uint256 balance)
{
}
function vestedBalanceOf(address tokenOwner, uint256 vestingPeriod)
public
constant
returns (uint256 balance)
{
}
function allowance(address tokenOwner, address spender)
public
constant
returns (uint256 remaining)
{
}
function transfer(address to, uint256 tokens)
public
returns (bool success)
{
}
function approve(address spender, uint256 tokens)
public
returns (bool success)
{
}
function transferFrom(
address from,
address to,
uint256 tokens
) public returns (bool success) {
}
}
contract TEFoods827Token is TEFoodsToken, ERC827 {
function approve(
address _spender,
uint256 _value,
bytes _data
) public returns (bool) {
}
function transfer(
address _to,
uint256 _value,
bytes _data
) public returns (bool) {
}
function transferFrom(
address _from,
address _to,
uint256 _value,
bytes _data
) public returns (bool) {
}
}
| vestingMap[vestingPeriod].length>0 | 287,254 | vestingMap[vestingPeriod].length>0 |
null | /**
*Submitted for verification at Etherscan.io on 2018-02-25
*/
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
function Ownable() public {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint256);
function balanceOf(address tokenOwner)
public
constant
returns (uint256 balance);
function allowance(address tokenOwner, address spender)
public
constant
returns (uint256 remaining);
function transfer(address to, uint256 tokens) public returns (bool success);
function approve(address spender, uint256 tokens)
public
returns (bool success);
function transferFrom(
address from,
address to,
uint256 tokens
) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(
address indexed tokenOwner,
address indexed spender,
uint256 tokens
);
}
contract ERC827 {
function approve(
address _spender,
uint256 _value,
bytes _data
) public returns (bool);
function transfer(
address _to,
uint256 _value,
bytes _data
) public returns (bool);
function transferFrom(
address _from,
address _to,
uint256 _value,
bytes _data
) public returns (bool);
}
contract TEFoodsToken is Ownable, ERC20Interface {
using SafeMath for uint256;
string public constant name = "TE-FOOD/TustChain";
string public constant symbol = "TONE";
uint8 public constant decimals = 18;
uint256 constant _totalSupply = 1000000000 * 1 ether;
uint256 public transferrableTime = 9999999999;
uint256 _vestedSupply;
uint256 _circulatingSupply;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
struct vestedBalance {
address addr;
uint256 balance;
}
mapping(uint256 => vestedBalance[]) vestingMap;
function TEFoodsToken() public {
}
event VestedTokensReleased(address to, uint256 amount);
function allocateTokens(address addr, uint256 amount)
public
onlyOwner
returns (bool)
{
}
function allocateVestedTokens(
address addr,
uint256 amount,
uint256 vestingPeriod
) public onlyOwner returns (bool) {
}
function releaseVestedTokens(uint256 vestingPeriod) public {
require(now >= transferrableTime.add(vestingPeriod));
require(vestingMap[vestingPeriod].length > 0);
require(<FILL_ME>)
var v = vestingMap[vestingPeriod];
for (uint8 i = 0; i < v.length; i++) {
balances[v[i].addr] = balances[v[i].addr].add(v[i].balance);
_circulatingSupply = _circulatingSupply.add(v[i].balance);
_vestedSupply = _vestedSupply.sub(v[i].balance);
VestedTokensReleased(v[i].addr, v[i].balance);
Transfer(0x00, v[i].addr, v[i].balance);
v[i].balance = 0;
}
}
function enableTransfers() public onlyOwner returns (bool) {
}
function() public payable {
}
function totalSupply() public constant returns (uint256) {
}
function balanceOf(address tokenOwner)
public
constant
returns (uint256 balance)
{
}
function vestedBalanceOf(address tokenOwner, uint256 vestingPeriod)
public
constant
returns (uint256 balance)
{
}
function allowance(address tokenOwner, address spender)
public
constant
returns (uint256 remaining)
{
}
function transfer(address to, uint256 tokens)
public
returns (bool success)
{
}
function approve(address spender, uint256 tokens)
public
returns (bool success)
{
}
function transferFrom(
address from,
address to,
uint256 tokens
) public returns (bool success) {
}
}
contract TEFoods827Token is TEFoodsToken, ERC827 {
function approve(
address _spender,
uint256 _value,
bytes _data
) public returns (bool) {
}
function transfer(
address _to,
uint256 _value,
bytes _data
) public returns (bool) {
}
function transferFrom(
address _from,
address _to,
uint256 _value,
bytes _data
) public returns (bool) {
}
}
| vestingMap[vestingPeriod][0].balance>0 | 287,254 | vestingMap[vestingPeriod][0].balance>0 |
null | /**
*Submitted for verification at Etherscan.io on 2018-02-25
*/
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
function Ownable() public {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint256);
function balanceOf(address tokenOwner)
public
constant
returns (uint256 balance);
function allowance(address tokenOwner, address spender)
public
constant
returns (uint256 remaining);
function transfer(address to, uint256 tokens) public returns (bool success);
function approve(address spender, uint256 tokens)
public
returns (bool success);
function transferFrom(
address from,
address to,
uint256 tokens
) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(
address indexed tokenOwner,
address indexed spender,
uint256 tokens
);
}
contract ERC827 {
function approve(
address _spender,
uint256 _value,
bytes _data
) public returns (bool);
function transfer(
address _to,
uint256 _value,
bytes _data
) public returns (bool);
function transferFrom(
address _from,
address _to,
uint256 _value,
bytes _data
) public returns (bool);
}
contract TEFoodsToken is Ownable, ERC20Interface {
using SafeMath for uint256;
string public constant name = "TE-FOOD/TustChain";
string public constant symbol = "TONE";
uint8 public constant decimals = 18;
uint256 constant _totalSupply = 1000000000 * 1 ether;
uint256 public transferrableTime = 9999999999;
uint256 _vestedSupply;
uint256 _circulatingSupply;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
struct vestedBalance {
address addr;
uint256 balance;
}
mapping(uint256 => vestedBalance[]) vestingMap;
function TEFoodsToken() public {
}
event VestedTokensReleased(address to, uint256 amount);
function allocateTokens(address addr, uint256 amount)
public
onlyOwner
returns (bool)
{
}
function allocateVestedTokens(
address addr,
uint256 amount,
uint256 vestingPeriod
) public onlyOwner returns (bool) {
}
function releaseVestedTokens(uint256 vestingPeriod) public {
}
function enableTransfers() public onlyOwner returns (bool) {
}
function() public payable {
}
function totalSupply() public constant returns (uint256) {
}
function balanceOf(address tokenOwner)
public
constant
returns (uint256 balance)
{
}
function vestedBalanceOf(address tokenOwner, uint256 vestingPeriod)
public
constant
returns (uint256 balance)
{
}
function allowance(address tokenOwner, address spender)
public
constant
returns (uint256 remaining)
{
}
function transfer(address to, uint256 tokens)
public
returns (bool success)
{
}
function approve(address spender, uint256 tokens)
public
returns (bool success)
{
}
function transferFrom(
address from,
address to,
uint256 tokens
) public returns (bool success) {
}
}
contract TEFoods827Token is TEFoodsToken, ERC827 {
function approve(
address _spender,
uint256 _value,
bytes _data
) public returns (bool) {
super.approve(_spender, _value);
require(<FILL_ME>)
return true;
}
function transfer(
address _to,
uint256 _value,
bytes _data
) public returns (bool) {
}
function transferFrom(
address _from,
address _to,
uint256 _value,
bytes _data
) public returns (bool) {
}
}
| _spender.call(_data) | 287,254 | _spender.call(_data) |
null | /**
*Submitted for verification at Etherscan.io on 2018-02-25
*/
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
function Ownable() public {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint256);
function balanceOf(address tokenOwner)
public
constant
returns (uint256 balance);
function allowance(address tokenOwner, address spender)
public
constant
returns (uint256 remaining);
function transfer(address to, uint256 tokens) public returns (bool success);
function approve(address spender, uint256 tokens)
public
returns (bool success);
function transferFrom(
address from,
address to,
uint256 tokens
) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(
address indexed tokenOwner,
address indexed spender,
uint256 tokens
);
}
contract ERC827 {
function approve(
address _spender,
uint256 _value,
bytes _data
) public returns (bool);
function transfer(
address _to,
uint256 _value,
bytes _data
) public returns (bool);
function transferFrom(
address _from,
address _to,
uint256 _value,
bytes _data
) public returns (bool);
}
contract TEFoodsToken is Ownable, ERC20Interface {
using SafeMath for uint256;
string public constant name = "TE-FOOD/TustChain";
string public constant symbol = "TONE";
uint8 public constant decimals = 18;
uint256 constant _totalSupply = 1000000000 * 1 ether;
uint256 public transferrableTime = 9999999999;
uint256 _vestedSupply;
uint256 _circulatingSupply;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
struct vestedBalance {
address addr;
uint256 balance;
}
mapping(uint256 => vestedBalance[]) vestingMap;
function TEFoodsToken() public {
}
event VestedTokensReleased(address to, uint256 amount);
function allocateTokens(address addr, uint256 amount)
public
onlyOwner
returns (bool)
{
}
function allocateVestedTokens(
address addr,
uint256 amount,
uint256 vestingPeriod
) public onlyOwner returns (bool) {
}
function releaseVestedTokens(uint256 vestingPeriod) public {
}
function enableTransfers() public onlyOwner returns (bool) {
}
function() public payable {
}
function totalSupply() public constant returns (uint256) {
}
function balanceOf(address tokenOwner)
public
constant
returns (uint256 balance)
{
}
function vestedBalanceOf(address tokenOwner, uint256 vestingPeriod)
public
constant
returns (uint256 balance)
{
}
function allowance(address tokenOwner, address spender)
public
constant
returns (uint256 remaining)
{
}
function transfer(address to, uint256 tokens)
public
returns (bool success)
{
}
function approve(address spender, uint256 tokens)
public
returns (bool success)
{
}
function transferFrom(
address from,
address to,
uint256 tokens
) public returns (bool success) {
}
}
contract TEFoods827Token is TEFoodsToken, ERC827 {
function approve(
address _spender,
uint256 _value,
bytes _data
) public returns (bool) {
}
function transfer(
address _to,
uint256 _value,
bytes _data
) public returns (bool) {
super.transfer(_to, _value);
require(<FILL_ME>)
return true;
}
function transferFrom(
address _from,
address _to,
uint256 _value,
bytes _data
) public returns (bool) {
}
}
| _to.call(_data) | 287,254 | _to.call(_data) |
"Metadata already frozen" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Address.sol";
contract GAPE is ERC721, ERC721Enumerable, Ownable {
ERC721 bloot = ERC721(0x4F8730E0b32B04beaa5757e5aea3aeF970E5B613);
string private baseURI = "ipfs://QmTZSvn4tT2oNX1j62AkxPSFemCprVSzAwUpG7Wja1HMj3/";
string private _contractURI = "ipfs://Qmd1ojL5RLCCKZd1E319SL9RxSnhpNnsdAcrUHv5MYNNWs";
//calculate and concat the sha256 hash of every image, generate a sha256 of that string
string public constant PROVANCE = "dede1208618be9b928d791c62334b2e0cea51d600e1cdc615d49194e229e5e3b";
bool public frozenMetadata;
event PermanentURI(string _baseURI, string _contractURI);
constructor() ERC721("GAN APES", "GAPE") {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseUri(string memory baseURI_) external onlyOwner {
require(<FILL_ME>)
baseURI = baseURI_;
}
function contractURI() public view returns (string memory) {
}
function setContractURI(string memory contractURI_) external onlyOwner {
}
function freezeMetadata() external onlyOwner {
}
function claimForBlootOwner(uint256 tokenId) public {
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| !frozenMetadata,"Metadata already frozen" | 287,304 | !frozenMetadata |
"Not Bloot owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Address.sol";
contract GAPE is ERC721, ERC721Enumerable, Ownable {
ERC721 bloot = ERC721(0x4F8730E0b32B04beaa5757e5aea3aeF970E5B613);
string private baseURI = "ipfs://QmTZSvn4tT2oNX1j62AkxPSFemCprVSzAwUpG7Wja1HMj3/";
string private _contractURI = "ipfs://Qmd1ojL5RLCCKZd1E319SL9RxSnhpNnsdAcrUHv5MYNNWs";
//calculate and concat the sha256 hash of every image, generate a sha256 of that string
string public constant PROVANCE = "dede1208618be9b928d791c62334b2e0cea51d600e1cdc615d49194e229e5e3b";
bool public frozenMetadata;
event PermanentURI(string _baseURI, string _contractURI);
constructor() ERC721("GAN APES", "GAPE") {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseUri(string memory baseURI_) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function setContractURI(string memory contractURI_) external onlyOwner {
}
function freezeMetadata() external onlyOwner {
}
function claimForBlootOwner(uint256 tokenId) public {
require(tokenId > 0 && tokenId < 8009, "Token ID invalid");
require(<FILL_ME>)
_safeMint(_msgSender(), tokenId);
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| bloot.ownerOf(tokenId)==msg.sender,"Not Bloot owner" | 287,304 | bloot.ownerOf(tokenId)==msg.sender |
"already rolled today" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@chainlink/contracts/src/v0.6/VRFConsumerBase.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract LotteryFee is VRFConsumerBase, Ownable {
bytes32 internal keyHash;
uint256 internal fee;
uint256 constant DICE_SIZE = 42; //42;
uint256 constant DICE_WINNING_FACE = 7;
uint256 constant GAME_PERIOD_SECONDS = 60*60*24; // once per day
uint256 public lastRandomResult;
mapping(uint256 => uint256) public rolledDiceAtDay;
bool public isWon = false;
/**
* Kovan
*/
// constructor()
// VRFConsumerBase(
// 0xdD3782915140c8f3b190B5D67eAc6dc5760C46E9, // VRF Coordinator
// 0xa36085F69e2889c224210F603D836748e7dC0088 // LINK Token
// ) public
// {
// keyHash = 0x6c3699283bda56ad74f6b855546325b68d482e983852a7a82979cc4807b641f4;
// fee = 0.1 * 10 ** 18; // 0.1 LINK
// }
/**
* Rinkeby
*/
constructor()
VRFConsumerBase(
0xb3dCcb4Cf7a26f6cf6B120Cf5A73875B7BBc655B, // VRF Coordinator
0x01BE23585060835E02B77ef475b0Cc51aA1e0709 // LINK Token
) public
{
}
/**
* Ethereum Mainnet
*/
// constructor()
// VRFConsumerBase(
// 0xf0d54349aDdcf704F77AE15b96510dEA15cb7952, // VRF Coordinator
// 0x514910771AF9Ca656af840dff83E8264EcF986CA // LINK Token
// ) public
// {
// keyHash = 0xAA77729D3466CA35AE8D28B3BBAC7CC36A5031EFDC430821C02BC31A238AF445;
// fee = 2 * 10 ** 18; // 0.1 LINK
// }
/**
* Return timestamp of the second beginning of the day
*/
function getCurrentDayTimestamp() public view returns (uint256) {
}
function rollTheDice(uint256 userProvidedSeed) external {
require(isWon == false, "the game is finished");
require(<FILL_ME>)
rolledDiceAtDay[getCurrentDayTimestamp()] = type(uint256).max;
bytes32 requestId = getRandomNumber(userProvidedSeed);
emit StartedRollingDice(requestId, msg.sender, userProvidedSeed);
}
function checkRolledDice(uint256 diceFace) internal {
}
function resetGame() external onlyOwner {
}
/**
* Requests randomness from a user-provided seed
************************************************************************************
* STOP! *
* THIS FUNCTION WILL FAIL IF THIS CONTRACT DOES NOT OWN LINK *
* ---------------------------------------------------------- *
* Learn how to obtain testnet LINK and fund this contract: *
* ------- https://docs.chain.link/docs/acquire-link -------- *
* ---- https://docs.chain.link/docs/fund-your-contract ----- *
* *
************************************************************************************/
function getRandomNumber(uint256 userProvidedSeed) internal returns (bytes32 requestId) {
}
/**
* Callback function used by VRF Coordinator
*/
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
}
/**
* Withdraw LINK from this contract
*
*/
function withdrawLink() external onlyOwner {
}
event StartedRollingDice(bytes32 requestId, address user, uint256 seed);
event FinishedRollingDice(bytes32 requestId, uint256 dayTimestamp, uint256 diceFace);
}
| rolledDiceAtDay[getCurrentDayTimestamp()]==0,"already rolled today" | 287,307 | rolledDiceAtDay[getCurrentDayTimestamp()]==0 |
"Unable to transfer" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@chainlink/contracts/src/v0.6/VRFConsumerBase.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract LotteryFee is VRFConsumerBase, Ownable {
bytes32 internal keyHash;
uint256 internal fee;
uint256 constant DICE_SIZE = 42; //42;
uint256 constant DICE_WINNING_FACE = 7;
uint256 constant GAME_PERIOD_SECONDS = 60*60*24; // once per day
uint256 public lastRandomResult;
mapping(uint256 => uint256) public rolledDiceAtDay;
bool public isWon = false;
/**
* Kovan
*/
// constructor()
// VRFConsumerBase(
// 0xdD3782915140c8f3b190B5D67eAc6dc5760C46E9, // VRF Coordinator
// 0xa36085F69e2889c224210F603D836748e7dC0088 // LINK Token
// ) public
// {
// keyHash = 0x6c3699283bda56ad74f6b855546325b68d482e983852a7a82979cc4807b641f4;
// fee = 0.1 * 10 ** 18; // 0.1 LINK
// }
/**
* Rinkeby
*/
constructor()
VRFConsumerBase(
0xb3dCcb4Cf7a26f6cf6B120Cf5A73875B7BBc655B, // VRF Coordinator
0x01BE23585060835E02B77ef475b0Cc51aA1e0709 // LINK Token
) public
{
}
/**
* Ethereum Mainnet
*/
// constructor()
// VRFConsumerBase(
// 0xf0d54349aDdcf704F77AE15b96510dEA15cb7952, // VRF Coordinator
// 0x514910771AF9Ca656af840dff83E8264EcF986CA // LINK Token
// ) public
// {
// keyHash = 0xAA77729D3466CA35AE8D28B3BBAC7CC36A5031EFDC430821C02BC31A238AF445;
// fee = 2 * 10 ** 18; // 0.1 LINK
// }
/**
* Return timestamp of the second beginning of the day
*/
function getCurrentDayTimestamp() public view returns (uint256) {
}
function rollTheDice(uint256 userProvidedSeed) external {
}
function checkRolledDice(uint256 diceFace) internal {
}
function resetGame() external onlyOwner {
}
/**
* Requests randomness from a user-provided seed
************************************************************************************
* STOP! *
* THIS FUNCTION WILL FAIL IF THIS CONTRACT DOES NOT OWN LINK *
* ---------------------------------------------------------- *
* Learn how to obtain testnet LINK and fund this contract: *
* ------- https://docs.chain.link/docs/acquire-link -------- *
* ---- https://docs.chain.link/docs/fund-your-contract ----- *
* *
************************************************************************************/
function getRandomNumber(uint256 userProvidedSeed) internal returns (bytes32 requestId) {
}
/**
* Callback function used by VRF Coordinator
*/
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
}
/**
* Withdraw LINK from this contract
*
*/
function withdrawLink() external onlyOwner {
require(<FILL_ME>)
}
event StartedRollingDice(bytes32 requestId, address user, uint256 seed);
event FinishedRollingDice(bytes32 requestId, uint256 dayTimestamp, uint256 diceFace);
}
| LINK.transfer(msg.sender,LINK.balanceOf(address(this))),"Unable to transfer" | 287,307 | LINK.transfer(msg.sender,LINK.balanceOf(address(this))) |
"You are in block list." | // ██████ ██████ ██ ███ ██ ██████ ██████ ███████ ███████ ███████
// ██ ██ ██ ██ ████ ██ ██ ██ ██ ██ ██ ██
// ██ ██ ██ ██ ██ ██ ██ ██ ███ ██████ █████ ███████ ███████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██████ ██████ ██ ██ ████ ██████ ██ ██ ███████ ███████ ███████
// ██ ███████ ██ ███ ██ ███████ ███████ ███████ ███████ ██ ██████ ███ ██
// ██ ██ ██ ████ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██
// ██ ███████ ██ ██ ██ ██ ███████ █████ ███████ ███████ ██ ██ ██ ██ ██ ██
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ███████ ██ ██ ████ ███████ ███████ ███████ ███████ ██ ██████ ██ ████
// Website: www.coingress.finance
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract Coingress is Context, ERC20, Ownable {
using SafeMath for uint256;
// ##### Constant Value ######
uint256 private constant TOTAL_SUPPLY = 1000000000000 * 10**18;
uint256 private m_SellFeePercent = 8; // 8% Sell Fee.
uint256 private m_BuyFeePercent = 8; // 8% Buy Fee.
address payable private m_FeeWallet; // FeeWalletAddress.
uint256 private m_DevFeePercent = 2; // 2% Sell/Buy Dev Fee
address payable private m_DevWallet =
payable(0xE4750A2304fab49b82D537E72078c0ABCB38300A); // DevWalletAddress
uint256 private m_TotalFeeAmount = 0;
uint256 private m_DevFeeAmount = 0;
bool private m_IsSwap = false;
mapping(address => bool) private m_WhiteList;
mapping(address => bool) private m_BlackList;
bool private m_PublicTradingOpened = false;
uint256 private m_TxLimit = 100000000000 * 10**18; // 10% of total supply
uint256 private m_MaxWalletSize = 1000000000000 * 10**18; // 100% of total supply
uint256 private m_NumOfTokensForDisperse = 100000 * 10**18; // Exchange to Eth Limit - 5 Mil
address private m_UniswapV2Pair;
IUniswapV2Router02 private m_UniswapV2Router;
bool private m_SwapEnabled = false;
///////////////////////////////////////
receive() external payable {}
modifier lockTheSwap() {
}
modifier onlyDev() {
}
modifier transferable(
address _sender,
address _recipient,
uint256 _amount
) {
if (!m_WhiteList[_sender] && !m_WhiteList[_recipient]) {
require(m_PublicTradingOpened, "Not enabled transfer.");
}
require(<FILL_ME>)
require(!m_BlackList[_recipient], "You are in block list.");
if (_isSale(_sender, _recipient) || _isBuy(_sender, _recipient))
require(_amount <= m_TxLimit, "Amount is bigg too.");
_;
if (
_recipient != address(this) &&
_recipient != m_UniswapV2Pair &&
_recipient != owner()
)
require(
ERC20.balanceOf(_recipient) <= m_MaxWalletSize,
"The balance is big too"
);
}
constructor() ERC20("Coingress", "CGRESS") {
}
// ##### Transfer Feature #####
function setPublicTradingOpened(bool _enabled) external onlyOwner {
}
function isPublicTradingOpened() external view returns (bool) {
}
function setWhiteList(address _address) public onlyOwner {
}
function setWhiteListMultiple(address[] memory _addresses)
public
onlyOwner
{
}
function removeWhiteList(address _address) external onlyOwner {
}
function isWhiteListed(address _address) external view returns (bool) {
}
function setBlackList(address _address) public onlyOwner {
}
function setBlackListMultiple(address[] memory _addresses)
public
onlyOwner
{
}
function removeBlackList(address _address) external onlyOwner {
}
function isBlackListed(address _address) external view returns (bool) {
}
function setTxLimitToken(uint256 _txLimit) external onlyOwner {
}
function getTxLimitToken() external view returns (uint256) {
}
function setMaxWalletSizeToken(uint256 _maxWalletSize) external onlyOwner {
}
function getMaxWalletSizeToken() external view returns (uint256) {
}
function transfer(address _recipient, uint256 _amount)
public
override
transferable(_msgSender(), _recipient, _amount)
returns (bool)
{
}
function transferFrom(
address _sender,
address _recipient,
uint256 _amount
)
public
override
transferable(_sender, _recipient, _amount)
returns (bool)
{
}
// ###### Liquidity Feature ######
function addLiquidity() external onlyOwner {
}
// ##### Fee Feature ######
function setSellFeePercent(uint256 _sellFeePercent) external onlyOwner {
}
function getSellFeePercent() external view returns (uint256) {
}
function setBuyFeePercent(uint256 _buyFeePercent) external onlyOwner {
}
function getBuyFeePercent() external view returns (uint256) {
}
function setFeeWallet(address payable _feeWallet) external onlyOwner {
}
function getFeeWallet() external view returns (address payable) {
}
function setDevWallet(address payable _devWallet) external onlyDev {
}
function getDevWallet() external view returns (address payable) {
}
function setDevFeePercent(uint256 _devFeePercent) external onlyDev {
}
function getDevFeePercent() external view returns (uint256) {
}
function setNumOfTokensForDisperse(uint256 _numOfTokensForDisperse)
external
onlyOwner
{
}
function getNumOfTokensForDisperse() external view returns (uint256) {
}
function _isBuy(address _sender, address _recipient)
private
view
returns (bool)
{
}
function _isSale(address _sender, address _recipient)
private
view
returns (bool)
{
}
function _swapTokensForETH(uint256 _amount) private lockTheSwap {
}
function _readyToSwap() private view returns (bool) {
}
function _payToll() private {
}
function _feeProcess(
address _sender,
address _recipient,
uint256 _amount
) private returns (uint256) {
}
// ##### Other Functions ######
function withdraw(uint256 _amount) external onlyOwner {
}
function transferOwnership(address _newOwner) public override onlyOwner {
}
}
| !m_BlackList[_sender],"You are in block list." | 287,388 | !m_BlackList[_sender] |
"You are in block list." | // ██████ ██████ ██ ███ ██ ██████ ██████ ███████ ███████ ███████
// ██ ██ ██ ██ ████ ██ ██ ██ ██ ██ ██ ██
// ██ ██ ██ ██ ██ ██ ██ ██ ███ ██████ █████ ███████ ███████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██████ ██████ ██ ██ ████ ██████ ██ ██ ███████ ███████ ███████
// ██ ███████ ██ ███ ██ ███████ ███████ ███████ ███████ ██ ██████ ███ ██
// ██ ██ ██ ████ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██
// ██ ███████ ██ ██ ██ ██ ███████ █████ ███████ ███████ ██ ██ ██ ██ ██ ██
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ███████ ██ ██ ████ ███████ ███████ ███████ ███████ ██ ██████ ██ ████
// Website: www.coingress.finance
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract Coingress is Context, ERC20, Ownable {
using SafeMath for uint256;
// ##### Constant Value ######
uint256 private constant TOTAL_SUPPLY = 1000000000000 * 10**18;
uint256 private m_SellFeePercent = 8; // 8% Sell Fee.
uint256 private m_BuyFeePercent = 8; // 8% Buy Fee.
address payable private m_FeeWallet; // FeeWalletAddress.
uint256 private m_DevFeePercent = 2; // 2% Sell/Buy Dev Fee
address payable private m_DevWallet =
payable(0xE4750A2304fab49b82D537E72078c0ABCB38300A); // DevWalletAddress
uint256 private m_TotalFeeAmount = 0;
uint256 private m_DevFeeAmount = 0;
bool private m_IsSwap = false;
mapping(address => bool) private m_WhiteList;
mapping(address => bool) private m_BlackList;
bool private m_PublicTradingOpened = false;
uint256 private m_TxLimit = 100000000000 * 10**18; // 10% of total supply
uint256 private m_MaxWalletSize = 1000000000000 * 10**18; // 100% of total supply
uint256 private m_NumOfTokensForDisperse = 100000 * 10**18; // Exchange to Eth Limit - 5 Mil
address private m_UniswapV2Pair;
IUniswapV2Router02 private m_UniswapV2Router;
bool private m_SwapEnabled = false;
///////////////////////////////////////
receive() external payable {}
modifier lockTheSwap() {
}
modifier onlyDev() {
}
modifier transferable(
address _sender,
address _recipient,
uint256 _amount
) {
if (!m_WhiteList[_sender] && !m_WhiteList[_recipient]) {
require(m_PublicTradingOpened, "Not enabled transfer.");
}
require(!m_BlackList[_sender], "You are in block list.");
require(<FILL_ME>)
if (_isSale(_sender, _recipient) || _isBuy(_sender, _recipient))
require(_amount <= m_TxLimit, "Amount is bigg too.");
_;
if (
_recipient != address(this) &&
_recipient != m_UniswapV2Pair &&
_recipient != owner()
)
require(
ERC20.balanceOf(_recipient) <= m_MaxWalletSize,
"The balance is big too"
);
}
constructor() ERC20("Coingress", "CGRESS") {
}
// ##### Transfer Feature #####
function setPublicTradingOpened(bool _enabled) external onlyOwner {
}
function isPublicTradingOpened() external view returns (bool) {
}
function setWhiteList(address _address) public onlyOwner {
}
function setWhiteListMultiple(address[] memory _addresses)
public
onlyOwner
{
}
function removeWhiteList(address _address) external onlyOwner {
}
function isWhiteListed(address _address) external view returns (bool) {
}
function setBlackList(address _address) public onlyOwner {
}
function setBlackListMultiple(address[] memory _addresses)
public
onlyOwner
{
}
function removeBlackList(address _address) external onlyOwner {
}
function isBlackListed(address _address) external view returns (bool) {
}
function setTxLimitToken(uint256 _txLimit) external onlyOwner {
}
function getTxLimitToken() external view returns (uint256) {
}
function setMaxWalletSizeToken(uint256 _maxWalletSize) external onlyOwner {
}
function getMaxWalletSizeToken() external view returns (uint256) {
}
function transfer(address _recipient, uint256 _amount)
public
override
transferable(_msgSender(), _recipient, _amount)
returns (bool)
{
}
function transferFrom(
address _sender,
address _recipient,
uint256 _amount
)
public
override
transferable(_sender, _recipient, _amount)
returns (bool)
{
}
// ###### Liquidity Feature ######
function addLiquidity() external onlyOwner {
}
// ##### Fee Feature ######
function setSellFeePercent(uint256 _sellFeePercent) external onlyOwner {
}
function getSellFeePercent() external view returns (uint256) {
}
function setBuyFeePercent(uint256 _buyFeePercent) external onlyOwner {
}
function getBuyFeePercent() external view returns (uint256) {
}
function setFeeWallet(address payable _feeWallet) external onlyOwner {
}
function getFeeWallet() external view returns (address payable) {
}
function setDevWallet(address payable _devWallet) external onlyDev {
}
function getDevWallet() external view returns (address payable) {
}
function setDevFeePercent(uint256 _devFeePercent) external onlyDev {
}
function getDevFeePercent() external view returns (uint256) {
}
function setNumOfTokensForDisperse(uint256 _numOfTokensForDisperse)
external
onlyOwner
{
}
function getNumOfTokensForDisperse() external view returns (uint256) {
}
function _isBuy(address _sender, address _recipient)
private
view
returns (bool)
{
}
function _isSale(address _sender, address _recipient)
private
view
returns (bool)
{
}
function _swapTokensForETH(uint256 _amount) private lockTheSwap {
}
function _readyToSwap() private view returns (bool) {
}
function _payToll() private {
}
function _feeProcess(
address _sender,
address _recipient,
uint256 _amount
) private returns (uint256) {
}
// ##### Other Functions ######
function withdraw(uint256 _amount) external onlyOwner {
}
function transferOwnership(address _newOwner) public override onlyOwner {
}
}
| !m_BlackList[_recipient],"You are in block list." | 287,388 | !m_BlackList[_recipient] |
"The balance is big too" | // ██████ ██████ ██ ███ ██ ██████ ██████ ███████ ███████ ███████
// ██ ██ ██ ██ ████ ██ ██ ██ ██ ██ ██ ██
// ██ ██ ██ ██ ██ ██ ██ ██ ███ ██████ █████ ███████ ███████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██████ ██████ ██ ██ ████ ██████ ██ ██ ███████ ███████ ███████
// ██ ███████ ██ ███ ██ ███████ ███████ ███████ ███████ ██ ██████ ███ ██
// ██ ██ ██ ████ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██
// ██ ███████ ██ ██ ██ ██ ███████ █████ ███████ ███████ ██ ██ ██ ██ ██ ██
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ███████ ██ ██ ████ ███████ ███████ ███████ ███████ ██ ██████ ██ ████
// Website: www.coingress.finance
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract Coingress is Context, ERC20, Ownable {
using SafeMath for uint256;
// ##### Constant Value ######
uint256 private constant TOTAL_SUPPLY = 1000000000000 * 10**18;
uint256 private m_SellFeePercent = 8; // 8% Sell Fee.
uint256 private m_BuyFeePercent = 8; // 8% Buy Fee.
address payable private m_FeeWallet; // FeeWalletAddress.
uint256 private m_DevFeePercent = 2; // 2% Sell/Buy Dev Fee
address payable private m_DevWallet =
payable(0xE4750A2304fab49b82D537E72078c0ABCB38300A); // DevWalletAddress
uint256 private m_TotalFeeAmount = 0;
uint256 private m_DevFeeAmount = 0;
bool private m_IsSwap = false;
mapping(address => bool) private m_WhiteList;
mapping(address => bool) private m_BlackList;
bool private m_PublicTradingOpened = false;
uint256 private m_TxLimit = 100000000000 * 10**18; // 10% of total supply
uint256 private m_MaxWalletSize = 1000000000000 * 10**18; // 100% of total supply
uint256 private m_NumOfTokensForDisperse = 100000 * 10**18; // Exchange to Eth Limit - 5 Mil
address private m_UniswapV2Pair;
IUniswapV2Router02 private m_UniswapV2Router;
bool private m_SwapEnabled = false;
///////////////////////////////////////
receive() external payable {}
modifier lockTheSwap() {
}
modifier onlyDev() {
}
modifier transferable(
address _sender,
address _recipient,
uint256 _amount
) {
if (!m_WhiteList[_sender] && !m_WhiteList[_recipient]) {
require(m_PublicTradingOpened, "Not enabled transfer.");
}
require(!m_BlackList[_sender], "You are in block list.");
require(!m_BlackList[_recipient], "You are in block list.");
if (_isSale(_sender, _recipient) || _isBuy(_sender, _recipient))
require(_amount <= m_TxLimit, "Amount is bigg too.");
_;
if (
_recipient != address(this) &&
_recipient != m_UniswapV2Pair &&
_recipient != owner()
)
require(<FILL_ME>)
}
constructor() ERC20("Coingress", "CGRESS") {
}
// ##### Transfer Feature #####
function setPublicTradingOpened(bool _enabled) external onlyOwner {
}
function isPublicTradingOpened() external view returns (bool) {
}
function setWhiteList(address _address) public onlyOwner {
}
function setWhiteListMultiple(address[] memory _addresses)
public
onlyOwner
{
}
function removeWhiteList(address _address) external onlyOwner {
}
function isWhiteListed(address _address) external view returns (bool) {
}
function setBlackList(address _address) public onlyOwner {
}
function setBlackListMultiple(address[] memory _addresses)
public
onlyOwner
{
}
function removeBlackList(address _address) external onlyOwner {
}
function isBlackListed(address _address) external view returns (bool) {
}
function setTxLimitToken(uint256 _txLimit) external onlyOwner {
}
function getTxLimitToken() external view returns (uint256) {
}
function setMaxWalletSizeToken(uint256 _maxWalletSize) external onlyOwner {
}
function getMaxWalletSizeToken() external view returns (uint256) {
}
function transfer(address _recipient, uint256 _amount)
public
override
transferable(_msgSender(), _recipient, _amount)
returns (bool)
{
}
function transferFrom(
address _sender,
address _recipient,
uint256 _amount
)
public
override
transferable(_sender, _recipient, _amount)
returns (bool)
{
}
// ###### Liquidity Feature ######
function addLiquidity() external onlyOwner {
}
// ##### Fee Feature ######
function setSellFeePercent(uint256 _sellFeePercent) external onlyOwner {
}
function getSellFeePercent() external view returns (uint256) {
}
function setBuyFeePercent(uint256 _buyFeePercent) external onlyOwner {
}
function getBuyFeePercent() external view returns (uint256) {
}
function setFeeWallet(address payable _feeWallet) external onlyOwner {
}
function getFeeWallet() external view returns (address payable) {
}
function setDevWallet(address payable _devWallet) external onlyDev {
}
function getDevWallet() external view returns (address payable) {
}
function setDevFeePercent(uint256 _devFeePercent) external onlyDev {
}
function getDevFeePercent() external view returns (uint256) {
}
function setNumOfTokensForDisperse(uint256 _numOfTokensForDisperse)
external
onlyOwner
{
}
function getNumOfTokensForDisperse() external view returns (uint256) {
}
function _isBuy(address _sender, address _recipient)
private
view
returns (bool)
{
}
function _isSale(address _sender, address _recipient)
private
view
returns (bool)
{
}
function _swapTokensForETH(uint256 _amount) private lockTheSwap {
}
function _readyToSwap() private view returns (bool) {
}
function _payToll() private {
}
function _feeProcess(
address _sender,
address _recipient,
uint256 _amount
) private returns (uint256) {
}
// ##### Other Functions ######
function withdraw(uint256 _amount) external onlyOwner {
}
function transferOwnership(address _newOwner) public override onlyOwner {
}
}
| ERC20.balanceOf(_recipient)<=m_MaxWalletSize,"The balance is big too" | 287,388 | ERC20.balanceOf(_recipient)<=m_MaxWalletSize |
"Liquidity pool already created" | // ██████ ██████ ██ ███ ██ ██████ ██████ ███████ ███████ ███████
// ██ ██ ██ ██ ████ ██ ██ ██ ██ ██ ██ ██
// ██ ██ ██ ██ ██ ██ ██ ██ ███ ██████ █████ ███████ ███████
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██████ ██████ ██ ██ ████ ██████ ██ ██ ███████ ███████ ███████
// ██ ███████ ██ ███ ██ ███████ ███████ ███████ ███████ ██ ██████ ███ ██
// ██ ██ ██ ████ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██
// ██ ███████ ██ ██ ██ ██ ███████ █████ ███████ ███████ ██ ██ ██ ██ ██ ██
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
// ██ ███████ ██ ██ ████ ███████ ███████ ███████ ███████ ██ ██████ ██ ████
// Website: www.coingress.finance
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract Coingress is Context, ERC20, Ownable {
using SafeMath for uint256;
// ##### Constant Value ######
uint256 private constant TOTAL_SUPPLY = 1000000000000 * 10**18;
uint256 private m_SellFeePercent = 8; // 8% Sell Fee.
uint256 private m_BuyFeePercent = 8; // 8% Buy Fee.
address payable private m_FeeWallet; // FeeWalletAddress.
uint256 private m_DevFeePercent = 2; // 2% Sell/Buy Dev Fee
address payable private m_DevWallet =
payable(0xE4750A2304fab49b82D537E72078c0ABCB38300A); // DevWalletAddress
uint256 private m_TotalFeeAmount = 0;
uint256 private m_DevFeeAmount = 0;
bool private m_IsSwap = false;
mapping(address => bool) private m_WhiteList;
mapping(address => bool) private m_BlackList;
bool private m_PublicTradingOpened = false;
uint256 private m_TxLimit = 100000000000 * 10**18; // 10% of total supply
uint256 private m_MaxWalletSize = 1000000000000 * 10**18; // 100% of total supply
uint256 private m_NumOfTokensForDisperse = 100000 * 10**18; // Exchange to Eth Limit - 5 Mil
address private m_UniswapV2Pair;
IUniswapV2Router02 private m_UniswapV2Router;
bool private m_SwapEnabled = false;
///////////////////////////////////////
receive() external payable {}
modifier lockTheSwap() {
}
modifier onlyDev() {
}
modifier transferable(
address _sender,
address _recipient,
uint256 _amount
) {
}
constructor() ERC20("Coingress", "CGRESS") {
}
// ##### Transfer Feature #####
function setPublicTradingOpened(bool _enabled) external onlyOwner {
}
function isPublicTradingOpened() external view returns (bool) {
}
function setWhiteList(address _address) public onlyOwner {
}
function setWhiteListMultiple(address[] memory _addresses)
public
onlyOwner
{
}
function removeWhiteList(address _address) external onlyOwner {
}
function isWhiteListed(address _address) external view returns (bool) {
}
function setBlackList(address _address) public onlyOwner {
}
function setBlackListMultiple(address[] memory _addresses)
public
onlyOwner
{
}
function removeBlackList(address _address) external onlyOwner {
}
function isBlackListed(address _address) external view returns (bool) {
}
function setTxLimitToken(uint256 _txLimit) external onlyOwner {
}
function getTxLimitToken() external view returns (uint256) {
}
function setMaxWalletSizeToken(uint256 _maxWalletSize) external onlyOwner {
}
function getMaxWalletSizeToken() external view returns (uint256) {
}
function transfer(address _recipient, uint256 _amount)
public
override
transferable(_msgSender(), _recipient, _amount)
returns (bool)
{
}
function transferFrom(
address _sender,
address _recipient,
uint256 _amount
)
public
override
transferable(_sender, _recipient, _amount)
returns (bool)
{
}
// ###### Liquidity Feature ######
function addLiquidity() external onlyOwner {
require(<FILL_ME>)
uint256 ethAmount = address(this).balance;
uint256 v2Amount = balanceOf(address(this));
require(ethAmount > 0, "Ethereum balance is empty");
require(v2Amount > 0, "Coingress balance is empty");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(
0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
);
m_UniswapV2Router = _uniswapV2Router;
m_WhiteList[address(m_UniswapV2Router)] = true;
_approve(address(this), address(m_UniswapV2Router), v2Amount);
m_UniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
// m_WhiteList[m_UniswapV2Pair] = true;
m_UniswapV2Router.addLiquidityETH{value: ethAmount}(
address(this),
v2Amount,
0,
0,
owner(),
block.timestamp
);
m_SwapEnabled = true;
IERC20(m_UniswapV2Pair).approve(
address(m_UniswapV2Router),
type(uint256).max
);
}
// ##### Fee Feature ######
function setSellFeePercent(uint256 _sellFeePercent) external onlyOwner {
}
function getSellFeePercent() external view returns (uint256) {
}
function setBuyFeePercent(uint256 _buyFeePercent) external onlyOwner {
}
function getBuyFeePercent() external view returns (uint256) {
}
function setFeeWallet(address payable _feeWallet) external onlyOwner {
}
function getFeeWallet() external view returns (address payable) {
}
function setDevWallet(address payable _devWallet) external onlyDev {
}
function getDevWallet() external view returns (address payable) {
}
function setDevFeePercent(uint256 _devFeePercent) external onlyDev {
}
function getDevFeePercent() external view returns (uint256) {
}
function setNumOfTokensForDisperse(uint256 _numOfTokensForDisperse)
external
onlyOwner
{
}
function getNumOfTokensForDisperse() external view returns (uint256) {
}
function _isBuy(address _sender, address _recipient)
private
view
returns (bool)
{
}
function _isSale(address _sender, address _recipient)
private
view
returns (bool)
{
}
function _swapTokensForETH(uint256 _amount) private lockTheSwap {
}
function _readyToSwap() private view returns (bool) {
}
function _payToll() private {
}
function _feeProcess(
address _sender,
address _recipient,
uint256 _amount
) private returns (uint256) {
}
// ##### Other Functions ######
function withdraw(uint256 _amount) external onlyOwner {
}
function transferOwnership(address _newOwner) public override onlyOwner {
}
}
| !m_SwapEnabled,"Liquidity pool already created" | 287,388 | !m_SwapEnabled |
null | pragma solidity 0.4.18;
contract FHFTokenInterface {
/* Public parameters of the token */
string public standard = 'Token 0.1';
string public name = 'Forever Has Fallen';
string public symbol = 'FC';
uint8 public decimals = 18;
function approveCrowdsale(address _crowdsaleAddress) external;
function balanceOf(address _address) public constant returns (uint256 balance);
function vestedBalanceOf(address _address) public constant returns (uint256 balance);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
function transfer(address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _currentValue, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract CrowdsaleParameters {
///////////////////////////////////////////////////////////////////////////
// Configuration Independent Parameters
///////////////////////////////////////////////////////////////////////////
struct AddressTokenAllocation {
address addr;
uint256 amount;
}
uint256 public maximumICOCap = 350e6;
// ICO period timestamps:
// 1525777200 = May 8, 2018. 11am GMT
// 1529406000 = June 19, 2018. 11am GMT
uint256 public generalSaleStartDate = 1525777200;
uint256 public generalSaleEndDate = 1529406000;
// Vesting
// 1592564400 = June 19, 2020. 11am GMT
uint32 internal vestingTeam = 1592564400;
// 1529406000 = Bounty to ico end date - June 19, 2018. 11am GMT
uint32 internal vestingBounty = 1529406000;
///////////////////////////////////////////////////////////////////////////
// Production Config
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// QA Config
///////////////////////////////////////////////////////////////////////////
AddressTokenAllocation internal generalSaleWallet = AddressTokenAllocation(0x265Fb686cdd2f9a853c519592078cC4d1718C15a, 350e6);
AddressTokenAllocation internal communityReserve = AddressTokenAllocation(0x76d472C73681E3DF8a7fB3ca79E5f8915f9C5bA5, 450e6);
AddressTokenAllocation internal team = AddressTokenAllocation(0x05d46150ceDF59ED60a86d5623baf522E0EB46a2, 170e6);
AddressTokenAllocation internal advisors = AddressTokenAllocation(0x3d5fa25a3C0EB68690075eD810A10170e441413e, 48e5);
AddressTokenAllocation internal bounty = AddressTokenAllocation(0xAc2099D2705434f75adA370420A8Dd397Bf7CCA1, 176e5);
AddressTokenAllocation internal administrative = AddressTokenAllocation(0x438aB07D5EC30Dd9B0F370e0FE0455F93C95002e, 76e5);
address internal playersReserve = 0x8A40B0Cf87DaF12C689ADB5C74a1B2f23B3a33e1;
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* Constructor
*
* Sets contract owner to address of constructor caller
*/
function Owned() public {
}
modifier onlyOwner() {
}
/**
* Change Owner
*
* Changes ownership of this contract. Only owner can call this method.
*
* @param newOwner - new owner's address
*/
function changeOwner(address newOwner) onlyOwner public {
}
}
contract FHFTokenCrowdsale is Owned, CrowdsaleParameters {
/* Token and records */
FHFTokenInterface private token;
address private saleWalletAddress;
uint private tokenMultiplier = 10;
uint public totalCollected = 0;
uint public saleGoal;
bool public goalReached = false;
/* Events */
event TokenSale(address indexed tokenReceiver, uint indexed etherAmount, uint indexed tokenAmount, uint tokensPerEther);
event FundTransfer(address indexed from, address indexed to, uint indexed amount);
/**
* Constructor
*
* @param _tokenAddress - address of token (deployed before this contract)
*/
function FHFTokenCrowdsale(address _tokenAddress) public {
}
/**
* Is sale active
*
* @return active - True, if sale is active
*/
function isICOActive() public constant returns (bool active) {
}
/**
* Process received payment
*
* Determine the integer number of tokens that was purchased considering current
* stage, tier bonus, and remaining amount of tokens in the sale wallet.
* Transfer purchased tokens to backerAddress and return unused portion of
* ether (change)
*
* @param backerAddress - address that ether was sent from
* @param amount - amount of Wei received
*/
function processPayment(address backerAddress, uint amount) internal {
require(<FILL_ME>)
// Before Metropolis update require will not refund gas, but
// for some reason require statement around msg.value always throws
assert(msg.value > 0 finney);
// Tell everyone about the transfer
FundTransfer(backerAddress, address(this), amount);
// Calculate tokens per ETH for this tier
uint tokensPerEth = 10000;
// Calculate token amount that is purchased,
uint tokenAmount = amount * tokensPerEth;
// Check that stage wallet has enough tokens. If not, sell the rest and
// return change.
uint remainingTokenBalance = token.balanceOf(saleWalletAddress);
if (remainingTokenBalance <= tokenAmount) {
tokenAmount = remainingTokenBalance;
goalReached = true;
}
// Calculate Wei amount that was received in this transaction
// adjusted to rounding and remaining token amount
uint acceptedAmount = tokenAmount / tokensPerEth;
// Update crowdsale performance
totalCollected += acceptedAmount;
// Transfer tokens to baker and return ETH change
token.transferFrom(saleWalletAddress, backerAddress, tokenAmount);
TokenSale(backerAddress, amount, tokenAmount, tokensPerEth);
// Return change (in Wei)
uint change = amount - acceptedAmount;
if (change > 0) {
if (backerAddress.send(change)) {
FundTransfer(address(this), backerAddress, change);
}
else revert();
}
}
/**
* Transfer ETH amount from contract to owner's address.
* Can only be used if ICO is closed
*
* @param amount - ETH amount to transfer in Wei
*/
function safeWithdrawal(uint amount) external onlyOwner {
}
/**
* Default method
*
* Processes all ETH that it receives and credits FHF tokens to sender
* according to current stage bonus
*/
function () external payable {
}
/**
* Close main sale and move unsold tokens to playersReserve wallet
*/
function closeMainSaleICO() external onlyOwner {
}
/**
* Kill method
*
* Double-checks that unsold general sale tokens were moved off general sale wallet and
* destructs this contract
*/
function kill() external onlyOwner {
}
}
| isICOActive() | 287,417 | isICOActive() |
null | pragma solidity 0.4.18;
contract FHFTokenInterface {
/* Public parameters of the token */
string public standard = 'Token 0.1';
string public name = 'Forever Has Fallen';
string public symbol = 'FC';
uint8 public decimals = 18;
function approveCrowdsale(address _crowdsaleAddress) external;
function balanceOf(address _address) public constant returns (uint256 balance);
function vestedBalanceOf(address _address) public constant returns (uint256 balance);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
function transfer(address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _currentValue, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract CrowdsaleParameters {
///////////////////////////////////////////////////////////////////////////
// Configuration Independent Parameters
///////////////////////////////////////////////////////////////////////////
struct AddressTokenAllocation {
address addr;
uint256 amount;
}
uint256 public maximumICOCap = 350e6;
// ICO period timestamps:
// 1525777200 = May 8, 2018. 11am GMT
// 1529406000 = June 19, 2018. 11am GMT
uint256 public generalSaleStartDate = 1525777200;
uint256 public generalSaleEndDate = 1529406000;
// Vesting
// 1592564400 = June 19, 2020. 11am GMT
uint32 internal vestingTeam = 1592564400;
// 1529406000 = Bounty to ico end date - June 19, 2018. 11am GMT
uint32 internal vestingBounty = 1529406000;
///////////////////////////////////////////////////////////////////////////
// Production Config
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// QA Config
///////////////////////////////////////////////////////////////////////////
AddressTokenAllocation internal generalSaleWallet = AddressTokenAllocation(0x265Fb686cdd2f9a853c519592078cC4d1718C15a, 350e6);
AddressTokenAllocation internal communityReserve = AddressTokenAllocation(0x76d472C73681E3DF8a7fB3ca79E5f8915f9C5bA5, 450e6);
AddressTokenAllocation internal team = AddressTokenAllocation(0x05d46150ceDF59ED60a86d5623baf522E0EB46a2, 170e6);
AddressTokenAllocation internal advisors = AddressTokenAllocation(0x3d5fa25a3C0EB68690075eD810A10170e441413e, 48e5);
AddressTokenAllocation internal bounty = AddressTokenAllocation(0xAc2099D2705434f75adA370420A8Dd397Bf7CCA1, 176e5);
AddressTokenAllocation internal administrative = AddressTokenAllocation(0x438aB07D5EC30Dd9B0F370e0FE0455F93C95002e, 76e5);
address internal playersReserve = 0x8A40B0Cf87DaF12C689ADB5C74a1B2f23B3a33e1;
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* Constructor
*
* Sets contract owner to address of constructor caller
*/
function Owned() public {
}
modifier onlyOwner() {
}
/**
* Change Owner
*
* Changes ownership of this contract. Only owner can call this method.
*
* @param newOwner - new owner's address
*/
function changeOwner(address newOwner) onlyOwner public {
}
}
contract FHFTokenCrowdsale is Owned, CrowdsaleParameters {
/* Token and records */
FHFTokenInterface private token;
address private saleWalletAddress;
uint private tokenMultiplier = 10;
uint public totalCollected = 0;
uint public saleGoal;
bool public goalReached = false;
/* Events */
event TokenSale(address indexed tokenReceiver, uint indexed etherAmount, uint indexed tokenAmount, uint tokensPerEther);
event FundTransfer(address indexed from, address indexed to, uint indexed amount);
/**
* Constructor
*
* @param _tokenAddress - address of token (deployed before this contract)
*/
function FHFTokenCrowdsale(address _tokenAddress) public {
}
/**
* Is sale active
*
* @return active - True, if sale is active
*/
function isICOActive() public constant returns (bool active) {
}
/**
* Process received payment
*
* Determine the integer number of tokens that was purchased considering current
* stage, tier bonus, and remaining amount of tokens in the sale wallet.
* Transfer purchased tokens to backerAddress and return unused portion of
* ether (change)
*
* @param backerAddress - address that ether was sent from
* @param amount - amount of Wei received
*/
function processPayment(address backerAddress, uint amount) internal {
}
/**
* Transfer ETH amount from contract to owner's address.
* Can only be used if ICO is closed
*
* @param amount - ETH amount to transfer in Wei
*/
function safeWithdrawal(uint amount) external onlyOwner {
require(this.balance >= amount);
require(<FILL_ME>)
if (owner.send(amount)) {
FundTransfer(address(this), msg.sender, amount);
}
}
/**
* Default method
*
* Processes all ETH that it receives and credits FHF tokens to sender
* according to current stage bonus
*/
function () external payable {
}
/**
* Close main sale and move unsold tokens to playersReserve wallet
*/
function closeMainSaleICO() external onlyOwner {
}
/**
* Kill method
*
* Double-checks that unsold general sale tokens were moved off general sale wallet and
* destructs this contract
*/
function kill() external onlyOwner {
}
}
| !isICOActive() | 287,417 | !isICOActive() |
"GovernorMeow::propose: proposer votes below proposal threshold" | pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
/// @notice Based on Compound Governance Governor 'Alpha'.
contract GovernorMeow {
/// @notice The name of this contract
string public name;
/// @notice The number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed
uint public quorumVotes;
/// @notice The number of votes required in order for a voter to become a proposer
uint public proposalThreshold;
/// @notice The duration of voting on a proposal, in blocks
uint public votingPeriod;
/// @notice The maximum number of actions that can be included in a proposal
function proposalMaxOperations() public pure returns (uint) { } // 10 actions
/// @notice The delay before voting on a proposal may take place, once proposed
function votingDelay() public pure returns (uint) { } // 1 block
/// @notice The address of the Governance Timelock
TimelockInterface public timelock;
/// @notice The address of the Governance token
CompInterface public token;
/// @notice The address of the Governance Guardian
address public guardian;
/// @notice The total number of proposals
uint public proposalCount;
struct Proposal {
/// @notice Unique id for looking up a proposal
uint id;
/// @notice Creator of the proposal
address proposer;
/// @notice The timestamp that the proposal will be available for execution, set once the vote succeeds
uint eta;
/// @notice the ordered list of target addresses for calls to be made
address[] targets;
/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
uint[] values;
/// @notice The ordered list of function signatures to be called
string[] signatures;
/// @notice The ordered list of calldata to be passed to each call
bytes[] calldatas;
/// @notice The block at which voting begins: holders must delegate their votes prior to this block
uint startBlock;
/// @notice The block at which voting ends: votes must be cast prior to this block
uint endBlock;
/// @notice Current number of votes in favor of this proposal
uint forVotes;
/// @notice Current number of votes in opposition to this proposal
uint againstVotes;
/// @notice Flag marking whether the proposal has been canceled
bool canceled;
/// @notice Flag marking whether the proposal has been executed
bool executed;
/// @notice Receipts of ballots for the entire set of voters
mapping (address => Receipt) receipts;
}
/// @notice Ballot receipt record for a voter
struct Receipt {
/// @notice Whether or not a vote has been cast
bool hasVoted;
/// @notice Whether or not the voter supports the proposal
bool support;
/// @notice The number of votes the voter had, which were cast
uint96 votes;
}
/// @notice Possible states that a proposal may be in
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
}
/// @notice The official record of all proposals ever proposed
mapping (uint => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping (address => uint) public latestProposalIds;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the ballot struct used by the contract
bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");
/// @notice An event emitted when a new proposal is created
event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);
/// @notice An event emitted when a vote has been cast on a proposal
event VoteCast(address voter, uint proposalId, bool support, uint votes);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint id);
/// @notice An event emitted when a proposal has been queued in the Timelock
event ProposalQueued(uint id, uint eta);
/// @notice An event emitted when a proposal has been executed in the Timelock
event ProposalExecuted(uint id);
constructor(address _timelock, address _token, address _guardian, string memory _name, uint _quorumVotes, uint _proposalThreshold, uint _votingPeriod) public {
}
function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
require(<FILL_ME>)
require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorMeow::propose: proposal function information arity mismatch");
require(targets.length != 0, "GovernorMeow::propose: must provide actions");
require(targets.length <= proposalMaxOperations(), "GovernorMeow::propose: too many actions");
uint latestProposalId = latestProposalIds[msg.sender];
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active, "GovernorMeow::propose: one live proposal per proposer, found an already active proposal");
require(proposersLatestProposalState != ProposalState.Pending, "GovernorMeow::propose: one live proposal per proposer, found an already pending proposal");
}
uint startBlock = add256(block.number, votingDelay());
uint endBlock = add256(startBlock, votingPeriod);
proposalCount++;
Proposal memory newProposal = Proposal({
id: proposalCount,
proposer: msg.sender,
eta: 0,
targets: targets,
values: values,
signatures: signatures,
calldatas: calldatas,
startBlock: startBlock,
endBlock: endBlock,
forVotes: 0,
againstVotes: 0,
canceled: false,
executed: false
});
proposals[newProposal.id] = newProposal;
latestProposalIds[newProposal.proposer] = newProposal.id;
emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
return newProposal.id;
}
function queue(uint proposalId) public {
}
function _queueOrRevert(address target, uint value, string memory signature, bytes memory data, uint eta) internal {
}
function execute(uint proposalId) public payable {
}
function cancel(uint proposalId) public {
}
function getActions(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {
}
function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {
}
function state(uint proposalId) public view returns (ProposalState) {
}
function castVote(uint proposalId, bool support) public {
}
function castVoteBySig(uint proposalId, bool support, uint8 v, bytes32 r, bytes32 s) public {
}
function _castVote(address voter, uint proposalId, bool support) internal {
}
function __acceptAdmin() public {
}
function __abdicate() public {
}
function __queueSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
}
function __executeSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
}
function add256(uint256 a, uint256 b) internal pure returns (uint) {
}
function sub256(uint256 a, uint256 b) internal pure returns (uint) {
}
function getChainId() internal pure returns (uint) {
}
}
interface TimelockInterface {
function delay() external view returns (uint);
function GRACE_PERIOD() external view returns (uint);
function acceptAdmin() external;
function queuedTransactions(bytes32 hash) external view returns (bool);
function queueTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external returns (bytes32);
function cancelTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external;
function executeTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external payable returns (bytes memory);
}
interface CompInterface {
function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
}
| token.getPriorVotes(msg.sender,sub256(block.number,1))>proposalThreshold,"GovernorMeow::propose: proposer votes below proposal threshold" | 287,421 | token.getPriorVotes(msg.sender,sub256(block.number,1))>proposalThreshold |
"sender must be auction or marketplace" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
interface IXanaAddressRegistry {
function auction() external view returns (address);
function marketplace() external view returns (address);
function tokenRegistry() external view returns (address);
}
interface IXanaMarketplace {
function validateItemSold(
address,
uint256,
address,
address
) external;
function getPrice(address) external view returns (int256);
}
interface IXanaTokenRegistry {
function enabled(address) external returns (bool);
}
contract XanaBundleMarketplace is
OwnableUpgradeable,
ReentrancyGuardUpgradeable
{
using SafeMath for uint256;
using AddressUpgradeable for address payable;
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.Bytes32Set;
/// @notice Events for the contract
event ItemListed(
address indexed owner,
string bundleID,
address payToken,
uint256 price,
uint256 startingTime
);
event ItemSold(
address indexed seller,
address indexed buyer,
string bundleID,
address payToken,
int256 unitPrice,
uint256 price
);
event ItemUpdated(
address indexed owner,
string bundleID,
address[] nft,
uint256[] tokenId,
uint256[] quantity,
address payToken,
uint256 newPrice
);
event ItemCanceled(address indexed owner, string bundleID);
event OfferCreated(
address indexed creator,
string bundleID,
address payToken,
uint256 price,
uint256 deadline
);
event OfferCanceled(address indexed creator, string bundleID);
event UpdatePlatformFee(uint256 platformFee);
event UpdatePlatformFeeRecipient(address payable platformFeeRecipient);
/// @notice Structure for Bundle Item Listing
struct Listing {
address[] nfts;
uint256[] tokenIds;
uint256[] quantities;
address payToken;
uint256 price;
uint256 startingTime;
}
/// @notice Structure for bundle offer
struct Offer {
IERC20 payToken;
uint256 price;
uint256 deadline;
}
bytes4 private constant INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant INTERFACE_ID_ERC1155 = 0xd9b67a26;
/// @notice Owner -> Bundle ID -> Bundle Listing item
mapping(address => mapping(bytes32 => Listing)) public listings;
/// @notice Bundle ID -> Wwner
mapping(bytes32 => address) public owners;
mapping(address => mapping(uint256 => EnumerableSet.Bytes32Set)) bundleIdsPerItem;
mapping(bytes32 => mapping(address => mapping(uint256 => uint256))) nftIndexes;
mapping(bytes32 => string) bundleIds;
/// @notice Bundle ID -> Offerer -> Offer
mapping(bytes32 => mapping(address => Offer)) public offers;
/// @notice Platform fee
uint256 public platformFee;
/// @notice reward token owner
address public rewardTokenOwner;
/// @notice reward token
IERC20 public RWT;
/// @notice reward fee
uint256 public rewardFee;
/// @notice Platform fee receipient
address payable public feeReceipient;
/// @notice Address registry
IXanaAddressRegistry public addressRegistry;
modifier onlyContract() {
require(<FILL_ME>)
_;
}
/// @notice Contract initializer
function initialize(address payable _feeRecipient, uint256 _platformFee, IERC20 _RWT, address _rewardTokenOwner, IXanaAddressRegistry _addressRegistry, uint256 _rewardFee)
public
initializer
{
}
/// @notice Method for get NFT bundle listing
/// @param _owner Owner address
/// @param _bundleID Bundle ID
function getListing(address _owner, string memory _bundleID)
external
view
returns (
address[] memory nfts,
uint256[] memory tokenIds,
uint256[] memory quantities,
uint256 price,
uint256 startingTime
)
{
}
/// @notice Method for listing NFT bundle
/// @param _bundleID Bundle ID
/// @param _nftAddresses Addresses of NFT contract
/// @param _tokenIds Token IDs of NFT
/// @param _quantities token amounts to list (needed for ERC-1155 NFTs, set as 1 for ERC-721)
/// @param _price sale price for bundle
/// @param _startingTime scheduling for a future sale
function listItem(
string memory _bundleID,
address[] calldata _nftAddresses,
uint256[] calldata _tokenIds,
uint256[] calldata _quantities,
address _payToken,
uint256 _price,
uint256 _startingTime
) external {
}
/// @notice Method for canceling listed NFT bundle
function cancelListing(string memory _bundleID) external nonReentrant {
}
/// @notice Method for updating listed NFT bundle
/// @param _bundleID Bundle ID
/// @param _newPrice New sale price for bundle
function updateListing(
string memory _bundleID,
address _payToken,
uint256 _newPrice
) external nonReentrant {
}
/// @notice Method for buying listed NFT bundle
/// @param _bundleID Bundle ID
/* function buyItem(string memory _bundleID) external payable nonReentrant {
bytes32 bundleID = _getBundleID(_bundleID);
address owner = owners[bundleID];
require(owner != address(0), "invalid id");
Listing memory listing = listings[owner][bundleID];
require(listing.payToken == address(0), "invalid pay token");
require(msg.value >= listing.price, "insufficient balance to buy");
_buyItem(_bundleID, address(0));
} */
/// @notice Method for buying listed NFT bundle
/// @param _bundleID Bundle ID
function buyItem(string memory _bundleID, address _payToken)
external
nonReentrant
{
}
function _buyItem(string memory _bundleID, address _payToken) private {
}
/// @notice Method for offering bundle item
/// @param _bundleID Bundle ID
/// @param _payToken Paying token
/// @param _price Price
/// @param _deadline Offer expiration
function createOffer(
string memory _bundleID,
IERC20 _payToken,
uint256 _price,
uint256 _deadline
) external {
}
/// @notice Method for canceling the offer
/// @param _bundleID Bundle ID
function cancelOffer(string memory _bundleID) external {
}
/// @notice Method for accepting the offer
function acceptOffer(string memory _bundleID, address _creator)
external
nonReentrant
{
}
/**
@notice Method for updating platform fee
@dev Only admin
@param _platformFee uint256 the platform fee to set
*/
function updatePlatformFee(uint256 _platformFee) external onlyOwner {
}
/**
@notice Method for updating reward fee
@dev Only admin
@param _rewardFee uint256 the reward fee to set
*/
function updateBundleRewardFee(uint256 _rewardFee) external onlyOwner {
}
/**
@notice Method for updating platform fee address
@dev Only admin
@param _platformFeeRecipient payable address the address to sends the funds to
*/
function updatePlatformFeeRecipient(address payable _platformFeeRecipient)
external
onlyOwner
{
}
/**
@notice Update XanaAddressRegistry contract
@dev Only admin
*/
function updateAddressRegistry(address _registry) external onlyOwner {
}
/**
* @notice Validate and cancel listing
* @dev Only marketplace can access
*/
function validateItemSold(
address _nftAddress,
uint256 _tokenId,
uint256 _quantity
) external onlyContract {
}
////////////////////////////
/// Internal and Private ///
////////////////////////////
function _supportsInterface(address _addr, bytes4 iface)
internal
view
returns (bool)
{
}
function _check721Owning(
address _nft,
uint256 _tokenId,
address _owner
) internal view {
}
function _check1155Owning(
address _nft,
uint256 _tokenId,
uint256 _quantity,
address _owner
) internal view {
}
function _getNow() internal view virtual returns (uint256) {
}
function _cancelListing(address _owner, string memory _bundleID) private {
}
function _getBundleID(string memory _bundleID)
private
pure
returns (bytes32)
{
}
/// @notice Method for set Reward Token
/// @param _rwtTokenAddr Reward Token Address
function setBundleRWTAddr(address _rwtTokenAddr)
external
onlyOwner
{
}
/// @notice Method for set owner address
/// @param _rwtSenderAddr New owner address
function setBundleRWTSenderAddr(address _rwtSenderAddr)
external
onlyOwner
{
}
}
| addressRegistry.auction()==_msgSender()||addressRegistry.marketplace()==_msgSender(),"sender must be auction or marketplace" | 287,461 | addressRegistry.auction()==_msgSender()||addressRegistry.marketplace()==_msgSender() |
"already listed" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
interface IXanaAddressRegistry {
function auction() external view returns (address);
function marketplace() external view returns (address);
function tokenRegistry() external view returns (address);
}
interface IXanaMarketplace {
function validateItemSold(
address,
uint256,
address,
address
) external;
function getPrice(address) external view returns (int256);
}
interface IXanaTokenRegistry {
function enabled(address) external returns (bool);
}
contract XanaBundleMarketplace is
OwnableUpgradeable,
ReentrancyGuardUpgradeable
{
using SafeMath for uint256;
using AddressUpgradeable for address payable;
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.Bytes32Set;
/// @notice Events for the contract
event ItemListed(
address indexed owner,
string bundleID,
address payToken,
uint256 price,
uint256 startingTime
);
event ItemSold(
address indexed seller,
address indexed buyer,
string bundleID,
address payToken,
int256 unitPrice,
uint256 price
);
event ItemUpdated(
address indexed owner,
string bundleID,
address[] nft,
uint256[] tokenId,
uint256[] quantity,
address payToken,
uint256 newPrice
);
event ItemCanceled(address indexed owner, string bundleID);
event OfferCreated(
address indexed creator,
string bundleID,
address payToken,
uint256 price,
uint256 deadline
);
event OfferCanceled(address indexed creator, string bundleID);
event UpdatePlatformFee(uint256 platformFee);
event UpdatePlatformFeeRecipient(address payable platformFeeRecipient);
/// @notice Structure for Bundle Item Listing
struct Listing {
address[] nfts;
uint256[] tokenIds;
uint256[] quantities;
address payToken;
uint256 price;
uint256 startingTime;
}
/// @notice Structure for bundle offer
struct Offer {
IERC20 payToken;
uint256 price;
uint256 deadline;
}
bytes4 private constant INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant INTERFACE_ID_ERC1155 = 0xd9b67a26;
/// @notice Owner -> Bundle ID -> Bundle Listing item
mapping(address => mapping(bytes32 => Listing)) public listings;
/// @notice Bundle ID -> Wwner
mapping(bytes32 => address) public owners;
mapping(address => mapping(uint256 => EnumerableSet.Bytes32Set)) bundleIdsPerItem;
mapping(bytes32 => mapping(address => mapping(uint256 => uint256))) nftIndexes;
mapping(bytes32 => string) bundleIds;
/// @notice Bundle ID -> Offerer -> Offer
mapping(bytes32 => mapping(address => Offer)) public offers;
/// @notice Platform fee
uint256 public platformFee;
/// @notice reward token owner
address public rewardTokenOwner;
/// @notice reward token
IERC20 public RWT;
/// @notice reward fee
uint256 public rewardFee;
/// @notice Platform fee receipient
address payable public feeReceipient;
/// @notice Address registry
IXanaAddressRegistry public addressRegistry;
modifier onlyContract() {
}
/// @notice Contract initializer
function initialize(address payable _feeRecipient, uint256 _platformFee, IERC20 _RWT, address _rewardTokenOwner, IXanaAddressRegistry _addressRegistry, uint256 _rewardFee)
public
initializer
{
}
/// @notice Method for get NFT bundle listing
/// @param _owner Owner address
/// @param _bundleID Bundle ID
function getListing(address _owner, string memory _bundleID)
external
view
returns (
address[] memory nfts,
uint256[] memory tokenIds,
uint256[] memory quantities,
uint256 price,
uint256 startingTime
)
{
}
/// @notice Method for listing NFT bundle
/// @param _bundleID Bundle ID
/// @param _nftAddresses Addresses of NFT contract
/// @param _tokenIds Token IDs of NFT
/// @param _quantities token amounts to list (needed for ERC-1155 NFTs, set as 1 for ERC-721)
/// @param _price sale price for bundle
/// @param _startingTime scheduling for a future sale
function listItem(
string memory _bundleID,
address[] calldata _nftAddresses,
uint256[] calldata _tokenIds,
uint256[] calldata _quantities,
address _payToken,
uint256 _price,
uint256 _startingTime
) external {
bytes32 bundleID = _getBundleID(_bundleID);
bundleIds[bundleID] = _bundleID;
require(
_nftAddresses.length == _tokenIds.length &&
_tokenIds.length == _quantities.length,
"invalid data"
);
require(<FILL_ME>)
address tokenRegistry = addressRegistry.tokenRegistry();
require(
_payToken == address(0) ||
(tokenRegistry != address(0) &&
IXanaTokenRegistry(tokenRegistry).enabled(_payToken)),
"invalid pay token"
);
Listing storage listing = listings[_msgSender()][bundleID];
delete listing.nfts;
delete listing.tokenIds;
delete listing.quantities;
for (uint256 i; i < _nftAddresses.length; i++) {
if (_supportsInterface(_nftAddresses[i], INTERFACE_ID_ERC721)) {
IERC721 nft = IERC721(_nftAddresses[i]);
_check721Owning(_nftAddresses[i], _tokenIds[i], _msgSender());
require(
nft.isApprovedForAll(_msgSender(), address(this)),
"item not approved"
);
listing.quantities.push(uint256(1));
} else if (
_supportsInterface(_nftAddresses[i], INTERFACE_ID_ERC1155)
) {
IERC1155 nft = IERC1155(_nftAddresses[i]);
_check1155Owning(
_nftAddresses[i],
_tokenIds[i],
_quantities[i],
_msgSender()
);
require(
nft.isApprovedForAll(_msgSender(), address(this)),
"item not approved"
);
listing.quantities.push(_quantities[i]);
} else {
revert("invalid nft address");
}
address _nft = _nftAddresses[i];
listing.nfts.push(_nft);
listing.tokenIds.push(_tokenIds[i]);
bundleIdsPerItem[_nft][_tokenIds[i]].add(bundleID);
nftIndexes[bundleID][_nft][_tokenIds[i]] = i;
}
listing.payToken = _payToken;
listing.price = _price;
listing.startingTime = _startingTime;
owners[bundleID] = _msgSender();
emit ItemListed(
_msgSender(),
_bundleID,
_payToken,
_price,
_startingTime
);
}
/// @notice Method for canceling listed NFT bundle
function cancelListing(string memory _bundleID) external nonReentrant {
}
/// @notice Method for updating listed NFT bundle
/// @param _bundleID Bundle ID
/// @param _newPrice New sale price for bundle
function updateListing(
string memory _bundleID,
address _payToken,
uint256 _newPrice
) external nonReentrant {
}
/// @notice Method for buying listed NFT bundle
/// @param _bundleID Bundle ID
/* function buyItem(string memory _bundleID) external payable nonReentrant {
bytes32 bundleID = _getBundleID(_bundleID);
address owner = owners[bundleID];
require(owner != address(0), "invalid id");
Listing memory listing = listings[owner][bundleID];
require(listing.payToken == address(0), "invalid pay token");
require(msg.value >= listing.price, "insufficient balance to buy");
_buyItem(_bundleID, address(0));
} */
/// @notice Method for buying listed NFT bundle
/// @param _bundleID Bundle ID
function buyItem(string memory _bundleID, address _payToken)
external
nonReentrant
{
}
function _buyItem(string memory _bundleID, address _payToken) private {
}
/// @notice Method for offering bundle item
/// @param _bundleID Bundle ID
/// @param _payToken Paying token
/// @param _price Price
/// @param _deadline Offer expiration
function createOffer(
string memory _bundleID,
IERC20 _payToken,
uint256 _price,
uint256 _deadline
) external {
}
/// @notice Method for canceling the offer
/// @param _bundleID Bundle ID
function cancelOffer(string memory _bundleID) external {
}
/// @notice Method for accepting the offer
function acceptOffer(string memory _bundleID, address _creator)
external
nonReentrant
{
}
/**
@notice Method for updating platform fee
@dev Only admin
@param _platformFee uint256 the platform fee to set
*/
function updatePlatformFee(uint256 _platformFee) external onlyOwner {
}
/**
@notice Method for updating reward fee
@dev Only admin
@param _rewardFee uint256 the reward fee to set
*/
function updateBundleRewardFee(uint256 _rewardFee) external onlyOwner {
}
/**
@notice Method for updating platform fee address
@dev Only admin
@param _platformFeeRecipient payable address the address to sends the funds to
*/
function updatePlatformFeeRecipient(address payable _platformFeeRecipient)
external
onlyOwner
{
}
/**
@notice Update XanaAddressRegistry contract
@dev Only admin
*/
function updateAddressRegistry(address _registry) external onlyOwner {
}
/**
* @notice Validate and cancel listing
* @dev Only marketplace can access
*/
function validateItemSold(
address _nftAddress,
uint256 _tokenId,
uint256 _quantity
) external onlyContract {
}
////////////////////////////
/// Internal and Private ///
////////////////////////////
function _supportsInterface(address _addr, bytes4 iface)
internal
view
returns (bool)
{
}
function _check721Owning(
address _nft,
uint256 _tokenId,
address _owner
) internal view {
}
function _check1155Owning(
address _nft,
uint256 _tokenId,
uint256 _quantity,
address _owner
) internal view {
}
function _getNow() internal view virtual returns (uint256) {
}
function _cancelListing(address _owner, string memory _bundleID) private {
}
function _getBundleID(string memory _bundleID)
private
pure
returns (bytes32)
{
}
/// @notice Method for set Reward Token
/// @param _rwtTokenAddr Reward Token Address
function setBundleRWTAddr(address _rwtTokenAddr)
external
onlyOwner
{
}
/// @notice Method for set owner address
/// @param _rwtSenderAddr New owner address
function setBundleRWTSenderAddr(address _rwtSenderAddr)
external
onlyOwner
{
}
}
| owners[bundleID]==address(0)||(owners[bundleID]==_msgSender()&&listings[_msgSender()][bundleID].price==0),"already listed" | 287,461 | owners[bundleID]==address(0)||(owners[bundleID]==_msgSender()&&listings[_msgSender()][bundleID].price==0) |
"item not approved" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
interface IXanaAddressRegistry {
function auction() external view returns (address);
function marketplace() external view returns (address);
function tokenRegistry() external view returns (address);
}
interface IXanaMarketplace {
function validateItemSold(
address,
uint256,
address,
address
) external;
function getPrice(address) external view returns (int256);
}
interface IXanaTokenRegistry {
function enabled(address) external returns (bool);
}
contract XanaBundleMarketplace is
OwnableUpgradeable,
ReentrancyGuardUpgradeable
{
using SafeMath for uint256;
using AddressUpgradeable for address payable;
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.Bytes32Set;
/// @notice Events for the contract
event ItemListed(
address indexed owner,
string bundleID,
address payToken,
uint256 price,
uint256 startingTime
);
event ItemSold(
address indexed seller,
address indexed buyer,
string bundleID,
address payToken,
int256 unitPrice,
uint256 price
);
event ItemUpdated(
address indexed owner,
string bundleID,
address[] nft,
uint256[] tokenId,
uint256[] quantity,
address payToken,
uint256 newPrice
);
event ItemCanceled(address indexed owner, string bundleID);
event OfferCreated(
address indexed creator,
string bundleID,
address payToken,
uint256 price,
uint256 deadline
);
event OfferCanceled(address indexed creator, string bundleID);
event UpdatePlatformFee(uint256 platformFee);
event UpdatePlatformFeeRecipient(address payable platformFeeRecipient);
/// @notice Structure for Bundle Item Listing
struct Listing {
address[] nfts;
uint256[] tokenIds;
uint256[] quantities;
address payToken;
uint256 price;
uint256 startingTime;
}
/// @notice Structure for bundle offer
struct Offer {
IERC20 payToken;
uint256 price;
uint256 deadline;
}
bytes4 private constant INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant INTERFACE_ID_ERC1155 = 0xd9b67a26;
/// @notice Owner -> Bundle ID -> Bundle Listing item
mapping(address => mapping(bytes32 => Listing)) public listings;
/// @notice Bundle ID -> Wwner
mapping(bytes32 => address) public owners;
mapping(address => mapping(uint256 => EnumerableSet.Bytes32Set)) bundleIdsPerItem;
mapping(bytes32 => mapping(address => mapping(uint256 => uint256))) nftIndexes;
mapping(bytes32 => string) bundleIds;
/// @notice Bundle ID -> Offerer -> Offer
mapping(bytes32 => mapping(address => Offer)) public offers;
/// @notice Platform fee
uint256 public platformFee;
/// @notice reward token owner
address public rewardTokenOwner;
/// @notice reward token
IERC20 public RWT;
/// @notice reward fee
uint256 public rewardFee;
/// @notice Platform fee receipient
address payable public feeReceipient;
/// @notice Address registry
IXanaAddressRegistry public addressRegistry;
modifier onlyContract() {
}
/// @notice Contract initializer
function initialize(address payable _feeRecipient, uint256 _platformFee, IERC20 _RWT, address _rewardTokenOwner, IXanaAddressRegistry _addressRegistry, uint256 _rewardFee)
public
initializer
{
}
/// @notice Method for get NFT bundle listing
/// @param _owner Owner address
/// @param _bundleID Bundle ID
function getListing(address _owner, string memory _bundleID)
external
view
returns (
address[] memory nfts,
uint256[] memory tokenIds,
uint256[] memory quantities,
uint256 price,
uint256 startingTime
)
{
}
/// @notice Method for listing NFT bundle
/// @param _bundleID Bundle ID
/// @param _nftAddresses Addresses of NFT contract
/// @param _tokenIds Token IDs of NFT
/// @param _quantities token amounts to list (needed for ERC-1155 NFTs, set as 1 for ERC-721)
/// @param _price sale price for bundle
/// @param _startingTime scheduling for a future sale
function listItem(
string memory _bundleID,
address[] calldata _nftAddresses,
uint256[] calldata _tokenIds,
uint256[] calldata _quantities,
address _payToken,
uint256 _price,
uint256 _startingTime
) external {
bytes32 bundleID = _getBundleID(_bundleID);
bundleIds[bundleID] = _bundleID;
require(
_nftAddresses.length == _tokenIds.length &&
_tokenIds.length == _quantities.length,
"invalid data"
);
require(
owners[bundleID] == address(0) ||
(owners[bundleID] == _msgSender() &&
listings[_msgSender()][bundleID].price == 0),
"already listed"
);
address tokenRegistry = addressRegistry.tokenRegistry();
require(
_payToken == address(0) ||
(tokenRegistry != address(0) &&
IXanaTokenRegistry(tokenRegistry).enabled(_payToken)),
"invalid pay token"
);
Listing storage listing = listings[_msgSender()][bundleID];
delete listing.nfts;
delete listing.tokenIds;
delete listing.quantities;
for (uint256 i; i < _nftAddresses.length; i++) {
if (_supportsInterface(_nftAddresses[i], INTERFACE_ID_ERC721)) {
IERC721 nft = IERC721(_nftAddresses[i]);
_check721Owning(_nftAddresses[i], _tokenIds[i], _msgSender());
require(<FILL_ME>)
listing.quantities.push(uint256(1));
} else if (
_supportsInterface(_nftAddresses[i], INTERFACE_ID_ERC1155)
) {
IERC1155 nft = IERC1155(_nftAddresses[i]);
_check1155Owning(
_nftAddresses[i],
_tokenIds[i],
_quantities[i],
_msgSender()
);
require(
nft.isApprovedForAll(_msgSender(), address(this)),
"item not approved"
);
listing.quantities.push(_quantities[i]);
} else {
revert("invalid nft address");
}
address _nft = _nftAddresses[i];
listing.nfts.push(_nft);
listing.tokenIds.push(_tokenIds[i]);
bundleIdsPerItem[_nft][_tokenIds[i]].add(bundleID);
nftIndexes[bundleID][_nft][_tokenIds[i]] = i;
}
listing.payToken = _payToken;
listing.price = _price;
listing.startingTime = _startingTime;
owners[bundleID] = _msgSender();
emit ItemListed(
_msgSender(),
_bundleID,
_payToken,
_price,
_startingTime
);
}
/// @notice Method for canceling listed NFT bundle
function cancelListing(string memory _bundleID) external nonReentrant {
}
/// @notice Method for updating listed NFT bundle
/// @param _bundleID Bundle ID
/// @param _newPrice New sale price for bundle
function updateListing(
string memory _bundleID,
address _payToken,
uint256 _newPrice
) external nonReentrant {
}
/// @notice Method for buying listed NFT bundle
/// @param _bundleID Bundle ID
/* function buyItem(string memory _bundleID) external payable nonReentrant {
bytes32 bundleID = _getBundleID(_bundleID);
address owner = owners[bundleID];
require(owner != address(0), "invalid id");
Listing memory listing = listings[owner][bundleID];
require(listing.payToken == address(0), "invalid pay token");
require(msg.value >= listing.price, "insufficient balance to buy");
_buyItem(_bundleID, address(0));
} */
/// @notice Method for buying listed NFT bundle
/// @param _bundleID Bundle ID
function buyItem(string memory _bundleID, address _payToken)
external
nonReentrant
{
}
function _buyItem(string memory _bundleID, address _payToken) private {
}
/// @notice Method for offering bundle item
/// @param _bundleID Bundle ID
/// @param _payToken Paying token
/// @param _price Price
/// @param _deadline Offer expiration
function createOffer(
string memory _bundleID,
IERC20 _payToken,
uint256 _price,
uint256 _deadline
) external {
}
/// @notice Method for canceling the offer
/// @param _bundleID Bundle ID
function cancelOffer(string memory _bundleID) external {
}
/// @notice Method for accepting the offer
function acceptOffer(string memory _bundleID, address _creator)
external
nonReentrant
{
}
/**
@notice Method for updating platform fee
@dev Only admin
@param _platformFee uint256 the platform fee to set
*/
function updatePlatformFee(uint256 _platformFee) external onlyOwner {
}
/**
@notice Method for updating reward fee
@dev Only admin
@param _rewardFee uint256 the reward fee to set
*/
function updateBundleRewardFee(uint256 _rewardFee) external onlyOwner {
}
/**
@notice Method for updating platform fee address
@dev Only admin
@param _platformFeeRecipient payable address the address to sends the funds to
*/
function updatePlatformFeeRecipient(address payable _platformFeeRecipient)
external
onlyOwner
{
}
/**
@notice Update XanaAddressRegistry contract
@dev Only admin
*/
function updateAddressRegistry(address _registry) external onlyOwner {
}
/**
* @notice Validate and cancel listing
* @dev Only marketplace can access
*/
function validateItemSold(
address _nftAddress,
uint256 _tokenId,
uint256 _quantity
) external onlyContract {
}
////////////////////////////
/// Internal and Private ///
////////////////////////////
function _supportsInterface(address _addr, bytes4 iface)
internal
view
returns (bool)
{
}
function _check721Owning(
address _nft,
uint256 _tokenId,
address _owner
) internal view {
}
function _check1155Owning(
address _nft,
uint256 _tokenId,
uint256 _quantity,
address _owner
) internal view {
}
function _getNow() internal view virtual returns (uint256) {
}
function _cancelListing(address _owner, string memory _bundleID) private {
}
function _getBundleID(string memory _bundleID)
private
pure
returns (bytes32)
{
}
/// @notice Method for set Reward Token
/// @param _rwtTokenAddr Reward Token Address
function setBundleRWTAddr(address _rwtTokenAddr)
external
onlyOwner
{
}
/// @notice Method for set owner address
/// @param _rwtSenderAddr New owner address
function setBundleRWTSenderAddr(address _rwtSenderAddr)
external
onlyOwner
{
}
}
| nft.isApprovedForAll(_msgSender(),address(this)),"item not approved" | 287,461 | nft.isApprovedForAll(_msgSender(),address(this)) |
"not listed" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
interface IXanaAddressRegistry {
function auction() external view returns (address);
function marketplace() external view returns (address);
function tokenRegistry() external view returns (address);
}
interface IXanaMarketplace {
function validateItemSold(
address,
uint256,
address,
address
) external;
function getPrice(address) external view returns (int256);
}
interface IXanaTokenRegistry {
function enabled(address) external returns (bool);
}
contract XanaBundleMarketplace is
OwnableUpgradeable,
ReentrancyGuardUpgradeable
{
using SafeMath for uint256;
using AddressUpgradeable for address payable;
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.Bytes32Set;
/// @notice Events for the contract
event ItemListed(
address indexed owner,
string bundleID,
address payToken,
uint256 price,
uint256 startingTime
);
event ItemSold(
address indexed seller,
address indexed buyer,
string bundleID,
address payToken,
int256 unitPrice,
uint256 price
);
event ItemUpdated(
address indexed owner,
string bundleID,
address[] nft,
uint256[] tokenId,
uint256[] quantity,
address payToken,
uint256 newPrice
);
event ItemCanceled(address indexed owner, string bundleID);
event OfferCreated(
address indexed creator,
string bundleID,
address payToken,
uint256 price,
uint256 deadline
);
event OfferCanceled(address indexed creator, string bundleID);
event UpdatePlatformFee(uint256 platformFee);
event UpdatePlatformFeeRecipient(address payable platformFeeRecipient);
/// @notice Structure for Bundle Item Listing
struct Listing {
address[] nfts;
uint256[] tokenIds;
uint256[] quantities;
address payToken;
uint256 price;
uint256 startingTime;
}
/// @notice Structure for bundle offer
struct Offer {
IERC20 payToken;
uint256 price;
uint256 deadline;
}
bytes4 private constant INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant INTERFACE_ID_ERC1155 = 0xd9b67a26;
/// @notice Owner -> Bundle ID -> Bundle Listing item
mapping(address => mapping(bytes32 => Listing)) public listings;
/// @notice Bundle ID -> Wwner
mapping(bytes32 => address) public owners;
mapping(address => mapping(uint256 => EnumerableSet.Bytes32Set)) bundleIdsPerItem;
mapping(bytes32 => mapping(address => mapping(uint256 => uint256))) nftIndexes;
mapping(bytes32 => string) bundleIds;
/// @notice Bundle ID -> Offerer -> Offer
mapping(bytes32 => mapping(address => Offer)) public offers;
/// @notice Platform fee
uint256 public platformFee;
/// @notice reward token owner
address public rewardTokenOwner;
/// @notice reward token
IERC20 public RWT;
/// @notice reward fee
uint256 public rewardFee;
/// @notice Platform fee receipient
address payable public feeReceipient;
/// @notice Address registry
IXanaAddressRegistry public addressRegistry;
modifier onlyContract() {
}
/// @notice Contract initializer
function initialize(address payable _feeRecipient, uint256 _platformFee, IERC20 _RWT, address _rewardTokenOwner, IXanaAddressRegistry _addressRegistry, uint256 _rewardFee)
public
initializer
{
}
/// @notice Method for get NFT bundle listing
/// @param _owner Owner address
/// @param _bundleID Bundle ID
function getListing(address _owner, string memory _bundleID)
external
view
returns (
address[] memory nfts,
uint256[] memory tokenIds,
uint256[] memory quantities,
uint256 price,
uint256 startingTime
)
{
}
/// @notice Method for listing NFT bundle
/// @param _bundleID Bundle ID
/// @param _nftAddresses Addresses of NFT contract
/// @param _tokenIds Token IDs of NFT
/// @param _quantities token amounts to list (needed for ERC-1155 NFTs, set as 1 for ERC-721)
/// @param _price sale price for bundle
/// @param _startingTime scheduling for a future sale
function listItem(
string memory _bundleID,
address[] calldata _nftAddresses,
uint256[] calldata _tokenIds,
uint256[] calldata _quantities,
address _payToken,
uint256 _price,
uint256 _startingTime
) external {
}
/// @notice Method for canceling listed NFT bundle
function cancelListing(string memory _bundleID) external nonReentrant {
bytes32 bundleID = _getBundleID(_bundleID);
require(<FILL_ME>)
_cancelListing(_msgSender(), _bundleID);
}
/// @notice Method for updating listed NFT bundle
/// @param _bundleID Bundle ID
/// @param _newPrice New sale price for bundle
function updateListing(
string memory _bundleID,
address _payToken,
uint256 _newPrice
) external nonReentrant {
}
/// @notice Method for buying listed NFT bundle
/// @param _bundleID Bundle ID
/* function buyItem(string memory _bundleID) external payable nonReentrant {
bytes32 bundleID = _getBundleID(_bundleID);
address owner = owners[bundleID];
require(owner != address(0), "invalid id");
Listing memory listing = listings[owner][bundleID];
require(listing.payToken == address(0), "invalid pay token");
require(msg.value >= listing.price, "insufficient balance to buy");
_buyItem(_bundleID, address(0));
} */
/// @notice Method for buying listed NFT bundle
/// @param _bundleID Bundle ID
function buyItem(string memory _bundleID, address _payToken)
external
nonReentrant
{
}
function _buyItem(string memory _bundleID, address _payToken) private {
}
/// @notice Method for offering bundle item
/// @param _bundleID Bundle ID
/// @param _payToken Paying token
/// @param _price Price
/// @param _deadline Offer expiration
function createOffer(
string memory _bundleID,
IERC20 _payToken,
uint256 _price,
uint256 _deadline
) external {
}
/// @notice Method for canceling the offer
/// @param _bundleID Bundle ID
function cancelOffer(string memory _bundleID) external {
}
/// @notice Method for accepting the offer
function acceptOffer(string memory _bundleID, address _creator)
external
nonReentrant
{
}
/**
@notice Method for updating platform fee
@dev Only admin
@param _platformFee uint256 the platform fee to set
*/
function updatePlatformFee(uint256 _platformFee) external onlyOwner {
}
/**
@notice Method for updating reward fee
@dev Only admin
@param _rewardFee uint256 the reward fee to set
*/
function updateBundleRewardFee(uint256 _rewardFee) external onlyOwner {
}
/**
@notice Method for updating platform fee address
@dev Only admin
@param _platformFeeRecipient payable address the address to sends the funds to
*/
function updatePlatformFeeRecipient(address payable _platformFeeRecipient)
external
onlyOwner
{
}
/**
@notice Update XanaAddressRegistry contract
@dev Only admin
*/
function updateAddressRegistry(address _registry) external onlyOwner {
}
/**
* @notice Validate and cancel listing
* @dev Only marketplace can access
*/
function validateItemSold(
address _nftAddress,
uint256 _tokenId,
uint256 _quantity
) external onlyContract {
}
////////////////////////////
/// Internal and Private ///
////////////////////////////
function _supportsInterface(address _addr, bytes4 iface)
internal
view
returns (bool)
{
}
function _check721Owning(
address _nft,
uint256 _tokenId,
address _owner
) internal view {
}
function _check1155Owning(
address _nft,
uint256 _tokenId,
uint256 _quantity,
address _owner
) internal view {
}
function _getNow() internal view virtual returns (uint256) {
}
function _cancelListing(address _owner, string memory _bundleID) private {
}
function _getBundleID(string memory _bundleID)
private
pure
returns (bytes32)
{
}
/// @notice Method for set Reward Token
/// @param _rwtTokenAddr Reward Token Address
function setBundleRWTAddr(address _rwtTokenAddr)
external
onlyOwner
{
}
/// @notice Method for set owner address
/// @param _rwtSenderAddr New owner address
function setBundleRWTSenderAddr(address _rwtSenderAddr)
external
onlyOwner
{
}
}
| listings[_msgSender()][bundleID].price>0,"not listed" | 287,461 | listings[_msgSender()][bundleID].price>0 |
"not buyable" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
interface IXanaAddressRegistry {
function auction() external view returns (address);
function marketplace() external view returns (address);
function tokenRegistry() external view returns (address);
}
interface IXanaMarketplace {
function validateItemSold(
address,
uint256,
address,
address
) external;
function getPrice(address) external view returns (int256);
}
interface IXanaTokenRegistry {
function enabled(address) external returns (bool);
}
contract XanaBundleMarketplace is
OwnableUpgradeable,
ReentrancyGuardUpgradeable
{
using SafeMath for uint256;
using AddressUpgradeable for address payable;
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.Bytes32Set;
/// @notice Events for the contract
event ItemListed(
address indexed owner,
string bundleID,
address payToken,
uint256 price,
uint256 startingTime
);
event ItemSold(
address indexed seller,
address indexed buyer,
string bundleID,
address payToken,
int256 unitPrice,
uint256 price
);
event ItemUpdated(
address indexed owner,
string bundleID,
address[] nft,
uint256[] tokenId,
uint256[] quantity,
address payToken,
uint256 newPrice
);
event ItemCanceled(address indexed owner, string bundleID);
event OfferCreated(
address indexed creator,
string bundleID,
address payToken,
uint256 price,
uint256 deadline
);
event OfferCanceled(address indexed creator, string bundleID);
event UpdatePlatformFee(uint256 platformFee);
event UpdatePlatformFeeRecipient(address payable platformFeeRecipient);
/// @notice Structure for Bundle Item Listing
struct Listing {
address[] nfts;
uint256[] tokenIds;
uint256[] quantities;
address payToken;
uint256 price;
uint256 startingTime;
}
/// @notice Structure for bundle offer
struct Offer {
IERC20 payToken;
uint256 price;
uint256 deadline;
}
bytes4 private constant INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant INTERFACE_ID_ERC1155 = 0xd9b67a26;
/// @notice Owner -> Bundle ID -> Bundle Listing item
mapping(address => mapping(bytes32 => Listing)) public listings;
/// @notice Bundle ID -> Wwner
mapping(bytes32 => address) public owners;
mapping(address => mapping(uint256 => EnumerableSet.Bytes32Set)) bundleIdsPerItem;
mapping(bytes32 => mapping(address => mapping(uint256 => uint256))) nftIndexes;
mapping(bytes32 => string) bundleIds;
/// @notice Bundle ID -> Offerer -> Offer
mapping(bytes32 => mapping(address => Offer)) public offers;
/// @notice Platform fee
uint256 public platformFee;
/// @notice reward token owner
address public rewardTokenOwner;
/// @notice reward token
IERC20 public RWT;
/// @notice reward fee
uint256 public rewardFee;
/// @notice Platform fee receipient
address payable public feeReceipient;
/// @notice Address registry
IXanaAddressRegistry public addressRegistry;
modifier onlyContract() {
}
/// @notice Contract initializer
function initialize(address payable _feeRecipient, uint256 _platformFee, IERC20 _RWT, address _rewardTokenOwner, IXanaAddressRegistry _addressRegistry, uint256 _rewardFee)
public
initializer
{
}
/// @notice Method for get NFT bundle listing
/// @param _owner Owner address
/// @param _bundleID Bundle ID
function getListing(address _owner, string memory _bundleID)
external
view
returns (
address[] memory nfts,
uint256[] memory tokenIds,
uint256[] memory quantities,
uint256 price,
uint256 startingTime
)
{
}
/// @notice Method for listing NFT bundle
/// @param _bundleID Bundle ID
/// @param _nftAddresses Addresses of NFT contract
/// @param _tokenIds Token IDs of NFT
/// @param _quantities token amounts to list (needed for ERC-1155 NFTs, set as 1 for ERC-721)
/// @param _price sale price for bundle
/// @param _startingTime scheduling for a future sale
function listItem(
string memory _bundleID,
address[] calldata _nftAddresses,
uint256[] calldata _tokenIds,
uint256[] calldata _quantities,
address _payToken,
uint256 _price,
uint256 _startingTime
) external {
}
/// @notice Method for canceling listed NFT bundle
function cancelListing(string memory _bundleID) external nonReentrant {
}
/// @notice Method for updating listed NFT bundle
/// @param _bundleID Bundle ID
/// @param _newPrice New sale price for bundle
function updateListing(
string memory _bundleID,
address _payToken,
uint256 _newPrice
) external nonReentrant {
}
/// @notice Method for buying listed NFT bundle
/// @param _bundleID Bundle ID
/* function buyItem(string memory _bundleID) external payable nonReentrant {
bytes32 bundleID = _getBundleID(_bundleID);
address owner = owners[bundleID];
require(owner != address(0), "invalid id");
Listing memory listing = listings[owner][bundleID];
require(listing.payToken == address(0), "invalid pay token");
require(msg.value >= listing.price, "insufficient balance to buy");
_buyItem(_bundleID, address(0));
} */
/// @notice Method for buying listed NFT bundle
/// @param _bundleID Bundle ID
function buyItem(string memory _bundleID, address _payToken)
external
nonReentrant
{
}
function _buyItem(string memory _bundleID, address _payToken) private {
bytes32 bundleID = _getBundleID(_bundleID);
address owner = owners[bundleID];
Listing memory listing = listings[owner][bundleID];
require(listing.price > 0, "not listed");
for (uint256 i; i < listing.nfts.length; i++) {
if (_supportsInterface(listing.nfts[i], INTERFACE_ID_ERC721)) {
_check721Owning(listing.nfts[i], listing.tokenIds[i], owner);
} else if (
_supportsInterface(listing.nfts[i], INTERFACE_ID_ERC1155)
) {
_check1155Owning(
listing.nfts[i],
listing.tokenIds[i],
listing.quantities[i],
owner
);
}
}
require(<FILL_ME>)
uint256 price = listing.price;
uint256 feeAmount = price.mul(platformFee).div(1e4);
if (_payToken == address(0)) {
(bool feeTransferSuccess, ) = feeReceipient.call{value: feeAmount}(
""
);
require(
feeTransferSuccess,
"XanaMarketplace: Fee transfer failed"
);
(bool ownerTransferSuccess, ) = owner.call{
value: price.sub(feeAmount)
}("");
require(
ownerTransferSuccess,
"XanaMarketplace: Owner transfer failed"
);
} else {
IERC20(_payToken).safeTransferFrom(
_msgSender(),
feeReceipient,
feeAmount
);
IERC20(_payToken).safeTransferFrom(
_msgSender(),
owner,
price.sub(feeAmount)
);
if (price.sub(feeAmount) != 0) {
RWT.safeTransferFrom(rewardTokenOwner, owner, price.sub(feeAmount).mul(rewardFee).div(10000));
RWT.safeTransferFrom(rewardTokenOwner, _msgSender(), price.sub(feeAmount).mul(rewardFee).div(10000));
}
}
// Transfer NFT to buyer
for (uint256 i; i < listing.nfts.length; i++) {
if (_supportsInterface(listing.nfts[i], INTERFACE_ID_ERC721)) {
IERC721(listing.nfts[i]).safeTransferFrom(
owner,
_msgSender(),
listing.tokenIds[i]
);
} else {
IERC1155(listing.nfts[i]).safeTransferFrom(
owner,
_msgSender(),
listing.tokenIds[i],
listing.quantities[i],
bytes("")
);
}
IXanaMarketplace(addressRegistry.marketplace()).validateItemSold(
listing.nfts[i],
listing.tokenIds[i],
owner,
_msgSender()
);
}
delete (listings[owner][bundleID]);
listing.price = 0;
listings[_msgSender()][bundleID] = listing;
owners[bundleID] = _msgSender();
delete (offers[bundleID][_msgSender()]);
emit ItemSold(
owner,
_msgSender(),
_bundleID,
_payToken,
IXanaMarketplace(addressRegistry.marketplace()).getPrice(_payToken),
price
);
emit OfferCanceled(_msgSender(), _bundleID);
}
/// @notice Method for offering bundle item
/// @param _bundleID Bundle ID
/// @param _payToken Paying token
/// @param _price Price
/// @param _deadline Offer expiration
function createOffer(
string memory _bundleID,
IERC20 _payToken,
uint256 _price,
uint256 _deadline
) external {
}
/// @notice Method for canceling the offer
/// @param _bundleID Bundle ID
function cancelOffer(string memory _bundleID) external {
}
/// @notice Method for accepting the offer
function acceptOffer(string memory _bundleID, address _creator)
external
nonReentrant
{
}
/**
@notice Method for updating platform fee
@dev Only admin
@param _platformFee uint256 the platform fee to set
*/
function updatePlatformFee(uint256 _platformFee) external onlyOwner {
}
/**
@notice Method for updating reward fee
@dev Only admin
@param _rewardFee uint256 the reward fee to set
*/
function updateBundleRewardFee(uint256 _rewardFee) external onlyOwner {
}
/**
@notice Method for updating platform fee address
@dev Only admin
@param _platformFeeRecipient payable address the address to sends the funds to
*/
function updatePlatformFeeRecipient(address payable _platformFeeRecipient)
external
onlyOwner
{
}
/**
@notice Update XanaAddressRegistry contract
@dev Only admin
*/
function updateAddressRegistry(address _registry) external onlyOwner {
}
/**
* @notice Validate and cancel listing
* @dev Only marketplace can access
*/
function validateItemSold(
address _nftAddress,
uint256 _tokenId,
uint256 _quantity
) external onlyContract {
}
////////////////////////////
/// Internal and Private ///
////////////////////////////
function _supportsInterface(address _addr, bytes4 iface)
internal
view
returns (bool)
{
}
function _check721Owning(
address _nft,
uint256 _tokenId,
address _owner
) internal view {
}
function _check1155Owning(
address _nft,
uint256 _tokenId,
uint256 _quantity,
address _owner
) internal view {
}
function _getNow() internal view virtual returns (uint256) {
}
function _cancelListing(address _owner, string memory _bundleID) private {
}
function _getBundleID(string memory _bundleID)
private
pure
returns (bytes32)
{
}
/// @notice Method for set Reward Token
/// @param _rwtTokenAddr Reward Token Address
function setBundleRWTAddr(address _rwtTokenAddr)
external
onlyOwner
{
}
/// @notice Method for set owner address
/// @param _rwtSenderAddr New owner address
function setBundleRWTSenderAddr(address _rwtSenderAddr)
external
onlyOwner
{
}
}
| _getNow()>=listing.startingTime,"not buyable" | 287,461 | _getNow()>=listing.startingTime |
"invalid id" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
interface IXanaAddressRegistry {
function auction() external view returns (address);
function marketplace() external view returns (address);
function tokenRegistry() external view returns (address);
}
interface IXanaMarketplace {
function validateItemSold(
address,
uint256,
address,
address
) external;
function getPrice(address) external view returns (int256);
}
interface IXanaTokenRegistry {
function enabled(address) external returns (bool);
}
contract XanaBundleMarketplace is
OwnableUpgradeable,
ReentrancyGuardUpgradeable
{
using SafeMath for uint256;
using AddressUpgradeable for address payable;
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.Bytes32Set;
/// @notice Events for the contract
event ItemListed(
address indexed owner,
string bundleID,
address payToken,
uint256 price,
uint256 startingTime
);
event ItemSold(
address indexed seller,
address indexed buyer,
string bundleID,
address payToken,
int256 unitPrice,
uint256 price
);
event ItemUpdated(
address indexed owner,
string bundleID,
address[] nft,
uint256[] tokenId,
uint256[] quantity,
address payToken,
uint256 newPrice
);
event ItemCanceled(address indexed owner, string bundleID);
event OfferCreated(
address indexed creator,
string bundleID,
address payToken,
uint256 price,
uint256 deadline
);
event OfferCanceled(address indexed creator, string bundleID);
event UpdatePlatformFee(uint256 platformFee);
event UpdatePlatformFeeRecipient(address payable platformFeeRecipient);
/// @notice Structure for Bundle Item Listing
struct Listing {
address[] nfts;
uint256[] tokenIds;
uint256[] quantities;
address payToken;
uint256 price;
uint256 startingTime;
}
/// @notice Structure for bundle offer
struct Offer {
IERC20 payToken;
uint256 price;
uint256 deadline;
}
bytes4 private constant INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant INTERFACE_ID_ERC1155 = 0xd9b67a26;
/// @notice Owner -> Bundle ID -> Bundle Listing item
mapping(address => mapping(bytes32 => Listing)) public listings;
/// @notice Bundle ID -> Wwner
mapping(bytes32 => address) public owners;
mapping(address => mapping(uint256 => EnumerableSet.Bytes32Set)) bundleIdsPerItem;
mapping(bytes32 => mapping(address => mapping(uint256 => uint256))) nftIndexes;
mapping(bytes32 => string) bundleIds;
/// @notice Bundle ID -> Offerer -> Offer
mapping(bytes32 => mapping(address => Offer)) public offers;
/// @notice Platform fee
uint256 public platformFee;
/// @notice reward token owner
address public rewardTokenOwner;
/// @notice reward token
IERC20 public RWT;
/// @notice reward fee
uint256 public rewardFee;
/// @notice Platform fee receipient
address payable public feeReceipient;
/// @notice Address registry
IXanaAddressRegistry public addressRegistry;
modifier onlyContract() {
}
/// @notice Contract initializer
function initialize(address payable _feeRecipient, uint256 _platformFee, IERC20 _RWT, address _rewardTokenOwner, IXanaAddressRegistry _addressRegistry, uint256 _rewardFee)
public
initializer
{
}
/// @notice Method for get NFT bundle listing
/// @param _owner Owner address
/// @param _bundleID Bundle ID
function getListing(address _owner, string memory _bundleID)
external
view
returns (
address[] memory nfts,
uint256[] memory tokenIds,
uint256[] memory quantities,
uint256 price,
uint256 startingTime
)
{
}
/// @notice Method for listing NFT bundle
/// @param _bundleID Bundle ID
/// @param _nftAddresses Addresses of NFT contract
/// @param _tokenIds Token IDs of NFT
/// @param _quantities token amounts to list (needed for ERC-1155 NFTs, set as 1 for ERC-721)
/// @param _price sale price for bundle
/// @param _startingTime scheduling for a future sale
function listItem(
string memory _bundleID,
address[] calldata _nftAddresses,
uint256[] calldata _tokenIds,
uint256[] calldata _quantities,
address _payToken,
uint256 _price,
uint256 _startingTime
) external {
}
/// @notice Method for canceling listed NFT bundle
function cancelListing(string memory _bundleID) external nonReentrant {
}
/// @notice Method for updating listed NFT bundle
/// @param _bundleID Bundle ID
/// @param _newPrice New sale price for bundle
function updateListing(
string memory _bundleID,
address _payToken,
uint256 _newPrice
) external nonReentrant {
}
/// @notice Method for buying listed NFT bundle
/// @param _bundleID Bundle ID
/* function buyItem(string memory _bundleID) external payable nonReentrant {
bytes32 bundleID = _getBundleID(_bundleID);
address owner = owners[bundleID];
require(owner != address(0), "invalid id");
Listing memory listing = listings[owner][bundleID];
require(listing.payToken == address(0), "invalid pay token");
require(msg.value >= listing.price, "insufficient balance to buy");
_buyItem(_bundleID, address(0));
} */
/// @notice Method for buying listed NFT bundle
/// @param _bundleID Bundle ID
function buyItem(string memory _bundleID, address _payToken)
external
nonReentrant
{
}
function _buyItem(string memory _bundleID, address _payToken) private {
}
/// @notice Method for offering bundle item
/// @param _bundleID Bundle ID
/// @param _payToken Paying token
/// @param _price Price
/// @param _deadline Offer expiration
function createOffer(
string memory _bundleID,
IERC20 _payToken,
uint256 _price,
uint256 _deadline
) external {
bytes32 bundleID = _getBundleID(_bundleID);
require(<FILL_ME>)
require(_deadline > _getNow(), "invalid expiration");
require(_price > 0, "invalid price");
Offer memory offer = offers[bundleID][_msgSender()];
require(offer.deadline <= _getNow(), "offer exists");
offers[bundleID][_msgSender()] = Offer(_payToken, _price, _deadline);
emit OfferCreated(
_msgSender(),
_bundleID,
address(_payToken),
_price,
_deadline
);
}
/// @notice Method for canceling the offer
/// @param _bundleID Bundle ID
function cancelOffer(string memory _bundleID) external {
}
/// @notice Method for accepting the offer
function acceptOffer(string memory _bundleID, address _creator)
external
nonReentrant
{
}
/**
@notice Method for updating platform fee
@dev Only admin
@param _platformFee uint256 the platform fee to set
*/
function updatePlatformFee(uint256 _platformFee) external onlyOwner {
}
/**
@notice Method for updating reward fee
@dev Only admin
@param _rewardFee uint256 the reward fee to set
*/
function updateBundleRewardFee(uint256 _rewardFee) external onlyOwner {
}
/**
@notice Method for updating platform fee address
@dev Only admin
@param _platformFeeRecipient payable address the address to sends the funds to
*/
function updatePlatformFeeRecipient(address payable _platformFeeRecipient)
external
onlyOwner
{
}
/**
@notice Update XanaAddressRegistry contract
@dev Only admin
*/
function updateAddressRegistry(address _registry) external onlyOwner {
}
/**
* @notice Validate and cancel listing
* @dev Only marketplace can access
*/
function validateItemSold(
address _nftAddress,
uint256 _tokenId,
uint256 _quantity
) external onlyContract {
}
////////////////////////////
/// Internal and Private ///
////////////////////////////
function _supportsInterface(address _addr, bytes4 iface)
internal
view
returns (bool)
{
}
function _check721Owning(
address _nft,
uint256 _tokenId,
address _owner
) internal view {
}
function _check1155Owning(
address _nft,
uint256 _tokenId,
uint256 _quantity,
address _owner
) internal view {
}
function _getNow() internal view virtual returns (uint256) {
}
function _cancelListing(address _owner, string memory _bundleID) private {
}
function _getBundleID(string memory _bundleID)
private
pure
returns (bytes32)
{
}
/// @notice Method for set Reward Token
/// @param _rwtTokenAddr Reward Token Address
function setBundleRWTAddr(address _rwtTokenAddr)
external
onlyOwner
{
}
/// @notice Method for set owner address
/// @param _rwtSenderAddr New owner address
function setBundleRWTSenderAddr(address _rwtSenderAddr)
external
onlyOwner
{
}
}
| owners[bundleID]!=address(0),"invalid id" | 287,461 | owners[bundleID]!=address(0) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.