comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"StakingBitgear: Could not send gear tokens" | pragma solidity ^0.6.0;
contract StakingBitgear is Ownable
{
using SafeMath for uint256;
IUniswapV2Pair public pair;
bool private ifGearZeroTokenInPair;
IERC20 public gearAddress;
uint256 public zeroDayStartTime;
uint256 public dayDurationSec;
uint256 constant public numDaysInMonth = 30;
uint256 constant public monthsInYear = 12;
modifier onlyWhenOpen
{
}
uint256 public allLpTokensStaked;
uint256 public allGearTokens;
uint256 public unfreezedGearTokens;
uint256 public freezedGearTokens;
event LpTokensIncome(address who, uint256 amount, uint256 day);
event LpTokensOutcome(address who, uint256 amount, uint256 day);
event GearTokenIncome(address who, uint256 amount, uint256 day);
event GearTokenOutcome(address who, uint256 amount, uint256 day);
event TokenFreezed(address who, uint256 amount, uint256 day);
event TokenUnfreezed(address who, uint256 amount, uint256 day);
uint256 public stakeIdLast;
uint256 constant public maxNumMonths = 3;
uint256[] public MonthsApyPercentsNumerator = [15, 20, 30];
uint256[] public MonthsApyPercentsDenominator = [100, 100, 100];
struct StakeInfo
{
uint256 stakeId;
uint256 startDay;
uint256 numMonthsStake;
uint256 stakedLP;
uint256 stakedGear;
uint256 freezedRewardGearTokens;
}
mapping(address => StakeInfo[]) public stakeList;
event StakeStart(
address who,
uint256 LpIncome,
uint256 gearEquivalent,
uint256 gearEarnings,
uint256 numMonths,
uint256 day,
uint256 stakeId
);
event StakeEnd(
address who,
uint256 stakeId,
uint256 LpOutcome,
uint256 gearEarnings,
uint256 servedNumMonths,
uint256 day
);
constructor(
IUniswapV2Pair _pair,
IERC20 _gearAddress,
uint256 _zeroDayStartTime,
uint256 _dayDurationSec
)
public
{
}
function gearTokenDonation(uint256 amount) external
{
}
function gearOwnerWithdraw(uint256 amount) external onlyOwner
{
address sender = _msgSender();
require(
sender == owner(),
"StakingBitgear: Sender is not owner"
);
require(
allGearTokens > amount,
"StakingBitgear: Not enough value on this contract"
);
require(
unfreezedGearTokens > amount,
"StakingBitgear: Not enough unfreezed value on this contract"
);
require(<FILL_ME>)
allGearTokens = allGearTokens.sub(amount);
unfreezedGearTokens = unfreezedGearTokens.sub(amount);
emit GearTokenOutcome(sender, amount, _currentDay());
}
function stakeStart(uint256 amount, uint256 numMonthsStake) external onlyWhenOpen
{
}
function stakeEnd(uint256 stakeIndex, uint256 stakeId) external onlyWhenOpen
{
}
function stakeListCount(address who) external view returns(uint256)
{
}
function currentDay() external view onlyWhenOpen returns(uint256)
{
}
function getDayUnixTime(uint256 day) public view returns(uint256)
{
}
function changeMonthsApyPercents(
uint256 month,
uint256 numerator,
uint256 denominator
)
external
onlyOwner
{
}
function getEndDayOfStakeInUnixTime(
address who,
uint256 stakeIndex,
uint256 stakeId
)
external
view
returns(uint256)
{
}
function getStakeDivsNow(
address who,
uint256 stakeIndex,
uint256 stakeId
)
external
view
returns(uint256)
{
}
function _getServedMonths(
uint256 currDay,
uint256 startDay,
uint256 numMonthsStake
)
private
pure
returns(uint256 servedMonths)
{
}
function _getGearEarnings(
uint256 gearAmount,
uint256 numOfMonths
)
private
view
returns (uint256 reward)
{
}
function _currentDay() private view returns(uint256)
{
}
function _removeStake(uint256 stakeIndex, uint256 stakeId) private
{
}
function _testMonthsApyPercents() private view
{
}
}
| gearAddress.transfer(sender,amount),"StakingBitgear: Could not send gear tokens" | 385,265 | gearAddress.transfer(sender,amount) |
"StakingBitgear: LP token transfer failed" | pragma solidity ^0.6.0;
contract StakingBitgear is Ownable
{
using SafeMath for uint256;
IUniswapV2Pair public pair;
bool private ifGearZeroTokenInPair;
IERC20 public gearAddress;
uint256 public zeroDayStartTime;
uint256 public dayDurationSec;
uint256 constant public numDaysInMonth = 30;
uint256 constant public monthsInYear = 12;
modifier onlyWhenOpen
{
}
uint256 public allLpTokensStaked;
uint256 public allGearTokens;
uint256 public unfreezedGearTokens;
uint256 public freezedGearTokens;
event LpTokensIncome(address who, uint256 amount, uint256 day);
event LpTokensOutcome(address who, uint256 amount, uint256 day);
event GearTokenIncome(address who, uint256 amount, uint256 day);
event GearTokenOutcome(address who, uint256 amount, uint256 day);
event TokenFreezed(address who, uint256 amount, uint256 day);
event TokenUnfreezed(address who, uint256 amount, uint256 day);
uint256 public stakeIdLast;
uint256 constant public maxNumMonths = 3;
uint256[] public MonthsApyPercentsNumerator = [15, 20, 30];
uint256[] public MonthsApyPercentsDenominator = [100, 100, 100];
struct StakeInfo
{
uint256 stakeId;
uint256 startDay;
uint256 numMonthsStake;
uint256 stakedLP;
uint256 stakedGear;
uint256 freezedRewardGearTokens;
}
mapping(address => StakeInfo[]) public stakeList;
event StakeStart(
address who,
uint256 LpIncome,
uint256 gearEquivalent,
uint256 gearEarnings,
uint256 numMonths,
uint256 day,
uint256 stakeId
);
event StakeEnd(
address who,
uint256 stakeId,
uint256 LpOutcome,
uint256 gearEarnings,
uint256 servedNumMonths,
uint256 day
);
constructor(
IUniswapV2Pair _pair,
IERC20 _gearAddress,
uint256 _zeroDayStartTime,
uint256 _dayDurationSec
)
public
{
}
function gearTokenDonation(uint256 amount) external
{
}
function gearOwnerWithdraw(uint256 amount) external onlyOwner
{
}
function stakeStart(uint256 amount, uint256 numMonthsStake) external onlyWhenOpen
{
require(
numMonthsStake > 0 && numMonthsStake <= maxNumMonths,
"StakingBitgear: Wrong number of months"
);
address sender = _msgSender();
// Get LP tokens
require(<FILL_ME>)
allLpTokensStaked = allLpTokensStaked.add(amount);
uint256 currDay = _currentDay();
emit LpTokensIncome(sender, amount, currDay);
// Calculate equivalent of LP tokens in Gear tokens
uint256 LpPairTotalSupply = pair.totalSupply();
uint256 gearPairTotalReserves;
//uint256 ethPairTotalReserves;
if (ifGearZeroTokenInPair)
(gearPairTotalReserves, /* ethPairTotalReserves */,) = pair.getReserves();
else
(/* ethPairTotalReserves */, gearPairTotalReserves,) = pair.getReserves();
uint256 gearEquivalent = gearPairTotalReserves.mul(amount).div(LpPairTotalSupply);
// Calculate earnings in Gear tokens that user will get
uint256 gearEarnings = _getGearEarnings(gearEquivalent, numMonthsStake);
// Freeze Gear tokens on contract
require(
unfreezedGearTokens >= gearEarnings,
"StakingBitgear: Insufficient funds of Gear tokens to this stake"
);
unfreezedGearTokens = unfreezedGearTokens.sub(gearEarnings);
freezedGearTokens = freezedGearTokens.add(gearEarnings);
emit TokenFreezed(sender, gearEarnings, currDay);
// Add stake into stakeList
StakeInfo memory st = StakeInfo(
++stakeIdLast,
currDay,
numMonthsStake,
amount,
gearEquivalent,
gearEarnings
);
stakeList[sender].push(st);
emit StakeStart(
sender,
amount,
gearEquivalent,
gearEarnings,
numMonthsStake,
currDay,
stakeIdLast
);
}
function stakeEnd(uint256 stakeIndex, uint256 stakeId) external onlyWhenOpen
{
}
function stakeListCount(address who) external view returns(uint256)
{
}
function currentDay() external view onlyWhenOpen returns(uint256)
{
}
function getDayUnixTime(uint256 day) public view returns(uint256)
{
}
function changeMonthsApyPercents(
uint256 month,
uint256 numerator,
uint256 denominator
)
external
onlyOwner
{
}
function getEndDayOfStakeInUnixTime(
address who,
uint256 stakeIndex,
uint256 stakeId
)
external
view
returns(uint256)
{
}
function getStakeDivsNow(
address who,
uint256 stakeIndex,
uint256 stakeId
)
external
view
returns(uint256)
{
}
function _getServedMonths(
uint256 currDay,
uint256 startDay,
uint256 numMonthsStake
)
private
pure
returns(uint256 servedMonths)
{
}
function _getGearEarnings(
uint256 gearAmount,
uint256 numOfMonths
)
private
view
returns (uint256 reward)
{
}
function _currentDay() private view returns(uint256)
{
}
function _removeStake(uint256 stakeIndex, uint256 stakeId) private
{
}
function _testMonthsApyPercents() private view
{
}
}
| pair.transferFrom(sender,address(this),amount),"StakingBitgear: LP token transfer failed" | 385,265 | pair.transferFrom(sender,address(this),amount) |
"StakingBitgear: Wrong MonthsApyPercents parameters" | pragma solidity ^0.6.0;
contract StakingBitgear is Ownable
{
using SafeMath for uint256;
IUniswapV2Pair public pair;
bool private ifGearZeroTokenInPair;
IERC20 public gearAddress;
uint256 public zeroDayStartTime;
uint256 public dayDurationSec;
uint256 constant public numDaysInMonth = 30;
uint256 constant public monthsInYear = 12;
modifier onlyWhenOpen
{
}
uint256 public allLpTokensStaked;
uint256 public allGearTokens;
uint256 public unfreezedGearTokens;
uint256 public freezedGearTokens;
event LpTokensIncome(address who, uint256 amount, uint256 day);
event LpTokensOutcome(address who, uint256 amount, uint256 day);
event GearTokenIncome(address who, uint256 amount, uint256 day);
event GearTokenOutcome(address who, uint256 amount, uint256 day);
event TokenFreezed(address who, uint256 amount, uint256 day);
event TokenUnfreezed(address who, uint256 amount, uint256 day);
uint256 public stakeIdLast;
uint256 constant public maxNumMonths = 3;
uint256[] public MonthsApyPercentsNumerator = [15, 20, 30];
uint256[] public MonthsApyPercentsDenominator = [100, 100, 100];
struct StakeInfo
{
uint256 stakeId;
uint256 startDay;
uint256 numMonthsStake;
uint256 stakedLP;
uint256 stakedGear;
uint256 freezedRewardGearTokens;
}
mapping(address => StakeInfo[]) public stakeList;
event StakeStart(
address who,
uint256 LpIncome,
uint256 gearEquivalent,
uint256 gearEarnings,
uint256 numMonths,
uint256 day,
uint256 stakeId
);
event StakeEnd(
address who,
uint256 stakeId,
uint256 LpOutcome,
uint256 gearEarnings,
uint256 servedNumMonths,
uint256 day
);
constructor(
IUniswapV2Pair _pair,
IERC20 _gearAddress,
uint256 _zeroDayStartTime,
uint256 _dayDurationSec
)
public
{
}
function gearTokenDonation(uint256 amount) external
{
}
function gearOwnerWithdraw(uint256 amount) external onlyOwner
{
}
function stakeStart(uint256 amount, uint256 numMonthsStake) external onlyWhenOpen
{
}
function stakeEnd(uint256 stakeIndex, uint256 stakeId) external onlyWhenOpen
{
}
function stakeListCount(address who) external view returns(uint256)
{
}
function currentDay() external view onlyWhenOpen returns(uint256)
{
}
function getDayUnixTime(uint256 day) public view returns(uint256)
{
}
function changeMonthsApyPercents(
uint256 month,
uint256 numerator,
uint256 denominator
)
external
onlyOwner
{
}
function getEndDayOfStakeInUnixTime(
address who,
uint256 stakeIndex,
uint256 stakeId
)
external
view
returns(uint256)
{
}
function getStakeDivsNow(
address who,
uint256 stakeIndex,
uint256 stakeId
)
external
view
returns(uint256)
{
}
function _getServedMonths(
uint256 currDay,
uint256 startDay,
uint256 numMonthsStake
)
private
pure
returns(uint256 servedMonths)
{
}
function _getGearEarnings(
uint256 gearAmount,
uint256 numOfMonths
)
private
view
returns (uint256 reward)
{
}
function _currentDay() private view returns(uint256)
{
}
function _removeStake(uint256 stakeIndex, uint256 stakeId) private
{
}
function _testMonthsApyPercents() private view
{
uint256 amount = 100000;
require(
maxNumMonths == 3,
"StakingBitgear: Wrong MonthsApyPercents parameters"
);
require(<FILL_ME>)
require(
amount
.mul(MonthsApyPercentsNumerator[1])
.div(MonthsApyPercentsDenominator[1])
>=
amount.mul(7).div(100),
"StakingBitgear: Wrong MonthsApyPercents parameters"
);
require(
amount
.mul(MonthsApyPercentsNumerator[2])
.div(MonthsApyPercentsDenominator[2])
>=
amount.mul(10).div(100),
"StakingBitgear: Wrong MonthsApyPercents parameters"
);
}
}
| amount.mul(MonthsApyPercentsNumerator[0]).div(MonthsApyPercentsDenominator[0])>=amount.mul(5).div(100),"StakingBitgear: Wrong MonthsApyPercents parameters" | 385,265 | amount.mul(MonthsApyPercentsNumerator[0]).div(MonthsApyPercentsDenominator[0])>=amount.mul(5).div(100) |
"StakingBitgear: Wrong MonthsApyPercents parameters" | pragma solidity ^0.6.0;
contract StakingBitgear is Ownable
{
using SafeMath for uint256;
IUniswapV2Pair public pair;
bool private ifGearZeroTokenInPair;
IERC20 public gearAddress;
uint256 public zeroDayStartTime;
uint256 public dayDurationSec;
uint256 constant public numDaysInMonth = 30;
uint256 constant public monthsInYear = 12;
modifier onlyWhenOpen
{
}
uint256 public allLpTokensStaked;
uint256 public allGearTokens;
uint256 public unfreezedGearTokens;
uint256 public freezedGearTokens;
event LpTokensIncome(address who, uint256 amount, uint256 day);
event LpTokensOutcome(address who, uint256 amount, uint256 day);
event GearTokenIncome(address who, uint256 amount, uint256 day);
event GearTokenOutcome(address who, uint256 amount, uint256 day);
event TokenFreezed(address who, uint256 amount, uint256 day);
event TokenUnfreezed(address who, uint256 amount, uint256 day);
uint256 public stakeIdLast;
uint256 constant public maxNumMonths = 3;
uint256[] public MonthsApyPercentsNumerator = [15, 20, 30];
uint256[] public MonthsApyPercentsDenominator = [100, 100, 100];
struct StakeInfo
{
uint256 stakeId;
uint256 startDay;
uint256 numMonthsStake;
uint256 stakedLP;
uint256 stakedGear;
uint256 freezedRewardGearTokens;
}
mapping(address => StakeInfo[]) public stakeList;
event StakeStart(
address who,
uint256 LpIncome,
uint256 gearEquivalent,
uint256 gearEarnings,
uint256 numMonths,
uint256 day,
uint256 stakeId
);
event StakeEnd(
address who,
uint256 stakeId,
uint256 LpOutcome,
uint256 gearEarnings,
uint256 servedNumMonths,
uint256 day
);
constructor(
IUniswapV2Pair _pair,
IERC20 _gearAddress,
uint256 _zeroDayStartTime,
uint256 _dayDurationSec
)
public
{
}
function gearTokenDonation(uint256 amount) external
{
}
function gearOwnerWithdraw(uint256 amount) external onlyOwner
{
}
function stakeStart(uint256 amount, uint256 numMonthsStake) external onlyWhenOpen
{
}
function stakeEnd(uint256 stakeIndex, uint256 stakeId) external onlyWhenOpen
{
}
function stakeListCount(address who) external view returns(uint256)
{
}
function currentDay() external view onlyWhenOpen returns(uint256)
{
}
function getDayUnixTime(uint256 day) public view returns(uint256)
{
}
function changeMonthsApyPercents(
uint256 month,
uint256 numerator,
uint256 denominator
)
external
onlyOwner
{
}
function getEndDayOfStakeInUnixTime(
address who,
uint256 stakeIndex,
uint256 stakeId
)
external
view
returns(uint256)
{
}
function getStakeDivsNow(
address who,
uint256 stakeIndex,
uint256 stakeId
)
external
view
returns(uint256)
{
}
function _getServedMonths(
uint256 currDay,
uint256 startDay,
uint256 numMonthsStake
)
private
pure
returns(uint256 servedMonths)
{
}
function _getGearEarnings(
uint256 gearAmount,
uint256 numOfMonths
)
private
view
returns (uint256 reward)
{
}
function _currentDay() private view returns(uint256)
{
}
function _removeStake(uint256 stakeIndex, uint256 stakeId) private
{
}
function _testMonthsApyPercents() private view
{
uint256 amount = 100000;
require(
maxNumMonths == 3,
"StakingBitgear: Wrong MonthsApyPercents parameters"
);
require(
amount
.mul(MonthsApyPercentsNumerator[0])
.div(MonthsApyPercentsDenominator[0])
>=
amount.mul(5).div(100),
"StakingBitgear: Wrong MonthsApyPercents parameters"
);
require(<FILL_ME>)
require(
amount
.mul(MonthsApyPercentsNumerator[2])
.div(MonthsApyPercentsDenominator[2])
>=
amount.mul(10).div(100),
"StakingBitgear: Wrong MonthsApyPercents parameters"
);
}
}
| amount.mul(MonthsApyPercentsNumerator[1]).div(MonthsApyPercentsDenominator[1])>=amount.mul(7).div(100),"StakingBitgear: Wrong MonthsApyPercents parameters" | 385,265 | amount.mul(MonthsApyPercentsNumerator[1]).div(MonthsApyPercentsDenominator[1])>=amount.mul(7).div(100) |
"StakingBitgear: Wrong MonthsApyPercents parameters" | pragma solidity ^0.6.0;
contract StakingBitgear is Ownable
{
using SafeMath for uint256;
IUniswapV2Pair public pair;
bool private ifGearZeroTokenInPair;
IERC20 public gearAddress;
uint256 public zeroDayStartTime;
uint256 public dayDurationSec;
uint256 constant public numDaysInMonth = 30;
uint256 constant public monthsInYear = 12;
modifier onlyWhenOpen
{
}
uint256 public allLpTokensStaked;
uint256 public allGearTokens;
uint256 public unfreezedGearTokens;
uint256 public freezedGearTokens;
event LpTokensIncome(address who, uint256 amount, uint256 day);
event LpTokensOutcome(address who, uint256 amount, uint256 day);
event GearTokenIncome(address who, uint256 amount, uint256 day);
event GearTokenOutcome(address who, uint256 amount, uint256 day);
event TokenFreezed(address who, uint256 amount, uint256 day);
event TokenUnfreezed(address who, uint256 amount, uint256 day);
uint256 public stakeIdLast;
uint256 constant public maxNumMonths = 3;
uint256[] public MonthsApyPercentsNumerator = [15, 20, 30];
uint256[] public MonthsApyPercentsDenominator = [100, 100, 100];
struct StakeInfo
{
uint256 stakeId;
uint256 startDay;
uint256 numMonthsStake;
uint256 stakedLP;
uint256 stakedGear;
uint256 freezedRewardGearTokens;
}
mapping(address => StakeInfo[]) public stakeList;
event StakeStart(
address who,
uint256 LpIncome,
uint256 gearEquivalent,
uint256 gearEarnings,
uint256 numMonths,
uint256 day,
uint256 stakeId
);
event StakeEnd(
address who,
uint256 stakeId,
uint256 LpOutcome,
uint256 gearEarnings,
uint256 servedNumMonths,
uint256 day
);
constructor(
IUniswapV2Pair _pair,
IERC20 _gearAddress,
uint256 _zeroDayStartTime,
uint256 _dayDurationSec
)
public
{
}
function gearTokenDonation(uint256 amount) external
{
}
function gearOwnerWithdraw(uint256 amount) external onlyOwner
{
}
function stakeStart(uint256 amount, uint256 numMonthsStake) external onlyWhenOpen
{
}
function stakeEnd(uint256 stakeIndex, uint256 stakeId) external onlyWhenOpen
{
}
function stakeListCount(address who) external view returns(uint256)
{
}
function currentDay() external view onlyWhenOpen returns(uint256)
{
}
function getDayUnixTime(uint256 day) public view returns(uint256)
{
}
function changeMonthsApyPercents(
uint256 month,
uint256 numerator,
uint256 denominator
)
external
onlyOwner
{
}
function getEndDayOfStakeInUnixTime(
address who,
uint256 stakeIndex,
uint256 stakeId
)
external
view
returns(uint256)
{
}
function getStakeDivsNow(
address who,
uint256 stakeIndex,
uint256 stakeId
)
external
view
returns(uint256)
{
}
function _getServedMonths(
uint256 currDay,
uint256 startDay,
uint256 numMonthsStake
)
private
pure
returns(uint256 servedMonths)
{
}
function _getGearEarnings(
uint256 gearAmount,
uint256 numOfMonths
)
private
view
returns (uint256 reward)
{
}
function _currentDay() private view returns(uint256)
{
}
function _removeStake(uint256 stakeIndex, uint256 stakeId) private
{
}
function _testMonthsApyPercents() private view
{
uint256 amount = 100000;
require(
maxNumMonths == 3,
"StakingBitgear: Wrong MonthsApyPercents parameters"
);
require(
amount
.mul(MonthsApyPercentsNumerator[0])
.div(MonthsApyPercentsDenominator[0])
>=
amount.mul(5).div(100),
"StakingBitgear: Wrong MonthsApyPercents parameters"
);
require(
amount
.mul(MonthsApyPercentsNumerator[1])
.div(MonthsApyPercentsDenominator[1])
>=
amount.mul(7).div(100),
"StakingBitgear: Wrong MonthsApyPercents parameters"
);
require(<FILL_ME>)
}
}
| amount.mul(MonthsApyPercentsNumerator[2]).div(MonthsApyPercentsDenominator[2])>=amount.mul(10).div(100),"StakingBitgear: Wrong MonthsApyPercents parameters" | 385,265 | amount.mul(MonthsApyPercentsNumerator[2]).div(MonthsApyPercentsDenominator[2])>=amount.mul(10).div(100) |
null | pragma solidity ^0.4.18;
/**
* @title Implementation of token that conforms the ERC-20 Token Standard
*/
contract Restriction {
address internal owner = msg.sender;
mapping(address => bool) internal granted;
modifier onlyOwner {
}
/**
* @notice Change the owner of the contract
* @param _owner New owner
*/
function changeOwner(address _owner) external onlyOwner {
}
event ChangeOwner(address indexed _owner);
}
/**
* @dev Interface of contracts that will receive tokens
*/
interface TokenReceiver {
function tokenFallback(address, uint256, bytes) external;
}
/**
* @dev Basic token
*/
contract BasicToken is Restriction {
string public name;
string public symbol;
uint8 public decimals = 0;
uint256 public totalSupply = 0;
mapping(address => uint256) private balances;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
/**
* @dev Construct a token.
* @param _name The name of the token.
* @param _symbol The symbol of the token.
* @param _decimals The decimals of the token.
* @param _supply The initial supply of the token.
*/
function BasicToken(string _name, string _symbol, uint8 _decimals, uint256 _supply) public {
}
/**
* @dev Get the balance of the given holder.
* @param _holder The address of the token holder to query the the balance of.
* @return The token amount owned by the holder.
*/
function balanceOf(address _holder) external view returns (uint256) {
}
/**
* @dev Transfer tokens to a specified holder.
* @param _to The address to transfer to.
* @param _amount The amount to be transferred.
* @return returns true on success or throw on failure
*/
function transfer(address _to, uint256 _amount) external returns (bool) {
}
/**
* @dev Transfer tokens to a specified holder.
* @param _to The address to transfer to.
* @param _amount The amount to be transferred.
* @param _data The data that is attached to this transaction.
* @return returns true on success or throw on failure
*/
function transfer(address _to, uint256 _amount, bytes _data) external returns (bool) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from The address from which you want to transfer tokens
* @param _to The address to which you want to transfer tokens
* @param _amount The amount of tokens to be transferred
* @param _data The data that is attached to this transaction.
* @return returns true on success or throw on failure
*/
function _transfer(address _from, address _to, uint256 _amount, bytes _data) internal returns (bool) {
}
/**
* @dev Mint tokens.
* @param _amount The amount of tokens to mint.
* @return returns true on success or throw on failure
*/
function _mintTokens(uint256 _amount) internal onlyOwner returns (bool success){
require(<FILL_ME>)
totalSupply += _amount;
balances[msg.sender] += _amount;
Transfer(address(0), msg.sender, _amount);
return true;
}
/**
* @dev Burn tokens.
* @param _amount The amount of tokens to burn.
* @return returns true on success or throw on failure
*/
function _burnTokens(uint256 _amount) internal returns (bool success){
}
}
contract ERC20Compatible {
mapping(address => mapping(address => uint256)) private allowed;
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function _transfer(address _from, address _to, uint256 _amount, bytes _data) internal returns (bool success);
/**
* @dev Get the amount of tokens that a holder allowed other holder to spend.
* @param _owner The address of the owner.
* @param _spender The address of the spender.
* @return amount The amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) external constant returns (uint256 amount) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* @param _spender The address of the holder who will spend the tokens of the msg.sender.
* @param _amount The amount of tokens allow to be spent.
* @return returns true on success or throw on failure
*/
function approve(address _spender, uint256 _amount) external returns (bool success) {
}
/**
* @dev Transfer tokens from one holder to the other holder.
* @param _from The address from which the tokens will be transfered.
* @param _to The address to which the tokens will be transfered.
* @param _amount The amount of tokens to be transferred.
* @return returns true on success or throw on failure
*/
function transferFrom(address _from, address _to, uint256 _amount) external returns (bool success) {
}
}
contract Regulatable is Restriction {
function _mintTokens(uint256 _amount) internal onlyOwner returns (bool success);
function _burnTokens(uint256 _amount) internal returns (bool success);
/**
* @notice Mint more tokens
* @param _amount The amount of token to be minted
* @return returns true on success or throw on failure
*/
function mintTokens(uint256 _amount) external onlyOwner returns (bool){
}
/**
* @notice Burn some tokens
* @param _amount The amount of token to be burnt
* @return returns true on success or throw on failure
*/
function burnTokens(uint256 _amount) external returns (bool){
}
}
contract Token is ERC20Compatible, Regulatable, BasicToken {
string private constant NAME = "Crypto USD";
string private constant SYMBOL = "USDc";
uint8 private constant DECIMALS = 2;
uint256 private constant SUPPLY = 201205110 * uint256(10) ** DECIMALS;
function Token() public
BasicToken(NAME, SYMBOL, DECIMALS, SUPPLY) {
}
}
| totalSupply+_amount>totalSupply | 385,266 | totalSupply+_amount>totalSupply |
null | pragma solidity ^0.4.18;
/**
* @title Implementation of token that conforms the ERC-20 Token Standard
*/
contract Restriction {
address internal owner = msg.sender;
mapping(address => bool) internal granted;
modifier onlyOwner {
}
/**
* @notice Change the owner of the contract
* @param _owner New owner
*/
function changeOwner(address _owner) external onlyOwner {
}
event ChangeOwner(address indexed _owner);
}
/**
* @dev Interface of contracts that will receive tokens
*/
interface TokenReceiver {
function tokenFallback(address, uint256, bytes) external;
}
/**
* @dev Basic token
*/
contract BasicToken is Restriction {
string public name;
string public symbol;
uint8 public decimals = 0;
uint256 public totalSupply = 0;
mapping(address => uint256) private balances;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
/**
* @dev Construct a token.
* @param _name The name of the token.
* @param _symbol The symbol of the token.
* @param _decimals The decimals of the token.
* @param _supply The initial supply of the token.
*/
function BasicToken(string _name, string _symbol, uint8 _decimals, uint256 _supply) public {
}
/**
* @dev Get the balance of the given holder.
* @param _holder The address of the token holder to query the the balance of.
* @return The token amount owned by the holder.
*/
function balanceOf(address _holder) external view returns (uint256) {
}
/**
* @dev Transfer tokens to a specified holder.
* @param _to The address to transfer to.
* @param _amount The amount to be transferred.
* @return returns true on success or throw on failure
*/
function transfer(address _to, uint256 _amount) external returns (bool) {
}
/**
* @dev Transfer tokens to a specified holder.
* @param _to The address to transfer to.
* @param _amount The amount to be transferred.
* @param _data The data that is attached to this transaction.
* @return returns true on success or throw on failure
*/
function transfer(address _to, uint256 _amount, bytes _data) external returns (bool) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from The address from which you want to transfer tokens
* @param _to The address to which you want to transfer tokens
* @param _amount The amount of tokens to be transferred
* @param _data The data that is attached to this transaction.
* @return returns true on success or throw on failure
*/
function _transfer(address _from, address _to, uint256 _amount, bytes _data) internal returns (bool) {
}
/**
* @dev Mint tokens.
* @param _amount The amount of tokens to mint.
* @return returns true on success or throw on failure
*/
function _mintTokens(uint256 _amount) internal onlyOwner returns (bool success){
}
/**
* @dev Burn tokens.
* @param _amount The amount of tokens to burn.
* @return returns true on success or throw on failure
*/
function _burnTokens(uint256 _amount) internal returns (bool success){
require(<FILL_ME>)
totalSupply -= _amount;
balances[owner] -= _amount;
Transfer(msg.sender, address(0), _amount);
return true;
}
}
contract ERC20Compatible {
mapping(address => mapping(address => uint256)) private allowed;
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function _transfer(address _from, address _to, uint256 _amount, bytes _data) internal returns (bool success);
/**
* @dev Get the amount of tokens that a holder allowed other holder to spend.
* @param _owner The address of the owner.
* @param _spender The address of the spender.
* @return amount The amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) external constant returns (uint256 amount) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* @param _spender The address of the holder who will spend the tokens of the msg.sender.
* @param _amount The amount of tokens allow to be spent.
* @return returns true on success or throw on failure
*/
function approve(address _spender, uint256 _amount) external returns (bool success) {
}
/**
* @dev Transfer tokens from one holder to the other holder.
* @param _from The address from which the tokens will be transfered.
* @param _to The address to which the tokens will be transfered.
* @param _amount The amount of tokens to be transferred.
* @return returns true on success or throw on failure
*/
function transferFrom(address _from, address _to, uint256 _amount) external returns (bool success) {
}
}
contract Regulatable is Restriction {
function _mintTokens(uint256 _amount) internal onlyOwner returns (bool success);
function _burnTokens(uint256 _amount) internal returns (bool success);
/**
* @notice Mint more tokens
* @param _amount The amount of token to be minted
* @return returns true on success or throw on failure
*/
function mintTokens(uint256 _amount) external onlyOwner returns (bool){
}
/**
* @notice Burn some tokens
* @param _amount The amount of token to be burnt
* @return returns true on success or throw on failure
*/
function burnTokens(uint256 _amount) external returns (bool){
}
}
contract Token is ERC20Compatible, Regulatable, BasicToken {
string private constant NAME = "Crypto USD";
string private constant SYMBOL = "USDc";
uint8 private constant DECIMALS = 2;
uint256 private constant SUPPLY = 201205110 * uint256(10) ** DECIMALS;
function Token() public
BasicToken(NAME, SYMBOL, DECIMALS, SUPPLY) {
}
}
| balances[msg.sender]>_amount | 385,266 | balances[msg.sender]>_amount |
null | pragma solidity ^0.4.19;
contract Ownable {
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() internal {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
/**
* Interface for the standard token.
* Based on https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
*/
interface EIP20Token {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// The owner of this contract should be an externally owned account
contract PinProtocolInvestment is Ownable {
// Address of the target contract
address public investment_address = 0x77D0f9017304e53181d9519792887E78161ABD25;
// Major partner address
address public major_partner_address = 0x8f0592bDCeE38774d93bC1fd2c97ee6540385356;
// Minor partner address
address public minor_partner_address = 0xC787C3f6F75D7195361b64318CE019f90507f806;
// Gas used for transfers.
uint public gas = 1000;
// Payments to this contract require a bit of gas. 100k should be enough.
function() payable public {
}
// Transfer some funds to the target investment address.
function execute_transfer(uint transfer_amount) internal {
// Major fee is 60% * (1/11) * value = 6 * value / (10 * 11)
uint major_fee = transfer_amount * 6 / (10 * 11);
// Minor fee is 40% * (1/11) * value = 4 * value / (10 * 11)
uint minor_fee = transfer_amount * 4 / (10 * 11);
require(<FILL_ME>)
require(minor_partner_address.call.gas(gas).value(minor_fee)());
// Send the rest
require(investment_address.call.gas(gas).value(transfer_amount - major_fee - minor_fee)());
}
// Sets the amount of gas allowed to investors
function set_transfer_gas(uint transfer_gas) public onlyOwner {
}
// We can use this function to move unwanted tokens in the contract
function approve_unwanted_tokens(EIP20Token token, address dest, uint value) public onlyOwner {
}
// This contract is designed to have no balance.
// However, we include this function to avoid stuck value by some unknown mishap.
function emergency_withdraw() public onlyOwner {
}
}
| major_partner_address.call.gas(gas).value(major_fee)() | 385,325 | major_partner_address.call.gas(gas).value(major_fee)() |
null | pragma solidity ^0.4.19;
contract Ownable {
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() internal {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
/**
* Interface for the standard token.
* Based on https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
*/
interface EIP20Token {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// The owner of this contract should be an externally owned account
contract PinProtocolInvestment is Ownable {
// Address of the target contract
address public investment_address = 0x77D0f9017304e53181d9519792887E78161ABD25;
// Major partner address
address public major_partner_address = 0x8f0592bDCeE38774d93bC1fd2c97ee6540385356;
// Minor partner address
address public minor_partner_address = 0xC787C3f6F75D7195361b64318CE019f90507f806;
// Gas used for transfers.
uint public gas = 1000;
// Payments to this contract require a bit of gas. 100k should be enough.
function() payable public {
}
// Transfer some funds to the target investment address.
function execute_transfer(uint transfer_amount) internal {
// Major fee is 60% * (1/11) * value = 6 * value / (10 * 11)
uint major_fee = transfer_amount * 6 / (10 * 11);
// Minor fee is 40% * (1/11) * value = 4 * value / (10 * 11)
uint minor_fee = transfer_amount * 4 / (10 * 11);
require(major_partner_address.call.gas(gas).value(major_fee)());
require(<FILL_ME>)
// Send the rest
require(investment_address.call.gas(gas).value(transfer_amount - major_fee - minor_fee)());
}
// Sets the amount of gas allowed to investors
function set_transfer_gas(uint transfer_gas) public onlyOwner {
}
// We can use this function to move unwanted tokens in the contract
function approve_unwanted_tokens(EIP20Token token, address dest, uint value) public onlyOwner {
}
// This contract is designed to have no balance.
// However, we include this function to avoid stuck value by some unknown mishap.
function emergency_withdraw() public onlyOwner {
}
}
| minor_partner_address.call.gas(gas).value(minor_fee)() | 385,325 | minor_partner_address.call.gas(gas).value(minor_fee)() |
null | pragma solidity ^0.4.19;
contract Ownable {
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() internal {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
/**
* Interface for the standard token.
* Based on https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
*/
interface EIP20Token {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// The owner of this contract should be an externally owned account
contract PinProtocolInvestment is Ownable {
// Address of the target contract
address public investment_address = 0x77D0f9017304e53181d9519792887E78161ABD25;
// Major partner address
address public major_partner_address = 0x8f0592bDCeE38774d93bC1fd2c97ee6540385356;
// Minor partner address
address public minor_partner_address = 0xC787C3f6F75D7195361b64318CE019f90507f806;
// Gas used for transfers.
uint public gas = 1000;
// Payments to this contract require a bit of gas. 100k should be enough.
function() payable public {
}
// Transfer some funds to the target investment address.
function execute_transfer(uint transfer_amount) internal {
// Major fee is 60% * (1/11) * value = 6 * value / (10 * 11)
uint major_fee = transfer_amount * 6 / (10 * 11);
// Minor fee is 40% * (1/11) * value = 4 * value / (10 * 11)
uint minor_fee = transfer_amount * 4 / (10 * 11);
require(major_partner_address.call.gas(gas).value(major_fee)());
require(minor_partner_address.call.gas(gas).value(minor_fee)());
// Send the rest
require(<FILL_ME>)
}
// Sets the amount of gas allowed to investors
function set_transfer_gas(uint transfer_gas) public onlyOwner {
}
// We can use this function to move unwanted tokens in the contract
function approve_unwanted_tokens(EIP20Token token, address dest, uint value) public onlyOwner {
}
// This contract is designed to have no balance.
// However, we include this function to avoid stuck value by some unknown mishap.
function emergency_withdraw() public onlyOwner {
}
}
| investment_address.call.gas(gas).value(transfer_amount-major_fee-minor_fee)() | 385,325 | investment_address.call.gas(gas).value(transfer_amount-major_fee-minor_fee)() |
null | pragma solidity ^0.4.19;
contract Ownable {
address public owner;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() internal {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
/**
* Interface for the standard token.
* Based on https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
*/
interface EIP20Token {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// The owner of this contract should be an externally owned account
contract PinProtocolInvestment is Ownable {
// Address of the target contract
address public investment_address = 0x77D0f9017304e53181d9519792887E78161ABD25;
// Major partner address
address public major_partner_address = 0x8f0592bDCeE38774d93bC1fd2c97ee6540385356;
// Minor partner address
address public minor_partner_address = 0xC787C3f6F75D7195361b64318CE019f90507f806;
// Gas used for transfers.
uint public gas = 1000;
// Payments to this contract require a bit of gas. 100k should be enough.
function() payable public {
}
// Transfer some funds to the target investment address.
function execute_transfer(uint transfer_amount) internal {
}
// Sets the amount of gas allowed to investors
function set_transfer_gas(uint transfer_gas) public onlyOwner {
}
// We can use this function to move unwanted tokens in the contract
function approve_unwanted_tokens(EIP20Token token, address dest, uint value) public onlyOwner {
}
// This contract is designed to have no balance.
// However, we include this function to avoid stuck value by some unknown mishap.
function emergency_withdraw() public onlyOwner {
require(<FILL_ME>)
}
}
| msg.sender.call.gas(gas).value(this.balance)() | 385,325 | msg.sender.call.gas(gas).value(this.balance)() |
"Incorrect Ether value." | pragma solidity ^0.8.0;
contract DaringDragonDen is ERC721Enumerable, Ownable {
uint256 public constant MAX_NFT_SUPPLY = 6000;
uint public constant MAX_PURCHASABLE = 20;
uint256 public constant SALE_START_TIME = 1627239600; // 3pm ET July 25th 2021
uint256 public constant DRAGONS_PRICE = 30000000000000000; // 0.03 ETH
string public PROVENANCE_HASH = "";
bool public saleStarted = true;
constructor() ERC721("Daring Dragon Den", "DDD") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function getTokenURI(uint256 tokenId) public view returns (string memory) {
}
function mint(uint256 amountToMint) public payable {
require(saleStarted == true, "This sale has not started.");
require(block.timestamp >= SALE_START_TIME, "Sale has not started.");
require(totalSupply() < MAX_NFT_SUPPLY, "All NFTs have been minted.");
require(amountToMint > 0, "You must mint at least one dragon.");
require(amountToMint <= 20, "You cannot mint more than 20 dragons.");
require(totalSupply() + amountToMint <= MAX_NFT_SUPPLY, "The amount of dragons you are trying to mint exceeds the MAX_NFT_SUPPLY.");
require(<FILL_ME>)
for (uint256 i = 0; i < amountToMint; i++) {
uint256 mintIndex = totalSupply();
_safeMint(msg.sender, mintIndex);
}
}
function startSale() public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function reserveTokens() public onlyOwner {
}
function setProvenanceHash(string memory _hash) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| DRAGONS_PRICE*amountToMint==msg.value,"Incorrect Ether value." | 385,329 | DRAGONS_PRICE*amountToMint==msg.value |
"unlocking..." | // SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "../libs/ERC20.sol";
import "../libs/DaoOwnable.sol";
contract vGaas is ERC20, DaoOwnable {
using SafeMath for uint256;
IERC20 public wsMeta;
mapping(address => uint256) public unstakeTime;
mapping(address => uint256) public unstakeValue;
uint256 public unstakeCD = 14;
event Stake(address indexed user, uint256 amount);
event RequestUnstake(address indexed user, uint256 amount, uint256 unlockTime);
event CancelUnstake(address indexed user, uint256 amount);
event Unstake(address indexed user, uint256 amount);
constructor(IERC20 wsMeta_) ERC20("Congruent DAO Vote Token", "vGaas", 18) {
}
function stake(uint256 amount) external {
}
function requestUnstake(uint256 amount) external {
}
function cancelUnstake(uint256 amount) external {
}
function unstake() external {
require(<FILL_ME>)
unstakeTime[msg.sender] = type(uint256).max;
wsMeta.transfer(msg.sender, unstakeValue[msg.sender]);
emit Unstake(msg.sender, unstakeValue[msg.sender]);
unstakeValue[msg.sender] = 0;
}
function moveWsGaas(uint256 amount) external onlyManager {
}
function setCoolDown(uint256 coolDownDays) external onlyManager {
}
function transfer(address, uint256) public pure override returns (bool) {
}
function transferFrom(address, address, uint256) public pure override returns (bool) {
}
}
| unstakeTime[msg.sender]<=block.timestamp,"unlocking..." | 385,608 | unstakeTime[msg.sender]<=block.timestamp |
null | pragma solidity ^0.4.18;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
mapping(address => bool) internal owners;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public{
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function addOwner(address newAllowed) onlyOwner public {
}
function removeOwner(address toRemove) onlyOwner public {
}
function isOwner() public view returns(bool){
}
}
contract FoxicoPool is Ownable {
using SafeMath for uint256;
mapping (address => uint256) public deposited;
mapping (address => uint256) public claimed;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
bool public refundEnabled;
event Refunded(address indexed beneficiary, uint256 weiAmount);
event AddDeposit(address indexed beneficiary, uint256 value);
function setStartTime(uint256 _startTime) public onlyOwner{
}
function setEndTime(uint256 _endTime) public onlyOwner{
}
function setWallet(address _wallet) public onlyOwner{
}
function setRefundEnabled(bool _refundEnabled) public onlyOwner{
}
function FoxicoPool(uint256 _startTime, uint256 _endTime, address _wallet) public {
}
function () external payable {
}
function addFunds() public payable onlyOwner {}
function deposit(address beneficiary) public payable {
}
function validPurchase() internal view returns (bool) {
}
// send ether to the fund collection wallet
function forwardFunds() onlyOwner public {
}
function refundWallet(address _wallet) onlyOwner public {
}
function claimRefund() public {
}
function refundFunds(address _wallet) internal {
require(_wallet != address(0));
require(<FILL_ME>)
require(now < endTime);
uint256 depositedValue = deposited[_wallet];
deposited[_wallet] = 0;
_wallet.transfer(depositedValue);
emit Refunded(_wallet, depositedValue);
}
}
| deposited[_wallet]>0 | 385,621 | deposited[_wallet]>0 |
null | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.7.6;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import "./visor/Visor.sol";
// @title Hypervisor
// @notice A Uniswap V2-like interface with fungible liquidity to Uniswap V3
// which allows for arbitrary liquidity provision: one-sided, lop-sided, and
// balanced
contract RewardsHypervisor is ERC20 {
using SafeERC20 for IERC20;
using SafeMath for uint256;
IERC20 public visr;
// @param _pool Uniswap V3 pool for which liquidity is managed
// @param _owner Owner of the Hypervisor
constructor(
address _visr
) ERC20("Reward Visor", "RVISR") {
}
// @param visr Amount of VISR transfered from sender to Hypervisor
// @param to Address to which liquidity tokens are minted
// @param from Address from which tokens are transferred
// @return shares Quantity of liquidity tokens minted as a result of deposit
function deposit(
uint256 visrDeposit,
address payable from,
address to
) external returns (uint256 shares) {
require(visrDeposit > 0, "deposits must be nonzero");
require(to != address(0) && to != address(this), "to");
require(from != address(0) && from != address(this), "from");
shares = visrDeposit;
if (totalSupply() != 0) {
uint256 visrBalance = visr.balanceOf(address(this));
shares = shares.mul(totalSupply()).div(visrBalance);
}
if(isContract(from)) {
require(<FILL_ME>)
Visor(from).delegatedTransferERC20(address(visr), address(this), visrDeposit);
}
else {
visr.safeTransferFrom(from, address(this), visrDeposit);
}
_mint(to, shares);
}
// @param shares Number of rewards shares to redeem for VISR
// @param to Address to which redeemed pool assets are sent
// @param from Address from which liquidity tokens are sent
// @return rewards Amount of visr redeemed by the submitted liquidity tokens
function withdraw(
uint256 shares,
address to,
address payable from
) external returns (uint256 rewards) {
}
function isContract(address _addr) private returns (bool isContract){
}
}
| Visor(from).owner()==msg.sender | 385,638 | Visor(from).owner()==msg.sender |
null | pragma solidity ^0.5.0;
interface Niguez {
function ra() external view returns (uint256);
function rx() external view returns (uint256);
}
interface Target {
function bet(uint _diceOne, uint _diceTwo) payable external;
}
contract CatchFireE66C {
address owner = msg.sender;
Niguez internal niguez = Niguez(0x031eaE8a8105217ab64359D4361022d0947f4572);
Target internal target = Target(0xE66C111d113c960dBaAd9496B887d3d646e80bc4);
uint minBet = 1000000000000000;
function ping() public payable {
require(msg.sender == owner);
uint256 initialBalance = address(this).balance;
uint256 targetBalance = address(target).balance;
uint256 rollone = niguez.ra() % 6 + 1;
uint256 rolltwo = niguez.rx() % 6 + 1;
uint256 totalroll = rollone + rolltwo;
uint256 betAmount;
if (totalroll == 2 || totalroll == 12) {
betAmount = targetBalance / 29;
} else if (rollone == rolltwo) {
betAmount = targetBalance / 7;
} else {
betAmount = targetBalance;
}
if (initialBalance >= betAmount && betAmount >= minBet) {
target.bet.value(betAmount)(rollone, rolltwo);
require(<FILL_ME>)
}
}
function () external payable {
}
function withdraw() public {
}
}
| address(this).balance>initialBalance | 385,806 | address(this).balance>initialBalance |
"Calling account is not an administrator." | pragma solidity 0.5.0;
/**
This contract allows a list of administrators to be tracked. This list can then be enforced
on functions with administrative permissions. Only the owner of the contract should be allowed
to modify the administrator list.
*/
contract Administratable is Ownable {
// The mapping to track administrator accounts - true is reserved for admin addresses.
mapping (address => bool) public administrators;
// Events to allow tracking add/remove.
event AdminAdded(address indexed addedAdmin, address indexed addedBy);
event AdminRemoved(address indexed removedAdmin, address indexed removedBy);
/**
Function modifier to enforce administrative permissions.
*/
modifier onlyAdministrator() {
require(<FILL_ME>)
_;
}
/**
Determine if the message sender is in the administrators list.
*/
function isAdministrator(address addressToTest) public view returns (bool) {
}
/**
Add an admin to the list. This should only be callable by the owner of the contract.
*/
function addAdmin(address adminToAdd) public onlyOwner {
}
/**
Remove an admin from the list. This should only be callable by the owner of the contract.
*/
function removeAdmin(address adminToRemove) public onlyOwner {
}
}
| isAdministrator(msg.sender),"Calling account is not an administrator." | 385,811 | isAdministrator(msg.sender) |
"Account to be added to admin list is already an admin" | pragma solidity 0.5.0;
/**
This contract allows a list of administrators to be tracked. This list can then be enforced
on functions with administrative permissions. Only the owner of the contract should be allowed
to modify the administrator list.
*/
contract Administratable is Ownable {
// The mapping to track administrator accounts - true is reserved for admin addresses.
mapping (address => bool) public administrators;
// Events to allow tracking add/remove.
event AdminAdded(address indexed addedAdmin, address indexed addedBy);
event AdminRemoved(address indexed removedAdmin, address indexed removedBy);
/**
Function modifier to enforce administrative permissions.
*/
modifier onlyAdministrator() {
}
/**
Determine if the message sender is in the administrators list.
*/
function isAdministrator(address addressToTest) public view returns (bool) {
}
/**
Add an admin to the list. This should only be callable by the owner of the contract.
*/
function addAdmin(address adminToAdd) public onlyOwner {
// Verify the account is not already an admin
require(<FILL_ME>)
// Set the address mapping to true to indicate it is an administrator account.
administrators[adminToAdd] = true;
// Emit the event for any watchers.
emit AdminAdded(adminToAdd, msg.sender);
}
/**
Remove an admin from the list. This should only be callable by the owner of the contract.
*/
function removeAdmin(address adminToRemove) public onlyOwner {
}
}
| administrators[adminToAdd]==false,"Account to be added to admin list is already an admin" | 385,811 | administrators[adminToAdd]==false |
"Account to be removed from admin list is not already an admin" | pragma solidity 0.5.0;
/**
This contract allows a list of administrators to be tracked. This list can then be enforced
on functions with administrative permissions. Only the owner of the contract should be allowed
to modify the administrator list.
*/
contract Administratable is Ownable {
// The mapping to track administrator accounts - true is reserved for admin addresses.
mapping (address => bool) public administrators;
// Events to allow tracking add/remove.
event AdminAdded(address indexed addedAdmin, address indexed addedBy);
event AdminRemoved(address indexed removedAdmin, address indexed removedBy);
/**
Function modifier to enforce administrative permissions.
*/
modifier onlyAdministrator() {
}
/**
Determine if the message sender is in the administrators list.
*/
function isAdministrator(address addressToTest) public view returns (bool) {
}
/**
Add an admin to the list. This should only be callable by the owner of the contract.
*/
function addAdmin(address adminToAdd) public onlyOwner {
}
/**
Remove an admin from the list. This should only be callable by the owner of the contract.
*/
function removeAdmin(address adminToRemove) public onlyOwner {
// Verify the account is an admin
require(<FILL_ME>)
// Set the address mapping to false to indicate it is NOT an administrator account.
administrators[adminToRemove] = false;
// Emit the event for any watchers.
emit AdminRemoved(adminToRemove, msg.sender);
}
}
| administrators[adminToRemove]==true,"Account to be removed from admin list is not already an admin" | 385,811 | administrators[adminToRemove]==true |
null | pragma solidity ^0.4.23;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract owned{
address public owner;
constructor ()public{
}
function changeOwner(address newOwner) public onlyOwner{
}
modifier onlyOwner{
}
}
contract Erc20Token {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view 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 NausiCoin is Erc20Token, owned {
string public name;
string public symbol;
uint public decimals;
uint _totalSupply;
mapping(address => uint) _balanceOf;
mapping(address => mapping(address => uint)) _allowance;
event Burn(address indexed from, uint amount);
event Mint(address indexed from, uint amount);
constructor(string tokenName, string tokenSymbol, uint tokenDecimals, uint tokenTotalSupply) public {
}
function totalSupply() public view returns (uint){
}
function balanceOf(address tokenOwner) public view returns (uint balance){
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining){
}
function transfer(address to, uint value) public returns (bool success){
}
function transferFrom(address from, address to, uint value) public returns (bool success){
require(<FILL_ME>)
_allowance[from][msg.sender] -= value;
_transfer(from, to, value);
return true;
}
function approve(address spender, uint value) public returns (bool succes) {
}
function approveAndCall(address spender, uint value, bytes extraData) public returns (bool success){
}
function burnFrom(address from, uint amount) public onlyOwner returns(bool success) {
}
function mintTo(address to, uint amount) public onlyOwner returns(bool success){
}
function() public payable {
}
function _transfer(address from, address to, uint value) internal{
}
}
| _allowance[from][msg.sender]>=value | 385,816 | _allowance[from][msg.sender]>=value |
null | pragma solidity ^0.4.23;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract owned{
address public owner;
constructor ()public{
}
function changeOwner(address newOwner) public onlyOwner{
}
modifier onlyOwner{
}
}
contract Erc20Token {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view 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 NausiCoin is Erc20Token, owned {
string public name;
string public symbol;
uint public decimals;
uint _totalSupply;
mapping(address => uint) _balanceOf;
mapping(address => mapping(address => uint)) _allowance;
event Burn(address indexed from, uint amount);
event Mint(address indexed from, uint amount);
constructor(string tokenName, string tokenSymbol, uint tokenDecimals, uint tokenTotalSupply) public {
}
function totalSupply() public view returns (uint){
}
function balanceOf(address tokenOwner) public view returns (uint balance){
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining){
}
function transfer(address to, uint value) public returns (bool success){
}
function transferFrom(address from, address to, uint value) public returns (bool success){
}
function approve(address spender, uint value) public returns (bool succes) {
}
function approveAndCall(address spender, uint value, bytes extraData) public returns (bool success){
}
function burnFrom(address from, uint amount) public onlyOwner returns(bool success) {
require(<FILL_ME>)
require(_balanceOf[from] - amount <= _balanceOf[from]);
if(owner != from){
require(_allowance[msg.sender][from] >= amount);
}
_balanceOf[from] -= amount;
_allowance[msg.sender][from] -= amount;
_totalSupply -= amount;
emit Burn(from, amount);
return true;
}
function mintTo(address to, uint amount) public onlyOwner returns(bool success){
}
function() public payable {
}
function _transfer(address from, address to, uint value) internal{
}
}
| _balanceOf[from]>=amount | 385,816 | _balanceOf[from]>=amount |
null | pragma solidity ^0.4.23;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract owned{
address public owner;
constructor ()public{
}
function changeOwner(address newOwner) public onlyOwner{
}
modifier onlyOwner{
}
}
contract Erc20Token {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view 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 NausiCoin is Erc20Token, owned {
string public name;
string public symbol;
uint public decimals;
uint _totalSupply;
mapping(address => uint) _balanceOf;
mapping(address => mapping(address => uint)) _allowance;
event Burn(address indexed from, uint amount);
event Mint(address indexed from, uint amount);
constructor(string tokenName, string tokenSymbol, uint tokenDecimals, uint tokenTotalSupply) public {
}
function totalSupply() public view returns (uint){
}
function balanceOf(address tokenOwner) public view returns (uint balance){
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining){
}
function transfer(address to, uint value) public returns (bool success){
}
function transferFrom(address from, address to, uint value) public returns (bool success){
}
function approve(address spender, uint value) public returns (bool succes) {
}
function approveAndCall(address spender, uint value, bytes extraData) public returns (bool success){
}
function burnFrom(address from, uint amount) public onlyOwner returns(bool success) {
require(_balanceOf[from] >= amount);
require(<FILL_ME>)
if(owner != from){
require(_allowance[msg.sender][from] >= amount);
}
_balanceOf[from] -= amount;
_allowance[msg.sender][from] -= amount;
_totalSupply -= amount;
emit Burn(from, amount);
return true;
}
function mintTo(address to, uint amount) public onlyOwner returns(bool success){
}
function() public payable {
}
function _transfer(address from, address to, uint value) internal{
}
}
| _balanceOf[from]-amount<=_balanceOf[from] | 385,816 | _balanceOf[from]-amount<=_balanceOf[from] |
null | pragma solidity ^0.4.23;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract owned{
address public owner;
constructor ()public{
}
function changeOwner(address newOwner) public onlyOwner{
}
modifier onlyOwner{
}
}
contract Erc20Token {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view 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 NausiCoin is Erc20Token, owned {
string public name;
string public symbol;
uint public decimals;
uint _totalSupply;
mapping(address => uint) _balanceOf;
mapping(address => mapping(address => uint)) _allowance;
event Burn(address indexed from, uint amount);
event Mint(address indexed from, uint amount);
constructor(string tokenName, string tokenSymbol, uint tokenDecimals, uint tokenTotalSupply) public {
}
function totalSupply() public view returns (uint){
}
function balanceOf(address tokenOwner) public view returns (uint balance){
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining){
}
function transfer(address to, uint value) public returns (bool success){
}
function transferFrom(address from, address to, uint value) public returns (bool success){
}
function approve(address spender, uint value) public returns (bool succes) {
}
function approveAndCall(address spender, uint value, bytes extraData) public returns (bool success){
}
function burnFrom(address from, uint amount) public onlyOwner returns(bool success) {
require(_balanceOf[from] >= amount);
require(_balanceOf[from] - amount <= _balanceOf[from]);
if(owner != from){
require(<FILL_ME>)
}
_balanceOf[from] -= amount;
_allowance[msg.sender][from] -= amount;
_totalSupply -= amount;
emit Burn(from, amount);
return true;
}
function mintTo(address to, uint amount) public onlyOwner returns(bool success){
}
function() public payable {
}
function _transfer(address from, address to, uint value) internal{
}
}
| _allowance[msg.sender][from]>=amount | 385,816 | _allowance[msg.sender][from]>=amount |
null | pragma solidity ^0.4.23;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract owned{
address public owner;
constructor ()public{
}
function changeOwner(address newOwner) public onlyOwner{
}
modifier onlyOwner{
}
}
contract Erc20Token {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view 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 NausiCoin is Erc20Token, owned {
string public name;
string public symbol;
uint public decimals;
uint _totalSupply;
mapping(address => uint) _balanceOf;
mapping(address => mapping(address => uint)) _allowance;
event Burn(address indexed from, uint amount);
event Mint(address indexed from, uint amount);
constructor(string tokenName, string tokenSymbol, uint tokenDecimals, uint tokenTotalSupply) public {
}
function totalSupply() public view returns (uint){
}
function balanceOf(address tokenOwner) public view returns (uint balance){
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining){
}
function transfer(address to, uint value) public returns (bool success){
}
function transferFrom(address from, address to, uint value) public returns (bool success){
}
function approve(address spender, uint value) public returns (bool succes) {
}
function approveAndCall(address spender, uint value, bytes extraData) public returns (bool success){
}
function burnFrom(address from, uint amount) public onlyOwner returns(bool success) {
}
function mintTo(address to, uint amount) public onlyOwner returns(bool success){
require(<FILL_ME>)
require(_totalSupply + amount >= _totalSupply);
_balanceOf[to] += amount;
_totalSupply += amount;
emit Mint(to, amount);
return true;
}
function() public payable {
}
function _transfer(address from, address to, uint value) internal{
}
}
| _balanceOf[to]+amount>=_balanceOf[to] | 385,816 | _balanceOf[to]+amount>=_balanceOf[to] |
null | pragma solidity ^0.4.23;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract owned{
address public owner;
constructor ()public{
}
function changeOwner(address newOwner) public onlyOwner{
}
modifier onlyOwner{
}
}
contract Erc20Token {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view 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 NausiCoin is Erc20Token, owned {
string public name;
string public symbol;
uint public decimals;
uint _totalSupply;
mapping(address => uint) _balanceOf;
mapping(address => mapping(address => uint)) _allowance;
event Burn(address indexed from, uint amount);
event Mint(address indexed from, uint amount);
constructor(string tokenName, string tokenSymbol, uint tokenDecimals, uint tokenTotalSupply) public {
}
function totalSupply() public view returns (uint){
}
function balanceOf(address tokenOwner) public view returns (uint balance){
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining){
}
function transfer(address to, uint value) public returns (bool success){
}
function transferFrom(address from, address to, uint value) public returns (bool success){
}
function approve(address spender, uint value) public returns (bool succes) {
}
function approveAndCall(address spender, uint value, bytes extraData) public returns (bool success){
}
function burnFrom(address from, uint amount) public onlyOwner returns(bool success) {
}
function mintTo(address to, uint amount) public onlyOwner returns(bool success){
require(_balanceOf[to] + amount >= _balanceOf[to]);
require(<FILL_ME>)
_balanceOf[to] += amount;
_totalSupply += amount;
emit Mint(to, amount);
return true;
}
function() public payable {
}
function _transfer(address from, address to, uint value) internal{
}
}
| _totalSupply+amount>=_totalSupply | 385,816 | _totalSupply+amount>=_totalSupply |
null | pragma solidity ^0.4.23;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract owned{
address public owner;
constructor ()public{
}
function changeOwner(address newOwner) public onlyOwner{
}
modifier onlyOwner{
}
}
contract Erc20Token {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view 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 NausiCoin is Erc20Token, owned {
string public name;
string public symbol;
uint public decimals;
uint _totalSupply;
mapping(address => uint) _balanceOf;
mapping(address => mapping(address => uint)) _allowance;
event Burn(address indexed from, uint amount);
event Mint(address indexed from, uint amount);
constructor(string tokenName, string tokenSymbol, uint tokenDecimals, uint tokenTotalSupply) public {
}
function totalSupply() public view returns (uint){
}
function balanceOf(address tokenOwner) public view returns (uint balance){
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining){
}
function transfer(address to, uint value) public returns (bool success){
}
function transferFrom(address from, address to, uint value) public returns (bool success){
}
function approve(address spender, uint value) public returns (bool succes) {
}
function approveAndCall(address spender, uint value, bytes extraData) public returns (bool success){
}
function burnFrom(address from, uint amount) public onlyOwner returns(bool success) {
}
function mintTo(address to, uint amount) public onlyOwner returns(bool success){
}
function() public payable {
}
function _transfer(address from, address to, uint value) internal{
require(to != 0x0);
require(<FILL_ME>)
require(_balanceOf[to] + value >= _balanceOf[to]);
uint previousBalance = _balanceOf[from] + _balanceOf[to];
_balanceOf[from] -= value;
_balanceOf[to] += value;
emit Transfer(from, to, value);
assert(_balanceOf[from] + _balanceOf[to] == previousBalance);
}
}
| _balanceOf[from]>=value | 385,816 | _balanceOf[from]>=value |
null | pragma solidity ^0.4.23;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract owned{
address public owner;
constructor ()public{
}
function changeOwner(address newOwner) public onlyOwner{
}
modifier onlyOwner{
}
}
contract Erc20Token {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view 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 NausiCoin is Erc20Token, owned {
string public name;
string public symbol;
uint public decimals;
uint _totalSupply;
mapping(address => uint) _balanceOf;
mapping(address => mapping(address => uint)) _allowance;
event Burn(address indexed from, uint amount);
event Mint(address indexed from, uint amount);
constructor(string tokenName, string tokenSymbol, uint tokenDecimals, uint tokenTotalSupply) public {
}
function totalSupply() public view returns (uint){
}
function balanceOf(address tokenOwner) public view returns (uint balance){
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining){
}
function transfer(address to, uint value) public returns (bool success){
}
function transferFrom(address from, address to, uint value) public returns (bool success){
}
function approve(address spender, uint value) public returns (bool succes) {
}
function approveAndCall(address spender, uint value, bytes extraData) public returns (bool success){
}
function burnFrom(address from, uint amount) public onlyOwner returns(bool success) {
}
function mintTo(address to, uint amount) public onlyOwner returns(bool success){
}
function() public payable {
}
function _transfer(address from, address to, uint value) internal{
require(to != 0x0);
require(_balanceOf[from] >= value);
require(<FILL_ME>)
uint previousBalance = _balanceOf[from] + _balanceOf[to];
_balanceOf[from] -= value;
_balanceOf[to] += value;
emit Transfer(from, to, value);
assert(_balanceOf[from] + _balanceOf[to] == previousBalance);
}
}
| _balanceOf[to]+value>=_balanceOf[to] | 385,816 | _balanceOf[to]+value>=_balanceOf[to] |
null | pragma solidity 0.4.25;
// Констракт.
contract MyMileage {
// Владелец контракта.
address private owner;
// Отображение хеш сумм фотографий и дат.
mapping(bytes32 => uint) private map;
// Модификатор доступа "только владелец".
modifier onlyOwner {
}
// Конструктор.
constructor() public {
}
// Добавление записи.
function put(bytes32 imageHash) onlyOwner public {
// Проверка пустого значения по ключу.
require(<FILL_ME>)
// Установка значения.
map[imageHash] = now;
}
// Проверка наличия значения.
function free(bytes32 imageHash) view public returns (bool) {
}
// Получение значения.
function get(bytes32 imageHash) view public returns (uint) {
}
// Получение кода подтверждения
// в виде хеша блока.
function getConfirmationCode() view public returns (bytes32) {
}
}
| free(imageHash) | 385,819 | free(imageHash) |
null | pragma solidity ^0.6;
contract AdminControlled {
address public admin;
uint public paused;
constructor(address _admin, uint flags) public {
}
modifier onlyAdmin {
}
modifier pausable(uint flag) {
require(<FILL_ME>)
_;
}
function adminPause(uint flags) public onlyAdmin {
}
function adminSstore(uint key, uint value) public onlyAdmin {
}
function adminSendEth(address payable destination, uint amount) public onlyAdmin {
}
function adminReceiveEth() public payable onlyAdmin {}
function adminDelegatecall(address target, bytes memory data) public payable onlyAdmin returns (bytes memory) {
}
}
| (paused&flag)==0||msg.sender==admin | 385,855 | (paused&flag)==0||msg.sender==admin |
"Exceeds max Nfts per wallet." | pragma solidity ^0.8.7;
library Address {
function isContract(address account) internal view returns (bool) {
}
}
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner)
public
view
virtual
override
returns (uint)
{
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId)
public
view
virtual
override
returns (address)
{
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId)
public
view
virtual
override
returns (address)
{
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId)
internal
view
virtual
returns (bool)
{
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` 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 tokenId
) internal virtual {}
}
pragma solidity ^0.8.7;
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account but rips out the core of the gas-wasting processing that comes from OpenZeppelin.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256 tokenId) {
}
}
pragma solidity ^0.8.7;
contract NonFungibleSmilebyTrippie2022 is ERC721Enumerable, Ownable {
using Strings for uint256;
string private uriPrefix;
string private uriSuffix = ".json";
string public hiddenURL = "ipfs://QmdYSVBSQeBBGzr6aYktdKWhhGqkSiBEn56K6aKcjSniLq";
uint256 public cost = 0.08 ether;
uint256 public whiteListCost = 0.065 ether;
uint8 public maxWLMintAmountPerWallet = 2;
uint8 public maxMintAmountPerWallet = 8;
mapping (address => uint8) public nftPerWLAddress;
mapping (address => uint8) public nftPerAddress;
uint8 public reserved = 22;
uint16 public constant maxSupply = 2022;
bool public WLpaused = false;
bool public paused = true;
bool public reveal = false;
bytes32 public whitelistMerkleRoot = 0x937455db6a0e344f787a4a95ab2a3b7ea0df96a20ce40bbb0246bfcbe40eb83f;
constructor() ERC721("Non Fungible Smile by Trippie2022 ", "$NFS") {
}
function mint(uint8 _mintAmount) external payable {
uint16 totalSupply = uint16(_owners.length);
require(_mintAmount > 0 , "Mint Amount cannot be zero");
require(totalSupply + _mintAmount <= maxSupply, "Sold out!!!");
require(<FILL_ME>)
require(!paused, "The contract is paused!");
require(msg.value >= cost * _mintAmount, "Insufficient funds!");
for(uint8 i; i < _mintAmount; i++) {
_mint(msg.sender, totalSupply + i);
}
nftPerAddress[msg.sender]= nftPerAddress[msg.sender] + _mintAmount ;
delete totalSupply;
delete _mintAmount;
}
function Reserve(address _receiver) external onlyOwner {
}
function Airdrop(address _receiver , uint16 _mintAmount) external onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed() external onlyOwner {
}
function setWLPaused() external onlyOwner {
}
function setPaused() external onlyOwner {
}
function setWLCost(uint256 _cost) external onlyOwner {
}
function setMaxTxPerWlAddress(uint8 _limit) external onlyOwner{
}
function setWhitelistMerkleRoot(bytes32 _whitelistMerkleRoot) external onlyOwner {
}
function getLeafNode(address _leaf) internal pure returns (bytes32 temp)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof , bytes32 merkleRoot) internal pure returns (bool) {
}
function whitelistMint(uint8 _mintAmount, bytes32[] calldata merkleProof) external payable {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) external onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) external onlyOwner {
}
function setCost(uint _cost) external onlyOwner{
}
function setMaxMintAmountPerWallet(uint8 _maxtx) external onlyOwner{
}
function withdraw() external onlyOwner {
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
function _baseURI() internal view returns (string memory) {
}
}
| nftPerAddress[msg.sender]+_mintAmount<=maxMintAmountPerWallet,"Exceeds max Nfts per wallet." | 385,900 | nftPerAddress[msg.sender]+_mintAmount<=maxMintAmountPerWallet |
"You are not whitelisted" | pragma solidity ^0.8.7;
library Address {
function isContract(address account) internal view returns (bool) {
}
}
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner)
public
view
virtual
override
returns (uint)
{
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId)
public
view
virtual
override
returns (address)
{
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId)
public
view
virtual
override
returns (address)
{
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId)
internal
view
virtual
returns (bool)
{
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` 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 tokenId
) internal virtual {}
}
pragma solidity ^0.8.7;
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account but rips out the core of the gas-wasting processing that comes from OpenZeppelin.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256 tokenId) {
}
}
pragma solidity ^0.8.7;
contract NonFungibleSmilebyTrippie2022 is ERC721Enumerable, Ownable {
using Strings for uint256;
string private uriPrefix;
string private uriSuffix = ".json";
string public hiddenURL = "ipfs://QmdYSVBSQeBBGzr6aYktdKWhhGqkSiBEn56K6aKcjSniLq";
uint256 public cost = 0.08 ether;
uint256 public whiteListCost = 0.065 ether;
uint8 public maxWLMintAmountPerWallet = 2;
uint8 public maxMintAmountPerWallet = 8;
mapping (address => uint8) public nftPerWLAddress;
mapping (address => uint8) public nftPerAddress;
uint8 public reserved = 22;
uint16 public constant maxSupply = 2022;
bool public WLpaused = false;
bool public paused = true;
bool public reveal = false;
bytes32 public whitelistMerkleRoot = 0x937455db6a0e344f787a4a95ab2a3b7ea0df96a20ce40bbb0246bfcbe40eb83f;
constructor() ERC721("Non Fungible Smile by Trippie2022 ", "$NFS") {
}
function mint(uint8 _mintAmount) external payable {
}
function Reserve(address _receiver) external onlyOwner {
}
function Airdrop(address _receiver , uint16 _mintAmount) external onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed() external onlyOwner {
}
function setWLPaused() external onlyOwner {
}
function setPaused() external onlyOwner {
}
function setWLCost(uint256 _cost) external onlyOwner {
}
function setMaxTxPerWlAddress(uint8 _limit) external onlyOwner{
}
function setWhitelistMerkleRoot(bytes32 _whitelistMerkleRoot) external onlyOwner {
}
function getLeafNode(address _leaf) internal pure returns (bytes32 temp)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof , bytes32 merkleRoot) internal pure returns (bool) {
}
function whitelistMint(uint8 _mintAmount, bytes32[] calldata merkleProof) external payable {
bytes32 leafnode = getLeafNode(msg.sender);
require(<FILL_ME>)
require (nftPerWLAddress[msg.sender] + _mintAmount <= maxWLMintAmountPerWallet, "Exceeds max NFT per wallet");
require(!WLpaused, "Whitelist minting is Paused!");
require(msg.value >= whiteListCost * _mintAmount, "Insufficient funds!");
uint16 totalSupply = uint16(_owners.length);
require(totalSupply + _mintAmount< 1023 , "Only 1022 NFTs are available for Presale");
for(uint8 i; i < _mintAmount; i++) {
_mint(msg.sender , totalSupply + i);
}
nftPerWLAddress[msg.sender] += _mintAmount;
if (totalSupply + _mintAmount >= 1022)
{
WLpaused = true;
paused = false;
}
delete totalSupply;
delete _mintAmount;
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) external onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) external onlyOwner {
}
function setCost(uint _cost) external onlyOwner{
}
function setMaxMintAmountPerWallet(uint8 _maxtx) external onlyOwner{
}
function withdraw() external onlyOwner {
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
function _baseURI() internal view returns (string memory) {
}
}
| _verify(leafnode,merkleProof,whitelistMerkleRoot),"You are not whitelisted" | 385,900 | _verify(leafnode,merkleProof,whitelistMerkleRoot) |
"Exceeds max NFT per wallet" | pragma solidity ^0.8.7;
library Address {
function isContract(address account) internal view returns (bool) {
}
}
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner)
public
view
virtual
override
returns (uint)
{
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId)
public
view
virtual
override
returns (address)
{
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId)
public
view
virtual
override
returns (address)
{
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId)
internal
view
virtual
returns (bool)
{
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` 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 tokenId
) internal virtual {}
}
pragma solidity ^0.8.7;
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account but rips out the core of the gas-wasting processing that comes from OpenZeppelin.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256 tokenId) {
}
}
pragma solidity ^0.8.7;
contract NonFungibleSmilebyTrippie2022 is ERC721Enumerable, Ownable {
using Strings for uint256;
string private uriPrefix;
string private uriSuffix = ".json";
string public hiddenURL = "ipfs://QmdYSVBSQeBBGzr6aYktdKWhhGqkSiBEn56K6aKcjSniLq";
uint256 public cost = 0.08 ether;
uint256 public whiteListCost = 0.065 ether;
uint8 public maxWLMintAmountPerWallet = 2;
uint8 public maxMintAmountPerWallet = 8;
mapping (address => uint8) public nftPerWLAddress;
mapping (address => uint8) public nftPerAddress;
uint8 public reserved = 22;
uint16 public constant maxSupply = 2022;
bool public WLpaused = false;
bool public paused = true;
bool public reveal = false;
bytes32 public whitelistMerkleRoot = 0x937455db6a0e344f787a4a95ab2a3b7ea0df96a20ce40bbb0246bfcbe40eb83f;
constructor() ERC721("Non Fungible Smile by Trippie2022 ", "$NFS") {
}
function mint(uint8 _mintAmount) external payable {
}
function Reserve(address _receiver) external onlyOwner {
}
function Airdrop(address _receiver , uint16 _mintAmount) external onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed() external onlyOwner {
}
function setWLPaused() external onlyOwner {
}
function setPaused() external onlyOwner {
}
function setWLCost(uint256 _cost) external onlyOwner {
}
function setMaxTxPerWlAddress(uint8 _limit) external onlyOwner{
}
function setWhitelistMerkleRoot(bytes32 _whitelistMerkleRoot) external onlyOwner {
}
function getLeafNode(address _leaf) internal pure returns (bytes32 temp)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof , bytes32 merkleRoot) internal pure returns (bool) {
}
function whitelistMint(uint8 _mintAmount, bytes32[] calldata merkleProof) external payable {
bytes32 leafnode = getLeafNode(msg.sender);
require(_verify(leafnode , merkleProof , whitelistMerkleRoot), "You are not whitelisted");
require(<FILL_ME>)
require(!WLpaused, "Whitelist minting is Paused!");
require(msg.value >= whiteListCost * _mintAmount, "Insufficient funds!");
uint16 totalSupply = uint16(_owners.length);
require(totalSupply + _mintAmount< 1023 , "Only 1022 NFTs are available for Presale");
for(uint8 i; i < _mintAmount; i++) {
_mint(msg.sender , totalSupply + i);
}
nftPerWLAddress[msg.sender] += _mintAmount;
if (totalSupply + _mintAmount >= 1022)
{
WLpaused = true;
paused = false;
}
delete totalSupply;
delete _mintAmount;
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) external onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) external onlyOwner {
}
function setCost(uint _cost) external onlyOwner{
}
function setMaxMintAmountPerWallet(uint8 _maxtx) external onlyOwner{
}
function withdraw() external onlyOwner {
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
function _baseURI() internal view returns (string memory) {
}
}
| nftPerWLAddress[msg.sender]+_mintAmount<=maxWLMintAmountPerWallet,"Exceeds max NFT per wallet" | 385,900 | nftPerWLAddress[msg.sender]+_mintAmount<=maxWLMintAmountPerWallet |
"Only 1022 NFTs are available for Presale" | pragma solidity ^0.8.7;
library Address {
function isContract(address account) internal view returns (bool) {
}
}
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
// Mapping from token ID to owner address
address[] internal _owners;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner)
public
view
virtual
override
returns (uint)
{
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId)
public
view
virtual
override
returns (address)
{
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId)
public
view
virtual
override
returns (address)
{
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `_data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId)
internal
view
virtual
returns (bool)
{
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` 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 tokenId
) internal virtual {}
}
pragma solidity ^0.8.7;
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account but rips out the core of the gas-wasting processing that comes from OpenZeppelin.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256 tokenId) {
}
}
pragma solidity ^0.8.7;
contract NonFungibleSmilebyTrippie2022 is ERC721Enumerable, Ownable {
using Strings for uint256;
string private uriPrefix;
string private uriSuffix = ".json";
string public hiddenURL = "ipfs://QmdYSVBSQeBBGzr6aYktdKWhhGqkSiBEn56K6aKcjSniLq";
uint256 public cost = 0.08 ether;
uint256 public whiteListCost = 0.065 ether;
uint8 public maxWLMintAmountPerWallet = 2;
uint8 public maxMintAmountPerWallet = 8;
mapping (address => uint8) public nftPerWLAddress;
mapping (address => uint8) public nftPerAddress;
uint8 public reserved = 22;
uint16 public constant maxSupply = 2022;
bool public WLpaused = false;
bool public paused = true;
bool public reveal = false;
bytes32 public whitelistMerkleRoot = 0x937455db6a0e344f787a4a95ab2a3b7ea0df96a20ce40bbb0246bfcbe40eb83f;
constructor() ERC721("Non Fungible Smile by Trippie2022 ", "$NFS") {
}
function mint(uint8 _mintAmount) external payable {
}
function Reserve(address _receiver) external onlyOwner {
}
function Airdrop(address _receiver , uint16 _mintAmount) external onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed() external onlyOwner {
}
function setWLPaused() external onlyOwner {
}
function setPaused() external onlyOwner {
}
function setWLCost(uint256 _cost) external onlyOwner {
}
function setMaxTxPerWlAddress(uint8 _limit) external onlyOwner{
}
function setWhitelistMerkleRoot(bytes32 _whitelistMerkleRoot) external onlyOwner {
}
function getLeafNode(address _leaf) internal pure returns (bytes32 temp)
{
}
function _verify(bytes32 leaf, bytes32[] memory proof , bytes32 merkleRoot) internal pure returns (bool) {
}
function whitelistMint(uint8 _mintAmount, bytes32[] calldata merkleProof) external payable {
bytes32 leafnode = getLeafNode(msg.sender);
require(_verify(leafnode , merkleProof , whitelistMerkleRoot), "You are not whitelisted");
require (nftPerWLAddress[msg.sender] + _mintAmount <= maxWLMintAmountPerWallet, "Exceeds max NFT per wallet");
require(!WLpaused, "Whitelist minting is Paused!");
require(msg.value >= whiteListCost * _mintAmount, "Insufficient funds!");
uint16 totalSupply = uint16(_owners.length);
require(<FILL_ME>)
for(uint8 i; i < _mintAmount; i++) {
_mint(msg.sender , totalSupply + i);
}
nftPerWLAddress[msg.sender] += _mintAmount;
if (totalSupply + _mintAmount >= 1022)
{
WLpaused = true;
paused = false;
}
delete totalSupply;
delete _mintAmount;
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) external onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) external onlyOwner {
}
function setCost(uint _cost) external onlyOwner{
}
function setMaxMintAmountPerWallet(uint8 _maxtx) external onlyOwner{
}
function withdraw() external onlyOwner {
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
function _baseURI() internal view returns (string memory) {
}
}
| totalSupply+_mintAmount<1023,"Only 1022 NFTs are available for Presale" | 385,900 | totalSupply+_mintAmount<1023 |
"Reserve mint would exceed max supply of tokens" | pragma solidity ^0.7.6;
contract AlienArchives is ERC721, Ownable {
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public constant MAX_TOKENS = 10000;
uint256 public constant PRICE_PER_TOKEN = 51000000000000000; // 0.051
uint256 public constant PRICE_PER_PRESALE_TOKEN = 40000000000000000; // 0.04
uint256 public constant MAX_TOKENS_PER_TX = 51;
uint256 public constant MAX_TOKENS_PER_PRESALE_TX = 51;
address public constant CURATORS_ADDRESS = 0x8698FD87B7Ead94d8C2b50e87A474641f201bE1c;
address public constant CRYPTOCRACY_ADDRESS = 0xD416d842126802A1f6579ceb77752053bF34E2d5;
address public constant BOOSTER_ADDRESS = 0xf6a6AF8223627C05075CBE24Da2Cf2B979EB5143;
string public PROVENANCE_HASH = "";
uint public RESERVED_TOKENS = 50;
bool public saleIsActive = false;
bool public presaleIsActive = false;
bool public frozenBaseUri = false;
bool public frozenProvenanceHash = false;
constructor() ERC721("Alien Archives", "AA") {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function freezeBaseURI() public onlyOwner {
}
function setProvenanceHash(string memory provenanceHashString) public onlyOwner {
}
function freezeProvenanceHash() public onlyOwner {
}
function reserveTokens(address to, uint256 amountToReserve) public onlyOwner {
require(<FILL_ME>)
require(amountToReserve > 0 && amountToReserve <= RESERVED_TOKENS, "Not enough reserve left for this mint");
for (uint i = 0; i < amountToReserve; i++) {
uint mintIndex = totalSupply() + 1;
_safeMint(to, mintIndex);
}
RESERVED_TOKENS = RESERVED_TOKENS.sub(amountToReserve);
}
function withdrawAll() public payable {
}
function mintPresaleTokens(uint numberOfTokens) public payable {
}
function mintTokens(uint numberOfTokens) public payable {
}
function toggleSaleIsActive() public onlyOwner {
}
function togglePresaleIsActive() public onlyOwner {
}
function _withdraw(address _address, uint256 _amount) private {
}
}
| totalSupply().add(amountToReserve)<=MAX_TOKENS,"Reserve mint would exceed max supply of tokens" | 385,914 | totalSupply().add(amountToReserve)<=MAX_TOKENS |
"You are not allowed to withdraw" | pragma solidity ^0.7.6;
contract AlienArchives is ERC721, Ownable {
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public constant MAX_TOKENS = 10000;
uint256 public constant PRICE_PER_TOKEN = 51000000000000000; // 0.051
uint256 public constant PRICE_PER_PRESALE_TOKEN = 40000000000000000; // 0.04
uint256 public constant MAX_TOKENS_PER_TX = 51;
uint256 public constant MAX_TOKENS_PER_PRESALE_TX = 51;
address public constant CURATORS_ADDRESS = 0x8698FD87B7Ead94d8C2b50e87A474641f201bE1c;
address public constant CRYPTOCRACY_ADDRESS = 0xD416d842126802A1f6579ceb77752053bF34E2d5;
address public constant BOOSTER_ADDRESS = 0xf6a6AF8223627C05075CBE24Da2Cf2B979EB5143;
string public PROVENANCE_HASH = "";
uint public RESERVED_TOKENS = 50;
bool public saleIsActive = false;
bool public presaleIsActive = false;
bool public frozenBaseUri = false;
bool public frozenProvenanceHash = false;
constructor() ERC721("Alien Archives", "AA") {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function freezeBaseURI() public onlyOwner {
}
function setProvenanceHash(string memory provenanceHashString) public onlyOwner {
}
function freezeProvenanceHash() public onlyOwner {
}
function reserveTokens(address to, uint256 amountToReserve) public onlyOwner {
}
function withdrawAll() public payable {
require(<FILL_ME>)
uint256 balance = address(this).balance;
require(balance > 0, "There are no funds to withdraw");
_withdraw(CRYPTOCRACY_ADDRESS, balance.mul(15).div(100));
_withdraw(BOOSTER_ADDRESS, balance.mul(5).div(100));
_withdraw(CURATORS_ADDRESS, address(this).balance);
}
function mintPresaleTokens(uint numberOfTokens) public payable {
}
function mintTokens(uint numberOfTokens) public payable {
}
function toggleSaleIsActive() public onlyOwner {
}
function togglePresaleIsActive() public onlyOwner {
}
function _withdraw(address _address, uint256 _amount) private {
}
}
| (msg.sender==CURATORS_ADDRESS||msg.sender==CRYPTOCRACY_ADDRESS),"You are not allowed to withdraw" | 385,914 | (msg.sender==CURATORS_ADDRESS||msg.sender==CRYPTOCRACY_ADDRESS) |
"Not enough Ether was sent to mint the requested number of tokens" | pragma solidity ^0.7.6;
contract AlienArchives is ERC721, Ownable {
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public constant MAX_TOKENS = 10000;
uint256 public constant PRICE_PER_TOKEN = 51000000000000000; // 0.051
uint256 public constant PRICE_PER_PRESALE_TOKEN = 40000000000000000; // 0.04
uint256 public constant MAX_TOKENS_PER_TX = 51;
uint256 public constant MAX_TOKENS_PER_PRESALE_TX = 51;
address public constant CURATORS_ADDRESS = 0x8698FD87B7Ead94d8C2b50e87A474641f201bE1c;
address public constant CRYPTOCRACY_ADDRESS = 0xD416d842126802A1f6579ceb77752053bF34E2d5;
address public constant BOOSTER_ADDRESS = 0xf6a6AF8223627C05075CBE24Da2Cf2B979EB5143;
string public PROVENANCE_HASH = "";
uint public RESERVED_TOKENS = 50;
bool public saleIsActive = false;
bool public presaleIsActive = false;
bool public frozenBaseUri = false;
bool public frozenProvenanceHash = false;
constructor() ERC721("Alien Archives", "AA") {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function freezeBaseURI() public onlyOwner {
}
function setProvenanceHash(string memory provenanceHashString) public onlyOwner {
}
function freezeProvenanceHash() public onlyOwner {
}
function reserveTokens(address to, uint256 amountToReserve) public onlyOwner {
}
function withdrawAll() public payable {
}
function mintPresaleTokens(uint numberOfTokens) public payable {
require(presaleIsActive, "Sale must be active to mint a new token");
require(numberOfTokens <= MAX_TOKENS_PER_PRESALE_TX, "You can only mint 2 tokens per transaction");
require(totalSupply().add(numberOfTokens) <= MAX_TOKENS, "This transaction would exceed the max allowed number of tokens");
require(<FILL_ME>)
require(numberOfTokens <= MAX_TOKENS.sub(RESERVED_TOKENS).sub(totalSupply()), "This tx, plus unminted reserves, would exceed max allowed number of tokens");
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = totalSupply() + 1;
if (totalSupply() < MAX_TOKENS) {
_safeMint(msg.sender, mintIndex);
}
}
}
function mintTokens(uint numberOfTokens) public payable {
}
function toggleSaleIsActive() public onlyOwner {
}
function togglePresaleIsActive() public onlyOwner {
}
function _withdraw(address _address, uint256 _amount) private {
}
}
| PRICE_PER_PRESALE_TOKEN.mul(numberOfTokens)<=msg.value,"Not enough Ether was sent to mint the requested number of tokens" | 385,914 | PRICE_PER_PRESALE_TOKEN.mul(numberOfTokens)<=msg.value |
"Not enough Ether was sent to mint the requested number of tokens" | pragma solidity ^0.7.6;
contract AlienArchives is ERC721, Ownable {
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public constant MAX_TOKENS = 10000;
uint256 public constant PRICE_PER_TOKEN = 51000000000000000; // 0.051
uint256 public constant PRICE_PER_PRESALE_TOKEN = 40000000000000000; // 0.04
uint256 public constant MAX_TOKENS_PER_TX = 51;
uint256 public constant MAX_TOKENS_PER_PRESALE_TX = 51;
address public constant CURATORS_ADDRESS = 0x8698FD87B7Ead94d8C2b50e87A474641f201bE1c;
address public constant CRYPTOCRACY_ADDRESS = 0xD416d842126802A1f6579ceb77752053bF34E2d5;
address public constant BOOSTER_ADDRESS = 0xf6a6AF8223627C05075CBE24Da2Cf2B979EB5143;
string public PROVENANCE_HASH = "";
uint public RESERVED_TOKENS = 50;
bool public saleIsActive = false;
bool public presaleIsActive = false;
bool public frozenBaseUri = false;
bool public frozenProvenanceHash = false;
constructor() ERC721("Alien Archives", "AA") {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function freezeBaseURI() public onlyOwner {
}
function setProvenanceHash(string memory provenanceHashString) public onlyOwner {
}
function freezeProvenanceHash() public onlyOwner {
}
function reserveTokens(address to, uint256 amountToReserve) public onlyOwner {
}
function withdrawAll() public payable {
}
function mintPresaleTokens(uint numberOfTokens) public payable {
}
function mintTokens(uint numberOfTokens) public payable {
require(saleIsActive, "Sale must be active to mint a new token");
require(numberOfTokens <= MAX_TOKENS_PER_TX, "You can only mint 20 tokens per transaction");
require(totalSupply().add(numberOfTokens) <= MAX_TOKENS, "This transaction would exceed the max allowed number of tokens");
require(<FILL_ME>)
require(numberOfTokens <= MAX_TOKENS.sub(RESERVED_TOKENS).sub(totalSupply()), "This tx, plus unminted reserves, would exceed max allowed number of tokens");
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = totalSupply() + 1;
if (totalSupply() < MAX_TOKENS) {
_safeMint(msg.sender, mintIndex);
}
}
}
function toggleSaleIsActive() public onlyOwner {
}
function togglePresaleIsActive() public onlyOwner {
}
function _withdraw(address _address, uint256 _amount) private {
}
}
| PRICE_PER_TOKEN.mul(numberOfTokens)<=msg.value,"Not enough Ether was sent to mint the requested number of tokens" | 385,914 | PRICE_PER_TOKEN.mul(numberOfTokens)<=msg.value |
"Not enough mints remaining to mint" | //SPDX-License-Identifier: MIT
//Contract based on [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
pragma solidity ^0.8.0;
contract ClubPenguinNFT is ERC721, IERC2981, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private tokenCounter;
string private baseURI = "ipfs://QmVnJNL6w6PW5gZ6tV6jagRfuCbXvuEwjy9CTnhsWY8EoM";
address private openSeaProxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
bool private isOpenSeaProxyActive = true;
uint256 public constant MAX_MINTS_PER_TX = 20;
uint256 public maxSupply = 3333;
uint256 public constant PUBLIC_SALE_PRICE = 0.02 ether;
uint256 public constant NUM_FREE_MINTS = 2222;
bool public isPublicSaleActive = true;
// ============ ACCESS CONTROL/SANITY MODIFIERS ============
modifier publicSaleActive() {
}
modifier maxMintsPerTX(uint256 numberOfTokens) {
}
modifier canMintNFTs(uint256 numberOfTokens) {
require(<FILL_ME>)
_;
}
modifier isCorrectPayment(uint256 price, uint256 numberOfTokens) {
}
constructor(
) ERC721("Club Penguin NFT", "PENGUIN") {
}
// ============ PUBLIC FUNCTIONS FOR MINTING ============
function mint(uint256 numberOfTokens)
external
payable
nonReentrant
isCorrectPayment(PUBLIC_SALE_PRICE, numberOfTokens)
publicSaleActive
canMintNFTs(numberOfTokens)
maxMintsPerTX(numberOfTokens)
{
}
// ============ PUBLIC READ-ONLY FUNCTIONS ============
function getBaseURI() external view returns (string memory) {
}
function getLastTokenId() external view returns (uint256) {
}
function totalSupply() external view returns (uint256) {
}
// ============ OWNER-ONLY ADMIN FUNCTIONS ============
function setBaseURI(string memory _baseURI) external onlyOwner {
}
// function to disable gasless listings for security in case
// opensea ever shuts down or is compromised
function setIsOpenSeaProxyActive(bool _isOpenSeaProxyActive)
external
onlyOwner
{
}
function setIsPublicSaleActive(bool _isPublicSaleActive)
external
onlyOwner
{
}
function withdraw() public onlyOwner {
}
function withdrawTokens(IERC20 token) public onlyOwner {
}
// ============ SUPPORTING FUNCTIONS ============
function nextTokenId() private returns (uint256) {
}
// ============ FUNCTION OVERRIDES ============
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, IERC165)
returns (bool)
{
}
/**
* @dev Override isApprovedForAll to allowlist user's OpenSea proxy accounts to enable gas-less listings.
*/
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* @dev See {IERC165-royaltyInfo}.
*/
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
// These contract definitions are used to create a reference to the OpenSea
// ProxyRegistry contract by using the registry's address (see isApprovedForAll).
contract OwnableDelegateProxy {
}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| tokenCounter.current()+numberOfTokens<=maxSupply,"Not enough mints remaining to mint" | 386,149 | tokenCounter.current()+numberOfTokens<=maxSupply |
null | pragma solidity ^0.4.13;
contract DependentOnIPFS {
/**
* @dev Validate a multihash bytes value
*/
function isValidIPFSMultihash(bytes _multihashBytes) internal pure returns (bool) {
}
}
contract Poll is DependentOnIPFS {
// There isn't a way around using time to determine when votes can be cast
// solhint-disable not-rely-on-time
bytes public pollDataMultihash;
uint16 public numChoices;
uint256 public startTime;
uint256 public endTime;
address public author;
mapping(address => uint16) public votes;
event VoteCast(address indexed voter, uint16 indexed choice);
function Poll(
bytes _ipfsHash,
uint16 _numChoices,
uint256 _startTime,
uint256 _endTime,
address _author
) public {
require(_startTime >= now && _endTime > _startTime);
require(<FILL_ME>)
numChoices = _numChoices;
startTime = _startTime;
endTime = _endTime;
pollDataMultihash = _ipfsHash;
author = _author;
}
/**
* @dev Cast or change your vote
* @param _choice The index of the option in the corresponding IPFS document.
*/
function vote(uint16 _choice) public duringPoll {
}
modifier duringPoll {
}
}
contract VotingCenter {
Poll[] public polls;
event PollCreated(address indexed poll, address indexed author);
/**
* @dev create a poll and store the address of the poll in this contract
* @param _ipfsHash Multihash for IPFS file containing poll information
* @param _numOptions Number of choices in this poll
* @param _startTime Time after which a user can cast a vote in the poll
* @param _endTime Time after which the poll no longer accepts new votes
* @return The address of the new Poll
*/
function createPoll(
bytes _ipfsHash,
uint16 _numOptions,
uint256 _startTime,
uint256 _endTime
) public returns (address) {
}
function allPolls() view public returns (Poll[]) {
}
function numPolls() view public returns (uint256) {
}
}
| isValidIPFSMultihash(_ipfsHash) | 386,161 | isValidIPFSMultihash(_ipfsHash) |
"RewardedPbtcWethUniV2Pair: _uniV2 not a contract" | pragma solidity ^0.5.0;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/ownership/Ownable.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "../lib/UniswapV2Library.sol";
import "../ModifiedUnipool.sol";
import "../interfaces/IWETH.sol";
contract RewardedPbtcWethUniV2Pair is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public pbtc;
IWETH public weth;
IUniswapV2Pair public uniV2;
ModifiedUnipool public modifiedUnipool;
uint256 public allowedSlippage;
event Staked(address indexed user, uint256 amount);
event Unstaked(address indexed user, uint256 pbtcAmount, uint256 ethAmount);
event AllowedSlippageChanged(uint256 slippage);
/**
* @param _uniV2 UniV2Pair address
* @param _modifiedUnipool ModifiedUnipool address
*/
constructor(address _uniV2, address _modifiedUnipool) public {
require(<FILL_ME>)
uniV2 = IUniswapV2Pair(_uniV2);
modifiedUnipool = ModifiedUnipool(_modifiedUnipool);
pbtc = IERC20(uniV2.token0());
weth = IWETH(uniV2.token1());
}
/**
* @notice function used to handle the ethers sent
* during the witdraw within the unstake function
*/
function() external payable {
}
/**
* @param _allowedSlippage new max allowed in percentage
*/
function setAllowedSlippage(uint256 _allowedSlippage) external onlyOwner {
}
/**
* @notice _stakeFor wrapper
*/
function stake() public payable returns (bool) {
}
/**
* @notice Burn all user's UniV2 staked in the ModifiedUnipool,
* unwrap the corresponding amount of WETH into ETH, collect
* rewards matured from the UniV2 staking and sent it to msg.sender.
* User must approve this contract to withdraw the corresponding
* amount of his UniV2 balance in behalf of him.
*/
function unstake() public returns (bool) {
}
/**
* @notice Wrap the Ethereum sent into WETH, swap the amount sent / 2
* into WETH and put them into a pBTC/WETH Uniswap pool.
* The amount of UniV2 token will be sent to ModifiedUnipool
* in order to mature rewards.
* @param _user address of the user who will have UniV2 tokens in ModifiedUnipool
* @param _amount amount of weth to use to perform this operation
*/
function _stakeFor(address _user, uint256 _amount) internal {
}
}
| Address.isContract(_uniV2),"RewardedPbtcWethUniV2Pair: _uniV2 not a contract" | 386,216 | Address.isContract(_uniV2) |
"RewardedPbtcWethUniV2Pair: amount not approved" | pragma solidity ^0.5.0;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/ownership/Ownable.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "../lib/UniswapV2Library.sol";
import "../ModifiedUnipool.sol";
import "../interfaces/IWETH.sol";
contract RewardedPbtcWethUniV2Pair is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public pbtc;
IWETH public weth;
IUniswapV2Pair public uniV2;
ModifiedUnipool public modifiedUnipool;
uint256 public allowedSlippage;
event Staked(address indexed user, uint256 amount);
event Unstaked(address indexed user, uint256 pbtcAmount, uint256 ethAmount);
event AllowedSlippageChanged(uint256 slippage);
/**
* @param _uniV2 UniV2Pair address
* @param _modifiedUnipool ModifiedUnipool address
*/
constructor(address _uniV2, address _modifiedUnipool) public {
}
/**
* @notice function used to handle the ethers sent
* during the witdraw within the unstake function
*/
function() external payable {
}
/**
* @param _allowedSlippage new max allowed in percentage
*/
function setAllowedSlippage(uint256 _allowedSlippage) external onlyOwner {
}
/**
* @notice _stakeFor wrapper
*/
function stake() public payable returns (bool) {
}
/**
* @notice Burn all user's UniV2 staked in the ModifiedUnipool,
* unwrap the corresponding amount of WETH into ETH, collect
* rewards matured from the UniV2 staking and sent it to msg.sender.
* User must approve this contract to withdraw the corresponding
* amount of his UniV2 balance in behalf of him.
*/
function unstake() public returns (bool) {
uint256 uniV2SenderBalance = modifiedUnipool.balanceOf(msg.sender);
require(<FILL_ME>)
modifiedUnipool.withdrawFrom(msg.sender, uniV2SenderBalance);
modifiedUnipool.getReward(msg.sender);
uniV2.transfer(address(uniV2), uniV2SenderBalance);
(uint256 pbtcAmount, uint256 wethAmount) = uniV2.burn(address(this));
weth.withdraw(wethAmount);
address(msg.sender).transfer(wethAmount);
pbtc.transfer(msg.sender, pbtcAmount);
emit Unstaked(msg.sender, pbtcAmount, wethAmount);
return true;
}
/**
* @notice Wrap the Ethereum sent into WETH, swap the amount sent / 2
* into WETH and put them into a pBTC/WETH Uniswap pool.
* The amount of UniV2 token will be sent to ModifiedUnipool
* in order to mature rewards.
* @param _user address of the user who will have UniV2 tokens in ModifiedUnipool
* @param _amount amount of weth to use to perform this operation
*/
function _stakeFor(address _user, uint256 _amount) internal {
}
}
| modifiedUnipool.allowance(msg.sender,address(this))>=uniV2SenderBalance,"RewardedPbtcWethUniV2Pair: amount not approved" | 386,216 | modifiedUnipool.allowance(msg.sender,address(this))>=uniV2SenderBalance |
"already a guranteed contributor, cannot more than once" | // 100000000000000000, "membership in Casa Crypto", 1546300799, "0x8855Ef4b740Fc23D822dC8e1cb44782e52c07e87", 20, 5, 5000000000000000000
// 100000000000000000, "Ethereum coding workshop 24th August 2018", 1538351999, "0x09b25F7627A8d509E5FaC01cB7692fdBc26A2663", 12, 3, 5000000000000000000
// For instance: effering limited "Early Bird" tickets that are guaranteed
contract AuctionMultipleGuaranteed is AuctionMultiple {
uint public howManyGuaranteed; // after guaranteed slots are used, we decrease the number of slots available (in the parent contract)
uint public priceGuaranteed;
address[] public guaranteedContributors; // cannot iterate mapping, keeping addresses in an array
mapping (address => uint) public guaranteedContributions;
function getGuaranteedContributorsLenght() public constant returns(uint) { } // lenght is not accessible from DApp, exposing convenience method: https://stackoverflow.com/questions/43016011/getting-the-length-of-public-array-variable-getter
event GuaranteedBid(address indexed bidder, uint value, uint timestamp);
constructor(uint _price, string _description, uint _timestampEnd, address _beneficiary, uint _howMany, uint _howManyGuaranteed, uint _priceGuaranteed) AuctionMultiple(_price, _description, _timestampEnd, _beneficiary, _howMany) public {
}
function bid() public payable {
require(now < timestampEnd, "cannot bid after the auction ends");
require(<FILL_ME>)
uint myBidId = contributors[msg.sender];
if (myBidId > 0) {
uint newTotalValue = bids[myBidId].value + msg.value;
if (newTotalValue >= priceGuaranteed && howManyGuaranteed > 0) {
_removeBid(myBidId);
_guarantedBid(newTotalValue);
} else {
super.bid(); // regular bid (sum is smaller than guranteed or guranteed already used)
}
} else if (msg.value >= priceGuaranteed && howManyGuaranteed > 0) {
_guarantedBid(msg.value);
} else {
super.bid(); // regular bid (completely new one)
}
}
function _guarantedBid(uint value) private {
}
function finalize() public ended() onlyOwner() {
}
}
| guaranteedContributions[msg.sender]==0,"already a guranteed contributor, cannot more than once" | 386,325 | guaranteedContributions[msg.sender]==0 |
"InvalidETHAmount" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract WantedPunks is Ownable, ERC721Enumerable {
using Strings for uint256;
event TokenURISet(string indexed tokenUri);
event TokenURILocked(string indexed tokenUri);
event CollectionRevealed();
event PresaleClosed();
event MultisigProposed(address multisig);
event MultisigUpdated(address multisig);
event Pause();
event Resume();
uint256 public constant PRE_PRICE = 39000000000000000;
uint256 public constant PRICE = 60000000000000000;
uint256 public constant MAX_WP_SUPPLY = 950;
uint256 public constant PRESALE_SUPPLY = 200;
uint256 public constant WP_PACK_LIMIT = 5;
uint256 private constant SPECIAL_RESERVE = 50;
uint256 private constant SPLIT = 40;
address private constant DEV_WALLET =
0xebA9F4d9D11A3bD96C5dE4bcE02da592a2676473;
string private constant PLACEHOLDER_SUFFIX = "placeholder.json";
string private constant METADATA_INFIX = "/metadata/";
string public constant provenance =
"7488c72e8faa6dbfaa4188434b1d50dd9602843031cc9bbbf402052088dbdc65";
// current metadata base prefix
string private _baseTokenUri;
uint256 private tipAccumulator;
uint256 private earningsAccumulator;
uint256 private specialReserveCounter;
address public multisig;
address private proposedMultisig;
bool public tokenURILocked;
bool public collectionRevealed;
bool public presaleOn;
bool public saleOn;
bool public paused;
constructor(address multisig_) ERC721("WP", "Wanted Punks") {
}
function finalizePresale() public onlyOwner {
}
function setTokenURI(string memory newUri)
public
onlyOwner
whenUriNotLocked
{
}
function lockTokenURI() public onlyOwner {
}
function presaleMint(uint256 punks) public payable {
_enforceNotPaused();
_enforcePresale();
uint256 ts = totalSupply();
uint256 sl = MAX_WP_SUPPLY;
require(punks > 0, "ZeroWantedPunksRequested");
// TODO: uncomment after testing
// if (punks > WP_PACK_LIMIT) revert BuyLimitExceeded(WP_PACK_LIMIT);
require(<FILL_ME>)
require(ts + punks <= sl, "MintingExceedsMaxSupply");
for (uint256 i = 0; i < punks; i++) {
_safeMint(msg.sender, ts + i);
}
uint256 tip = (msg.value * SPLIT) / 100;
tipAccumulator += tip;
earningsAccumulator += (msg.value - tip);
if (totalSupply() == sl) {
_finalizePresale();
}
}
/// @dev mint up to `punks` tokens
function mint(uint256 punks) public payable {
}
function memorialize(uint256 punks) public onlyOwner {
}
function tipdraw(uint256 amount) public onlyDev {
}
function withdraw(uint256 amount) public onlyOwner {
}
/**
* @dev Returns placeholder for a minted token prior to reveal time,
* the regular tokenURI otherise.
*
* @param tokenId Identity of an existing (minted) WP NFT.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory result)
{
}
function earnings() public view returns (uint256 bal) {
}
function reveal() public onlyOwner {
}
function proposeMultisigUpdate(address proposal) public onlyDev {
}
function approveMultisigUpdate(address confirmation) public onlyOwner {
}
function toggle() public onlyOwner {
}
//
// BASEMENT
//
function _pause() internal {
}
function _enforceNotPaused() internal view {
}
modifier onlyDev() {
}
modifier whenUriNotLocked() {
}
function _enforcePresale() internal view {
}
function _enforceSale() internal view {
}
function placeholderURI() internal view returns (string memory) {
}
function regularURI(uint256 tokenId) internal view returns (string memory) {
}
function _reveal() internal {
}
function _finalizePresale() internal {
}
}
| PRE_PRICE*punks==msg.value,"InvalidETHAmount" | 386,456 | PRE_PRICE*punks==msg.value |
"MintingExceedsMaxSupply" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract WantedPunks is Ownable, ERC721Enumerable {
using Strings for uint256;
event TokenURISet(string indexed tokenUri);
event TokenURILocked(string indexed tokenUri);
event CollectionRevealed();
event PresaleClosed();
event MultisigProposed(address multisig);
event MultisigUpdated(address multisig);
event Pause();
event Resume();
uint256 public constant PRE_PRICE = 39000000000000000;
uint256 public constant PRICE = 60000000000000000;
uint256 public constant MAX_WP_SUPPLY = 950;
uint256 public constant PRESALE_SUPPLY = 200;
uint256 public constant WP_PACK_LIMIT = 5;
uint256 private constant SPECIAL_RESERVE = 50;
uint256 private constant SPLIT = 40;
address private constant DEV_WALLET =
0xebA9F4d9D11A3bD96C5dE4bcE02da592a2676473;
string private constant PLACEHOLDER_SUFFIX = "placeholder.json";
string private constant METADATA_INFIX = "/metadata/";
string public constant provenance =
"7488c72e8faa6dbfaa4188434b1d50dd9602843031cc9bbbf402052088dbdc65";
// current metadata base prefix
string private _baseTokenUri;
uint256 private tipAccumulator;
uint256 private earningsAccumulator;
uint256 private specialReserveCounter;
address public multisig;
address private proposedMultisig;
bool public tokenURILocked;
bool public collectionRevealed;
bool public presaleOn;
bool public saleOn;
bool public paused;
constructor(address multisig_) ERC721("WP", "Wanted Punks") {
}
function finalizePresale() public onlyOwner {
}
function setTokenURI(string memory newUri)
public
onlyOwner
whenUriNotLocked
{
}
function lockTokenURI() public onlyOwner {
}
function presaleMint(uint256 punks) public payable {
_enforceNotPaused();
_enforcePresale();
uint256 ts = totalSupply();
uint256 sl = MAX_WP_SUPPLY;
require(punks > 0, "ZeroWantedPunksRequested");
// TODO: uncomment after testing
// if (punks > WP_PACK_LIMIT) revert BuyLimitExceeded(WP_PACK_LIMIT);
require(PRE_PRICE * punks == msg.value, "InvalidETHAmount");
require(<FILL_ME>)
for (uint256 i = 0; i < punks; i++) {
_safeMint(msg.sender, ts + i);
}
uint256 tip = (msg.value * SPLIT) / 100;
tipAccumulator += tip;
earningsAccumulator += (msg.value - tip);
if (totalSupply() == sl) {
_finalizePresale();
}
}
/// @dev mint up to `punks` tokens
function mint(uint256 punks) public payable {
}
function memorialize(uint256 punks) public onlyOwner {
}
function tipdraw(uint256 amount) public onlyDev {
}
function withdraw(uint256 amount) public onlyOwner {
}
/**
* @dev Returns placeholder for a minted token prior to reveal time,
* the regular tokenURI otherise.
*
* @param tokenId Identity of an existing (minted) WP NFT.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory result)
{
}
function earnings() public view returns (uint256 bal) {
}
function reveal() public onlyOwner {
}
function proposeMultisigUpdate(address proposal) public onlyDev {
}
function approveMultisigUpdate(address confirmation) public onlyOwner {
}
function toggle() public onlyOwner {
}
//
// BASEMENT
//
function _pause() internal {
}
function _enforceNotPaused() internal view {
}
modifier onlyDev() {
}
modifier whenUriNotLocked() {
}
function _enforcePresale() internal view {
}
function _enforceSale() internal view {
}
function placeholderURI() internal view returns (string memory) {
}
function regularURI(uint256 tokenId) internal view returns (string memory) {
}
function _reveal() internal {
}
function _finalizePresale() internal {
}
}
| ts+punks<=sl,"MintingExceedsMaxSupply" | 386,456 | ts+punks<=sl |
"InvalidETHAmount" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract WantedPunks is Ownable, ERC721Enumerable {
using Strings for uint256;
event TokenURISet(string indexed tokenUri);
event TokenURILocked(string indexed tokenUri);
event CollectionRevealed();
event PresaleClosed();
event MultisigProposed(address multisig);
event MultisigUpdated(address multisig);
event Pause();
event Resume();
uint256 public constant PRE_PRICE = 39000000000000000;
uint256 public constant PRICE = 60000000000000000;
uint256 public constant MAX_WP_SUPPLY = 950;
uint256 public constant PRESALE_SUPPLY = 200;
uint256 public constant WP_PACK_LIMIT = 5;
uint256 private constant SPECIAL_RESERVE = 50;
uint256 private constant SPLIT = 40;
address private constant DEV_WALLET =
0xebA9F4d9D11A3bD96C5dE4bcE02da592a2676473;
string private constant PLACEHOLDER_SUFFIX = "placeholder.json";
string private constant METADATA_INFIX = "/metadata/";
string public constant provenance =
"7488c72e8faa6dbfaa4188434b1d50dd9602843031cc9bbbf402052088dbdc65";
// current metadata base prefix
string private _baseTokenUri;
uint256 private tipAccumulator;
uint256 private earningsAccumulator;
uint256 private specialReserveCounter;
address public multisig;
address private proposedMultisig;
bool public tokenURILocked;
bool public collectionRevealed;
bool public presaleOn;
bool public saleOn;
bool public paused;
constructor(address multisig_) ERC721("WP", "Wanted Punks") {
}
function finalizePresale() public onlyOwner {
}
function setTokenURI(string memory newUri)
public
onlyOwner
whenUriNotLocked
{
}
function lockTokenURI() public onlyOwner {
}
function presaleMint(uint256 punks) public payable {
}
/// @dev mint up to `punks` tokens
function mint(uint256 punks) public payable {
_enforceNotPaused();
_enforceSale();
uint256 ts = totalSupply();
uint256 sl = MAX_WP_SUPPLY;
require(ts < MAX_WP_SUPPLY, "WantedPunksSoldOut");
require(punks > 0, "ZeroWantedPunksRequested");
require(punks <= WP_PACK_LIMIT, "BuyLimitExceeded");
require(<FILL_ME>)
require(ts + punks <= sl, "MintingExceedsMaxSupply");
for (uint256 i = 0; i < punks; i++) {
_safeMint(msg.sender, ts + i);
}
uint256 tip = (msg.value * SPLIT) / 100;
tipAccumulator += tip;
earningsAccumulator += (msg.value - tip);
if (totalSupply() == sl) {
_reveal();
}
}
function memorialize(uint256 punks) public onlyOwner {
}
function tipdraw(uint256 amount) public onlyDev {
}
function withdraw(uint256 amount) public onlyOwner {
}
/**
* @dev Returns placeholder for a minted token prior to reveal time,
* the regular tokenURI otherise.
*
* @param tokenId Identity of an existing (minted) WP NFT.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory result)
{
}
function earnings() public view returns (uint256 bal) {
}
function reveal() public onlyOwner {
}
function proposeMultisigUpdate(address proposal) public onlyDev {
}
function approveMultisigUpdate(address confirmation) public onlyOwner {
}
function toggle() public onlyOwner {
}
//
// BASEMENT
//
function _pause() internal {
}
function _enforceNotPaused() internal view {
}
modifier onlyDev() {
}
modifier whenUriNotLocked() {
}
function _enforcePresale() internal view {
}
function _enforceSale() internal view {
}
function placeholderURI() internal view returns (string memory) {
}
function regularURI(uint256 tokenId) internal view returns (string memory) {
}
function _reveal() internal {
}
function _finalizePresale() internal {
}
}
| PRICE*punks==msg.value,"InvalidETHAmount" | 386,456 | PRICE*punks==msg.value |
"MintingExceedsSpecialReserve" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract WantedPunks is Ownable, ERC721Enumerable {
using Strings for uint256;
event TokenURISet(string indexed tokenUri);
event TokenURILocked(string indexed tokenUri);
event CollectionRevealed();
event PresaleClosed();
event MultisigProposed(address multisig);
event MultisigUpdated(address multisig);
event Pause();
event Resume();
uint256 public constant PRE_PRICE = 39000000000000000;
uint256 public constant PRICE = 60000000000000000;
uint256 public constant MAX_WP_SUPPLY = 950;
uint256 public constant PRESALE_SUPPLY = 200;
uint256 public constant WP_PACK_LIMIT = 5;
uint256 private constant SPECIAL_RESERVE = 50;
uint256 private constant SPLIT = 40;
address private constant DEV_WALLET =
0xebA9F4d9D11A3bD96C5dE4bcE02da592a2676473;
string private constant PLACEHOLDER_SUFFIX = "placeholder.json";
string private constant METADATA_INFIX = "/metadata/";
string public constant provenance =
"7488c72e8faa6dbfaa4188434b1d50dd9602843031cc9bbbf402052088dbdc65";
// current metadata base prefix
string private _baseTokenUri;
uint256 private tipAccumulator;
uint256 private earningsAccumulator;
uint256 private specialReserveCounter;
address public multisig;
address private proposedMultisig;
bool public tokenURILocked;
bool public collectionRevealed;
bool public presaleOn;
bool public saleOn;
bool public paused;
constructor(address multisig_) ERC721("WP", "Wanted Punks") {
}
function finalizePresale() public onlyOwner {
}
function setTokenURI(string memory newUri)
public
onlyOwner
whenUriNotLocked
{
}
function lockTokenURI() public onlyOwner {
}
function presaleMint(uint256 punks) public payable {
}
/// @dev mint up to `punks` tokens
function mint(uint256 punks) public payable {
}
function memorialize(uint256 punks) public onlyOwner {
require(<FILL_ME>)
require(punks > 0, "ZeroWantedPunksRequested");
for (uint256 i = 0; i < punks; i++) {
_safeMint(multisig, MAX_WP_SUPPLY + specialReserveCounter + i);
}
specialReserveCounter += punks;
}
function tipdraw(uint256 amount) public onlyDev {
}
function withdraw(uint256 amount) public onlyOwner {
}
/**
* @dev Returns placeholder for a minted token prior to reveal time,
* the regular tokenURI otherise.
*
* @param tokenId Identity of an existing (minted) WP NFT.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory result)
{
}
function earnings() public view returns (uint256 bal) {
}
function reveal() public onlyOwner {
}
function proposeMultisigUpdate(address proposal) public onlyDev {
}
function approveMultisigUpdate(address confirmation) public onlyOwner {
}
function toggle() public onlyOwner {
}
//
// BASEMENT
//
function _pause() internal {
}
function _enforceNotPaused() internal view {
}
modifier onlyDev() {
}
modifier whenUriNotLocked() {
}
function _enforcePresale() internal view {
}
function _enforceSale() internal view {
}
function placeholderURI() internal view returns (string memory) {
}
function regularURI(uint256 tokenId) internal view returns (string memory) {
}
function _reveal() internal {
}
function _finalizePresale() internal {
}
}
| specialReserveCounter+punks<=SPECIAL_RESERVE,"MintingExceedsSpecialReserve" | 386,456 | specialReserveCounter+punks<=SPECIAL_RESERVE |
"StrangerDetected" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract WantedPunks is Ownable, ERC721Enumerable {
using Strings for uint256;
event TokenURISet(string indexed tokenUri);
event TokenURILocked(string indexed tokenUri);
event CollectionRevealed();
event PresaleClosed();
event MultisigProposed(address multisig);
event MultisigUpdated(address multisig);
event Pause();
event Resume();
uint256 public constant PRE_PRICE = 39000000000000000;
uint256 public constant PRICE = 60000000000000000;
uint256 public constant MAX_WP_SUPPLY = 950;
uint256 public constant PRESALE_SUPPLY = 200;
uint256 public constant WP_PACK_LIMIT = 5;
uint256 private constant SPECIAL_RESERVE = 50;
uint256 private constant SPLIT = 40;
address private constant DEV_WALLET =
0xebA9F4d9D11A3bD96C5dE4bcE02da592a2676473;
string private constant PLACEHOLDER_SUFFIX = "placeholder.json";
string private constant METADATA_INFIX = "/metadata/";
string public constant provenance =
"7488c72e8faa6dbfaa4188434b1d50dd9602843031cc9bbbf402052088dbdc65";
// current metadata base prefix
string private _baseTokenUri;
uint256 private tipAccumulator;
uint256 private earningsAccumulator;
uint256 private specialReserveCounter;
address public multisig;
address private proposedMultisig;
bool public tokenURILocked;
bool public collectionRevealed;
bool public presaleOn;
bool public saleOn;
bool public paused;
constructor(address multisig_) ERC721("WP", "Wanted Punks") {
}
function finalizePresale() public onlyOwner {
}
function setTokenURI(string memory newUri)
public
onlyOwner
whenUriNotLocked
{
}
function lockTokenURI() public onlyOwner {
}
function presaleMint(uint256 punks) public payable {
}
/// @dev mint up to `punks` tokens
function mint(uint256 punks) public payable {
}
function memorialize(uint256 punks) public onlyOwner {
}
function tipdraw(uint256 amount) public onlyDev {
}
function withdraw(uint256 amount) public onlyOwner {
}
/**
* @dev Returns placeholder for a minted token prior to reveal time,
* the regular tokenURI otherise.
*
* @param tokenId Identity of an existing (minted) WP NFT.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory result)
{
}
function earnings() public view returns (uint256 bal) {
require(<FILL_ME>)
bal = (msg.sender == DEV_WALLET) ? tipAccumulator : earningsAccumulator;
}
function reveal() public onlyOwner {
}
function proposeMultisigUpdate(address proposal) public onlyDev {
}
function approveMultisigUpdate(address confirmation) public onlyOwner {
}
function toggle() public onlyOwner {
}
//
// BASEMENT
//
function _pause() internal {
}
function _enforceNotPaused() internal view {
}
modifier onlyDev() {
}
modifier whenUriNotLocked() {
}
function _enforcePresale() internal view {
}
function _enforceSale() internal view {
}
function placeholderURI() internal view returns (string memory) {
}
function regularURI(uint256 tokenId) internal view returns (string memory) {
}
function _reveal() internal {
}
function _finalizePresale() internal {
}
}
| (msg.sender==owner())||(msg.sender==DEV_WALLET),"StrangerDetected" | 386,456 | (msg.sender==owner())||(msg.sender==DEV_WALLET) |
"TokenURILockedErr" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract WantedPunks is Ownable, ERC721Enumerable {
using Strings for uint256;
event TokenURISet(string indexed tokenUri);
event TokenURILocked(string indexed tokenUri);
event CollectionRevealed();
event PresaleClosed();
event MultisigProposed(address multisig);
event MultisigUpdated(address multisig);
event Pause();
event Resume();
uint256 public constant PRE_PRICE = 39000000000000000;
uint256 public constant PRICE = 60000000000000000;
uint256 public constant MAX_WP_SUPPLY = 950;
uint256 public constant PRESALE_SUPPLY = 200;
uint256 public constant WP_PACK_LIMIT = 5;
uint256 private constant SPECIAL_RESERVE = 50;
uint256 private constant SPLIT = 40;
address private constant DEV_WALLET =
0xebA9F4d9D11A3bD96C5dE4bcE02da592a2676473;
string private constant PLACEHOLDER_SUFFIX = "placeholder.json";
string private constant METADATA_INFIX = "/metadata/";
string public constant provenance =
"7488c72e8faa6dbfaa4188434b1d50dd9602843031cc9bbbf402052088dbdc65";
// current metadata base prefix
string private _baseTokenUri;
uint256 private tipAccumulator;
uint256 private earningsAccumulator;
uint256 private specialReserveCounter;
address public multisig;
address private proposedMultisig;
bool public tokenURILocked;
bool public collectionRevealed;
bool public presaleOn;
bool public saleOn;
bool public paused;
constructor(address multisig_) ERC721("WP", "Wanted Punks") {
}
function finalizePresale() public onlyOwner {
}
function setTokenURI(string memory newUri)
public
onlyOwner
whenUriNotLocked
{
}
function lockTokenURI() public onlyOwner {
}
function presaleMint(uint256 punks) public payable {
}
/// @dev mint up to `punks` tokens
function mint(uint256 punks) public payable {
}
function memorialize(uint256 punks) public onlyOwner {
}
function tipdraw(uint256 amount) public onlyDev {
}
function withdraw(uint256 amount) public onlyOwner {
}
/**
* @dev Returns placeholder for a minted token prior to reveal time,
* the regular tokenURI otherise.
*
* @param tokenId Identity of an existing (minted) WP NFT.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory result)
{
}
function earnings() public view returns (uint256 bal) {
}
function reveal() public onlyOwner {
}
function proposeMultisigUpdate(address proposal) public onlyDev {
}
function approveMultisigUpdate(address confirmation) public onlyOwner {
}
function toggle() public onlyOwner {
}
//
// BASEMENT
//
function _pause() internal {
}
function _enforceNotPaused() internal view {
}
modifier onlyDev() {
}
modifier whenUriNotLocked() {
require(<FILL_ME>)
_;
}
function _enforcePresale() internal view {
}
function _enforceSale() internal view {
}
function placeholderURI() internal view returns (string memory) {
}
function regularURI(uint256 tokenId) internal view returns (string memory) {
}
function _reveal() internal {
}
function _finalizePresale() internal {
}
}
| !tokenURILocked,"TokenURILockedErr" | 386,456 | !tokenURILocked |
null | pragma solidity ^0.4.25;
/**
Multiplier ETHMOON_V2: returns 125%-150% of each investment!
Fully transparent smartcontract with automatic payments proven professionals.
An additional level of protection against fraud - you can make only two deposits, until you get 125%-150%.
1. Send any sum to smart contract address
- sum from 0.01 to 5 ETH
- min 250000 gas limit
- you are added to a queue
- only two deposit until you got 125%-150%
2. Wait a little bit
3. ...
4. PROFIT! You have got 125%-150%
How is that?
1. The first investor in the queue (you will become the
first in some time) receives next investments until
it become 125%-150% of his initial investment.
2. You will receive payments in several parts or all at once
3. Once you receive 125%-150% of your initial investment you are
removed from the queue.
4. You can make more than one deposits at once
5. The balance of this contract should normally be 0 because
all the money are immediately go to payouts
So the last pays to the first (or to several first ones if the deposit big enough)
and the investors paid 125%-150% are removed from the queue
new investor --| brand new investor --|
investor5 | new investor |
investor4 | =======> investor5 |
investor3 | investor4 |
(part. paid) investor2 <| investor3 |
(fully paid) investor1 <-| investor2 <----| (pay until 125%-150%)
Контракт ETHMOON_V2: возвращает 125%-150% от вашего депозита!
Полностью прозрачный смартконтракт с автоматическими выплатами, проверенный профессионалами.
Дополнительный уровень защиты от обмана - вы сможете внести только два депозита, пока вы не получите 125%-150%.
1. Пошлите любую ненулевую сумму на адрес контракта
- сумма от 0.01 до 5 ETH
- gas limit минимум 250000
- вы встанете в очередь
- только два депозита, пока не получите 125%-150%
2. Немного подождите
3. ...
4. PROFIT! Вам пришло 125%-150% от вашего депозита.
Как это возможно?
1. Первый инвестор в очереди (вы станете первым очень скоро) получает выплаты от
новых инвесторов до тех пор, пока не получит 125%-150% от своего депозита
2. Выплаты могут приходить несколькими частями или все сразу
3. Как только вы получаете 125%-150% от вашего депозита, вы удаляетесь из очереди
4. Вы можете делать несколько депозитов сразу
5. Баланс этого контракта должен обычно быть в районе 0, потому что все поступления
сразу же направляются на выплаты
Таким образом, последние платят первым, и инвесторы, достигшие выплат 125%-150% от
депозита, удаляются из очереди, уступая место остальным
новый инвестор --| совсем новый инвестор --|
инвестор5 | новый инвестор |
инвестор4 | =======> инвестор5 |
инвестор3 | инвестор4 |
(част. выплата) инвестор2 <| инвестор3 |
(полная выплата) инвестор1 <-| инвестор2 <----| (доплата до 125%-150%)
*/
contract EthmoonV2 {
// address for promo expences
address constant private PROMO = 0xa4Db4f62314Db6539B60F0e1CBE2377b918953Bd;
address constant private TECH = 0x093D552Bde4D55D2e32dedA3a04D3B2ceA2B5595;
// percent for promo/tech expences
uint constant public PROMO_PERCENT = 6;
uint constant public TECH_PERCENT = 2;
// how many percent for your deposit to be multiplied
uint constant public START_MULTIPLIER = 125;
// deposit limits
uint constant public MIN_DEPOSIT = .01 ether;
uint constant public MAX_DEPOSIT = 5 ether;
// count participation
mapping(address => uint) public participation;
// the deposit structure holds all the info about the deposit made
struct Deposit {
address depositor; // the depositor address
uint128 deposit; // the deposit amount
uint128 expect; // how much we should pay out (initially it is 125%-150% of deposit)
}
Deposit[] private queue; // the queue
uint public currentReceiverIndex = 0; // the index of the first depositor in the queue. The receiver of investments!
// this function receives all the deposits
// stores them and make immediate payouts
function () public payable {
require(gasleft() >= 220000, "We require more gas!"); // we need gas to process queue
require(<FILL_ME>) // do not allow too big investments to stabilize payouts
uint multiplier = percentRate(msg.sender);
// add the investor into the queue. Mark that he expects to receive 125%-150% of deposit back
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value * multiplier/100)));
participation[msg.sender] = participation[msg.sender] + 1;
// send some promo to enable this contract to leave long-long time
uint promo = msg.value * PROMO_PERCENT/100;
PROMO.transfer(promo);
uint tech = msg.value * TECH_PERCENT/100;
TECH.transfer(tech);
// pay to first investors in line
pay();
}
// used to pay to current investors
// each new transaction processes 1 - 4+ investors in the head of queue
// depending on balance and gas left
function pay() private {
}
// get the deposit info by its index
// you can get deposit index from
function getDeposit(uint idx) public view returns (address depositor, uint deposit, uint expect){
}
// get the count of deposits of specific investor
function getDepositsCount(address depositor) public view returns (uint) {
}
// get all deposits (index, deposit, expect) of a specific investor
function getDeposits(address depositor) public view returns (uint[] idxs, uint128[] deposits, uint128[] expects) {
}
// get current queue size
function getQueueLength() public view returns (uint) {
}
// get persent rate
function percentRate(address depositor) public view returns(uint) {
}
}
| (msg.value>=MIN_DEPOSIT)&&(msg.value<=MAX_DEPOSIT) | 386,463 | (msg.value>=MIN_DEPOSIT)&&(msg.value<=MAX_DEPOSIT) |
null | pragma solidity ^0.4.24;
contract DACCToken {
string public name = "Decentralized Accessible Content Chain";
string public symbol = "DACC";
uint256 public decimals = 6;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
uint256 public totalSupply = 30000000000000000;
bool public stopped = false;
address owner = 0x1e113613C889C76b792AdfdcbBd155904F3310a5;
modifier isOwner {
}
modifier isRunning {
}
modifier isValidAddress {
}
constructor() public {
}
function transfer(address _to, uint256 _value) isRunning isValidAddress public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) isRunning isValidAddress public returns (bool success) {
}
function approve(address _spender, uint256 _value) isRunning isValidAddress public returns (bool success) {
}
function stop() isOwner public {
}
function start() isOwner public {
}
function setName(string _name) isOwner public {
}
function airdrop(address[] _DACusers,uint256[] _values) isRunning public {
require(_DACusers.length > 0);
require(_DACusers.length == _values.length);
uint256 amount = 0;
uint i = 0;
for (i = 0; i < _DACusers.length; i++) {
require(<FILL_ME>)
amount += _values[i];
}
require(balanceOf[msg.sender] >= amount);
balanceOf[msg.sender] -= amount;
for (i = 0; i < _DACusers.length; i++) {
require(balanceOf[_DACusers[i]] + _values[i] >= balanceOf[_DACusers[i]]);
balanceOf[_DACusers[i]] += _values[i];
emit Transfer(msg.sender, _DACusers[i], _values[i]);
}
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
| amount+_values[i]>=amount | 386,544 | amount+_values[i]>=amount |
null | pragma solidity ^0.4.24;
contract DACCToken {
string public name = "Decentralized Accessible Content Chain";
string public symbol = "DACC";
uint256 public decimals = 6;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
uint256 public totalSupply = 30000000000000000;
bool public stopped = false;
address owner = 0x1e113613C889C76b792AdfdcbBd155904F3310a5;
modifier isOwner {
}
modifier isRunning {
}
modifier isValidAddress {
}
constructor() public {
}
function transfer(address _to, uint256 _value) isRunning isValidAddress public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) isRunning isValidAddress public returns (bool success) {
}
function approve(address _spender, uint256 _value) isRunning isValidAddress public returns (bool success) {
}
function stop() isOwner public {
}
function start() isOwner public {
}
function setName(string _name) isOwner public {
}
function airdrop(address[] _DACusers,uint256[] _values) isRunning public {
require(_DACusers.length > 0);
require(_DACusers.length == _values.length);
uint256 amount = 0;
uint i = 0;
for (i = 0; i < _DACusers.length; i++) {
require(amount + _values[i] >= amount);
amount += _values[i];
}
require(balanceOf[msg.sender] >= amount);
balanceOf[msg.sender] -= amount;
for (i = 0; i < _DACusers.length; i++) {
require(<FILL_ME>)
balanceOf[_DACusers[i]] += _values[i];
emit Transfer(msg.sender, _DACusers[i], _values[i]);
}
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
| balanceOf[_DACusers[i]]+_values[i]>=balanceOf[_DACusers[i]] | 386,544 | balanceOf[_DACusers[i]]+_values[i]>=balanceOf[_DACusers[i]] |
"Whitelist is sold out" | pragma solidity ^0.8.2;
contract WeedApes is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using SafeMath for uint256;
using ECDSA for bytes32;
using Strings for uint256;
Counters.Counter private tokenSupply;
Counters.Counter private influncerGiveawaySupply;
string public WEED_APE_PROVENANCE = "";
uint256 public constant MAX_SUPPLY = 5000;
uint256 public constant MAX_SUPPLY_WHITELIST = 500;
uint256 public constant MAX_GIVEAWAY_INFLUENCER = 100;
uint256 public constant WHITELIST_MINT_CAP = 10;
uint256 public constant MAX_WEED_APE_PER_PURCHASE = 10;
uint256 public constant WALLET_CAP = 50;
uint256 private WEED_APE_PRICE = 0.04 ether;
string public tokenBaseURI;
string public unrevealedURI;
bool public presaleActive = false;
bool public mintActive = false;
address private constant twoStageAuthenticatorOne = 0x44F510EF8e46FE092f2CA8aD403a7446dBB0Ce88;
address private constant twoStageAuthenticatorTwo = 0x91Ed3bCcF88763d38EC2F72B0a713FDE88b53Ae1;
bool private twoStage = false;
mapping(address => uint256) private whitelistAddressMintCount;
mapping(address => bool) private influncerGiveaways;
constructor() ERC721("Weed Ape Blunt Club", "WAPES")
{
}
/**************
* Flip States *
**************/
function flipPresaleState() external onlyOwner
{
}
function enablePublicSale() external onlyOwner
{
}
function enactTwoStage() external
{
}
/********************
* Setter functions *
********************/
function setProvenanceHash(string memory provenanceHash) external onlyOwner
{
}
function setTokenBaseURI(string memory _baseURI) external onlyOwner
{
}
function setUnrevealedURI(string memory _unrevealedUri) external onlyOwner
{
}
function tokenURI(uint256 _tokenId) override public view returns (string memory)
{
}
function addInfluencerGiveaway(address _address) external onlyOwner
{
}
function getTokenSupply() public view returns (uint256)
{
}
/********
* Mint *
********/
// Whitelist mint function
function presaleMint(uint256 _quantity) external payable nonReentrant
{
require(presaleActive, "Presale is not active");
require(<FILL_ME>)
require(_quantity <= WHITELIST_MINT_CAP, "Exceeds whitelist mint cap");
_safeMintWeedApes(_quantity);
}
// Public mint function
function publicMint(uint256 _quantity) external payable
{
}
function influncerGiveawayMint() external
{
}
function _safeMintWeedApes(uint256 _quantity) internal
{
}
/***************
* Withdrawals *
***************/
// Withdraws entire balance of contract (ETH) to owner account (owner-only)
function withdraw() public onlyOwner
{
}
// Withdraws amount specified (ETH) from balance of contract to owner account (owner-only)
function withdrawPartial(uint256 _amount)
public
onlyOwner
{
}
/************
* Security *
************/
function verifyOwnerSignature(bytes32 hash, bytes memory signature) private view returns(bool)
{
}
}
| tokenSupply.current().add(_quantity)<=MAX_SUPPLY_WHITELIST,"Whitelist is sold out" | 386,565 | tokenSupply.current().add(_quantity)<=MAX_SUPPLY_WHITELIST |
"You are not allowed to use this function" | pragma solidity ^0.8.2;
contract WeedApes is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using SafeMath for uint256;
using ECDSA for bytes32;
using Strings for uint256;
Counters.Counter private tokenSupply;
Counters.Counter private influncerGiveawaySupply;
string public WEED_APE_PROVENANCE = "";
uint256 public constant MAX_SUPPLY = 5000;
uint256 public constant MAX_SUPPLY_WHITELIST = 500;
uint256 public constant MAX_GIVEAWAY_INFLUENCER = 100;
uint256 public constant WHITELIST_MINT_CAP = 10;
uint256 public constant MAX_WEED_APE_PER_PURCHASE = 10;
uint256 public constant WALLET_CAP = 50;
uint256 private WEED_APE_PRICE = 0.04 ether;
string public tokenBaseURI;
string public unrevealedURI;
bool public presaleActive = false;
bool public mintActive = false;
address private constant twoStageAuthenticatorOne = 0x44F510EF8e46FE092f2CA8aD403a7446dBB0Ce88;
address private constant twoStageAuthenticatorTwo = 0x91Ed3bCcF88763d38EC2F72B0a713FDE88b53Ae1;
bool private twoStage = false;
mapping(address => uint256) private whitelistAddressMintCount;
mapping(address => bool) private influncerGiveaways;
constructor() ERC721("Weed Ape Blunt Club", "WAPES")
{
}
/**************
* Flip States *
**************/
function flipPresaleState() external onlyOwner
{
}
function enablePublicSale() external onlyOwner
{
}
function enactTwoStage() external
{
}
/********************
* Setter functions *
********************/
function setProvenanceHash(string memory provenanceHash) external onlyOwner
{
}
function setTokenBaseURI(string memory _baseURI) external onlyOwner
{
}
function setUnrevealedURI(string memory _unrevealedUri) external onlyOwner
{
}
function tokenURI(uint256 _tokenId) override public view returns (string memory)
{
}
function addInfluencerGiveaway(address _address) external onlyOwner
{
}
function getTokenSupply() public view returns (uint256)
{
}
/********
* Mint *
********/
// Whitelist mint function
function presaleMint(uint256 _quantity) external payable nonReentrant
{
}
// Public mint function
function publicMint(uint256 _quantity) external payable
{
}
function influncerGiveawayMint() external
{
require(<FILL_ME>)
require(tokenSupply.current().add(5) <= MAX_SUPPLY, "This purchase would exceed the max supply");
require(influncerGiveawaySupply.current().add(5) <= MAX_GIVEAWAY_INFLUENCER);
for (uint256 i = 0; i < 4; i++)
{
uint256 mintIndex = tokenSupply.current();
if (mintIndex < MAX_SUPPLY)
{
tokenSupply.increment();
influncerGiveawaySupply.increment();
_safeMint(msg.sender, mintIndex);
}
}
influncerGiveaways[msg.sender] = false;
}
function _safeMintWeedApes(uint256 _quantity) internal
{
}
/***************
* Withdrawals *
***************/
// Withdraws entire balance of contract (ETH) to owner account (owner-only)
function withdraw() public onlyOwner
{
}
// Withdraws amount specified (ETH) from balance of contract to owner account (owner-only)
function withdrawPartial(uint256 _amount)
public
onlyOwner
{
}
/************
* Security *
************/
function verifyOwnerSignature(bytes32 hash, bytes memory signature) private view returns(bool)
{
}
}
| influncerGiveaways[msg.sender]==true,"You are not allowed to use this function" | 386,565 | influncerGiveaways[msg.sender]==true |
"This purchase would exceed the max supply" | pragma solidity ^0.8.2;
contract WeedApes is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using SafeMath for uint256;
using ECDSA for bytes32;
using Strings for uint256;
Counters.Counter private tokenSupply;
Counters.Counter private influncerGiveawaySupply;
string public WEED_APE_PROVENANCE = "";
uint256 public constant MAX_SUPPLY = 5000;
uint256 public constant MAX_SUPPLY_WHITELIST = 500;
uint256 public constant MAX_GIVEAWAY_INFLUENCER = 100;
uint256 public constant WHITELIST_MINT_CAP = 10;
uint256 public constant MAX_WEED_APE_PER_PURCHASE = 10;
uint256 public constant WALLET_CAP = 50;
uint256 private WEED_APE_PRICE = 0.04 ether;
string public tokenBaseURI;
string public unrevealedURI;
bool public presaleActive = false;
bool public mintActive = false;
address private constant twoStageAuthenticatorOne = 0x44F510EF8e46FE092f2CA8aD403a7446dBB0Ce88;
address private constant twoStageAuthenticatorTwo = 0x91Ed3bCcF88763d38EC2F72B0a713FDE88b53Ae1;
bool private twoStage = false;
mapping(address => uint256) private whitelistAddressMintCount;
mapping(address => bool) private influncerGiveaways;
constructor() ERC721("Weed Ape Blunt Club", "WAPES")
{
}
/**************
* Flip States *
**************/
function flipPresaleState() external onlyOwner
{
}
function enablePublicSale() external onlyOwner
{
}
function enactTwoStage() external
{
}
/********************
* Setter functions *
********************/
function setProvenanceHash(string memory provenanceHash) external onlyOwner
{
}
function setTokenBaseURI(string memory _baseURI) external onlyOwner
{
}
function setUnrevealedURI(string memory _unrevealedUri) external onlyOwner
{
}
function tokenURI(uint256 _tokenId) override public view returns (string memory)
{
}
function addInfluencerGiveaway(address _address) external onlyOwner
{
}
function getTokenSupply() public view returns (uint256)
{
}
/********
* Mint *
********/
// Whitelist mint function
function presaleMint(uint256 _quantity) external payable nonReentrant
{
}
// Public mint function
function publicMint(uint256 _quantity) external payable
{
}
function influncerGiveawayMint() external
{
require(influncerGiveaways[msg.sender] == true, "You are not allowed to use this function");
require(<FILL_ME>)
require(influncerGiveawaySupply.current().add(5) <= MAX_GIVEAWAY_INFLUENCER);
for (uint256 i = 0; i < 4; i++)
{
uint256 mintIndex = tokenSupply.current();
if (mintIndex < MAX_SUPPLY)
{
tokenSupply.increment();
influncerGiveawaySupply.increment();
_safeMint(msg.sender, mintIndex);
}
}
influncerGiveaways[msg.sender] = false;
}
function _safeMintWeedApes(uint256 _quantity) internal
{
}
/***************
* Withdrawals *
***************/
// Withdraws entire balance of contract (ETH) to owner account (owner-only)
function withdraw() public onlyOwner
{
}
// Withdraws amount specified (ETH) from balance of contract to owner account (owner-only)
function withdrawPartial(uint256 _amount)
public
onlyOwner
{
}
/************
* Security *
************/
function verifyOwnerSignature(bytes32 hash, bytes memory signature) private view returns(bool)
{
}
}
| tokenSupply.current().add(5)<=MAX_SUPPLY,"This purchase would exceed the max supply" | 386,565 | tokenSupply.current().add(5)<=MAX_SUPPLY |
null | pragma solidity ^0.8.2;
contract WeedApes is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using SafeMath for uint256;
using ECDSA for bytes32;
using Strings for uint256;
Counters.Counter private tokenSupply;
Counters.Counter private influncerGiveawaySupply;
string public WEED_APE_PROVENANCE = "";
uint256 public constant MAX_SUPPLY = 5000;
uint256 public constant MAX_SUPPLY_WHITELIST = 500;
uint256 public constant MAX_GIVEAWAY_INFLUENCER = 100;
uint256 public constant WHITELIST_MINT_CAP = 10;
uint256 public constant MAX_WEED_APE_PER_PURCHASE = 10;
uint256 public constant WALLET_CAP = 50;
uint256 private WEED_APE_PRICE = 0.04 ether;
string public tokenBaseURI;
string public unrevealedURI;
bool public presaleActive = false;
bool public mintActive = false;
address private constant twoStageAuthenticatorOne = 0x44F510EF8e46FE092f2CA8aD403a7446dBB0Ce88;
address private constant twoStageAuthenticatorTwo = 0x91Ed3bCcF88763d38EC2F72B0a713FDE88b53Ae1;
bool private twoStage = false;
mapping(address => uint256) private whitelistAddressMintCount;
mapping(address => bool) private influncerGiveaways;
constructor() ERC721("Weed Ape Blunt Club", "WAPES")
{
}
/**************
* Flip States *
**************/
function flipPresaleState() external onlyOwner
{
}
function enablePublicSale() external onlyOwner
{
}
function enactTwoStage() external
{
}
/********************
* Setter functions *
********************/
function setProvenanceHash(string memory provenanceHash) external onlyOwner
{
}
function setTokenBaseURI(string memory _baseURI) external onlyOwner
{
}
function setUnrevealedURI(string memory _unrevealedUri) external onlyOwner
{
}
function tokenURI(uint256 _tokenId) override public view returns (string memory)
{
}
function addInfluencerGiveaway(address _address) external onlyOwner
{
}
function getTokenSupply() public view returns (uint256)
{
}
/********
* Mint *
********/
// Whitelist mint function
function presaleMint(uint256 _quantity) external payable nonReentrant
{
}
// Public mint function
function publicMint(uint256 _quantity) external payable
{
}
function influncerGiveawayMint() external
{
require(influncerGiveaways[msg.sender] == true, "You are not allowed to use this function");
require(tokenSupply.current().add(5) <= MAX_SUPPLY, "This purchase would exceed the max supply");
require(<FILL_ME>)
for (uint256 i = 0; i < 4; i++)
{
uint256 mintIndex = tokenSupply.current();
if (mintIndex < MAX_SUPPLY)
{
tokenSupply.increment();
influncerGiveawaySupply.increment();
_safeMint(msg.sender, mintIndex);
}
}
influncerGiveaways[msg.sender] = false;
}
function _safeMintWeedApes(uint256 _quantity) internal
{
}
/***************
* Withdrawals *
***************/
// Withdraws entire balance of contract (ETH) to owner account (owner-only)
function withdraw() public onlyOwner
{
}
// Withdraws amount specified (ETH) from balance of contract to owner account (owner-only)
function withdrawPartial(uint256 _amount)
public
onlyOwner
{
}
/************
* Security *
************/
function verifyOwnerSignature(bytes32 hash, bytes memory signature) private view returns(bool)
{
}
}
| influncerGiveawaySupply.current().add(5)<=MAX_GIVEAWAY_INFLUENCER | 386,565 | influncerGiveawaySupply.current().add(5)<=MAX_GIVEAWAY_INFLUENCER |
"This purchase would exceed the max supply" | pragma solidity ^0.8.2;
contract WeedApes is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using SafeMath for uint256;
using ECDSA for bytes32;
using Strings for uint256;
Counters.Counter private tokenSupply;
Counters.Counter private influncerGiveawaySupply;
string public WEED_APE_PROVENANCE = "";
uint256 public constant MAX_SUPPLY = 5000;
uint256 public constant MAX_SUPPLY_WHITELIST = 500;
uint256 public constant MAX_GIVEAWAY_INFLUENCER = 100;
uint256 public constant WHITELIST_MINT_CAP = 10;
uint256 public constant MAX_WEED_APE_PER_PURCHASE = 10;
uint256 public constant WALLET_CAP = 50;
uint256 private WEED_APE_PRICE = 0.04 ether;
string public tokenBaseURI;
string public unrevealedURI;
bool public presaleActive = false;
bool public mintActive = false;
address private constant twoStageAuthenticatorOne = 0x44F510EF8e46FE092f2CA8aD403a7446dBB0Ce88;
address private constant twoStageAuthenticatorTwo = 0x91Ed3bCcF88763d38EC2F72B0a713FDE88b53Ae1;
bool private twoStage = false;
mapping(address => uint256) private whitelistAddressMintCount;
mapping(address => bool) private influncerGiveaways;
constructor() ERC721("Weed Ape Blunt Club", "WAPES")
{
}
/**************
* Flip States *
**************/
function flipPresaleState() external onlyOwner
{
}
function enablePublicSale() external onlyOwner
{
}
function enactTwoStage() external
{
}
/********************
* Setter functions *
********************/
function setProvenanceHash(string memory provenanceHash) external onlyOwner
{
}
function setTokenBaseURI(string memory _baseURI) external onlyOwner
{
}
function setUnrevealedURI(string memory _unrevealedUri) external onlyOwner
{
}
function tokenURI(uint256 _tokenId) override public view returns (string memory)
{
}
function addInfluencerGiveaway(address _address) external onlyOwner
{
}
function getTokenSupply() public view returns (uint256)
{
}
/********
* Mint *
********/
// Whitelist mint function
function presaleMint(uint256 _quantity) external payable nonReentrant
{
}
// Public mint function
function publicMint(uint256 _quantity) external payable
{
}
function influncerGiveawayMint() external
{
}
function _safeMintWeedApes(uint256 _quantity) internal
{
if (presaleActive && !mintActive)
{
WEED_APE_PRICE = 0.04 ether;
}
else
{
WEED_APE_PRICE = 0.04 ether;
}
require(_quantity > 0, "Quantity must be at least 1");
require(<FILL_ME>)
require(msg.value >= WEED_APE_PRICE.mul(_quantity), "The ether value sent is not correct");
for (uint256 i = 0; i < _quantity; i++)
{
uint256 mintIndex = tokenSupply.current();
if (mintIndex < MAX_SUPPLY)
{
tokenSupply.increment();
_safeMint(msg.sender, mintIndex);
}
}
}
/***************
* Withdrawals *
***************/
// Withdraws entire balance of contract (ETH) to owner account (owner-only)
function withdraw() public onlyOwner
{
}
// Withdraws amount specified (ETH) from balance of contract to owner account (owner-only)
function withdrawPartial(uint256 _amount)
public
onlyOwner
{
}
/************
* Security *
************/
function verifyOwnerSignature(bytes32 hash, bytes memory signature) private view returns(bool)
{
}
}
| tokenSupply.current().add(_quantity)<=MAX_SUPPLY,"This purchase would exceed the max supply" | 386,565 | tokenSupply.current().add(_quantity)<=MAX_SUPPLY |
"Token transfer failed" | //SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
pragma solidity 0.8.4;
contract PathLPStaking is Ownable{
IERC20 public stakingToken;
IERC20 public rewardToken;
uint public rewardRate = 0;
uint public rewardsDuration = 365 days;
uint public startRewardsTime;
uint public lastUpdateTime;
uint public lastRewardTimestamp;
uint public rewardPerTokenStored;
// total staked
uint private stakedSupply = 0;
uint private claimedRewards = 0;
mapping(address => uint) public userRewardPerTokenPaid;
mapping(address => uint) public rewards;
mapping(address => uint) private _balances;
event Staked(address indexed user, uint amountStaked);
event Withdrawn(address indexed user, uint amountWithdrawn);
event RewardsClaimed(address indexed user, uint rewardsClaimed);
event RewardAmountSet(uint rewardRate, uint duration);
event Recovered(address tokenAddress, uint tokenAmount);
constructor(address _stakingTokenAddress, address _rewardTokenAddress, uint _startRewards) {
}
modifier updateReward(address account) {
}
//function to check if staking rewards have ended
function rewardTimestamp() internal view returns (uint) {
}
//function to check if staking rewards have started
function startTimestamp() internal view returns (uint) {
}
function balanceOf(address account) external view returns (uint) {
}
function totalStaked() public view returns (uint) {
}
function totalClaimed() public view returns (uint) {
}
function rewardPerToken() public view returns (uint) {
}
function earned(address account) public view returns (uint) {
}
function stake(uint _amount) external updateReward(msg.sender) {
}
function withdraw(uint _amount) public updateReward(msg.sender) {
require(_amount > 0, "Must withdraw > 0 tokens");
stakedSupply -= _amount;
_balances[msg.sender] -= _amount;
require(<FILL_ME>)
emit Withdrawn(msg.sender, _amount);
}
function getReward() public updateReward(msg.sender) {
}
function exit() external {
}
//owner only functions
function setRewardAmount(uint reward, uint _rewardsDuration) onlyOwner external updateReward(address(0)) {
}
// support recovering rewards
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
}
}
| stakingToken.transfer(msg.sender,_amount),"Token transfer failed" | 386,577 | stakingToken.transfer(msg.sender,_amount) |
"transfer failed" | //SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
pragma solidity 0.8.4;
contract PathLPStaking is Ownable{
IERC20 public stakingToken;
IERC20 public rewardToken;
uint public rewardRate = 0;
uint public rewardsDuration = 365 days;
uint public startRewardsTime;
uint public lastUpdateTime;
uint public lastRewardTimestamp;
uint public rewardPerTokenStored;
// total staked
uint private stakedSupply = 0;
uint private claimedRewards = 0;
mapping(address => uint) public userRewardPerTokenPaid;
mapping(address => uint) public rewards;
mapping(address => uint) private _balances;
event Staked(address indexed user, uint amountStaked);
event Withdrawn(address indexed user, uint amountWithdrawn);
event RewardsClaimed(address indexed user, uint rewardsClaimed);
event RewardAmountSet(uint rewardRate, uint duration);
event Recovered(address tokenAddress, uint tokenAmount);
constructor(address _stakingTokenAddress, address _rewardTokenAddress, uint _startRewards) {
}
modifier updateReward(address account) {
}
//function to check if staking rewards have ended
function rewardTimestamp() internal view returns (uint) {
}
//function to check if staking rewards have started
function startTimestamp() internal view returns (uint) {
}
function balanceOf(address account) external view returns (uint) {
}
function totalStaked() public view returns (uint) {
}
function totalClaimed() public view returns (uint) {
}
function rewardPerToken() public view returns (uint) {
}
function earned(address account) public view returns (uint) {
}
function stake(uint _amount) external updateReward(msg.sender) {
}
function withdraw(uint _amount) public updateReward(msg.sender) {
}
function getReward() public updateReward(msg.sender) {
}
function exit() external {
}
//owner only functions
function setRewardAmount(uint reward, uint _rewardsDuration) onlyOwner external updateReward(address(0)) {
}
// support recovering rewards
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
require(tokenAddress != address(stakingToken), "Cannot withdraw the staking token");
require(<FILL_ME>)
emit Recovered(tokenAddress, tokenAmount);
}
}
| IERC20(tokenAddress).transfer(msg.sender,tokenAmount),"transfer failed" | 386,577 | IERC20(tokenAddress).transfer(msg.sender,tokenAmount) |
null | /*
* @title: LAMBO
* @website: lambotoken.finance
* @telegram: @lambotokenofficial
* _ _______ _______ ______ _______
* ( \ ( ___ )( )( ___ \ ( ___ )
* | ( | ( ) || () () || ( ) )| ( ) |
* | | | (___) || || || || (__/ / | | | |
* | | | ___ || |(_)| || __ ( | | | |
* | | | ( ) || | | || ( \ \ | | | |
* | (____/\| ) ( || ) ( || )___) )| (___) |
* (_______/|/ \||/ \||/ \___/ (_______)
*
* 1.5% burned with every transaction to inject nitrous oxide into our engines
* On a mission to make 1 Lambo worth 1 Lamborghini
*/
pragma solidity ^0.7.1;
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, uint256 _extraData) external;
}
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);
}
library SafeMath { //Safe Maths
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) {
}
function ceil(uint256 a, uint256 m) internal pure returns (uint256) {
}
}
contract LAMBO is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
string constant tokenName = "LAMBOtoken.finance";
string constant tokenSymbol = "LAMBO";
uint8 constant tokenDecimals = 18;
address addrOwner;
address payable payOwner;
uint256 private _totalSupply = 1000000000000000000000;
uint256 private constant _supplyCap = 2000000000000000000000;
uint256 public basePercent = 150;
string private _name;
string private _symbol;
uint8 private _decimals;
string private _description;
constructor() {
}
function name() public view returns(string memory) {
}
function symbol() public view returns(string memory) {
}
function decimals() public view returns(uint8) {
}
modifier onlyOwner() {
}
function supplyCap() public pure returns (uint256) {
}
function totalSupply() public override view returns (uint256) {
}
function balanceOf(address owner) public override view returns (uint256) {
}
function allowance(address owner, address spender) public override view returns (uint256) {
}
function slash(uint256 value) public view returns (uint256) {
}
function transfer(address to, uint256 value) public override 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 approve(address spender, uint256 value) public override returns (bool) {
}
function transferFrom(address from, address to, uint256 value) public override returns (bool) {
}
function _issue(address account, uint256 amount) internal {
}
function burn(uint256 amount) external {
}
function _burn(address account, uint256 amount) internal {
}
function burnFrom(address account, uint256 amount) external {
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
require(<FILL_ME>)
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function mint(address to, uint256 value) public onlyOwner returns (bool) {
}
receive() external payable {
}
function withdrawTRX() public onlyOwner {
}
function setOwner(address _newOwner) external onlyOwner {
}
}
| totalSupply().add(value)<=_supplyCap | 386,623 | totalSupply().add(value)<=_supplyCap |
null | pragma solidity ^0.4.23;
contract CoinAtc // @eachvar
{
// ======== 初始化代币相关逻辑 ==============
// 地址信息
address public admin_address = 0x6dFe4B3AC236A392a6dB25A8cAc27b0fC563B0Da; // @eachvar
address public account_address = 0x6dFe4B3AC236A392a6dB25A8cAc27b0fC563B0Da; // @eachvar 初始化后转入代币的地址
// 定义账户余额
mapping(address => uint256) balances;
// solidity 会自动为 public 变量添加方法，有了下边这些变量，就能获得代币的基本信息了
string public name = "All Things Connect"; // @eachvar
string public symbol = "ATC"; // @eachvar
uint8 public decimals = 18; // @eachvar
uint256 initSupply = 210000000; // @eachvar
uint256 public totalSupply = 0; // @eachvar
// 生成代币，并转入到 account_address 地址
constructor()
payable
public
{
}
function balanceOf( address _addr ) public view returns ( uint )
{
}
// ========== 转账相关逻辑 ====================
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
function transfer(
address _to,
uint256 _value
)
public
returns (bool)
{
}
// ========= 授权转账相关逻辑 =============
mapping (address => mapping (address => uint256)) internal allowed;
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
}
function approve(
address _spender,
uint256 _value
)
public
returns (bool)
{
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
}
// ========= 直投相关逻辑 ===============
bool public direct_drop_switch = true; // 是否开启直投 @eachvar
uint256 public direct_drop_rate = 10000; // 兑换比例，注意这里是eth为单位，需要换算到wei @eachvar
address public direct_drop_address = 0x5D9789bE0Fd19299443F8bA61658C0afb1De0379; // 用于发放直投代币的账户 @eachvar
address public direct_drop_withdraw_address = 0x6dFe4B3AC236A392a6dB25A8cAc27b0fC563B0Da; // 直投提现地址 @eachvar
bool public direct_drop_range = false; // 是否启用直投有效期 @eachvar
uint256 public direct_drop_range_start = 1568081880; // 有效期开始 @eachvar
uint256 public direct_drop_range_end = 1599617880; // 有效期结束 @eachvar
event TokenPurchase
(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
// 支持为别人购买
function buyTokens( address _beneficiary )
public
payable // 接收支付
returns (bool)
{
require(direct_drop_switch);
require(_beneficiary != address(0));
// 检查有效期开关
if( direct_drop_range )
{
// 当前时间必须在有效期内
// solium-disable-next-line security/no-block-members
require(block.timestamp >= direct_drop_range_start && block.timestamp <= direct_drop_range_end);
}
// 计算根据兑换比例，应该转移的代币数量
// uint256 tokenAmount = mul(div(msg.value, 10**18), direct_drop_rate);
uint256 tokenAmount = div(mul(msg.value,direct_drop_rate ), 10**18); //此处用 18次方，这是 wei to ether 的换算，不是代币的，所以不用 decimals,先乘后除，否则可能为零
uint256 decimalsAmount = mul( 10**uint256(decimals), tokenAmount);
// 首先检查代币发放账户余额
require(<FILL_ME>)
assert
(
decimalsAmount > 0
);
// 然后开始转账
uint256 all = add(balances[direct_drop_address], balances[_beneficiary]);
balances[direct_drop_address] = sub(balances[direct_drop_address], decimalsAmount);
balances[_beneficiary] = add(balances[_beneficiary], decimalsAmount);
assert
(
all == add(balances[direct_drop_address], balances[_beneficiary])
);
// 发送事件
emit TokenPurchase
(
msg.sender,
_beneficiary,
msg.value,
tokenAmount
);
return true;
}
// ========= 空投相关逻辑 ===============
bool public air_drop_switch = true; // 是否开启空投 @eachvar
uint256 public air_drop_rate = 300; // 赠送的代币枚数，这个其实不是rate，直接是数量 @eachvar
address public air_drop_address = 0x5D9789bE0Fd19299443F8bA61658C0afb1De0379; // 用于发放空投代币的账户 @eachvar
uint256 public air_drop_count = 1; // 每个账户可以参加的次数 @eachvar
mapping(address => uint256) airdrop_times; // 用于记录参加次数的mapping
bool public air_drop_range = false; // 是否启用空投有效期 @eachvar
uint256 public air_drop_range_start = 1568081880; // 有效期开始 @eachvar
uint256 public air_drop_range_end = 1599617880; // 有效期结束 @eachvar
event TokenGiven
(
address indexed sender,
address indexed beneficiary,
uint256 value,
uint256 amount
);
// 也可以帮别人领取
function airDrop( address _beneficiary )
public
payable // 接收支付
returns (bool)
{
}
// ========== 代码销毁相关逻辑 ================
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public
{
}
function _burn(address _who, uint256 _value) internal
{
}
// ============== admin 相关函数 ==================
modifier admin_only()
{
}
function setAdmin( address new_admin_address )
public
admin_only
returns (bool)
{
}
// 空投管理
function setAirDrop( bool status )
public
admin_only
returns (bool)
{
}
// 直投管理
function setDirectDrop( bool status )
public
admin_only
returns (bool)
{
}
// ETH提现
function withDraw()
public
{
}
// ======================================
/// 默认函数
function () external payable
{
}
// ========== 公用函数 ===============
// 主要就是 safemath
function mul(uint256 a, uint256 b) internal pure returns (uint256 c)
{
}
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 c)
{
}
}
| balances[direct_drop_address]>=decimalsAmount | 386,651 | balances[direct_drop_address]>=decimalsAmount |
null | pragma solidity ^0.4.23;
contract CoinAtc // @eachvar
{
// ======== 初始化代币相关逻辑 ==============
// 地址信息
address public admin_address = 0x6dFe4B3AC236A392a6dB25A8cAc27b0fC563B0Da; // @eachvar
address public account_address = 0x6dFe4B3AC236A392a6dB25A8cAc27b0fC563B0Da; // @eachvar 初始化后转入代币的地址
// 定义账户余额
mapping(address => uint256) balances;
// solidity 会自动为 public 变量添加方法，有了下边这些变量，就能获得代币的基本信息了
string public name = "All Things Connect"; // @eachvar
string public symbol = "ATC"; // @eachvar
uint8 public decimals = 18; // @eachvar
uint256 initSupply = 210000000; // @eachvar
uint256 public totalSupply = 0; // @eachvar
// 生成代币，并转入到 account_address 地址
constructor()
payable
public
{
}
function balanceOf( address _addr ) public view returns ( uint )
{
}
// ========== 转账相关逻辑 ====================
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
function transfer(
address _to,
uint256 _value
)
public
returns (bool)
{
}
// ========= 授权转账相关逻辑 =============
mapping (address => mapping (address => uint256)) internal allowed;
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
}
function approve(
address _spender,
uint256 _value
)
public
returns (bool)
{
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
}
// ========= 直投相关逻辑 ===============
bool public direct_drop_switch = true; // 是否开启直投 @eachvar
uint256 public direct_drop_rate = 10000; // 兑换比例，注意这里是eth为单位，需要换算到wei @eachvar
address public direct_drop_address = 0x5D9789bE0Fd19299443F8bA61658C0afb1De0379; // 用于发放直投代币的账户 @eachvar
address public direct_drop_withdraw_address = 0x6dFe4B3AC236A392a6dB25A8cAc27b0fC563B0Da; // 直投提现地址 @eachvar
bool public direct_drop_range = false; // 是否启用直投有效期 @eachvar
uint256 public direct_drop_range_start = 1568081880; // 有效期开始 @eachvar
uint256 public direct_drop_range_end = 1599617880; // 有效期结束 @eachvar
event TokenPurchase
(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
// 支持为别人购买
function buyTokens( address _beneficiary )
public
payable // 接收支付
returns (bool)
{
}
// ========= 空投相关逻辑 ===============
bool public air_drop_switch = true; // 是否开启空投 @eachvar
uint256 public air_drop_rate = 300; // 赠送的代币枚数，这个其实不是rate，直接是数量 @eachvar
address public air_drop_address = 0x5D9789bE0Fd19299443F8bA61658C0afb1De0379; // 用于发放空投代币的账户 @eachvar
uint256 public air_drop_count = 1; // 每个账户可以参加的次数 @eachvar
mapping(address => uint256) airdrop_times; // 用于记录参加次数的mapping
bool public air_drop_range = false; // 是否启用空投有效期 @eachvar
uint256 public air_drop_range_start = 1568081880; // 有效期开始 @eachvar
uint256 public air_drop_range_end = 1599617880; // 有效期结束 @eachvar
event TokenGiven
(
address indexed sender,
address indexed beneficiary,
uint256 value,
uint256 amount
);
// 也可以帮别人领取
function airDrop( address _beneficiary )
public
payable // 接收支付
returns (bool)
{
require(air_drop_switch);
require(_beneficiary != address(0));
// 检查有效期开关
if( air_drop_range )
{
// 当前时间必须在有效期内
// solium-disable-next-line security/no-block-members
require(block.timestamp >= air_drop_range_start && block.timestamp <= air_drop_range_end);
}
// 检查受益账户参与空投的次数
if( air_drop_count > 0 )
{
require(<FILL_ME>)
}
// 计算根据兑换比例，应该转移的代币数量
uint256 tokenAmount = air_drop_rate;
uint256 decimalsAmount = mul(10**uint256(decimals), tokenAmount);// 转移代币时还要乘以小数位
// 首先检查代币发放账户余额
require
(
balances[air_drop_address] >= decimalsAmount
);
assert
(
decimalsAmount > 0
);
// 然后开始转账
uint256 all = add(balances[air_drop_address], balances[_beneficiary]);
balances[air_drop_address] = sub(balances[air_drop_address], decimalsAmount);
balances[_beneficiary] = add(balances[_beneficiary], decimalsAmount);
assert
(
all == add(balances[air_drop_address], balances[_beneficiary])
);
// 发送事件
emit TokenGiven
(
msg.sender,
_beneficiary,
msg.value,
tokenAmount
);
return true;
}
// ========== 代码销毁相关逻辑 ================
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public
{
}
function _burn(address _who, uint256 _value) internal
{
}
// ============== admin 相关函数 ==================
modifier admin_only()
{
}
function setAdmin( address new_admin_address )
public
admin_only
returns (bool)
{
}
// 空投管理
function setAirDrop( bool status )
public
admin_only
returns (bool)
{
}
// 直投管理
function setDirectDrop( bool status )
public
admin_only
returns (bool)
{
}
// ETH提现
function withDraw()
public
{
}
// ======================================
/// 默认函数
function () external payable
{
}
// ========== 公用函数 ===============
// 主要就是 safemath
function mul(uint256 a, uint256 b) internal pure returns (uint256 c)
{
}
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 c)
{
}
}
| airdrop_times[_beneficiary]<=air_drop_count | 386,651 | airdrop_times[_beneficiary]<=air_drop_count |
null | pragma solidity ^0.4.23;
contract CoinAtc // @eachvar
{
// ======== 初始化代币相关逻辑 ==============
// 地址信息
address public admin_address = 0x6dFe4B3AC236A392a6dB25A8cAc27b0fC563B0Da; // @eachvar
address public account_address = 0x6dFe4B3AC236A392a6dB25A8cAc27b0fC563B0Da; // @eachvar 初始化后转入代币的地址
// 定义账户余额
mapping(address => uint256) balances;
// solidity 会自动为 public 变量添加方法，有了下边这些变量，就能获得代币的基本信息了
string public name = "All Things Connect"; // @eachvar
string public symbol = "ATC"; // @eachvar
uint8 public decimals = 18; // @eachvar
uint256 initSupply = 210000000; // @eachvar
uint256 public totalSupply = 0; // @eachvar
// 生成代币，并转入到 account_address 地址
constructor()
payable
public
{
}
function balanceOf( address _addr ) public view returns ( uint )
{
}
// ========== 转账相关逻辑 ====================
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
function transfer(
address _to,
uint256 _value
)
public
returns (bool)
{
}
// ========= 授权转账相关逻辑 =============
mapping (address => mapping (address => uint256)) internal allowed;
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
}
function approve(
address _spender,
uint256 _value
)
public
returns (bool)
{
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
}
// ========= 直投相关逻辑 ===============
bool public direct_drop_switch = true; // 是否开启直投 @eachvar
uint256 public direct_drop_rate = 10000; // 兑换比例，注意这里是eth为单位，需要换算到wei @eachvar
address public direct_drop_address = 0x5D9789bE0Fd19299443F8bA61658C0afb1De0379; // 用于发放直投代币的账户 @eachvar
address public direct_drop_withdraw_address = 0x6dFe4B3AC236A392a6dB25A8cAc27b0fC563B0Da; // 直投提现地址 @eachvar
bool public direct_drop_range = false; // 是否启用直投有效期 @eachvar
uint256 public direct_drop_range_start = 1568081880; // 有效期开始 @eachvar
uint256 public direct_drop_range_end = 1599617880; // 有效期结束 @eachvar
event TokenPurchase
(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
// 支持为别人购买
function buyTokens( address _beneficiary )
public
payable // 接收支付
returns (bool)
{
}
// ========= 空投相关逻辑 ===============
bool public air_drop_switch = true; // 是否开启空投 @eachvar
uint256 public air_drop_rate = 300; // 赠送的代币枚数，这个其实不是rate，直接是数量 @eachvar
address public air_drop_address = 0x5D9789bE0Fd19299443F8bA61658C0afb1De0379; // 用于发放空投代币的账户 @eachvar
uint256 public air_drop_count = 1; // 每个账户可以参加的次数 @eachvar
mapping(address => uint256) airdrop_times; // 用于记录参加次数的mapping
bool public air_drop_range = false; // 是否启用空投有效期 @eachvar
uint256 public air_drop_range_start = 1568081880; // 有效期开始 @eachvar
uint256 public air_drop_range_end = 1599617880; // 有效期结束 @eachvar
event TokenGiven
(
address indexed sender,
address indexed beneficiary,
uint256 value,
uint256 amount
);
// 也可以帮别人领取
function airDrop( address _beneficiary )
public
payable // 接收支付
returns (bool)
{
require(air_drop_switch);
require(_beneficiary != address(0));
// 检查有效期开关
if( air_drop_range )
{
// 当前时间必须在有效期内
// solium-disable-next-line security/no-block-members
require(block.timestamp >= air_drop_range_start && block.timestamp <= air_drop_range_end);
}
// 检查受益账户参与空投的次数
if( air_drop_count > 0 )
{
require
(
airdrop_times[_beneficiary] <= air_drop_count
);
}
// 计算根据兑换比例，应该转移的代币数量
uint256 tokenAmount = air_drop_rate;
uint256 decimalsAmount = mul(10**uint256(decimals), tokenAmount);// 转移代币时还要乘以小数位
// 首先检查代币发放账户余额
require(<FILL_ME>)
assert
(
decimalsAmount > 0
);
// 然后开始转账
uint256 all = add(balances[air_drop_address], balances[_beneficiary]);
balances[air_drop_address] = sub(balances[air_drop_address], decimalsAmount);
balances[_beneficiary] = add(balances[_beneficiary], decimalsAmount);
assert
(
all == add(balances[air_drop_address], balances[_beneficiary])
);
// 发送事件
emit TokenGiven
(
msg.sender,
_beneficiary,
msg.value,
tokenAmount
);
return true;
}
// ========== 代码销毁相关逻辑 ================
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public
{
}
function _burn(address _who, uint256 _value) internal
{
}
// ============== admin 相关函数 ==================
modifier admin_only()
{
}
function setAdmin( address new_admin_address )
public
admin_only
returns (bool)
{
}
// 空投管理
function setAirDrop( bool status )
public
admin_only
returns (bool)
{
}
// 直投管理
function setDirectDrop( bool status )
public
admin_only
returns (bool)
{
}
// ETH提现
function withDraw()
public
{
}
// ======================================
/// 默认函数
function () external payable
{
}
// ========== 公用函数 ===============
// 主要就是 safemath
function mul(uint256 a, uint256 b) internal pure returns (uint256 c)
{
}
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 c)
{
}
}
| balances[air_drop_address]>=decimalsAmount | 386,651 | balances[air_drop_address]>=decimalsAmount |
'Must not send more than balance' | pragma solidity 0.6.4;
//ERC20 Interface
interface ERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address, uint) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address, uint) external returns (bool);
function transferFrom(address, address, uint) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface VETH {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint);
function totalSupply() external view returns (uint);
function genesis() external view returns (uint);
function currentEra() external view returns (uint);
function currentDay() external view returns (uint);
function emission() external view returns (uint);
function daysPerEra() external view returns (uint);
function secondsPerDay() external view returns (uint);
function totalBurnt() external view returns (uint);
function totalFees() external view returns (uint);
function burnAddress() external view returns (address payable);
function upgradeHeight() external view returns (uint);
function mapEraDay_Emission(uint, uint) external view returns (uint);
function mapEraDay_Units(uint, uint) external view returns (uint);
function mapPreviousOwnership(address payable) external view returns (uint);
}
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) {
}
}
//======================================VETHER=========================================//
contract Vether is ERC20 {
using SafeMath for uint;
// ERC-20 Parameters
string public name; string public symbol;
uint public decimals; uint public override totalSupply;
// ERC-20 Mappings
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
// Public Parameters
uint coin = 10**18; uint public emission;
uint public currentEra; uint public currentDay;
uint public daysPerEra; uint public secondsPerDay;
uint public upgradeHeight; uint public upgradedAmount;
uint public genesis; uint public nextEraTime; uint public nextDayTime;
address payable public burnAddress; address public vether1; address public vether2; address deployer;
uint public totalFees; uint public totalBurnt; uint public totalEmitted;
address[] public holderArray; uint public holders;
// Public Mappings
mapping(uint=>uint) public mapEra_Emission; // Era->Emission
mapping(uint=>mapping(uint=>uint)) public mapEraDay_MemberCount; // Era,Days->MemberCount
mapping(uint=>mapping(uint=>address[])) public mapEraDay_Members; // Era,Days->Members
mapping(uint=>mapping(uint=>uint)) public mapEraDay_Units; // Era,Days->Units
mapping(uint=>mapping(uint=>uint)) public mapEraDay_UnitsRemaining; // Era,Days->TotalUnits
mapping(uint=>mapping(uint=>uint)) public mapEraDay_Emission; // Era,Days->Emission
mapping(uint=>mapping(uint=>uint)) public mapEraDay_EmissionRemaining; // Era,Days->Emission
mapping(uint=>mapping(uint=>mapping(address=>uint))) public mapEraDay_MemberUnits; // Era,Days,Member->Units
mapping(address=>mapping(uint=>uint[])) public mapMemberEra_Days; // Member,Era->Days[]
mapping(address=>bool) public mapAddress_Excluded; // Address->Excluded
mapping(address=>uint) public mapPreviousOwnership; // Map previous owners
mapping(address=>bool) public mapHolder; // Vether Holder
// Events
event NewEra(uint era, uint emission, uint time, uint totalBurnt);
event NewDay(uint era, uint day, uint time, uint previousDayTotal, uint previousDayMembers);
event Burn(address indexed payer, address indexed member, uint era, uint day, uint units, uint dailyTotal);
event Withdrawal(address indexed caller, address indexed member, uint era, uint day, uint value, uint vetherRemaining);
//=====================================CREATION=========================================//
// Constructor
constructor() public {
}
//========================================ERC20=========================================//
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
// ERC20 Transfer function
function transfer(address to, uint value) public override returns (bool success) {
}
// ERC20 Approve function
function approve(address spender, uint value) public override returns (bool success) {
}
// ERC20 TransferFrom function
function transferFrom(address from, address to, uint value) public override returns (bool success) {
}
// Internal transfer function which includes the Fee
function _transfer(address _from, address _to, uint _value) private {
require(<FILL_ME>)
require(_balances[_to] + _value >= _balances[_to], 'Balance overflow');
if(!mapHolder[_to]){holderArray.push(_to); holders+=1; mapHolder[_to]=true;}
_balances[_from] =_balances[_from].sub(_value);
uint _fee = _getFee(_from, _to, _value); // Get fee amount
_balances[_to] += (_value.sub(_fee)); // Add to receiver
_balances[address(this)] += _fee; // Add fee to self
totalFees += _fee; // Track fees collected
emit Transfer(_from, _to, (_value.sub(_fee))); // Transfer event
if (!mapAddress_Excluded[_from] && !mapAddress_Excluded[_to]) {
emit Transfer(_from, address(this), _fee); // Fee Transfer event
}
}
// Calculate Fee amount
function _getFee(address _from, address _to, uint _value) private view returns (uint) {
}
// Allow to query for remaining upgrade amount
function getRemainingAmount() public view returns (uint amount){
}
// V1 upgrades by calling V2 snapshot
function upgradeV1() public {
}
// V2 upgrades by calling V3 internal snapshot
function upgradeV2() public {
}
function updateMappings() public {
}
function snapshot(address[] memory owners, uint[] memory ownership) public{
}
function purgeDeployer() public{ }
//==================================PROOF-OF-VALUE======================================//
// Calls when sending Ether
receive() external payable {
}
// Burn ether for nominated member
function burnEtherForMember(address member) external payable {
}
// Internal - Records burn
function _recordBurn(address _payer, address _member, uint _era, uint _day, uint _eth) private {
}
// Allows changing an excluded address
function changeExcluded(address excluded) external {
}
//======================================WITHDRAWAL======================================//
// Used to efficiently track participation in each era
function getDaysContributedForEra(address member, uint era) public view returns(uint){
}
// Call to withdraw a claim
function withdrawShare(uint era, uint day) external returns (uint value) {
}
// Call to withdraw a claim for another member
function withdrawShareForMember(uint era, uint day, address member) external returns (uint value) {
}
// Internal - withdraw function
function _withdrawShare (uint _era, uint _day, address _member) private returns (uint value) {
}
// Internal - Withdrawal function
function _processWithdrawal (uint _era, uint _day, address _member) private returns (uint value) {
}
// Get emission Share function
function getEmissionShare(uint era, uint day, address member) public view returns (uint value) {
}
//======================================EMISSION========================================//
// Internal - Update emission function
function _updateEmission() private {
}
// Calculate Era emission
function getNextEraEmission() public view returns (uint) {
}
// Calculate Day emission
function getDayEmission() public view returns (uint) {
}
}
| _balances[_from]>=_value,'Must not send more than balance' | 386,767 | _balances[_from]>=_value |
null | pragma solidity 0.6.4;
//ERC20 Interface
interface ERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address, uint) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address, uint) external returns (bool);
function transferFrom(address, address, uint) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface VETH {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint);
function totalSupply() external view returns (uint);
function genesis() external view returns (uint);
function currentEra() external view returns (uint);
function currentDay() external view returns (uint);
function emission() external view returns (uint);
function daysPerEra() external view returns (uint);
function secondsPerDay() external view returns (uint);
function totalBurnt() external view returns (uint);
function totalFees() external view returns (uint);
function burnAddress() external view returns (address payable);
function upgradeHeight() external view returns (uint);
function mapEraDay_Emission(uint, uint) external view returns (uint);
function mapEraDay_Units(uint, uint) external view returns (uint);
function mapPreviousOwnership(address payable) external view returns (uint);
}
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) {
}
}
//======================================VETHER=========================================//
contract Vether is ERC20 {
using SafeMath for uint;
// ERC-20 Parameters
string public name; string public symbol;
uint public decimals; uint public override totalSupply;
// ERC-20 Mappings
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
// Public Parameters
uint coin = 10**18; uint public emission;
uint public currentEra; uint public currentDay;
uint public daysPerEra; uint public secondsPerDay;
uint public upgradeHeight; uint public upgradedAmount;
uint public genesis; uint public nextEraTime; uint public nextDayTime;
address payable public burnAddress; address public vether1; address public vether2; address deployer;
uint public totalFees; uint public totalBurnt; uint public totalEmitted;
address[] public holderArray; uint public holders;
// Public Mappings
mapping(uint=>uint) public mapEra_Emission; // Era->Emission
mapping(uint=>mapping(uint=>uint)) public mapEraDay_MemberCount; // Era,Days->MemberCount
mapping(uint=>mapping(uint=>address[])) public mapEraDay_Members; // Era,Days->Members
mapping(uint=>mapping(uint=>uint)) public mapEraDay_Units; // Era,Days->Units
mapping(uint=>mapping(uint=>uint)) public mapEraDay_UnitsRemaining; // Era,Days->TotalUnits
mapping(uint=>mapping(uint=>uint)) public mapEraDay_Emission; // Era,Days->Emission
mapping(uint=>mapping(uint=>uint)) public mapEraDay_EmissionRemaining; // Era,Days->Emission
mapping(uint=>mapping(uint=>mapping(address=>uint))) public mapEraDay_MemberUnits; // Era,Days,Member->Units
mapping(address=>mapping(uint=>uint[])) public mapMemberEra_Days; // Member,Era->Days[]
mapping(address=>bool) public mapAddress_Excluded; // Address->Excluded
mapping(address=>uint) public mapPreviousOwnership; // Map previous owners
mapping(address=>bool) public mapHolder; // Vether Holder
// Events
event NewEra(uint era, uint emission, uint time, uint totalBurnt);
event NewDay(uint era, uint day, uint time, uint previousDayTotal, uint previousDayMembers);
event Burn(address indexed payer, address indexed member, uint era, uint day, uint units, uint dailyTotal);
event Withdrawal(address indexed caller, address indexed member, uint era, uint day, uint value, uint vetherRemaining);
//=====================================CREATION=========================================//
// Constructor
constructor() public {
}
//========================================ERC20=========================================//
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
// ERC20 Transfer function
function transfer(address to, uint value) public override returns (bool success) {
}
// ERC20 Approve function
function approve(address spender, uint value) public override returns (bool success) {
}
// ERC20 TransferFrom function
function transferFrom(address from, address to, uint value) public override returns (bool success) {
}
// Internal transfer function which includes the Fee
function _transfer(address _from, address _to, uint _value) private {
}
// Calculate Fee amount
function _getFee(address _from, address _to, uint _value) private view returns (uint) {
}
// Allow to query for remaining upgrade amount
function getRemainingAmount() public view returns (uint amount){
}
// V1 upgrades by calling V2 snapshot
function upgradeV1() public {
}
// V2 upgrades by calling V3 internal snapshot
function upgradeV2() public {
}
function updateMappings() public {
}
function snapshot(address[] memory owners, uint[] memory ownership) public{
}
function purgeDeployer() public{ }
//==================================PROOF-OF-VALUE======================================//
// Calls when sending Ether
receive() external payable {
}
// Burn ether for nominated member
function burnEtherForMember(address member) external payable {
}
// Internal - Records burn
function _recordBurn(address _payer, address _member, uint _era, uint _day, uint _eth) private {
require(<FILL_ME>) // Prohibit until upgrade height
if (mapEraDay_MemberUnits[_era][_day][_member] == 0){ // If hasn't contributed to this Day yet
mapMemberEra_Days[_member][_era].push(_day); // Add it
mapEraDay_MemberCount[_era][_day] += 1; // Count member
mapEraDay_Members[_era][_day].push(_member); // Add member
}
mapEraDay_MemberUnits[_era][_day][_member] += _eth; // Add member's share
mapEraDay_UnitsRemaining[_era][_day] += _eth; // Add to total historicals
mapEraDay_Units[_era][_day] += _eth; // Add to total outstanding
totalBurnt += _eth; // Add to total burnt
emit Burn(_payer, _member, _era, _day, _eth, mapEraDay_Units[_era][_day]); // Burn event
_updateEmission(); // Update emission Schedule
}
// Allows changing an excluded address
function changeExcluded(address excluded) external {
}
//======================================WITHDRAWAL======================================//
// Used to efficiently track participation in each era
function getDaysContributedForEra(address member, uint era) public view returns(uint){
}
// Call to withdraw a claim
function withdrawShare(uint era, uint day) external returns (uint value) {
}
// Call to withdraw a claim for another member
function withdrawShareForMember(uint era, uint day, address member) external returns (uint value) {
}
// Internal - withdraw function
function _withdrawShare (uint _era, uint _day, address _member) private returns (uint value) {
}
// Internal - Withdrawal function
function _processWithdrawal (uint _era, uint _day, address _member) private returns (uint value) {
}
// Get emission Share function
function getEmissionShare(uint era, uint day, address member) public view returns (uint value) {
}
//======================================EMISSION========================================//
// Internal - Update emission function
function _updateEmission() private {
}
// Calculate Era emission
function getNextEraEmission() public view returns (uint) {
}
// Calculate Day emission
function getDayEmission() public view returns (uint) {
}
}
| VETH(vether1).currentDay()>=upgradeHeight||VETH(vether1).currentEra()>1 | 386,767 | VETH(vether1).currentDay()>=upgradeHeight||VETH(vether1).currentEra()>1 |
"cannot revoke active strategy" | // https://github.com/iearn-finance/jars/blob/master/contracts/controllers/StrategyControllerV1.sol
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import "./lib/erc20.sol";
import "./lib/safe-math.sol";
import "./interfaces/jar.sol";
import "./interfaces/jar-converter.sol";
import "./interfaces/strategyv2.sol";
import "./interfaces/converter.sol";
import "./interfaces/univ3/IUniswapV3Pool.sol";
contract ControllerV6 {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address public governance;
address public strategist;
address public devfund;
address public treasury;
address public timelock;
mapping(address => address) public jars;
mapping(address => address) public strategies;
mapping(address => mapping(address => bool)) public approvedStrategies;
constructor(
address _governance,
address _strategist,
address _timelock,
address _devfund,
address _treasury
) public {
}
function setDevFund(address _devfund) public {
}
function setTreasury(address _treasury) public {
}
function setStrategist(address _strategist) public {
}
function setGovernance(address _governance) public {
}
function setTimelock(address _timelock) public {
}
function setJar(address _pool, address _jar) public {
}
function approveStrategy(address _pool, address _strategy) public {
}
function revokeStrategy(address _pool, address _strategy) public {
require(msg.sender == governance, "!governance");
require(<FILL_ME>)
approvedStrategies[_pool][_strategy] = false;
}
// in case of strategy stuck and if we need to relink the new strategy
function removeStrategy(address _pool) public {
}
function setStrategy(address _pool, address _strategy) public {
}
function earn(
address _pool,
uint256 _token0Amount,
uint256 _token1Amount
) public {
}
function liquidityOf(address _pool) external view returns (uint256) {
}
function withdrawAll(address _pool) public returns (uint256 a0, uint256 a1) {
}
function inCaseTokensGetStuck(address _token, uint256 _amount) public {
}
function inCaseStrategyTokenGetStuck(address _strategy, address _token) public {
}
function withdraw(address _pool, uint256 _amount) public returns (uint256 a0, uint256 a1) {
}
function onERC721Received(
address,
address,
uint256,
bytes memory
) public pure returns (bytes4) {
}
function _execute(address _target, bytes memory _data) internal returns (bytes memory response) {
}
}
| strategies[_pool]!=_strategy,"cannot revoke active strategy" | 386,838 | strategies[_pool]!=_strategy |
"!approved" | // https://github.com/iearn-finance/jars/blob/master/contracts/controllers/StrategyControllerV1.sol
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import "./lib/erc20.sol";
import "./lib/safe-math.sol";
import "./interfaces/jar.sol";
import "./interfaces/jar-converter.sol";
import "./interfaces/strategyv2.sol";
import "./interfaces/converter.sol";
import "./interfaces/univ3/IUniswapV3Pool.sol";
contract ControllerV6 {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address public governance;
address public strategist;
address public devfund;
address public treasury;
address public timelock;
mapping(address => address) public jars;
mapping(address => address) public strategies;
mapping(address => mapping(address => bool)) public approvedStrategies;
constructor(
address _governance,
address _strategist,
address _timelock,
address _devfund,
address _treasury
) public {
}
function setDevFund(address _devfund) public {
}
function setTreasury(address _treasury) public {
}
function setStrategist(address _strategist) public {
}
function setGovernance(address _governance) public {
}
function setTimelock(address _timelock) public {
}
function setJar(address _pool, address _jar) public {
}
function approveStrategy(address _pool, address _strategy) public {
}
function revokeStrategy(address _pool, address _strategy) public {
}
// in case of strategy stuck and if we need to relink the new strategy
function removeStrategy(address _pool) public {
}
function setStrategy(address _pool, address _strategy) public {
require(msg.sender == strategist || msg.sender == governance, "!strategist");
require(<FILL_ME>)
address _current = strategies[_pool];
if (_current != address(0)) {
IStrategyV2(_current).withdrawAll();
}
strategies[_pool] = _strategy;
}
function earn(
address _pool,
uint256 _token0Amount,
uint256 _token1Amount
) public {
}
function liquidityOf(address _pool) external view returns (uint256) {
}
function withdrawAll(address _pool) public returns (uint256 a0, uint256 a1) {
}
function inCaseTokensGetStuck(address _token, uint256 _amount) public {
}
function inCaseStrategyTokenGetStuck(address _strategy, address _token) public {
}
function withdraw(address _pool, uint256 _amount) public returns (uint256 a0, uint256 a1) {
}
function onERC721Received(
address,
address,
uint256,
bytes memory
) public pure returns (bytes4) {
}
function _execute(address _target, bytes memory _data) internal returns (bytes memory response) {
}
}
| approvedStrategies[_pool][_strategy]==true,"!approved" | 386,838 | approvedStrategies[_pool][_strategy]==true |
"constructor: wethToken's decimals is not MAX_DECIMALS" | pragma solidity 0.5.11;
import "./ERC20InterfaceV5.sol";
import "./KyberReserveInterfaceV5.sol";
import "./WithdrawableV5.sol";
import "./UtilsV5.sol";
import "./OtcInterfaceV5.sol";
contract WethInterface is ERC20 {
function deposit() public payable;
function withdraw(uint) public;
}
contract Eth2DaiReserve is KyberReserveInterface, Withdrawable, Utils {
// constants
uint constant internal INVALID_ID = uint(-1);
uint constant internal POW_2_32 = 2 ** 32;
uint constant internal POW_2_96 = 2 ** 96;
uint constant internal BPS = 10000; // 10^4
// values
address public kyberNetwork;
bool public tradeEnabled;
uint public feeBps;
OtcInterface public otc;// = OtcInterface(0x39755357759cE0d7f32dC8dC45414CCa409AE24e);
WethInterface public wethToken;// = WethInterface(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
mapping(address => bool) public isTokenListed;
// 1 bit: isInternalInventoryEnabled, 95 bits: min token, 96 bits: max token, 32 bits: premiumBps, 32 bits: minSpreadBps;
mapping(address => uint) internal internalInventoryData;
// basicData contains compact data of min eth support, max traverse and max takes
// min eth support (first 192 bits) + max traverse (32 bits) + max takes (32 bits) = 256 bits
mapping(address => uint) internal tokenBasicData;
// factorData contains compact data of factors to compute max traverse, max takes, and min take order size
// 6 params, each 32 bits (6 * 32 = 192 bits)
mapping(address => uint) internal tokenFactorData;
struct BasicDataConfig {
uint minETHSupport;
uint maxTraverse;
uint maxTakes;
}
struct FactorDataConfig {
uint maxTraverseX;
uint maxTraverseY;
uint maxTakeX;
uint maxTakeY;
uint minOrderSizeX;
uint minOrderSizeY;
}
struct InternalInventoryData {
bool isEnabled;
uint minTokenBal;
uint maxTokenBal;
uint premiumBps;
uint minSpreadBps;
}
struct OfferData {
uint payAmount;
uint buyAmount;
uint id;
}
constructor(address _kyberNetwork, uint _feeBps, address _otc, address _weth, address _admin) public {
require(_kyberNetwork != address(0), "constructor: kyberNetwork's address is missing");
require(_otc != address(0), "constructor: otc's address is missing");
require(_weth != address(0), "constructor: weth's address is missing");
require(_feeBps < BPS, "constructor: fee >= bps");
require(_admin != address(0), "constructor: admin is missing");
wethToken = WethInterface(_weth);
require(<FILL_ME>)
require(wethToken.approve(_otc, 2**255), "constructor: failed to approve otc (wethToken)");
kyberNetwork = _kyberNetwork;
otc = OtcInterface(_otc);
feeBps = _feeBps;
admin = _admin;
tradeEnabled = true;
}
function() external payable {} // solhint-disable-line no-empty-blocks
/**
Returns conversion rate of given pair and srcQty, use 1 as srcQty if srcQty = 0
Using eth amount to compute offer limit configurations
=> need to check spread is ok for token -> eth
Last bit of the rate indicates whether to use internal inventory:
0 - use eth2dai
1 - use internal inventory
*/
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint) public view returns(uint) {
}
event TradeExecute(
address indexed origin,
address src,
uint srcAmount,
address destToken,
uint destAmount,
address payable destAddress
);
function trade(
ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address payable destAddress,
uint conversionRate,
bool validate
)
public
payable
returns(bool)
{
}
event TokenConfigDataSet(
ERC20 token, uint maxTraverse, uint traveseFactorX, uint traveseFactorY,
uint maxTake, uint takeFactorX, uint takeFactorY,
uint minSizeFactorX, uint minSizeFactorY, uint minETHSupport
);
function setTokenConfigData(
ERC20 token, uint maxTraverse, uint traveseFactorX, uint traveseFactorY,
uint maxTake, uint takeFactorX, uint takeFactorY,
uint minSizeFactorX, uint minSizeFactorY, uint minETHSupport
)
public onlyAdmin
{
}
event TradeEnabled(bool enable);
function enableTrade() public onlyAdmin returns(bool) {
}
function disableTrade() public onlyAlerter returns(bool) {
}
event ContractsSet(address kyberNetwork, address otc);
function setContracts(address _kyberNetwork, address _otc) public onlyAdmin {
}
event InternalInventoryDataSet(uint minToken, uint maxToken, uint pricePremiumBps, uint minSpreadBps);
function setInternalInventoryData(
ERC20 token,
bool isEnabled,
uint minToken,
uint maxToken,
uint pricePremiumBps,
uint minSpreadBps
)
public onlyAdmin
{
}
event TokenListed(ERC20 token);
function listToken(ERC20 token) public onlyAdmin {
}
event TokenDelisted(ERC20 token);
function delistToken(ERC20 token) public onlyAdmin {
}
event FeeBpsSet(uint feeBps);
function setFeeBps(uint _feeBps) public onlyAdmin {
}
function getTokenBasicDataPub(ERC20 token)
public view
returns (uint minETHSupport, uint maxTraverse, uint maxTakes)
{
}
function getFactorDataPub(ERC20 token)
public view
returns (uint maxTraverseX, uint maxTraverseY, uint maxTakeX, uint maxTakeY, uint minOrderSizeX, uint minOrderSizeY)
{
}
function getInternalInventoryDataPub(ERC20 token)
public view
returns(bool isEnabled, uint minTokenBal, uint maxTokenBal, uint premiumBps, uint minSpreadBps)
{
}
/// @dev do a trade
/// @param srcToken Src token
/// @param srcAmount Amount of src token
/// @param destToken Destination token
/// @param destAddress Destination address to send tokens to
/// @return true iff trade is successful
function doTrade(
ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address payable destAddress,
uint conversionRate,
bool validate
)
internal
returns(bool)
{
}
function takeMatchingOrders(ERC20 destToken, uint srcAmount, OfferData[] memory offers)
internal
returns(uint actualDestAmount)
{
}
function shouldUseInternalInventory(
ERC20 token,
uint tokenVal,
uint ethVal,
bool ethToToken,
OfferData memory bid,
OfferData memory ask
)
internal view
returns(bool shouldUse, uint premiumBps)
{
}
function applyInternalInventoryHintToRate(
uint rate,
bool useInternalInventory
)
internal pure
returns(uint)
{
}
function valueAfterReducingFee(uint val) internal view returns(uint) {
}
function valueAfterAddingPremium(uint val, uint premium) internal pure returns(uint) {
}
function findBestOffers(
ERC20 dstToken,
ERC20 srcToken,
uint srcAmount,
OfferData memory bid,
OfferData memory ask
)
internal view
returns(uint totalDestAmount, OfferData[] memory offers)
{
}
// returns max takes, max traverse, min order size to take using config factor data
function calcOfferLimitsFromFactorData(
ERC20 token,
bool isEthToToken,
OfferData memory bid,
OfferData memory ask, uint srcAmount
)
internal view
returns(uint maxTakes, uint maxTraverse, uint minPayAmount)
{
}
// bid: buy WETH, ask: sell WETH (their base token is DAI)
function getFirstBidAndAskOrders(ERC20 token)
internal view
returns(OfferData memory bid, OfferData memory ask)
{
}
function getFirstOffer(ERC20 offerSellGem, ERC20 offerBuyGem)
internal view
returns(uint offerId, uint offerPayAmount, uint offerBuyAmount)
{
}
function checkValidSpread(OfferData memory bid, OfferData memory ask, bool isCheckingMinSpread, uint minSpreadBps)
internal pure
returns(bool)
{
}
function getTokenBasicData(ERC20 token)
internal view
returns(BasicDataConfig memory data)
{
}
function getFactorData(ERC20 token)
internal view
returns(FactorDataConfig memory data)
{
}
function getInternalInventoryData(ERC20 token)
internal view
returns(InternalInventoryData memory data)
{
}
function encodeInternalInventoryData(bool isEnabled, uint minTokenBal, uint maxTokenBal, uint premiumBps, uint minSpreadBps)
internal pure
returns(uint data)
{
}
function decodeInternalInventoryData(uint data)
internal pure
returns(bool isEnabled, uint minTokenBal, uint maxTokenBal, uint premiumBps, uint minSpreadBps)
{
}
function encodeTokenBasicData(uint ethSize, uint maxTraverse, uint maxTakes)
internal pure
returns(uint data)
{
}
function decodeTokenBasicData(uint data)
internal pure
returns(uint ethSize, uint maxTraverse, uint maxTakes)
{
}
function encodeFactorData(uint traverseX, uint traverseY, uint takeX, uint takeY, uint minSizeX, uint minSizeY)
internal pure
returns(uint data)
{
}
function decodeFactorData(uint data)
internal pure
returns(uint traverseX, uint traverseY, uint takeX, uint takeY, uint minSizeX, uint minSizeY)
{
}
}
| getDecimals(wethToken)==MAX_DECIMALS,"constructor: wethToken's decimals is not MAX_DECIMALS" | 386,886 | getDecimals(wethToken)==MAX_DECIMALS |
"constructor: failed to approve otc (wethToken)" | pragma solidity 0.5.11;
import "./ERC20InterfaceV5.sol";
import "./KyberReserveInterfaceV5.sol";
import "./WithdrawableV5.sol";
import "./UtilsV5.sol";
import "./OtcInterfaceV5.sol";
contract WethInterface is ERC20 {
function deposit() public payable;
function withdraw(uint) public;
}
contract Eth2DaiReserve is KyberReserveInterface, Withdrawable, Utils {
// constants
uint constant internal INVALID_ID = uint(-1);
uint constant internal POW_2_32 = 2 ** 32;
uint constant internal POW_2_96 = 2 ** 96;
uint constant internal BPS = 10000; // 10^4
// values
address public kyberNetwork;
bool public tradeEnabled;
uint public feeBps;
OtcInterface public otc;// = OtcInterface(0x39755357759cE0d7f32dC8dC45414CCa409AE24e);
WethInterface public wethToken;// = WethInterface(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
mapping(address => bool) public isTokenListed;
// 1 bit: isInternalInventoryEnabled, 95 bits: min token, 96 bits: max token, 32 bits: premiumBps, 32 bits: minSpreadBps;
mapping(address => uint) internal internalInventoryData;
// basicData contains compact data of min eth support, max traverse and max takes
// min eth support (first 192 bits) + max traverse (32 bits) + max takes (32 bits) = 256 bits
mapping(address => uint) internal tokenBasicData;
// factorData contains compact data of factors to compute max traverse, max takes, and min take order size
// 6 params, each 32 bits (6 * 32 = 192 bits)
mapping(address => uint) internal tokenFactorData;
struct BasicDataConfig {
uint minETHSupport;
uint maxTraverse;
uint maxTakes;
}
struct FactorDataConfig {
uint maxTraverseX;
uint maxTraverseY;
uint maxTakeX;
uint maxTakeY;
uint minOrderSizeX;
uint minOrderSizeY;
}
struct InternalInventoryData {
bool isEnabled;
uint minTokenBal;
uint maxTokenBal;
uint premiumBps;
uint minSpreadBps;
}
struct OfferData {
uint payAmount;
uint buyAmount;
uint id;
}
constructor(address _kyberNetwork, uint _feeBps, address _otc, address _weth, address _admin) public {
require(_kyberNetwork != address(0), "constructor: kyberNetwork's address is missing");
require(_otc != address(0), "constructor: otc's address is missing");
require(_weth != address(0), "constructor: weth's address is missing");
require(_feeBps < BPS, "constructor: fee >= bps");
require(_admin != address(0), "constructor: admin is missing");
wethToken = WethInterface(_weth);
require(getDecimals(wethToken) == MAX_DECIMALS, "constructor: wethToken's decimals is not MAX_DECIMALS");
require(<FILL_ME>)
kyberNetwork = _kyberNetwork;
otc = OtcInterface(_otc);
feeBps = _feeBps;
admin = _admin;
tradeEnabled = true;
}
function() external payable {} // solhint-disable-line no-empty-blocks
/**
Returns conversion rate of given pair and srcQty, use 1 as srcQty if srcQty = 0
Using eth amount to compute offer limit configurations
=> need to check spread is ok for token -> eth
Last bit of the rate indicates whether to use internal inventory:
0 - use eth2dai
1 - use internal inventory
*/
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint) public view returns(uint) {
}
event TradeExecute(
address indexed origin,
address src,
uint srcAmount,
address destToken,
uint destAmount,
address payable destAddress
);
function trade(
ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address payable destAddress,
uint conversionRate,
bool validate
)
public
payable
returns(bool)
{
}
event TokenConfigDataSet(
ERC20 token, uint maxTraverse, uint traveseFactorX, uint traveseFactorY,
uint maxTake, uint takeFactorX, uint takeFactorY,
uint minSizeFactorX, uint minSizeFactorY, uint minETHSupport
);
function setTokenConfigData(
ERC20 token, uint maxTraverse, uint traveseFactorX, uint traveseFactorY,
uint maxTake, uint takeFactorX, uint takeFactorY,
uint minSizeFactorX, uint minSizeFactorY, uint minETHSupport
)
public onlyAdmin
{
}
event TradeEnabled(bool enable);
function enableTrade() public onlyAdmin returns(bool) {
}
function disableTrade() public onlyAlerter returns(bool) {
}
event ContractsSet(address kyberNetwork, address otc);
function setContracts(address _kyberNetwork, address _otc) public onlyAdmin {
}
event InternalInventoryDataSet(uint minToken, uint maxToken, uint pricePremiumBps, uint minSpreadBps);
function setInternalInventoryData(
ERC20 token,
bool isEnabled,
uint minToken,
uint maxToken,
uint pricePremiumBps,
uint minSpreadBps
)
public onlyAdmin
{
}
event TokenListed(ERC20 token);
function listToken(ERC20 token) public onlyAdmin {
}
event TokenDelisted(ERC20 token);
function delistToken(ERC20 token) public onlyAdmin {
}
event FeeBpsSet(uint feeBps);
function setFeeBps(uint _feeBps) public onlyAdmin {
}
function getTokenBasicDataPub(ERC20 token)
public view
returns (uint minETHSupport, uint maxTraverse, uint maxTakes)
{
}
function getFactorDataPub(ERC20 token)
public view
returns (uint maxTraverseX, uint maxTraverseY, uint maxTakeX, uint maxTakeY, uint minOrderSizeX, uint minOrderSizeY)
{
}
function getInternalInventoryDataPub(ERC20 token)
public view
returns(bool isEnabled, uint minTokenBal, uint maxTokenBal, uint premiumBps, uint minSpreadBps)
{
}
/// @dev do a trade
/// @param srcToken Src token
/// @param srcAmount Amount of src token
/// @param destToken Destination token
/// @param destAddress Destination address to send tokens to
/// @return true iff trade is successful
function doTrade(
ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address payable destAddress,
uint conversionRate,
bool validate
)
internal
returns(bool)
{
}
function takeMatchingOrders(ERC20 destToken, uint srcAmount, OfferData[] memory offers)
internal
returns(uint actualDestAmount)
{
}
function shouldUseInternalInventory(
ERC20 token,
uint tokenVal,
uint ethVal,
bool ethToToken,
OfferData memory bid,
OfferData memory ask
)
internal view
returns(bool shouldUse, uint premiumBps)
{
}
function applyInternalInventoryHintToRate(
uint rate,
bool useInternalInventory
)
internal pure
returns(uint)
{
}
function valueAfterReducingFee(uint val) internal view returns(uint) {
}
function valueAfterAddingPremium(uint val, uint premium) internal pure returns(uint) {
}
function findBestOffers(
ERC20 dstToken,
ERC20 srcToken,
uint srcAmount,
OfferData memory bid,
OfferData memory ask
)
internal view
returns(uint totalDestAmount, OfferData[] memory offers)
{
}
// returns max takes, max traverse, min order size to take using config factor data
function calcOfferLimitsFromFactorData(
ERC20 token,
bool isEthToToken,
OfferData memory bid,
OfferData memory ask, uint srcAmount
)
internal view
returns(uint maxTakes, uint maxTraverse, uint minPayAmount)
{
}
// bid: buy WETH, ask: sell WETH (their base token is DAI)
function getFirstBidAndAskOrders(ERC20 token)
internal view
returns(OfferData memory bid, OfferData memory ask)
{
}
function getFirstOffer(ERC20 offerSellGem, ERC20 offerBuyGem)
internal view
returns(uint offerId, uint offerPayAmount, uint offerBuyAmount)
{
}
function checkValidSpread(OfferData memory bid, OfferData memory ask, bool isCheckingMinSpread, uint minSpreadBps)
internal pure
returns(bool)
{
}
function getTokenBasicData(ERC20 token)
internal view
returns(BasicDataConfig memory data)
{
}
function getFactorData(ERC20 token)
internal view
returns(FactorDataConfig memory data)
{
}
function getInternalInventoryData(ERC20 token)
internal view
returns(InternalInventoryData memory data)
{
}
function encodeInternalInventoryData(bool isEnabled, uint minTokenBal, uint maxTokenBal, uint premiumBps, uint minSpreadBps)
internal pure
returns(uint data)
{
}
function decodeInternalInventoryData(uint data)
internal pure
returns(bool isEnabled, uint minTokenBal, uint maxTokenBal, uint premiumBps, uint minSpreadBps)
{
}
function encodeTokenBasicData(uint ethSize, uint maxTraverse, uint maxTakes)
internal pure
returns(uint data)
{
}
function decodeTokenBasicData(uint data)
internal pure
returns(uint ethSize, uint maxTraverse, uint maxTakes)
{
}
function encodeFactorData(uint traverseX, uint traverseY, uint takeX, uint takeY, uint minSizeX, uint minSizeY)
internal pure
returns(uint data)
{
}
function decodeFactorData(uint data)
internal pure
returns(uint traverseX, uint traverseY, uint takeX, uint takeY, uint minSizeX, uint minSizeY)
{
}
}
| wethToken.approve(_otc,2**255),"constructor: failed to approve otc (wethToken)" | 386,886 | wethToken.approve(_otc,2**255) |
"trade: doTrade returns false" | pragma solidity 0.5.11;
import "./ERC20InterfaceV5.sol";
import "./KyberReserveInterfaceV5.sol";
import "./WithdrawableV5.sol";
import "./UtilsV5.sol";
import "./OtcInterfaceV5.sol";
contract WethInterface is ERC20 {
function deposit() public payable;
function withdraw(uint) public;
}
contract Eth2DaiReserve is KyberReserveInterface, Withdrawable, Utils {
// constants
uint constant internal INVALID_ID = uint(-1);
uint constant internal POW_2_32 = 2 ** 32;
uint constant internal POW_2_96 = 2 ** 96;
uint constant internal BPS = 10000; // 10^4
// values
address public kyberNetwork;
bool public tradeEnabled;
uint public feeBps;
OtcInterface public otc;// = OtcInterface(0x39755357759cE0d7f32dC8dC45414CCa409AE24e);
WethInterface public wethToken;// = WethInterface(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
mapping(address => bool) public isTokenListed;
// 1 bit: isInternalInventoryEnabled, 95 bits: min token, 96 bits: max token, 32 bits: premiumBps, 32 bits: minSpreadBps;
mapping(address => uint) internal internalInventoryData;
// basicData contains compact data of min eth support, max traverse and max takes
// min eth support (first 192 bits) + max traverse (32 bits) + max takes (32 bits) = 256 bits
mapping(address => uint) internal tokenBasicData;
// factorData contains compact data of factors to compute max traverse, max takes, and min take order size
// 6 params, each 32 bits (6 * 32 = 192 bits)
mapping(address => uint) internal tokenFactorData;
struct BasicDataConfig {
uint minETHSupport;
uint maxTraverse;
uint maxTakes;
}
struct FactorDataConfig {
uint maxTraverseX;
uint maxTraverseY;
uint maxTakeX;
uint maxTakeY;
uint minOrderSizeX;
uint minOrderSizeY;
}
struct InternalInventoryData {
bool isEnabled;
uint minTokenBal;
uint maxTokenBal;
uint premiumBps;
uint minSpreadBps;
}
struct OfferData {
uint payAmount;
uint buyAmount;
uint id;
}
constructor(address _kyberNetwork, uint _feeBps, address _otc, address _weth, address _admin) public {
}
function() external payable {} // solhint-disable-line no-empty-blocks
/**
Returns conversion rate of given pair and srcQty, use 1 as srcQty if srcQty = 0
Using eth amount to compute offer limit configurations
=> need to check spread is ok for token -> eth
Last bit of the rate indicates whether to use internal inventory:
0 - use eth2dai
1 - use internal inventory
*/
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint) public view returns(uint) {
}
event TradeExecute(
address indexed origin,
address src,
uint srcAmount,
address destToken,
uint destAmount,
address payable destAddress
);
function trade(
ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address payable destAddress,
uint conversionRate,
bool validate
)
public
payable
returns(bool)
{
require(tradeEnabled, "trade: tradeEnabled is false");
require(msg.sender == kyberNetwork, "trade: not call from kyberNetwork's contract");
require(srcToken == ETH_TOKEN_ADDRESS || destToken == ETH_TOKEN_ADDRESS, "trade: srcToken or destToken must be ETH");
ERC20 token = srcToken == ETH_TOKEN_ADDRESS ? destToken : srcToken;
require(isTokenListed[address(token)], "trade: token is not listed");
require(<FILL_ME>)
return true;
}
event TokenConfigDataSet(
ERC20 token, uint maxTraverse, uint traveseFactorX, uint traveseFactorY,
uint maxTake, uint takeFactorX, uint takeFactorY,
uint minSizeFactorX, uint minSizeFactorY, uint minETHSupport
);
function setTokenConfigData(
ERC20 token, uint maxTraverse, uint traveseFactorX, uint traveseFactorY,
uint maxTake, uint takeFactorX, uint takeFactorY,
uint minSizeFactorX, uint minSizeFactorY, uint minETHSupport
)
public onlyAdmin
{
}
event TradeEnabled(bool enable);
function enableTrade() public onlyAdmin returns(bool) {
}
function disableTrade() public onlyAlerter returns(bool) {
}
event ContractsSet(address kyberNetwork, address otc);
function setContracts(address _kyberNetwork, address _otc) public onlyAdmin {
}
event InternalInventoryDataSet(uint minToken, uint maxToken, uint pricePremiumBps, uint minSpreadBps);
function setInternalInventoryData(
ERC20 token,
bool isEnabled,
uint minToken,
uint maxToken,
uint pricePremiumBps,
uint minSpreadBps
)
public onlyAdmin
{
}
event TokenListed(ERC20 token);
function listToken(ERC20 token) public onlyAdmin {
}
event TokenDelisted(ERC20 token);
function delistToken(ERC20 token) public onlyAdmin {
}
event FeeBpsSet(uint feeBps);
function setFeeBps(uint _feeBps) public onlyAdmin {
}
function getTokenBasicDataPub(ERC20 token)
public view
returns (uint minETHSupport, uint maxTraverse, uint maxTakes)
{
}
function getFactorDataPub(ERC20 token)
public view
returns (uint maxTraverseX, uint maxTraverseY, uint maxTakeX, uint maxTakeY, uint minOrderSizeX, uint minOrderSizeY)
{
}
function getInternalInventoryDataPub(ERC20 token)
public view
returns(bool isEnabled, uint minTokenBal, uint maxTokenBal, uint premiumBps, uint minSpreadBps)
{
}
/// @dev do a trade
/// @param srcToken Src token
/// @param srcAmount Amount of src token
/// @param destToken Destination token
/// @param destAddress Destination address to send tokens to
/// @return true iff trade is successful
function doTrade(
ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address payable destAddress,
uint conversionRate,
bool validate
)
internal
returns(bool)
{
}
function takeMatchingOrders(ERC20 destToken, uint srcAmount, OfferData[] memory offers)
internal
returns(uint actualDestAmount)
{
}
function shouldUseInternalInventory(
ERC20 token,
uint tokenVal,
uint ethVal,
bool ethToToken,
OfferData memory bid,
OfferData memory ask
)
internal view
returns(bool shouldUse, uint premiumBps)
{
}
function applyInternalInventoryHintToRate(
uint rate,
bool useInternalInventory
)
internal pure
returns(uint)
{
}
function valueAfterReducingFee(uint val) internal view returns(uint) {
}
function valueAfterAddingPremium(uint val, uint premium) internal pure returns(uint) {
}
function findBestOffers(
ERC20 dstToken,
ERC20 srcToken,
uint srcAmount,
OfferData memory bid,
OfferData memory ask
)
internal view
returns(uint totalDestAmount, OfferData[] memory offers)
{
}
// returns max takes, max traverse, min order size to take using config factor data
function calcOfferLimitsFromFactorData(
ERC20 token,
bool isEthToToken,
OfferData memory bid,
OfferData memory ask, uint srcAmount
)
internal view
returns(uint maxTakes, uint maxTraverse, uint minPayAmount)
{
}
// bid: buy WETH, ask: sell WETH (their base token is DAI)
function getFirstBidAndAskOrders(ERC20 token)
internal view
returns(OfferData memory bid, OfferData memory ask)
{
}
function getFirstOffer(ERC20 offerSellGem, ERC20 offerBuyGem)
internal view
returns(uint offerId, uint offerPayAmount, uint offerBuyAmount)
{
}
function checkValidSpread(OfferData memory bid, OfferData memory ask, bool isCheckingMinSpread, uint minSpreadBps)
internal pure
returns(bool)
{
}
function getTokenBasicData(ERC20 token)
internal view
returns(BasicDataConfig memory data)
{
}
function getFactorData(ERC20 token)
internal view
returns(FactorDataConfig memory data)
{
}
function getInternalInventoryData(ERC20 token)
internal view
returns(InternalInventoryData memory data)
{
}
function encodeInternalInventoryData(bool isEnabled, uint minTokenBal, uint maxTokenBal, uint premiumBps, uint minSpreadBps)
internal pure
returns(uint data)
{
}
function decodeInternalInventoryData(uint data)
internal pure
returns(bool isEnabled, uint minTokenBal, uint maxTokenBal, uint premiumBps, uint minSpreadBps)
{
}
function encodeTokenBasicData(uint ethSize, uint maxTraverse, uint maxTakes)
internal pure
returns(uint data)
{
}
function decodeTokenBasicData(uint data)
internal pure
returns(uint ethSize, uint maxTraverse, uint maxTakes)
{
}
function encodeFactorData(uint traverseX, uint traverseY, uint takeX, uint takeY, uint minSizeX, uint minSizeY)
internal pure
returns(uint data)
{
}
function decodeFactorData(uint data)
internal pure
returns(uint traverseX, uint traverseY, uint takeX, uint takeY, uint minSizeX, uint minSizeY)
{
}
}
| doTrade(srcToken,srcAmount,destToken,destAddress,conversionRate,validate),"trade: doTrade returns false" | 386,886 | doTrade(srcToken,srcAmount,destToken,destAddress,conversionRate,validate) |
"doTrade: (useInternalInventory) can not transfer back token" | pragma solidity 0.5.11;
import "./ERC20InterfaceV5.sol";
import "./KyberReserveInterfaceV5.sol";
import "./WithdrawableV5.sol";
import "./UtilsV5.sol";
import "./OtcInterfaceV5.sol";
contract WethInterface is ERC20 {
function deposit() public payable;
function withdraw(uint) public;
}
contract Eth2DaiReserve is KyberReserveInterface, Withdrawable, Utils {
// constants
uint constant internal INVALID_ID = uint(-1);
uint constant internal POW_2_32 = 2 ** 32;
uint constant internal POW_2_96 = 2 ** 96;
uint constant internal BPS = 10000; // 10^4
// values
address public kyberNetwork;
bool public tradeEnabled;
uint public feeBps;
OtcInterface public otc;// = OtcInterface(0x39755357759cE0d7f32dC8dC45414CCa409AE24e);
WethInterface public wethToken;// = WethInterface(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
mapping(address => bool) public isTokenListed;
// 1 bit: isInternalInventoryEnabled, 95 bits: min token, 96 bits: max token, 32 bits: premiumBps, 32 bits: minSpreadBps;
mapping(address => uint) internal internalInventoryData;
// basicData contains compact data of min eth support, max traverse and max takes
// min eth support (first 192 bits) + max traverse (32 bits) + max takes (32 bits) = 256 bits
mapping(address => uint) internal tokenBasicData;
// factorData contains compact data of factors to compute max traverse, max takes, and min take order size
// 6 params, each 32 bits (6 * 32 = 192 bits)
mapping(address => uint) internal tokenFactorData;
struct BasicDataConfig {
uint minETHSupport;
uint maxTraverse;
uint maxTakes;
}
struct FactorDataConfig {
uint maxTraverseX;
uint maxTraverseY;
uint maxTakeX;
uint maxTakeY;
uint minOrderSizeX;
uint minOrderSizeY;
}
struct InternalInventoryData {
bool isEnabled;
uint minTokenBal;
uint maxTokenBal;
uint premiumBps;
uint minSpreadBps;
}
struct OfferData {
uint payAmount;
uint buyAmount;
uint id;
}
constructor(address _kyberNetwork, uint _feeBps, address _otc, address _weth, address _admin) public {
}
function() external payable {} // solhint-disable-line no-empty-blocks
/**
Returns conversion rate of given pair and srcQty, use 1 as srcQty if srcQty = 0
Using eth amount to compute offer limit configurations
=> need to check spread is ok for token -> eth
Last bit of the rate indicates whether to use internal inventory:
0 - use eth2dai
1 - use internal inventory
*/
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint) public view returns(uint) {
}
event TradeExecute(
address indexed origin,
address src,
uint srcAmount,
address destToken,
uint destAmount,
address payable destAddress
);
function trade(
ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address payable destAddress,
uint conversionRate,
bool validate
)
public
payable
returns(bool)
{
}
event TokenConfigDataSet(
ERC20 token, uint maxTraverse, uint traveseFactorX, uint traveseFactorY,
uint maxTake, uint takeFactorX, uint takeFactorY,
uint minSizeFactorX, uint minSizeFactorY, uint minETHSupport
);
function setTokenConfigData(
ERC20 token, uint maxTraverse, uint traveseFactorX, uint traveseFactorY,
uint maxTake, uint takeFactorX, uint takeFactorY,
uint minSizeFactorX, uint minSizeFactorY, uint minETHSupport
)
public onlyAdmin
{
}
event TradeEnabled(bool enable);
function enableTrade() public onlyAdmin returns(bool) {
}
function disableTrade() public onlyAlerter returns(bool) {
}
event ContractsSet(address kyberNetwork, address otc);
function setContracts(address _kyberNetwork, address _otc) public onlyAdmin {
}
event InternalInventoryDataSet(uint minToken, uint maxToken, uint pricePremiumBps, uint minSpreadBps);
function setInternalInventoryData(
ERC20 token,
bool isEnabled,
uint minToken,
uint maxToken,
uint pricePremiumBps,
uint minSpreadBps
)
public onlyAdmin
{
}
event TokenListed(ERC20 token);
function listToken(ERC20 token) public onlyAdmin {
}
event TokenDelisted(ERC20 token);
function delistToken(ERC20 token) public onlyAdmin {
}
event FeeBpsSet(uint feeBps);
function setFeeBps(uint _feeBps) public onlyAdmin {
}
function getTokenBasicDataPub(ERC20 token)
public view
returns (uint minETHSupport, uint maxTraverse, uint maxTakes)
{
}
function getFactorDataPub(ERC20 token)
public view
returns (uint maxTraverseX, uint maxTraverseY, uint maxTakeX, uint maxTakeY, uint minOrderSizeX, uint minOrderSizeY)
{
}
function getInternalInventoryDataPub(ERC20 token)
public view
returns(bool isEnabled, uint minTokenBal, uint maxTokenBal, uint premiumBps, uint minSpreadBps)
{
}
/// @dev do a trade
/// @param srcToken Src token
/// @param srcAmount Amount of src token
/// @param destToken Destination token
/// @param destAddress Destination address to send tokens to
/// @return true iff trade is successful
function doTrade(
ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address payable destAddress,
uint conversionRate,
bool validate
)
internal
returns(bool)
{
// can skip validation if done at kyber network level
if (validate) {
require(conversionRate > 0, "doTrade: conversionRate is 0");
if (srcToken == ETH_TOKEN_ADDRESS)
require(msg.value == srcAmount, "doTrade: msg.value != srcAmount");
else
require(msg.value == 0, "doTrade: msg.value must be 0");
}
uint userExpectedDestAmount = calcDstQty(srcAmount, MAX_DECIMALS, MAX_DECIMALS, conversionRate);
require(userExpectedDestAmount > 0, "doTrade: userExpectedDestAmount == 0"); // sanity check
uint actualDestAmount;
// using hint to check if we should use our internal inventory
bool useInternalInventory = conversionRate % 2 == 1;
if (useInternalInventory) {
// taking from internal inventory and return
if (srcToken == ETH_TOKEN_ADDRESS) {
// transfer back only requested dest amount.
require(<FILL_ME>)
} else {
// collect src token
require(srcToken.transferFrom(msg.sender, address(this), srcAmount), "doTrade: (useInternalInventory) can not collect src token");
// transfer back only requested dest amount.
destAddress.transfer(userExpectedDestAmount);
}
emit TradeExecute(msg.sender, address(srcToken), srcAmount, address(destToken), userExpectedDestAmount, destAddress);
return true;
}
OfferData memory bid;
OfferData memory ask;
(bid, ask) = getFirstBidAndAskOrders(srcToken == ETH_TOKEN_ADDRESS ? destToken : srcToken);
// get offers to take
OfferData[] memory offers;
if (srcToken == ETH_TOKEN_ADDRESS) {
(actualDestAmount, offers) = findBestOffers(destToken, wethToken, srcAmount, bid, ask);
} else {
(actualDestAmount, offers) = findBestOffers(wethToken, srcToken, srcAmount, bid, ask);
}
require(actualDestAmount >= userExpectedDestAmount, "doTrade: actualDestAmount is less than userExpectedDestAmount");
if (srcToken == ETH_TOKEN_ADDRESS) {
wethToken.deposit.value(msg.value)();
actualDestAmount = takeMatchingOrders(destToken, srcAmount, offers);
require(actualDestAmount >= userExpectedDestAmount, "doTrade: actualDestAmount is less than userExpectedDestAmount, eth to token");
// transfer back only requested dest amount
require(destToken.transfer(destAddress, userExpectedDestAmount), "doTrade: can not transfer back requested token");
} else {
// collect src tokens
require(srcToken.transferFrom(msg.sender, address(this), srcAmount), "doTrade: can not collect src token");
actualDestAmount = takeMatchingOrders(wethToken, srcAmount, offers);
require(actualDestAmount >= userExpectedDestAmount, "doTrade: actualDestAmount is less than userExpectedDestAmount, token to eth");
wethToken.withdraw(actualDestAmount);
// transfer back only requested dest amount.
destAddress.transfer(userExpectedDestAmount);
}
emit TradeExecute(msg.sender, address(srcToken), srcAmount, address(destToken), userExpectedDestAmount, destAddress);
return true;
}
function takeMatchingOrders(ERC20 destToken, uint srcAmount, OfferData[] memory offers)
internal
returns(uint actualDestAmount)
{
}
function shouldUseInternalInventory(
ERC20 token,
uint tokenVal,
uint ethVal,
bool ethToToken,
OfferData memory bid,
OfferData memory ask
)
internal view
returns(bool shouldUse, uint premiumBps)
{
}
function applyInternalInventoryHintToRate(
uint rate,
bool useInternalInventory
)
internal pure
returns(uint)
{
}
function valueAfterReducingFee(uint val) internal view returns(uint) {
}
function valueAfterAddingPremium(uint val, uint premium) internal pure returns(uint) {
}
function findBestOffers(
ERC20 dstToken,
ERC20 srcToken,
uint srcAmount,
OfferData memory bid,
OfferData memory ask
)
internal view
returns(uint totalDestAmount, OfferData[] memory offers)
{
}
// returns max takes, max traverse, min order size to take using config factor data
function calcOfferLimitsFromFactorData(
ERC20 token,
bool isEthToToken,
OfferData memory bid,
OfferData memory ask, uint srcAmount
)
internal view
returns(uint maxTakes, uint maxTraverse, uint minPayAmount)
{
}
// bid: buy WETH, ask: sell WETH (their base token is DAI)
function getFirstBidAndAskOrders(ERC20 token)
internal view
returns(OfferData memory bid, OfferData memory ask)
{
}
function getFirstOffer(ERC20 offerSellGem, ERC20 offerBuyGem)
internal view
returns(uint offerId, uint offerPayAmount, uint offerBuyAmount)
{
}
function checkValidSpread(OfferData memory bid, OfferData memory ask, bool isCheckingMinSpread, uint minSpreadBps)
internal pure
returns(bool)
{
}
function getTokenBasicData(ERC20 token)
internal view
returns(BasicDataConfig memory data)
{
}
function getFactorData(ERC20 token)
internal view
returns(FactorDataConfig memory data)
{
}
function getInternalInventoryData(ERC20 token)
internal view
returns(InternalInventoryData memory data)
{
}
function encodeInternalInventoryData(bool isEnabled, uint minTokenBal, uint maxTokenBal, uint premiumBps, uint minSpreadBps)
internal pure
returns(uint data)
{
}
function decodeInternalInventoryData(uint data)
internal pure
returns(bool isEnabled, uint minTokenBal, uint maxTokenBal, uint premiumBps, uint minSpreadBps)
{
}
function encodeTokenBasicData(uint ethSize, uint maxTraverse, uint maxTakes)
internal pure
returns(uint data)
{
}
function decodeTokenBasicData(uint data)
internal pure
returns(uint ethSize, uint maxTraverse, uint maxTakes)
{
}
function encodeFactorData(uint traverseX, uint traverseY, uint takeX, uint takeY, uint minSizeX, uint minSizeY)
internal pure
returns(uint data)
{
}
function decodeFactorData(uint data)
internal pure
returns(uint traverseX, uint traverseY, uint takeX, uint takeY, uint minSizeX, uint minSizeY)
{
}
}
| destToken.transfer(destAddress,userExpectedDestAmount),"doTrade: (useInternalInventory) can not transfer back token" | 386,886 | destToken.transfer(destAddress,userExpectedDestAmount) |
"Token Locked" | pragma solidity ^0.7.6;
contract UnifarmV2Fixed is Ownable {
struct lockabelToken {
uint256 lockableDays;
bool optionableStatus;
}
Unifarm public uniV2;
using SafeMath for uint256;
uint256[] public intervalDays = [1, 8, 15, 22, 29, 36];
uint256 public constant DAYS = 1 days;
mapping(address => uint256) public totalUnStakingB;
mapping(address => uint256) public totalUnStakingA;
mapping(address => lockabelToken) public lockableDetailsB;
mapping(address => mapping(uint256 => bool)) public unstakeStatus;
event IntervalDaysDetails(uint256[] updatedIntervals, uint256 time);
event Claim(
address indexed userAddress,
address indexed stakedTokenAddress,
address indexed tokenAddress,
uint256 claimRewards,
uint256 time
);
event UnStake(
address indexed userAddress,
address indexed unStakedtokenAddress,
uint256 unStakedAmount,
uint256 time,
uint256 stakeID
);
event ReferralEarn(
address indexed userAddress,
address indexed callerAddress,
address indexed rewardTokenAddress,
uint256 rewardAmount,
uint256 time
);
event LockableTokenDetails(
address indexed tokenAddress,
uint256 lockableDys,
bool optionalbleStatus,
uint256 updatedTime
);
event WithdrawDetails(
address indexed tokenAddress,
uint256 withdrawalAmount,
uint256 time
);
constructor(address v2Address) Ownable(msg.sender) {
}
function init(address[] memory tokenAddress)
external
onlyOwner
returns (bool)
{
}
function transferFromContractV2(address tokenAddress) internal {
}
/**
* @notice send rewards
* @param stakedToken Stake amount of the user
* @param tokenAddress Reward token address
* @param amount Amount to be transferred as reward
*/
function sendToken(
address user,
address stakedToken,
address tokenAddress,
uint256 amount
) internal {
}
/**
* @notice Unstake and claim rewards
* @param stakeId Stake ID of the user
*/
function unStake(address user, uint256 stakeId) external whenNotPaused {
require(
msg.sender == user || msg.sender == _owner,
"UNSTAKE: Invalid User Entry"
);
(
,
address[] memory tokenAddress,
bool[] memory activeStatus,
,
uint256[] memory stakedAmount,
uint256[] memory startTime
) = (uniV2.viewStakingDetails(user));
// lockableDays check
require(<FILL_ME>)
// optional lock check
if (lockableDetailsB[tokenAddress[stakeId]].optionableStatus == true) {
require(
startTime[stakeId].add(uniV2.stakeDuration()) <= block.timestamp,
"Locked in optional lock"
);
}
// Checks
if (unstakeStatus[user][stakeId] == false && activeStatus[stakeId] == true)
unstakeStatus[user][stakeId] = true;
else revert("UNSTAKE : Unstaked Already");
// State updation
uint256 totalStaking =
uniV2.totalStaking(tokenAddress[stakeId]).sub(
totalUnStakingB[tokenAddress[stakeId]].add(
totalUnStakingA[tokenAddress[stakeId]]
)
);
totalUnStakingB[tokenAddress[stakeId]] = totalUnStakingB[
tokenAddress[stakeId]
]
.add(stakedAmount[stakeId]);
// Balance check
require(
IERC20(tokenAddress[stakeId]).balanceOf(address(this)) >=
stakedAmount[stakeId],
"UNSTAKE : Insufficient Balance"
);
IERC20(tokenAddress[stakeId]).transfer(user, stakedAmount[stakeId]);
claimRewards(user, stakeId, totalStaking);
// Emit state changes
emit UnStake(
user,
tokenAddress[stakeId],
stakedAmount[stakeId],
block.timestamp,
stakeId
);
}
function updateIntervalDays(uint256[] memory _interval) external onlyOwner {
}
function lockableToken(
address tokenAddress,
uint8 lockableStatus,
uint256 lockedDays,
bool optionableStatus
) external onlyOwner {
}
function transferV2Ownership(address newOwner) external onlyOwner {
}
function safeWithdraw(address tokenAddress, uint256 amount)
external
onlyOwner
{
}
function updateV2Address(address v2Address)
external
onlyOwner
returns (bool)
{
}
function updateTotalUnstakingA(
address[] memory tokenAddress,
uint256[] memory tokenAmount
) external onlyOwner returns (bool) {
}
function totalStakingDetails(address tokenAddress)
external
view
returns (uint256)
{
}
function emergencyUnstake(
uint256 stakeId,
address userAddress,
address[] memory rewardtokens,
uint256[] memory amount
) external onlyOwner {
}
function lockContract(bool pauseStatus) external onlyOwner {
}
/**
* @notice Get rewards for one day
* @param stakedAmount Stake amount of the user
* @param stakedToken Staked token address of the user
* @param rewardToken Reward token address
* @param totalStake totalStakeAmount
* @return reward One dayh reward for the user
*/
function getOneDayReward(
uint256 stakedAmount,
address stakedToken,
address rewardToken,
uint256 totalStake
) public view returns (uint256 reward) {
}
function claimRewards(
address user,
uint256 stakeId,
uint256 totalStaking
) internal {
}
function _rewardCalculation(
address user,
address referrerAddress,
address stakedToken,
uint256 stakedAmount,
uint256 interval,
uint256 totalStake
) internal {
}
}
| lockableDetailsB[tokenAddress[stakeId]].lockableDays<=block.timestamp,"Token Locked" | 387,089 | lockableDetailsB[tokenAddress[stakeId]].lockableDays<=block.timestamp |
"Locked in optional lock" | pragma solidity ^0.7.6;
contract UnifarmV2Fixed is Ownable {
struct lockabelToken {
uint256 lockableDays;
bool optionableStatus;
}
Unifarm public uniV2;
using SafeMath for uint256;
uint256[] public intervalDays = [1, 8, 15, 22, 29, 36];
uint256 public constant DAYS = 1 days;
mapping(address => uint256) public totalUnStakingB;
mapping(address => uint256) public totalUnStakingA;
mapping(address => lockabelToken) public lockableDetailsB;
mapping(address => mapping(uint256 => bool)) public unstakeStatus;
event IntervalDaysDetails(uint256[] updatedIntervals, uint256 time);
event Claim(
address indexed userAddress,
address indexed stakedTokenAddress,
address indexed tokenAddress,
uint256 claimRewards,
uint256 time
);
event UnStake(
address indexed userAddress,
address indexed unStakedtokenAddress,
uint256 unStakedAmount,
uint256 time,
uint256 stakeID
);
event ReferralEarn(
address indexed userAddress,
address indexed callerAddress,
address indexed rewardTokenAddress,
uint256 rewardAmount,
uint256 time
);
event LockableTokenDetails(
address indexed tokenAddress,
uint256 lockableDys,
bool optionalbleStatus,
uint256 updatedTime
);
event WithdrawDetails(
address indexed tokenAddress,
uint256 withdrawalAmount,
uint256 time
);
constructor(address v2Address) Ownable(msg.sender) {
}
function init(address[] memory tokenAddress)
external
onlyOwner
returns (bool)
{
}
function transferFromContractV2(address tokenAddress) internal {
}
/**
* @notice send rewards
* @param stakedToken Stake amount of the user
* @param tokenAddress Reward token address
* @param amount Amount to be transferred as reward
*/
function sendToken(
address user,
address stakedToken,
address tokenAddress,
uint256 amount
) internal {
}
/**
* @notice Unstake and claim rewards
* @param stakeId Stake ID of the user
*/
function unStake(address user, uint256 stakeId) external whenNotPaused {
require(
msg.sender == user || msg.sender == _owner,
"UNSTAKE: Invalid User Entry"
);
(
,
address[] memory tokenAddress,
bool[] memory activeStatus,
,
uint256[] memory stakedAmount,
uint256[] memory startTime
) = (uniV2.viewStakingDetails(user));
// lockableDays check
require(
lockableDetailsB[tokenAddress[stakeId]].lockableDays <= block.timestamp,
"Token Locked"
);
// optional lock check
if (lockableDetailsB[tokenAddress[stakeId]].optionableStatus == true) {
require(<FILL_ME>)
}
// Checks
if (unstakeStatus[user][stakeId] == false && activeStatus[stakeId] == true)
unstakeStatus[user][stakeId] = true;
else revert("UNSTAKE : Unstaked Already");
// State updation
uint256 totalStaking =
uniV2.totalStaking(tokenAddress[stakeId]).sub(
totalUnStakingB[tokenAddress[stakeId]].add(
totalUnStakingA[tokenAddress[stakeId]]
)
);
totalUnStakingB[tokenAddress[stakeId]] = totalUnStakingB[
tokenAddress[stakeId]
]
.add(stakedAmount[stakeId]);
// Balance check
require(
IERC20(tokenAddress[stakeId]).balanceOf(address(this)) >=
stakedAmount[stakeId],
"UNSTAKE : Insufficient Balance"
);
IERC20(tokenAddress[stakeId]).transfer(user, stakedAmount[stakeId]);
claimRewards(user, stakeId, totalStaking);
// Emit state changes
emit UnStake(
user,
tokenAddress[stakeId],
stakedAmount[stakeId],
block.timestamp,
stakeId
);
}
function updateIntervalDays(uint256[] memory _interval) external onlyOwner {
}
function lockableToken(
address tokenAddress,
uint8 lockableStatus,
uint256 lockedDays,
bool optionableStatus
) external onlyOwner {
}
function transferV2Ownership(address newOwner) external onlyOwner {
}
function safeWithdraw(address tokenAddress, uint256 amount)
external
onlyOwner
{
}
function updateV2Address(address v2Address)
external
onlyOwner
returns (bool)
{
}
function updateTotalUnstakingA(
address[] memory tokenAddress,
uint256[] memory tokenAmount
) external onlyOwner returns (bool) {
}
function totalStakingDetails(address tokenAddress)
external
view
returns (uint256)
{
}
function emergencyUnstake(
uint256 stakeId,
address userAddress,
address[] memory rewardtokens,
uint256[] memory amount
) external onlyOwner {
}
function lockContract(bool pauseStatus) external onlyOwner {
}
/**
* @notice Get rewards for one day
* @param stakedAmount Stake amount of the user
* @param stakedToken Staked token address of the user
* @param rewardToken Reward token address
* @param totalStake totalStakeAmount
* @return reward One dayh reward for the user
*/
function getOneDayReward(
uint256 stakedAmount,
address stakedToken,
address rewardToken,
uint256 totalStake
) public view returns (uint256 reward) {
}
function claimRewards(
address user,
uint256 stakeId,
uint256 totalStaking
) internal {
}
function _rewardCalculation(
address user,
address referrerAddress,
address stakedToken,
uint256 stakedAmount,
uint256 interval,
uint256 totalStake
) internal {
}
}
| startTime[stakeId].add(uniV2.stakeDuration())<=block.timestamp,"Locked in optional lock" | 387,089 | startTime[stakeId].add(uniV2.stakeDuration())<=block.timestamp |
"UNSTAKE : Insufficient Balance" | pragma solidity ^0.7.6;
contract UnifarmV2Fixed is Ownable {
struct lockabelToken {
uint256 lockableDays;
bool optionableStatus;
}
Unifarm public uniV2;
using SafeMath for uint256;
uint256[] public intervalDays = [1, 8, 15, 22, 29, 36];
uint256 public constant DAYS = 1 days;
mapping(address => uint256) public totalUnStakingB;
mapping(address => uint256) public totalUnStakingA;
mapping(address => lockabelToken) public lockableDetailsB;
mapping(address => mapping(uint256 => bool)) public unstakeStatus;
event IntervalDaysDetails(uint256[] updatedIntervals, uint256 time);
event Claim(
address indexed userAddress,
address indexed stakedTokenAddress,
address indexed tokenAddress,
uint256 claimRewards,
uint256 time
);
event UnStake(
address indexed userAddress,
address indexed unStakedtokenAddress,
uint256 unStakedAmount,
uint256 time,
uint256 stakeID
);
event ReferralEarn(
address indexed userAddress,
address indexed callerAddress,
address indexed rewardTokenAddress,
uint256 rewardAmount,
uint256 time
);
event LockableTokenDetails(
address indexed tokenAddress,
uint256 lockableDys,
bool optionalbleStatus,
uint256 updatedTime
);
event WithdrawDetails(
address indexed tokenAddress,
uint256 withdrawalAmount,
uint256 time
);
constructor(address v2Address) Ownable(msg.sender) {
}
function init(address[] memory tokenAddress)
external
onlyOwner
returns (bool)
{
}
function transferFromContractV2(address tokenAddress) internal {
}
/**
* @notice send rewards
* @param stakedToken Stake amount of the user
* @param tokenAddress Reward token address
* @param amount Amount to be transferred as reward
*/
function sendToken(
address user,
address stakedToken,
address tokenAddress,
uint256 amount
) internal {
}
/**
* @notice Unstake and claim rewards
* @param stakeId Stake ID of the user
*/
function unStake(address user, uint256 stakeId) external whenNotPaused {
require(
msg.sender == user || msg.sender == _owner,
"UNSTAKE: Invalid User Entry"
);
(
,
address[] memory tokenAddress,
bool[] memory activeStatus,
,
uint256[] memory stakedAmount,
uint256[] memory startTime
) = (uniV2.viewStakingDetails(user));
// lockableDays check
require(
lockableDetailsB[tokenAddress[stakeId]].lockableDays <= block.timestamp,
"Token Locked"
);
// optional lock check
if (lockableDetailsB[tokenAddress[stakeId]].optionableStatus == true) {
require(
startTime[stakeId].add(uniV2.stakeDuration()) <= block.timestamp,
"Locked in optional lock"
);
}
// Checks
if (unstakeStatus[user][stakeId] == false && activeStatus[stakeId] == true)
unstakeStatus[user][stakeId] = true;
else revert("UNSTAKE : Unstaked Already");
// State updation
uint256 totalStaking =
uniV2.totalStaking(tokenAddress[stakeId]).sub(
totalUnStakingB[tokenAddress[stakeId]].add(
totalUnStakingA[tokenAddress[stakeId]]
)
);
totalUnStakingB[tokenAddress[stakeId]] = totalUnStakingB[
tokenAddress[stakeId]
]
.add(stakedAmount[stakeId]);
// Balance check
require(<FILL_ME>)
IERC20(tokenAddress[stakeId]).transfer(user, stakedAmount[stakeId]);
claimRewards(user, stakeId, totalStaking);
// Emit state changes
emit UnStake(
user,
tokenAddress[stakeId],
stakedAmount[stakeId],
block.timestamp,
stakeId
);
}
function updateIntervalDays(uint256[] memory _interval) external onlyOwner {
}
function lockableToken(
address tokenAddress,
uint8 lockableStatus,
uint256 lockedDays,
bool optionableStatus
) external onlyOwner {
}
function transferV2Ownership(address newOwner) external onlyOwner {
}
function safeWithdraw(address tokenAddress, uint256 amount)
external
onlyOwner
{
}
function updateV2Address(address v2Address)
external
onlyOwner
returns (bool)
{
}
function updateTotalUnstakingA(
address[] memory tokenAddress,
uint256[] memory tokenAmount
) external onlyOwner returns (bool) {
}
function totalStakingDetails(address tokenAddress)
external
view
returns (uint256)
{
}
function emergencyUnstake(
uint256 stakeId,
address userAddress,
address[] memory rewardtokens,
uint256[] memory amount
) external onlyOwner {
}
function lockContract(bool pauseStatus) external onlyOwner {
}
/**
* @notice Get rewards for one day
* @param stakedAmount Stake amount of the user
* @param stakedToken Staked token address of the user
* @param rewardToken Reward token address
* @param totalStake totalStakeAmount
* @return reward One dayh reward for the user
*/
function getOneDayReward(
uint256 stakedAmount,
address stakedToken,
address rewardToken,
uint256 totalStake
) public view returns (uint256 reward) {
}
function claimRewards(
address user,
uint256 stakeId,
uint256 totalStaking
) internal {
}
function _rewardCalculation(
address user,
address referrerAddress,
address stakedToken,
uint256 stakedAmount,
uint256 interval,
uint256 totalStake
) internal {
}
}
| IERC20(tokenAddress[stakeId]).balanceOf(address(this))>=stakedAmount[stakeId],"UNSTAKE : Insufficient Balance" | 387,089 | IERC20(tokenAddress[stakeId]).balanceOf(address(this))>=stakedAmount[stakeId] |
"SAFEWITHDRAW: Transfer failed" | pragma solidity ^0.7.6;
contract UnifarmV2Fixed is Ownable {
struct lockabelToken {
uint256 lockableDays;
bool optionableStatus;
}
Unifarm public uniV2;
using SafeMath for uint256;
uint256[] public intervalDays = [1, 8, 15, 22, 29, 36];
uint256 public constant DAYS = 1 days;
mapping(address => uint256) public totalUnStakingB;
mapping(address => uint256) public totalUnStakingA;
mapping(address => lockabelToken) public lockableDetailsB;
mapping(address => mapping(uint256 => bool)) public unstakeStatus;
event IntervalDaysDetails(uint256[] updatedIntervals, uint256 time);
event Claim(
address indexed userAddress,
address indexed stakedTokenAddress,
address indexed tokenAddress,
uint256 claimRewards,
uint256 time
);
event UnStake(
address indexed userAddress,
address indexed unStakedtokenAddress,
uint256 unStakedAmount,
uint256 time,
uint256 stakeID
);
event ReferralEarn(
address indexed userAddress,
address indexed callerAddress,
address indexed rewardTokenAddress,
uint256 rewardAmount,
uint256 time
);
event LockableTokenDetails(
address indexed tokenAddress,
uint256 lockableDys,
bool optionalbleStatus,
uint256 updatedTime
);
event WithdrawDetails(
address indexed tokenAddress,
uint256 withdrawalAmount,
uint256 time
);
constructor(address v2Address) Ownable(msg.sender) {
}
function init(address[] memory tokenAddress)
external
onlyOwner
returns (bool)
{
}
function transferFromContractV2(address tokenAddress) internal {
}
/**
* @notice send rewards
* @param stakedToken Stake amount of the user
* @param tokenAddress Reward token address
* @param amount Amount to be transferred as reward
*/
function sendToken(
address user,
address stakedToken,
address tokenAddress,
uint256 amount
) internal {
}
/**
* @notice Unstake and claim rewards
* @param stakeId Stake ID of the user
*/
function unStake(address user, uint256 stakeId) external whenNotPaused {
}
function updateIntervalDays(uint256[] memory _interval) external onlyOwner {
}
function lockableToken(
address tokenAddress,
uint8 lockableStatus,
uint256 lockedDays,
bool optionableStatus
) external onlyOwner {
}
function transferV2Ownership(address newOwner) external onlyOwner {
}
function safeWithdraw(address tokenAddress, uint256 amount)
external
onlyOwner
{
require(
IERC20(tokenAddress).balanceOf(address(this)) >= amount,
"SAFEWITHDRAW: Insufficient Balance"
);
require(<FILL_ME>)
emit WithdrawDetails(tokenAddress, amount, block.timestamp);
}
function updateV2Address(address v2Address)
external
onlyOwner
returns (bool)
{
}
function updateTotalUnstakingA(
address[] memory tokenAddress,
uint256[] memory tokenAmount
) external onlyOwner returns (bool) {
}
function totalStakingDetails(address tokenAddress)
external
view
returns (uint256)
{
}
function emergencyUnstake(
uint256 stakeId,
address userAddress,
address[] memory rewardtokens,
uint256[] memory amount
) external onlyOwner {
}
function lockContract(bool pauseStatus) external onlyOwner {
}
/**
* @notice Get rewards for one day
* @param stakedAmount Stake amount of the user
* @param stakedToken Staked token address of the user
* @param rewardToken Reward token address
* @param totalStake totalStakeAmount
* @return reward One dayh reward for the user
*/
function getOneDayReward(
uint256 stakedAmount,
address stakedToken,
address rewardToken,
uint256 totalStake
) public view returns (uint256 reward) {
}
function claimRewards(
address user,
uint256 stakeId,
uint256 totalStaking
) internal {
}
function _rewardCalculation(
address user,
address referrerAddress,
address stakedToken,
uint256 stakedAmount,
uint256 interval,
uint256 totalStake
) internal {
}
}
| IERC20(tokenAddress).transfer(_owner,amount)==true,"SAFEWITHDRAW: Transfer failed" | 387,089 | IERC20(tokenAddress).transfer(_owner,amount)==true |
"EMERGENCY : Insufficient Reward Balance" | pragma solidity ^0.7.6;
contract UnifarmV2Fixed is Ownable {
struct lockabelToken {
uint256 lockableDays;
bool optionableStatus;
}
Unifarm public uniV2;
using SafeMath for uint256;
uint256[] public intervalDays = [1, 8, 15, 22, 29, 36];
uint256 public constant DAYS = 1 days;
mapping(address => uint256) public totalUnStakingB;
mapping(address => uint256) public totalUnStakingA;
mapping(address => lockabelToken) public lockableDetailsB;
mapping(address => mapping(uint256 => bool)) public unstakeStatus;
event IntervalDaysDetails(uint256[] updatedIntervals, uint256 time);
event Claim(
address indexed userAddress,
address indexed stakedTokenAddress,
address indexed tokenAddress,
uint256 claimRewards,
uint256 time
);
event UnStake(
address indexed userAddress,
address indexed unStakedtokenAddress,
uint256 unStakedAmount,
uint256 time,
uint256 stakeID
);
event ReferralEarn(
address indexed userAddress,
address indexed callerAddress,
address indexed rewardTokenAddress,
uint256 rewardAmount,
uint256 time
);
event LockableTokenDetails(
address indexed tokenAddress,
uint256 lockableDys,
bool optionalbleStatus,
uint256 updatedTime
);
event WithdrawDetails(
address indexed tokenAddress,
uint256 withdrawalAmount,
uint256 time
);
constructor(address v2Address) Ownable(msg.sender) {
}
function init(address[] memory tokenAddress)
external
onlyOwner
returns (bool)
{
}
function transferFromContractV2(address tokenAddress) internal {
}
/**
* @notice send rewards
* @param stakedToken Stake amount of the user
* @param tokenAddress Reward token address
* @param amount Amount to be transferred as reward
*/
function sendToken(
address user,
address stakedToken,
address tokenAddress,
uint256 amount
) internal {
}
/**
* @notice Unstake and claim rewards
* @param stakeId Stake ID of the user
*/
function unStake(address user, uint256 stakeId) external whenNotPaused {
}
function updateIntervalDays(uint256[] memory _interval) external onlyOwner {
}
function lockableToken(
address tokenAddress,
uint8 lockableStatus,
uint256 lockedDays,
bool optionableStatus
) external onlyOwner {
}
function transferV2Ownership(address newOwner) external onlyOwner {
}
function safeWithdraw(address tokenAddress, uint256 amount)
external
onlyOwner
{
}
function updateV2Address(address v2Address)
external
onlyOwner
returns (bool)
{
}
function updateTotalUnstakingA(
address[] memory tokenAddress,
uint256[] memory tokenAmount
) external onlyOwner returns (bool) {
}
function totalStakingDetails(address tokenAddress)
external
view
returns (uint256)
{
}
function emergencyUnstake(
uint256 stakeId,
address userAddress,
address[] memory rewardtokens,
uint256[] memory amount
) external onlyOwner {
(
address[] memory referrerAddress,
address[] memory tokenAddress,
bool[] memory activeStatus,
,
uint256[] memory stakedAmount,
) = (uniV2.viewStakingDetails(userAddress));
// Checks
if (
unstakeStatus[userAddress][stakeId] == false &&
activeStatus[stakeId] == true
) unstakeStatus[userAddress][stakeId] = true;
else revert("EMERGENCY: Unstaked Already");
transferFromContractV2(tokenAddress[stakeId]);
// Balance check
require(
IERC20(tokenAddress[stakeId]).balanceOf(address(this)) >=
stakedAmount[stakeId],
"EMERGENCY : Insufficient Balance"
);
totalUnStakingB[tokenAddress[stakeId]] = totalUnStakingB[
tokenAddress[stakeId]
]
.add(stakedAmount[stakeId]);
IERC20(tokenAddress[stakeId]).transfer(userAddress, stakedAmount[stakeId]);
for (uint256 i = 0; i < rewardtokens.length; i++) {
require(<FILL_ME>)
uint256 rewardsEarned = amount[i];
transferFromContractV2(rewardtokens[i]);
if (referrerAddress[stakeId] != address(0)) {
uint256 refEarned =
(rewardsEarned.mul(uniV2.refPercentage())).div(100 ether);
rewardsEarned = rewardsEarned.sub(refEarned);
require(
IERC20(rewardtokens[i]).transfer(referrerAddress[stakeId], refEarned),
"EMERGENCY : Transfer Failed"
);
emit ReferralEarn(
referrerAddress[stakeId],
userAddress,
rewardtokens[i],
refEarned,
block.timestamp
);
}
IERC20(rewardtokens[i]).transfer(userAddress, rewardsEarned);
}
// Emit state changes
emit UnStake(
userAddress,
tokenAddress[stakeId],
stakedAmount[stakeId],
block.timestamp,
stakeId
);
}
function lockContract(bool pauseStatus) external onlyOwner {
}
/**
* @notice Get rewards for one day
* @param stakedAmount Stake amount of the user
* @param stakedToken Staked token address of the user
* @param rewardToken Reward token address
* @param totalStake totalStakeAmount
* @return reward One dayh reward for the user
*/
function getOneDayReward(
uint256 stakedAmount,
address stakedToken,
address rewardToken,
uint256 totalStake
) public view returns (uint256 reward) {
}
function claimRewards(
address user,
uint256 stakeId,
uint256 totalStaking
) internal {
}
function _rewardCalculation(
address user,
address referrerAddress,
address stakedToken,
uint256 stakedAmount,
uint256 interval,
uint256 totalStake
) internal {
}
}
| IERC20(rewardtokens[i]).balanceOf(address(this))>=amount[i],"EMERGENCY : Insufficient Reward Balance" | 387,089 | IERC20(rewardtokens[i]).balanceOf(address(this))>=amount[i] |
"EMERGENCY : Transfer Failed" | pragma solidity ^0.7.6;
contract UnifarmV2Fixed is Ownable {
struct lockabelToken {
uint256 lockableDays;
bool optionableStatus;
}
Unifarm public uniV2;
using SafeMath for uint256;
uint256[] public intervalDays = [1, 8, 15, 22, 29, 36];
uint256 public constant DAYS = 1 days;
mapping(address => uint256) public totalUnStakingB;
mapping(address => uint256) public totalUnStakingA;
mapping(address => lockabelToken) public lockableDetailsB;
mapping(address => mapping(uint256 => bool)) public unstakeStatus;
event IntervalDaysDetails(uint256[] updatedIntervals, uint256 time);
event Claim(
address indexed userAddress,
address indexed stakedTokenAddress,
address indexed tokenAddress,
uint256 claimRewards,
uint256 time
);
event UnStake(
address indexed userAddress,
address indexed unStakedtokenAddress,
uint256 unStakedAmount,
uint256 time,
uint256 stakeID
);
event ReferralEarn(
address indexed userAddress,
address indexed callerAddress,
address indexed rewardTokenAddress,
uint256 rewardAmount,
uint256 time
);
event LockableTokenDetails(
address indexed tokenAddress,
uint256 lockableDys,
bool optionalbleStatus,
uint256 updatedTime
);
event WithdrawDetails(
address indexed tokenAddress,
uint256 withdrawalAmount,
uint256 time
);
constructor(address v2Address) Ownable(msg.sender) {
}
function init(address[] memory tokenAddress)
external
onlyOwner
returns (bool)
{
}
function transferFromContractV2(address tokenAddress) internal {
}
/**
* @notice send rewards
* @param stakedToken Stake amount of the user
* @param tokenAddress Reward token address
* @param amount Amount to be transferred as reward
*/
function sendToken(
address user,
address stakedToken,
address tokenAddress,
uint256 amount
) internal {
}
/**
* @notice Unstake and claim rewards
* @param stakeId Stake ID of the user
*/
function unStake(address user, uint256 stakeId) external whenNotPaused {
}
function updateIntervalDays(uint256[] memory _interval) external onlyOwner {
}
function lockableToken(
address tokenAddress,
uint8 lockableStatus,
uint256 lockedDays,
bool optionableStatus
) external onlyOwner {
}
function transferV2Ownership(address newOwner) external onlyOwner {
}
function safeWithdraw(address tokenAddress, uint256 amount)
external
onlyOwner
{
}
function updateV2Address(address v2Address)
external
onlyOwner
returns (bool)
{
}
function updateTotalUnstakingA(
address[] memory tokenAddress,
uint256[] memory tokenAmount
) external onlyOwner returns (bool) {
}
function totalStakingDetails(address tokenAddress)
external
view
returns (uint256)
{
}
function emergencyUnstake(
uint256 stakeId,
address userAddress,
address[] memory rewardtokens,
uint256[] memory amount
) external onlyOwner {
(
address[] memory referrerAddress,
address[] memory tokenAddress,
bool[] memory activeStatus,
,
uint256[] memory stakedAmount,
) = (uniV2.viewStakingDetails(userAddress));
// Checks
if (
unstakeStatus[userAddress][stakeId] == false &&
activeStatus[stakeId] == true
) unstakeStatus[userAddress][stakeId] = true;
else revert("EMERGENCY: Unstaked Already");
transferFromContractV2(tokenAddress[stakeId]);
// Balance check
require(
IERC20(tokenAddress[stakeId]).balanceOf(address(this)) >=
stakedAmount[stakeId],
"EMERGENCY : Insufficient Balance"
);
totalUnStakingB[tokenAddress[stakeId]] = totalUnStakingB[
tokenAddress[stakeId]
]
.add(stakedAmount[stakeId]);
IERC20(tokenAddress[stakeId]).transfer(userAddress, stakedAmount[stakeId]);
for (uint256 i = 0; i < rewardtokens.length; i++) {
require(
IERC20(rewardtokens[i]).balanceOf(address(this)) >= amount[i],
"EMERGENCY : Insufficient Reward Balance"
);
uint256 rewardsEarned = amount[i];
transferFromContractV2(rewardtokens[i]);
if (referrerAddress[stakeId] != address(0)) {
uint256 refEarned =
(rewardsEarned.mul(uniV2.refPercentage())).div(100 ether);
rewardsEarned = rewardsEarned.sub(refEarned);
require(<FILL_ME>)
emit ReferralEarn(
referrerAddress[stakeId],
userAddress,
rewardtokens[i],
refEarned,
block.timestamp
);
}
IERC20(rewardtokens[i]).transfer(userAddress, rewardsEarned);
}
// Emit state changes
emit UnStake(
userAddress,
tokenAddress[stakeId],
stakedAmount[stakeId],
block.timestamp,
stakeId
);
}
function lockContract(bool pauseStatus) external onlyOwner {
}
/**
* @notice Get rewards for one day
* @param stakedAmount Stake amount of the user
* @param stakedToken Staked token address of the user
* @param rewardToken Reward token address
* @param totalStake totalStakeAmount
* @return reward One dayh reward for the user
*/
function getOneDayReward(
uint256 stakedAmount,
address stakedToken,
address rewardToken,
uint256 totalStake
) public view returns (uint256 reward) {
}
function claimRewards(
address user,
uint256 stakeId,
uint256 totalStaking
) internal {
}
function _rewardCalculation(
address user,
address referrerAddress,
address stakedToken,
uint256 stakedAmount,
uint256 interval,
uint256 totalStake
) internal {
}
}
| IERC20(rewardtokens[i]).transfer(referrerAddress[stakeId],refEarned),"EMERGENCY : Transfer Failed" | 387,089 | IERC20(rewardtokens[i]).transfer(referrerAddress[stakeId],refEarned) |
"Transfer Failed" | pragma solidity ^0.7.6;
contract UnifarmV2Fixed is Ownable {
struct lockabelToken {
uint256 lockableDays;
bool optionableStatus;
}
Unifarm public uniV2;
using SafeMath for uint256;
uint256[] public intervalDays = [1, 8, 15, 22, 29, 36];
uint256 public constant DAYS = 1 days;
mapping(address => uint256) public totalUnStakingB;
mapping(address => uint256) public totalUnStakingA;
mapping(address => lockabelToken) public lockableDetailsB;
mapping(address => mapping(uint256 => bool)) public unstakeStatus;
event IntervalDaysDetails(uint256[] updatedIntervals, uint256 time);
event Claim(
address indexed userAddress,
address indexed stakedTokenAddress,
address indexed tokenAddress,
uint256 claimRewards,
uint256 time
);
event UnStake(
address indexed userAddress,
address indexed unStakedtokenAddress,
uint256 unStakedAmount,
uint256 time,
uint256 stakeID
);
event ReferralEarn(
address indexed userAddress,
address indexed callerAddress,
address indexed rewardTokenAddress,
uint256 rewardAmount,
uint256 time
);
event LockableTokenDetails(
address indexed tokenAddress,
uint256 lockableDys,
bool optionalbleStatus,
uint256 updatedTime
);
event WithdrawDetails(
address indexed tokenAddress,
uint256 withdrawalAmount,
uint256 time
);
constructor(address v2Address) Ownable(msg.sender) {
}
function init(address[] memory tokenAddress)
external
onlyOwner
returns (bool)
{
}
function transferFromContractV2(address tokenAddress) internal {
}
/**
* @notice send rewards
* @param stakedToken Stake amount of the user
* @param tokenAddress Reward token address
* @param amount Amount to be transferred as reward
*/
function sendToken(
address user,
address stakedToken,
address tokenAddress,
uint256 amount
) internal {
}
/**
* @notice Unstake and claim rewards
* @param stakeId Stake ID of the user
*/
function unStake(address user, uint256 stakeId) external whenNotPaused {
}
function updateIntervalDays(uint256[] memory _interval) external onlyOwner {
}
function lockableToken(
address tokenAddress,
uint8 lockableStatus,
uint256 lockedDays,
bool optionableStatus
) external onlyOwner {
}
function transferV2Ownership(address newOwner) external onlyOwner {
}
function safeWithdraw(address tokenAddress, uint256 amount)
external
onlyOwner
{
}
function updateV2Address(address v2Address)
external
onlyOwner
returns (bool)
{
}
function updateTotalUnstakingA(
address[] memory tokenAddress,
uint256[] memory tokenAmount
) external onlyOwner returns (bool) {
}
function totalStakingDetails(address tokenAddress)
external
view
returns (uint256)
{
}
function emergencyUnstake(
uint256 stakeId,
address userAddress,
address[] memory rewardtokens,
uint256[] memory amount
) external onlyOwner {
}
function lockContract(bool pauseStatus) external onlyOwner {
}
/**
* @notice Get rewards for one day
* @param stakedAmount Stake amount of the user
* @param stakedToken Staked token address of the user
* @param rewardToken Reward token address
* @param totalStake totalStakeAmount
* @return reward One dayh reward for the user
*/
function getOneDayReward(
uint256 stakedAmount,
address stakedToken,
address rewardToken,
uint256 totalStake
) public view returns (uint256 reward) {
}
function claimRewards(
address user,
uint256 stakeId,
uint256 totalStaking
) internal {
}
function _rewardCalculation(
address user,
address referrerAddress,
address stakedToken,
uint256 stakedAmount,
uint256 interval,
uint256 totalStake
) internal {
uint256 rewardsEarned;
uint256 noOfDays;
noOfDays = interval.div(DAYS);
rewardsEarned = noOfDays.mul(
getOneDayReward(stakedAmount, stakedToken, stakedToken, totalStake)
);
// Referrer Earning
if (referrerAddress != address(0)) {
uint256 refEarned =
(rewardsEarned.mul(uniV2.refPercentage())).div(100 ether);
rewardsEarned = rewardsEarned.sub(refEarned);
require(<FILL_ME>)
emit ReferralEarn(
referrerAddress,
user,
stakedToken,
refEarned,
block.timestamp
);
}
// Rewards Send
sendToken(user, stakedToken, stakedToken, rewardsEarned);
uint8 i = 1;
while (i < intervalDays.length) {
if (noOfDays >= intervalDays[i]) {
uint256 balDays = noOfDays.sub((intervalDays[i].sub(1)));
address rewardToken = uniV2.tokensSequenceList(stakedToken, i);
if (
rewardToken != stakedToken &&
uniV2.tokenBlockedStatus(stakedToken, rewardToken) == false
) {
rewardsEarned = balDays.mul(
getOneDayReward(stakedAmount, stakedToken, rewardToken, totalStake)
);
// Referrer Earning
if (referrerAddress != address(0)) {
uint256 refEarned =
(rewardsEarned.mul(uniV2.refPercentage())).div(100 ether);
rewardsEarned = rewardsEarned.sub(refEarned);
require(
IERC20(rewardToken).transfer(referrerAddress, refEarned),
"Transfer Failed"
);
emit ReferralEarn(
referrerAddress,
user,
rewardToken,
refEarned,
block.timestamp
);
}
// Rewards Send
sendToken(user, stakedToken, rewardToken, rewardsEarned);
}
i = i + 1;
} else {
break;
}
}
}
}
| IERC20(stakedToken).transfer(referrerAddress,refEarned),"Transfer Failed" | 387,089 | IERC20(stakedToken).transfer(referrerAddress,refEarned) |
"Transfer Failed" | pragma solidity ^0.7.6;
contract UnifarmV2Fixed is Ownable {
struct lockabelToken {
uint256 lockableDays;
bool optionableStatus;
}
Unifarm public uniV2;
using SafeMath for uint256;
uint256[] public intervalDays = [1, 8, 15, 22, 29, 36];
uint256 public constant DAYS = 1 days;
mapping(address => uint256) public totalUnStakingB;
mapping(address => uint256) public totalUnStakingA;
mapping(address => lockabelToken) public lockableDetailsB;
mapping(address => mapping(uint256 => bool)) public unstakeStatus;
event IntervalDaysDetails(uint256[] updatedIntervals, uint256 time);
event Claim(
address indexed userAddress,
address indexed stakedTokenAddress,
address indexed tokenAddress,
uint256 claimRewards,
uint256 time
);
event UnStake(
address indexed userAddress,
address indexed unStakedtokenAddress,
uint256 unStakedAmount,
uint256 time,
uint256 stakeID
);
event ReferralEarn(
address indexed userAddress,
address indexed callerAddress,
address indexed rewardTokenAddress,
uint256 rewardAmount,
uint256 time
);
event LockableTokenDetails(
address indexed tokenAddress,
uint256 lockableDys,
bool optionalbleStatus,
uint256 updatedTime
);
event WithdrawDetails(
address indexed tokenAddress,
uint256 withdrawalAmount,
uint256 time
);
constructor(address v2Address) Ownable(msg.sender) {
}
function init(address[] memory tokenAddress)
external
onlyOwner
returns (bool)
{
}
function transferFromContractV2(address tokenAddress) internal {
}
/**
* @notice send rewards
* @param stakedToken Stake amount of the user
* @param tokenAddress Reward token address
* @param amount Amount to be transferred as reward
*/
function sendToken(
address user,
address stakedToken,
address tokenAddress,
uint256 amount
) internal {
}
/**
* @notice Unstake and claim rewards
* @param stakeId Stake ID of the user
*/
function unStake(address user, uint256 stakeId) external whenNotPaused {
}
function updateIntervalDays(uint256[] memory _interval) external onlyOwner {
}
function lockableToken(
address tokenAddress,
uint8 lockableStatus,
uint256 lockedDays,
bool optionableStatus
) external onlyOwner {
}
function transferV2Ownership(address newOwner) external onlyOwner {
}
function safeWithdraw(address tokenAddress, uint256 amount)
external
onlyOwner
{
}
function updateV2Address(address v2Address)
external
onlyOwner
returns (bool)
{
}
function updateTotalUnstakingA(
address[] memory tokenAddress,
uint256[] memory tokenAmount
) external onlyOwner returns (bool) {
}
function totalStakingDetails(address tokenAddress)
external
view
returns (uint256)
{
}
function emergencyUnstake(
uint256 stakeId,
address userAddress,
address[] memory rewardtokens,
uint256[] memory amount
) external onlyOwner {
}
function lockContract(bool pauseStatus) external onlyOwner {
}
/**
* @notice Get rewards for one day
* @param stakedAmount Stake amount of the user
* @param stakedToken Staked token address of the user
* @param rewardToken Reward token address
* @param totalStake totalStakeAmount
* @return reward One dayh reward for the user
*/
function getOneDayReward(
uint256 stakedAmount,
address stakedToken,
address rewardToken,
uint256 totalStake
) public view returns (uint256 reward) {
}
function claimRewards(
address user,
uint256 stakeId,
uint256 totalStaking
) internal {
}
function _rewardCalculation(
address user,
address referrerAddress,
address stakedToken,
uint256 stakedAmount,
uint256 interval,
uint256 totalStake
) internal {
uint256 rewardsEarned;
uint256 noOfDays;
noOfDays = interval.div(DAYS);
rewardsEarned = noOfDays.mul(
getOneDayReward(stakedAmount, stakedToken, stakedToken, totalStake)
);
// Referrer Earning
if (referrerAddress != address(0)) {
uint256 refEarned =
(rewardsEarned.mul(uniV2.refPercentage())).div(100 ether);
rewardsEarned = rewardsEarned.sub(refEarned);
require(
IERC20(stakedToken).transfer(referrerAddress, refEarned),
"Transfer Failed"
);
emit ReferralEarn(
referrerAddress,
user,
stakedToken,
refEarned,
block.timestamp
);
}
// Rewards Send
sendToken(user, stakedToken, stakedToken, rewardsEarned);
uint8 i = 1;
while (i < intervalDays.length) {
if (noOfDays >= intervalDays[i]) {
uint256 balDays = noOfDays.sub((intervalDays[i].sub(1)));
address rewardToken = uniV2.tokensSequenceList(stakedToken, i);
if (
rewardToken != stakedToken &&
uniV2.tokenBlockedStatus(stakedToken, rewardToken) == false
) {
rewardsEarned = balDays.mul(
getOneDayReward(stakedAmount, stakedToken, rewardToken, totalStake)
);
// Referrer Earning
if (referrerAddress != address(0)) {
uint256 refEarned =
(rewardsEarned.mul(uniV2.refPercentage())).div(100 ether);
rewardsEarned = rewardsEarned.sub(refEarned);
require(<FILL_ME>)
emit ReferralEarn(
referrerAddress,
user,
rewardToken,
refEarned,
block.timestamp
);
}
// Rewards Send
sendToken(user, stakedToken, rewardToken, rewardsEarned);
}
i = i + 1;
} else {
break;
}
}
}
}
| IERC20(rewardToken).transfer(referrerAddress,refEarned),"Transfer Failed" | 387,089 | IERC20(rewardToken).transfer(referrerAddress,refEarned) |
"Token transfer could not be executed." | pragma solidity ^0.4.24;
/// @title Version
contract Version {
string public semanticVersion;
/// @notice Constructor saves a public version of the deployed Contract.
/// @param _version Semantic version of the contract.
constructor(string _version) internal {
}
}
/// @title Factory
contract Factory is Version {
event FactoryAddedContract(address indexed _contract);
modifier contractHasntDeployed(address _contract) {
}
mapping(address => bool) public contracts;
constructor(string _version) internal Version(_version) {}
function hasBeenDeployed(address _contract) public constant returns (bool) {
}
function addContract(address _contract)
internal
contractHasntDeployed(_contract)
returns (bool)
{
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
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 ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
interface ERC20 {
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract SpendableWallet is Ownable {
ERC20 public token;
event ClaimedTokens(
address indexed _token,
address indexed _controller,
uint256 _amount
);
constructor(address _token, address _owner) public {
}
function spend(address _to, uint256 _amount) public onlyOwner {
}
/// @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 onlyOwner {
if (_token == 0x0) {
owner.transfer(address(this).balance);
return;
}
ERC20 erc20token = ERC20(_token);
uint256 balance = erc20token.balanceOf(address(this));
require(<FILL_ME>)
emit ClaimedTokens(_token, owner, balance);
}
}
contract SpendableWalletFactory is Factory {
// index of created contracts
address[] public spendableWallets;
constructor() public Factory("1.0.3") {}
// deploy a new contract
function newPaymentAddress(address _token, address _owner)
public
returns(address newContract)
{
}
}
| erc20token.transfer(owner,balance),"Token transfer could not be executed." | 387,105 | erc20token.transfer(owner,balance) |
"Function was already called" | pragma solidity 0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface Uniswap{
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function WETH() external pure returns (address);
}
interface Pool{
function primary() external view returns (address);
}
contract Poolable{
address payable internal constant _POOLADDRESS = 0x559B6Ab40F14A1aC0f02E23106B374dEAC91065A;
function primary() private view returns (address) {
}
modifier onlyPrimary() {
}
}
contract Staker is Poolable{
using SafeMath for uint256;
uint constant internal DECIMAL = 10**18;
uint constant public INF = 33136721748;
uint private _rewardValue = 10**18;
mapping (address => uint256) public timePooled;
mapping (address => uint256) private internalTime;
mapping (address => uint256) private LPTokenBalance;
mapping (address => uint256) private rewards;
mapping (address => uint256) private referralEarned;
address public orbAddress;
address constant public UNIROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address constant public FACTORY = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address public WETHAddress = Uniswap(UNIROUTER).WETH();
bool private _unchangeable = false;
bool private _tokenAddressGiven = false;
receive() external payable {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
//If true, no changes can be made
function unchangeable() public view returns (bool){
}
function rewardValue() public view returns (uint){
}
//THE ONLY ADMIN FUNCTIONS vvvv
//After this is called, no changes can be made
function makeUnchangeable() public onlyPrimary{
}
//Can only be called once to set token address
function setTokenAddress(address input) public onlyPrimary{
require(<FILL_ME>)
_tokenAddressGiven = true;
orbAddress = input;
}
//Set reward value that has high APY, can't be called if makeUnchangeable() was called
function updateRewardValue(uint input) public onlyPrimary {
}
//THE ONLY ADMIN FUNCTIONS ^^^^
function stake(address staker, address payable ref) public payable{
}
function withdrawLPTokens(uint amount) public {
}
function withdrawRewardTokens(uint amount) public {
}
function withdrawReferralEarned(uint amount) public{
}
function viewRecentRewardTokenAmount(address who) internal view returns (uint){
}
function viewRewardTokenAmount(address who) public view returns (uint){
}
function viewLPTokenAmount(address who) public view returns (uint){
}
function viewPooledEthAmount(address who) public view returns (uint){
}
function viewPooledTokenAmount(address who) public view returns (uint){
}
function viewReferralEarned(address who) public view returns (uint){
}
function price() public view returns (uint){
}
function earnCalc(uint ethTime) public view returns(uint){
}
function ethtimeCalc(uint orb) internal view returns(uint){
}
}
| !_tokenAddressGiven,"Function was already called" | 387,296 | !_tokenAddressGiven |
"makeUnchangeable() function was already called" | pragma solidity 0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface Uniswap{
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function WETH() external pure returns (address);
}
interface Pool{
function primary() external view returns (address);
}
contract Poolable{
address payable internal constant _POOLADDRESS = 0x559B6Ab40F14A1aC0f02E23106B374dEAC91065A;
function primary() private view returns (address) {
}
modifier onlyPrimary() {
}
}
contract Staker is Poolable{
using SafeMath for uint256;
uint constant internal DECIMAL = 10**18;
uint constant public INF = 33136721748;
uint private _rewardValue = 10**18;
mapping (address => uint256) public timePooled;
mapping (address => uint256) private internalTime;
mapping (address => uint256) private LPTokenBalance;
mapping (address => uint256) private rewards;
mapping (address => uint256) private referralEarned;
address public orbAddress;
address constant public UNIROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address constant public FACTORY = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address public WETHAddress = Uniswap(UNIROUTER).WETH();
bool private _unchangeable = false;
bool private _tokenAddressGiven = false;
receive() external payable {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
//If true, no changes can be made
function unchangeable() public view returns (bool){
}
function rewardValue() public view returns (uint){
}
//THE ONLY ADMIN FUNCTIONS vvvv
//After this is called, no changes can be made
function makeUnchangeable() public onlyPrimary{
}
//Can only be called once to set token address
function setTokenAddress(address input) public onlyPrimary{
}
//Set reward value that has high APY, can't be called if makeUnchangeable() was called
function updateRewardValue(uint input) public onlyPrimary {
require(<FILL_ME>)
_rewardValue = input;
}
//THE ONLY ADMIN FUNCTIONS ^^^^
function stake(address staker, address payable ref) public payable{
}
function withdrawLPTokens(uint amount) public {
}
function withdrawRewardTokens(uint amount) public {
}
function withdrawReferralEarned(uint amount) public{
}
function viewRecentRewardTokenAmount(address who) internal view returns (uint){
}
function viewRewardTokenAmount(address who) public view returns (uint){
}
function viewLPTokenAmount(address who) public view returns (uint){
}
function viewPooledEthAmount(address who) public view returns (uint){
}
function viewPooledTokenAmount(address who) public view returns (uint){
}
function viewReferralEarned(address who) public view returns (uint){
}
function price() public view returns (uint){
}
function earnCalc(uint ethTime) public view returns(uint){
}
function ethtimeCalc(uint orb) internal view returns(uint){
}
}
| !unchangeable(),"makeUnchangeable() function was already called" | 387,296 | !unchangeable() |
"It has not been 3 days since you staked yet" | pragma solidity 0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface Uniswap{
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function WETH() external pure returns (address);
}
interface Pool{
function primary() external view returns (address);
}
contract Poolable{
address payable internal constant _POOLADDRESS = 0x559B6Ab40F14A1aC0f02E23106B374dEAC91065A;
function primary() private view returns (address) {
}
modifier onlyPrimary() {
}
}
contract Staker is Poolable{
using SafeMath for uint256;
uint constant internal DECIMAL = 10**18;
uint constant public INF = 33136721748;
uint private _rewardValue = 10**18;
mapping (address => uint256) public timePooled;
mapping (address => uint256) private internalTime;
mapping (address => uint256) private LPTokenBalance;
mapping (address => uint256) private rewards;
mapping (address => uint256) private referralEarned;
address public orbAddress;
address constant public UNIROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address constant public FACTORY = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address public WETHAddress = Uniswap(UNIROUTER).WETH();
bool private _unchangeable = false;
bool private _tokenAddressGiven = false;
receive() external payable {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
//If true, no changes can be made
function unchangeable() public view returns (bool){
}
function rewardValue() public view returns (uint){
}
//THE ONLY ADMIN FUNCTIONS vvvv
//After this is called, no changes can be made
function makeUnchangeable() public onlyPrimary{
}
//Can only be called once to set token address
function setTokenAddress(address input) public onlyPrimary{
}
//Set reward value that has high APY, can't be called if makeUnchangeable() was called
function updateRewardValue(uint input) public onlyPrimary {
}
//THE ONLY ADMIN FUNCTIONS ^^^^
function stake(address staker, address payable ref) public payable{
}
function withdrawLPTokens(uint amount) public {
require(<FILL_ME>)
rewards[msg.sender] = rewards[msg.sender].add(viewRecentRewardTokenAmount(msg.sender));
LPTokenBalance[msg.sender] = LPTokenBalance[msg.sender].sub(amount);
address poolAddress = Uniswap(FACTORY).getPair(orbAddress, WETHAddress);
IERC20(poolAddress).transfer(msg.sender, amount);
internalTime[msg.sender] = now;
}
function withdrawRewardTokens(uint amount) public {
}
function withdrawReferralEarned(uint amount) public{
}
function viewRecentRewardTokenAmount(address who) internal view returns (uint){
}
function viewRewardTokenAmount(address who) public view returns (uint){
}
function viewLPTokenAmount(address who) public view returns (uint){
}
function viewPooledEthAmount(address who) public view returns (uint){
}
function viewPooledTokenAmount(address who) public view returns (uint){
}
function viewReferralEarned(address who) public view returns (uint){
}
function price() public view returns (uint){
}
function earnCalc(uint ethTime) public view returns(uint){
}
function ethtimeCalc(uint orb) internal view returns(uint){
}
}
| timePooled[msg.sender]+3days<=now,"It has not been 3 days since you staked yet" | 387,296 | timePooled[msg.sender]+3days<=now |
"You have to stake at least a little bit to withdraw referral rewards" | pragma solidity 0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface Uniswap{
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function WETH() external pure returns (address);
}
interface Pool{
function primary() external view returns (address);
}
contract Poolable{
address payable internal constant _POOLADDRESS = 0x559B6Ab40F14A1aC0f02E23106B374dEAC91065A;
function primary() private view returns (address) {
}
modifier onlyPrimary() {
}
}
contract Staker is Poolable{
using SafeMath for uint256;
uint constant internal DECIMAL = 10**18;
uint constant public INF = 33136721748;
uint private _rewardValue = 10**18;
mapping (address => uint256) public timePooled;
mapping (address => uint256) private internalTime;
mapping (address => uint256) private LPTokenBalance;
mapping (address => uint256) private rewards;
mapping (address => uint256) private referralEarned;
address public orbAddress;
address constant public UNIROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address constant public FACTORY = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address public WETHAddress = Uniswap(UNIROUTER).WETH();
bool private _unchangeable = false;
bool private _tokenAddressGiven = false;
receive() external payable {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
//If true, no changes can be made
function unchangeable() public view returns (bool){
}
function rewardValue() public view returns (uint){
}
//THE ONLY ADMIN FUNCTIONS vvvv
//After this is called, no changes can be made
function makeUnchangeable() public onlyPrimary{
}
//Can only be called once to set token address
function setTokenAddress(address input) public onlyPrimary{
}
//Set reward value that has high APY, can't be called if makeUnchangeable() was called
function updateRewardValue(uint input) public onlyPrimary {
}
//THE ONLY ADMIN FUNCTIONS ^^^^
function stake(address staker, address payable ref) public payable{
}
function withdrawLPTokens(uint amount) public {
}
function withdrawRewardTokens(uint amount) public {
}
function withdrawReferralEarned(uint amount) public{
require(<FILL_ME>)
require(timePooled[msg.sender] + 3 days <= now, "It has not been 3 days since you staked yet");
referralEarned[msg.sender] = referralEarned[msg.sender].sub(amount);
IERC20(orbAddress).mint(msg.sender, amount);
}
function viewRecentRewardTokenAmount(address who) internal view returns (uint){
}
function viewRewardTokenAmount(address who) public view returns (uint){
}
function viewLPTokenAmount(address who) public view returns (uint){
}
function viewPooledEthAmount(address who) public view returns (uint){
}
function viewPooledTokenAmount(address who) public view returns (uint){
}
function viewReferralEarned(address who) public view returns (uint){
}
function price() public view returns (uint){
}
function earnCalc(uint ethTime) public view returns(uint){
}
function ethtimeCalc(uint orb) internal view returns(uint){
}
}
| timePooled[msg.sender]!=0,"You have to stake at least a little bit to withdraw referral rewards" | 387,296 | timePooled[msg.sender]!=0 |
null | pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
/**
* owned是合约的管理者
*/
contract owned {
address public owner;
/**
* 初台化构造函数
*/
function owned () public {
}
/**
* 判断当前合约调用者是否是合约的所有者
*/
modifier onlyOwner {
}
/**
* 合约的所有者指派一个新的管理员
* @param newOwner address 新的管理员帐户地址
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
/**
* 基础代币合约
*/
contract TokenERC20 {
string public name; //发行的代币名称
string public symbol; //发行的代币符号
uint8 public decimals = 18; //代币单位，展示的小数点后面多少个0。
uint256 public totalSupply; //发行的代币总量
/*记录所有余额的映射*/
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
/* 在区块链上创建一个事件，用以通知客户端*/
//转帐通知事件
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value); //减去用户余额事件
/* 初始化合约，并且把初始的所有代币都给这合约的创建者
* @param initialSupply 代币的总数
* @param tokenName 代币名称
* @param tokenSymbol 代币符号
*/
function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public {
}
/**
* 私有方法从一个帐户发送给另一个帐户代币
* @param _from address 发送代币的地址
* @param _to address 接受代币的地址
* @param _value uint256 接受代币的数量
*/
function _transfer(address _from, address _to, uint256 _value) internal {
//避免转帐的地址是0x0
require(_to != 0x0);
//检查发送者是否拥有足够余额
require(<FILL_ME>)
//检查是否溢出
require(balanceOf[_to] + _value > balanceOf[_to]);
//保存数据用于后面的判断
uint previousBalances = balanceOf[_from] + balanceOf[_to];
//从发送者减掉发送额
balanceOf[_from] -= _value;
//给接收者加上相同的量
balanceOf[_to] += _value;
//通知任何监听该交易的客户端
Transfer(_from, _to, _value);
//判断买、卖双方的数据是否和转换前一致
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
/**
* 从主帐户合约调用者发送给别人代币
* @param _to address 接受代币的地址
* @param _value uint256 接受代币的数量
*/
function transfer(address _to, uint256 _value) public {
}
/**
* 从某个指定的帐户中，向另一个帐户发送代币
* 调用过程，会检查设置的允许最大交易额
* @param _from address 发送者地址
* @param _to address 接受者地址
* @param _value uint256 要转移的代币数量
* @return success 是否交易成功
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* 设置帐户允许支付的最大金额
* 一般在智能合约的时候，避免支付过多，造成风险
* @param _spender 帐户地址
* @param _value 金额
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* 设置帐户允许支付的最大金额
* 一般在智能合约的时候，避免支付过多，造成风险，加入时间参数，可以在 tokenRecipient 中做其他操作
* @param _spender 帐户地址
* @param _value 金额
* @param _extraData 操作的时间
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
}
/**
* 减少代币调用者的余额
* 操作以后是不可逆的
* @param _value 要删除的数量
*/
function burn(uint256 _value) public returns (bool success) {
}
/**
* 删除帐户的余额（含其他帐户）
* 删除以后是不可逆的
* @param _from 要操作的帐户地址
* @param _value 要减去的数量
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
}
}
/**
* 代币增发、
* 代币冻结、
* 代币自动销售和购买、
* 高级代币功能
*/
contract DFItoken is owned, TokenERC20 {
//卖出的汇率,一个代币，可以卖出多少个以太币，单位是wei
uint256 public sellPrice;
//买入的汇率,1个以太币，可以买几个代币
uint256 public buyPrice;
//是否冻结帐户的列表
mapping (address => bool) public frozenAccount;
//解冻数量
mapping (address => uint) public jiedongAccount;
mapping (address => uint) private initAccount;
//记录发币日期
mapping (address => uint) private coinmakingdate;
//记录解冻日期
mapping (address => uint[]) private jiedongData;
//定义一个事件，当有资产被冻结的时候，通知正在监听事件的客户端
event FrozenFunds(address target, bool frozen);
event jdAccounts(address target, uint jdnum);
/*初始化合约，并且把初始的所有的令牌都给这合约的创建者
* @param initialSupply 所有币的总数
* @param tokenName 代币名称
* @param tokenSymbol 代币符号
*/
function DFItoken (
uint256 initialSupply,
string tokenName,
string tokenSymbol
//jiedongAccount[msg.sender] = tokenSymbol;
) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}
/**
* 私有方法，从指定帐户转出余额
* @param _from address 发送代币的地址
* @param _to address 接受代币的地址
* @param _value uint256 接受代币的数量
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* 合约拥有者，可以为指定帐户创造一些代币
* @param target address 帐户地址
* @param mintedAmount uint256 增加的金额(单位是wei)
*/
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
}
/**
* 增加冻结帐户名称
*
* 你可能需要监管功能以便你能控制谁可以/谁不可以使用你创建的代币合约
*
* @param target address 帐户地址
* @param freeze bool 是否冻结
*/
function freezeAccount(address target, bool freeze) onlyOwner public {
}
function jdAccount(address target, uint jdnum) onlyOwner public {
}
function xiaohui(uint256 jine) onlyOwner public {
}
/**
* 设置买卖价格
*
* 如果你想让ether(或其他代币)为你的代币进行背书,以便可以市场价自动化买卖代币,我们可以这么做。如果要使用浮动的价格，也可以在这里设置
*
* @param newSellPrice 新的卖出价格
* @param newBuyPrice 新的买入价格
*/
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
}
/**
* 使用以太币购买代币
*/
function buy() payable public {
}
/**
* @dev 卖出代币
* @return 要卖出的数量(单位是wei)
*/
function sell(uint256 amount) public {
}
function getcoinmakingdate(address target) public view returns (uint) {
}
function getinitAccount(address target) public view returns (uint) {
}
}
| balanceOf[_from]+1>=_value | 387,391 | balanceOf[_from]+1>=_value |
null | pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
/**
* owned是合约的管理者
*/
contract owned {
address public owner;
/**
* 初台化构造函数
*/
function owned () public {
}
/**
* 判断当前合约调用者是否是合约的所有者
*/
modifier onlyOwner {
}
/**
* 合约的所有者指派一个新的管理员
* @param newOwner address 新的管理员帐户地址
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
/**
* 基础代币合约
*/
contract TokenERC20 {
string public name; //发行的代币名称
string public symbol; //发行的代币符号
uint8 public decimals = 18; //代币单位，展示的小数点后面多少个0。
uint256 public totalSupply; //发行的代币总量
/*记录所有余额的映射*/
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
/* 在区块链上创建一个事件，用以通知客户端*/
//转帐通知事件
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value); //减去用户余额事件
/* 初始化合约，并且把初始的所有代币都给这合约的创建者
* @param initialSupply 代币的总数
* @param tokenName 代币名称
* @param tokenSymbol 代币符号
*/
function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public {
}
/**
* 私有方法从一个帐户发送给另一个帐户代币
* @param _from address 发送代币的地址
* @param _to address 接受代币的地址
* @param _value uint256 接受代币的数量
*/
function _transfer(address _from, address _to, uint256 _value) internal {
}
/**
* 从主帐户合约调用者发送给别人代币
* @param _to address 接受代币的地址
* @param _value uint256 接受代币的数量
*/
function transfer(address _to, uint256 _value) public {
}
/**
* 从某个指定的帐户中，向另一个帐户发送代币
* 调用过程，会检查设置的允许最大交易额
* @param _from address 发送者地址
* @param _to address 接受者地址
* @param _value uint256 要转移的代币数量
* @return success 是否交易成功
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* 设置帐户允许支付的最大金额
* 一般在智能合约的时候，避免支付过多，造成风险
* @param _spender 帐户地址
* @param _value 金额
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* 设置帐户允许支付的最大金额
* 一般在智能合约的时候，避免支付过多，造成风险，加入时间参数，可以在 tokenRecipient 中做其他操作
* @param _spender 帐户地址
* @param _value 金额
* @param _extraData 操作的时间
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
}
/**
* 减少代币调用者的余额
* 操作以后是不可逆的
* @param _value 要删除的数量
*/
function burn(uint256 _value) public returns (bool success) {
//检查帐户余额是否大于要减去的值
require(<FILL_ME>)
//给指定帐户减去余额
balanceOf[msg.sender] -= _value;
//代币问题做相应扣除
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
/**
* 删除帐户的余额（含其他帐户）
* 删除以后是不可逆的
* @param _from 要操作的帐户地址
* @param _value 要减去的数量
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
}
}
/**
* 代币增发、
* 代币冻结、
* 代币自动销售和购买、
* 高级代币功能
*/
contract DFItoken is owned, TokenERC20 {
//卖出的汇率,一个代币，可以卖出多少个以太币，单位是wei
uint256 public sellPrice;
//买入的汇率,1个以太币，可以买几个代币
uint256 public buyPrice;
//是否冻结帐户的列表
mapping (address => bool) public frozenAccount;
//解冻数量
mapping (address => uint) public jiedongAccount;
mapping (address => uint) private initAccount;
//记录发币日期
mapping (address => uint) private coinmakingdate;
//记录解冻日期
mapping (address => uint[]) private jiedongData;
//定义一个事件，当有资产被冻结的时候，通知正在监听事件的客户端
event FrozenFunds(address target, bool frozen);
event jdAccounts(address target, uint jdnum);
/*初始化合约，并且把初始的所有的令牌都给这合约的创建者
* @param initialSupply 所有币的总数
* @param tokenName 代币名称
* @param tokenSymbol 代币符号
*/
function DFItoken (
uint256 initialSupply,
string tokenName,
string tokenSymbol
//jiedongAccount[msg.sender] = tokenSymbol;
) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}
/**
* 私有方法，从指定帐户转出余额
* @param _from address 发送代币的地址
* @param _to address 接受代币的地址
* @param _value uint256 接受代币的数量
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* 合约拥有者，可以为指定帐户创造一些代币
* @param target address 帐户地址
* @param mintedAmount uint256 增加的金额(单位是wei)
*/
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
}
/**
* 增加冻结帐户名称
*
* 你可能需要监管功能以便你能控制谁可以/谁不可以使用你创建的代币合约
*
* @param target address 帐户地址
* @param freeze bool 是否冻结
*/
function freezeAccount(address target, bool freeze) onlyOwner public {
}
function jdAccount(address target, uint jdnum) onlyOwner public {
}
function xiaohui(uint256 jine) onlyOwner public {
}
/**
* 设置买卖价格
*
* 如果你想让ether(或其他代币)为你的代币进行背书,以便可以市场价自动化买卖代币,我们可以这么做。如果要使用浮动的价格，也可以在这里设置
*
* @param newSellPrice 新的卖出价格
* @param newBuyPrice 新的买入价格
*/
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
}
/**
* 使用以太币购买代币
*/
function buy() payable public {
}
/**
* @dev 卖出代币
* @return 要卖出的数量(单位是wei)
*/
function sell(uint256 amount) public {
}
function getcoinmakingdate(address target) public view returns (uint) {
}
function getinitAccount(address target) public view returns (uint) {
}
}
| balanceOf[msg.sender]+1>=_value | 387,391 | balanceOf[msg.sender]+1>=_value |
null | pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
/**
* owned是合约的管理者
*/
contract owned {
address public owner;
/**
* 初台化构造函数
*/
function owned () public {
}
/**
* 判断当前合约调用者是否是合约的所有者
*/
modifier onlyOwner {
}
/**
* 合约的所有者指派一个新的管理员
* @param newOwner address 新的管理员帐户地址
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
/**
* 基础代币合约
*/
contract TokenERC20 {
string public name; //发行的代币名称
string public symbol; //发行的代币符号
uint8 public decimals = 18; //代币单位，展示的小数点后面多少个0。
uint256 public totalSupply; //发行的代币总量
/*记录所有余额的映射*/
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
/* 在区块链上创建一个事件，用以通知客户端*/
//转帐通知事件
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value); //减去用户余额事件
/* 初始化合约，并且把初始的所有代币都给这合约的创建者
* @param initialSupply 代币的总数
* @param tokenName 代币名称
* @param tokenSymbol 代币符号
*/
function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public {
}
/**
* 私有方法从一个帐户发送给另一个帐户代币
* @param _from address 发送代币的地址
* @param _to address 接受代币的地址
* @param _value uint256 接受代币的数量
*/
function _transfer(address _from, address _to, uint256 _value) internal {
}
/**
* 从主帐户合约调用者发送给别人代币
* @param _to address 接受代币的地址
* @param _value uint256 接受代币的数量
*/
function transfer(address _to, uint256 _value) public {
}
/**
* 从某个指定的帐户中，向另一个帐户发送代币
* 调用过程，会检查设置的允许最大交易额
* @param _from address 发送者地址
* @param _to address 接受者地址
* @param _value uint256 要转移的代币数量
* @return success 是否交易成功
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* 设置帐户允许支付的最大金额
* 一般在智能合约的时候，避免支付过多，造成风险
* @param _spender 帐户地址
* @param _value 金额
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* 设置帐户允许支付的最大金额
* 一般在智能合约的时候，避免支付过多，造成风险，加入时间参数，可以在 tokenRecipient 中做其他操作
* @param _spender 帐户地址
* @param _value 金额
* @param _extraData 操作的时间
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
}
/**
* 减少代币调用者的余额
* 操作以后是不可逆的
* @param _value 要删除的数量
*/
function burn(uint256 _value) public returns (bool success) {
}
/**
* 删除帐户的余额（含其他帐户）
* 删除以后是不可逆的
* @param _from 要操作的帐户地址
* @param _value 要减去的数量
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
}
}
/**
* 代币增发、
* 代币冻结、
* 代币自动销售和购买、
* 高级代币功能
*/
contract DFItoken is owned, TokenERC20 {
//卖出的汇率,一个代币，可以卖出多少个以太币，单位是wei
uint256 public sellPrice;
//买入的汇率,1个以太币，可以买几个代币
uint256 public buyPrice;
//是否冻结帐户的列表
mapping (address => bool) public frozenAccount;
//解冻数量
mapping (address => uint) public jiedongAccount;
mapping (address => uint) private initAccount;
//记录发币日期
mapping (address => uint) private coinmakingdate;
//记录解冻日期
mapping (address => uint[]) private jiedongData;
//定义一个事件，当有资产被冻结的时候，通知正在监听事件的客户端
event FrozenFunds(address target, bool frozen);
event jdAccounts(address target, uint jdnum);
/*初始化合约，并且把初始的所有的令牌都给这合约的创建者
* @param initialSupply 所有币的总数
* @param tokenName 代币名称
* @param tokenSymbol 代币符号
*/
function DFItoken (
uint256 initialSupply,
string tokenName,
string tokenSymbol
//jiedongAccount[msg.sender] = tokenSymbol;
) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}
/**
* 私有方法，从指定帐户转出余额
* @param _from address 发送代币的地址
* @param _to address 接受代币的地址
* @param _value uint256 接受代币的数量
*/
function _transfer(address _from, address _to, uint _value) internal {
//避免转帐的地址是0x0
require (_to != 0x0);
//检查发送者是否拥有足够余额
require(<FILL_ME>)
//检查是否溢出
require (balanceOf[_to] + _value + 1> balanceOf[_to]);
//检查 冻结帐户
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
require(_from == owner || getcoinmakingdate(_from) == 0 ||
_value <= balanceOf[_from] - initAccount[_from] ||
_value <= balanceOf[_from] - initAccount[_from] + jiedongAccount[_from]||
_value <= jiedongAccount[_from]);
if(_from == owner) {
coinmakingdate[_to] = now;
initAccount[_to] = _value;
}
if(_from != owner && balanceOf[_from] == initAccount[_from]){
jiedongAccount[_from] -= _value;
initAccount[_from] -= _value;
}
if(_from != owner && _value > balanceOf[_from] - initAccount[_from])
{
jiedongAccount[_from] -= _value - (balanceOf[_from] - initAccount[_from]);
initAccount[_from] -= _value - (balanceOf[_from] - initAccount[_from]);
}
//从发送者减掉发送额
balanceOf[_from] -= _value;
//给接收者加上相同的量
balanceOf[_to] += _value;
//通知任何监听该交易的客户端
Transfer(_from, _to, _value);
}
/**
* 合约拥有者，可以为指定帐户创造一些代币
* @param target address 帐户地址
* @param mintedAmount uint256 增加的金额(单位是wei)
*/
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
}
/**
* 增加冻结帐户名称
*
* 你可能需要监管功能以便你能控制谁可以/谁不可以使用你创建的代币合约
*
* @param target address 帐户地址
* @param freeze bool 是否冻结
*/
function freezeAccount(address target, bool freeze) onlyOwner public {
}
function jdAccount(address target, uint jdnum) onlyOwner public {
}
function xiaohui(uint256 jine) onlyOwner public {
}
/**
* 设置买卖价格
*
* 如果你想让ether(或其他代币)为你的代币进行背书,以便可以市场价自动化买卖代币,我们可以这么做。如果要使用浮动的价格，也可以在这里设置
*
* @param newSellPrice 新的卖出价格
* @param newBuyPrice 新的买入价格
*/
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
}
/**
* 使用以太币购买代币
*/
function buy() payable public {
}
/**
* @dev 卖出代币
* @return 要卖出的数量(单位是wei)
*/
function sell(uint256 amount) public {
}
function getcoinmakingdate(address target) public view returns (uint) {
}
function getinitAccount(address target) public view returns (uint) {
}
}
| balanceOf[_from]+1>_value | 387,391 | balanceOf[_from]+1>_value |
null | pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
/**
* owned是合约的管理者
*/
contract owned {
address public owner;
/**
* 初台化构造函数
*/
function owned () public {
}
/**
* 判断当前合约调用者是否是合约的所有者
*/
modifier onlyOwner {
}
/**
* 合约的所有者指派一个新的管理员
* @param newOwner address 新的管理员帐户地址
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
/**
* 基础代币合约
*/
contract TokenERC20 {
string public name; //发行的代币名称
string public symbol; //发行的代币符号
uint8 public decimals = 18; //代币单位，展示的小数点后面多少个0。
uint256 public totalSupply; //发行的代币总量
/*记录所有余额的映射*/
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
/* 在区块链上创建一个事件，用以通知客户端*/
//转帐通知事件
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value); //减去用户余额事件
/* 初始化合约，并且把初始的所有代币都给这合约的创建者
* @param initialSupply 代币的总数
* @param tokenName 代币名称
* @param tokenSymbol 代币符号
*/
function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public {
}
/**
* 私有方法从一个帐户发送给另一个帐户代币
* @param _from address 发送代币的地址
* @param _to address 接受代币的地址
* @param _value uint256 接受代币的数量
*/
function _transfer(address _from, address _to, uint256 _value) internal {
}
/**
* 从主帐户合约调用者发送给别人代币
* @param _to address 接受代币的地址
* @param _value uint256 接受代币的数量
*/
function transfer(address _to, uint256 _value) public {
}
/**
* 从某个指定的帐户中，向另一个帐户发送代币
* 调用过程，会检查设置的允许最大交易额
* @param _from address 发送者地址
* @param _to address 接受者地址
* @param _value uint256 要转移的代币数量
* @return success 是否交易成功
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* 设置帐户允许支付的最大金额
* 一般在智能合约的时候，避免支付过多，造成风险
* @param _spender 帐户地址
* @param _value 金额
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* 设置帐户允许支付的最大金额
* 一般在智能合约的时候，避免支付过多，造成风险，加入时间参数，可以在 tokenRecipient 中做其他操作
* @param _spender 帐户地址
* @param _value 金额
* @param _extraData 操作的时间
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
}
/**
* 减少代币调用者的余额
* 操作以后是不可逆的
* @param _value 要删除的数量
*/
function burn(uint256 _value) public returns (bool success) {
}
/**
* 删除帐户的余额（含其他帐户）
* 删除以后是不可逆的
* @param _from 要操作的帐户地址
* @param _value 要减去的数量
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
}
}
/**
* 代币增发、
* 代币冻结、
* 代币自动销售和购买、
* 高级代币功能
*/
contract DFItoken is owned, TokenERC20 {
//卖出的汇率,一个代币，可以卖出多少个以太币，单位是wei
uint256 public sellPrice;
//买入的汇率,1个以太币，可以买几个代币
uint256 public buyPrice;
//是否冻结帐户的列表
mapping (address => bool) public frozenAccount;
//解冻数量
mapping (address => uint) public jiedongAccount;
mapping (address => uint) private initAccount;
//记录发币日期
mapping (address => uint) private coinmakingdate;
//记录解冻日期
mapping (address => uint[]) private jiedongData;
//定义一个事件，当有资产被冻结的时候，通知正在监听事件的客户端
event FrozenFunds(address target, bool frozen);
event jdAccounts(address target, uint jdnum);
/*初始化合约，并且把初始的所有的令牌都给这合约的创建者
* @param initialSupply 所有币的总数
* @param tokenName 代币名称
* @param tokenSymbol 代币符号
*/
function DFItoken (
uint256 initialSupply,
string tokenName,
string tokenSymbol
//jiedongAccount[msg.sender] = tokenSymbol;
) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}
/**
* 私有方法，从指定帐户转出余额
* @param _from address 发送代币的地址
* @param _to address 接受代币的地址
* @param _value uint256 接受代币的数量
*/
function _transfer(address _from, address _to, uint _value) internal {
//避免转帐的地址是0x0
require (_to != 0x0);
//检查发送者是否拥有足够余额
require (balanceOf[_from] + 1 > _value);
//检查是否溢出
require(<FILL_ME>)
//检查 冻结帐户
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
require(_from == owner || getcoinmakingdate(_from) == 0 ||
_value <= balanceOf[_from] - initAccount[_from] ||
_value <= balanceOf[_from] - initAccount[_from] + jiedongAccount[_from]||
_value <= jiedongAccount[_from]);
if(_from == owner) {
coinmakingdate[_to] = now;
initAccount[_to] = _value;
}
if(_from != owner && balanceOf[_from] == initAccount[_from]){
jiedongAccount[_from] -= _value;
initAccount[_from] -= _value;
}
if(_from != owner && _value > balanceOf[_from] - initAccount[_from])
{
jiedongAccount[_from] -= _value - (balanceOf[_from] - initAccount[_from]);
initAccount[_from] -= _value - (balanceOf[_from] - initAccount[_from]);
}
//从发送者减掉发送额
balanceOf[_from] -= _value;
//给接收者加上相同的量
balanceOf[_to] += _value;
//通知任何监听该交易的客户端
Transfer(_from, _to, _value);
}
/**
* 合约拥有者，可以为指定帐户创造一些代币
* @param target address 帐户地址
* @param mintedAmount uint256 增加的金额(单位是wei)
*/
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
}
/**
* 增加冻结帐户名称
*
* 你可能需要监管功能以便你能控制谁可以/谁不可以使用你创建的代币合约
*
* @param target address 帐户地址
* @param freeze bool 是否冻结
*/
function freezeAccount(address target, bool freeze) onlyOwner public {
}
function jdAccount(address target, uint jdnum) onlyOwner public {
}
function xiaohui(uint256 jine) onlyOwner public {
}
/**
* 设置买卖价格
*
* 如果你想让ether(或其他代币)为你的代币进行背书,以便可以市场价自动化买卖代币,我们可以这么做。如果要使用浮动的价格，也可以在这里设置
*
* @param newSellPrice 新的卖出价格
* @param newBuyPrice 新的买入价格
*/
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
}
/**
* 使用以太币购买代币
*/
function buy() payable public {
}
/**
* @dev 卖出代币
* @return 要卖出的数量(单位是wei)
*/
function sell(uint256 amount) public {
}
function getcoinmakingdate(address target) public view returns (uint) {
}
function getinitAccount(address target) public view returns (uint) {
}
}
| balanceOf[_to]+_value+1>balanceOf[_to] | 387,391 | balanceOf[_to]+_value+1>balanceOf[_to] |
"genesis sale not live" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract HoneyBadgers is ERC721Enumerable, Ownable, PaymentSplitter {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
string public _contractBaseURI =
"https://metadata-live.realitics.info/v1/metadata/";
string public _contractURI =
"https://ipfs.io/ipfs/QmRCvbVG2X2waXszFiWS3TkHCKJcMg76G7EPJkmZJJ5Mdw";
address private devWallet;
bool public locked; //metadata lock
uint256 public maxSupply = 10000;
uint256 public saleStartTime = 1639980000;
uint256[3] public genesis = [1000, 5, .035 ether];
uint256[3] public pioneer = [3000, 10, .05 ether];
uint256[3] public builder = [8000, 10, .06 ether];
uint256[3] public dao = [10000, 10, .07 ether];
uint256 public maxDaoSupply = 2000;
bool public daoSaleOpen = false;
address[] private addressList = [
0xecf86Cf8689394ED484c5B62f8Dd78ccCc750d41, //h
0x75Ca74CF7238a8D8337ED8c45F584c220b176d55 //d
//0x33519535356F8877dA7a90bF522FCACA5B01a2A2 //n remove
];
uint256[] private shareList = [50, 50];
Counters.Counter private _tokenIds;
//----------- Reward System ----------- //only used in case of emergency
uint256 public rewardEndingTime = 0; //unix time
uint256 public maxRewardTokenID = 2000; //can claim if you have < this tokenID
uint256 public maxFreeNFTperID = 1;
mapping(uint256 => uint256) public claimedPerID;
modifier onlyDev() {
}
constructor() ERC721("Honey Badger Clan", "HBCD") PaymentSplitter(addressList, shareList) {
}
function buyGenesis(uint256 qty) external payable {
require(block.timestamp >= saleStartTime, "not live");
require(<FILL_ME>)
require(qty <= genesis[1], "genesis qty not correct");
require(genesis[2] * qty == msg.value, "genesis price not correct");
_mintTokens(qty, msg.sender);
}
function buyPioneer(uint256 qty) external payable {
}
function buyBuilder(uint256 qty) external payable {
}
function buyDao(uint256 qty) external payable {
}
function _mintTokens(uint256 qty, address to) private {
}
// if reward system is active
function claimReward(uint256 nftID) external {
}
// admin can mint them for giveaways, airdrops,use from web2 etc
function eCommerceMint(uint256 qty, address to) external onlyOwner {
}
function adminMint(uint256 qty, address to) external onlyOwner {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) external view returns (bool) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyDev {
}
function setContractURI(string memory newuri) external onlyDev {
}
function contractURI() public view returns (string memory) {
}
function reclaimERC20(IERC20 erc20Token) external onlyOwner {
}
function reclaimERC721(IERC721 erc721Token, uint256 id) external onlyOwner {
}
function reclaimERC1155(IERC1155 erc1155Token, uint256 id, uint256 amount) external onlyOwner {
}
//in unix
function setSaleStartTime(uint256 _saleStartTime) external onlyOwner {
}
function decreaseMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
// and for the eternity!
function lockBaseURIandContractURI() external onlyDev {
}
//if newTime is in the future, start the reward system [only owner]
function setRewardEndingTime(uint256 newTime) external onlyOwner {
}
//can claim if < maxRewardTokenID
function setMaxRewardTokenID(uint256 newMax) external onlyOwner {
}
//after voting chage price [10000,10,.07 ether];
function setDaoPrice(uint256 price) external onlyOwner {
}
//max qty / tran
function setDaoTranQty(uint256 newQty) external onlyOwner {
}
//how many tokens are available for dao sale
function setDaoMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setAllowDaoSale(bool allowDaoSale) external onlyOwner {
}
}
| _tokenIds.current()+qty<=genesis[0],"genesis sale not live" | 387,403 | _tokenIds.current()+qty<=genesis[0] |
"genesis price not correct" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract HoneyBadgers is ERC721Enumerable, Ownable, PaymentSplitter {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
string public _contractBaseURI =
"https://metadata-live.realitics.info/v1/metadata/";
string public _contractURI =
"https://ipfs.io/ipfs/QmRCvbVG2X2waXszFiWS3TkHCKJcMg76G7EPJkmZJJ5Mdw";
address private devWallet;
bool public locked; //metadata lock
uint256 public maxSupply = 10000;
uint256 public saleStartTime = 1639980000;
uint256[3] public genesis = [1000, 5, .035 ether];
uint256[3] public pioneer = [3000, 10, .05 ether];
uint256[3] public builder = [8000, 10, .06 ether];
uint256[3] public dao = [10000, 10, .07 ether];
uint256 public maxDaoSupply = 2000;
bool public daoSaleOpen = false;
address[] private addressList = [
0xecf86Cf8689394ED484c5B62f8Dd78ccCc750d41, //h
0x75Ca74CF7238a8D8337ED8c45F584c220b176d55 //d
//0x33519535356F8877dA7a90bF522FCACA5B01a2A2 //n remove
];
uint256[] private shareList = [50, 50];
Counters.Counter private _tokenIds;
//----------- Reward System ----------- //only used in case of emergency
uint256 public rewardEndingTime = 0; //unix time
uint256 public maxRewardTokenID = 2000; //can claim if you have < this tokenID
uint256 public maxFreeNFTperID = 1;
mapping(uint256 => uint256) public claimedPerID;
modifier onlyDev() {
}
constructor() ERC721("Honey Badger Clan", "HBCD") PaymentSplitter(addressList, shareList) {
}
function buyGenesis(uint256 qty) external payable {
require(block.timestamp >= saleStartTime, "not live");
require(
_tokenIds.current() + qty <= genesis[0], "genesis sale not live"
);
require(qty <= genesis[1], "genesis qty not correct");
require(<FILL_ME>)
_mintTokens(qty, msg.sender);
}
function buyPioneer(uint256 qty) external payable {
}
function buyBuilder(uint256 qty) external payable {
}
function buyDao(uint256 qty) external payable {
}
function _mintTokens(uint256 qty, address to) private {
}
// if reward system is active
function claimReward(uint256 nftID) external {
}
// admin can mint them for giveaways, airdrops,use from web2 etc
function eCommerceMint(uint256 qty, address to) external onlyOwner {
}
function adminMint(uint256 qty, address to) external onlyOwner {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) external view returns (bool) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyDev {
}
function setContractURI(string memory newuri) external onlyDev {
}
function contractURI() public view returns (string memory) {
}
function reclaimERC20(IERC20 erc20Token) external onlyOwner {
}
function reclaimERC721(IERC721 erc721Token, uint256 id) external onlyOwner {
}
function reclaimERC1155(IERC1155 erc1155Token, uint256 id, uint256 amount) external onlyOwner {
}
//in unix
function setSaleStartTime(uint256 _saleStartTime) external onlyOwner {
}
function decreaseMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
// and for the eternity!
function lockBaseURIandContractURI() external onlyDev {
}
//if newTime is in the future, start the reward system [only owner]
function setRewardEndingTime(uint256 newTime) external onlyOwner {
}
//can claim if < maxRewardTokenID
function setMaxRewardTokenID(uint256 newMax) external onlyOwner {
}
//after voting chage price [10000,10,.07 ether];
function setDaoPrice(uint256 price) external onlyOwner {
}
//max qty / tran
function setDaoTranQty(uint256 newQty) external onlyOwner {
}
//how many tokens are available for dao sale
function setDaoMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setAllowDaoSale(bool allowDaoSale) external onlyOwner {
}
}
| genesis[2]*qty==msg.value,"genesis price not correct" | 387,403 | genesis[2]*qty==msg.value |
"pioneer sale not live" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract HoneyBadgers is ERC721Enumerable, Ownable, PaymentSplitter {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
string public _contractBaseURI =
"https://metadata-live.realitics.info/v1/metadata/";
string public _contractURI =
"https://ipfs.io/ipfs/QmRCvbVG2X2waXszFiWS3TkHCKJcMg76G7EPJkmZJJ5Mdw";
address private devWallet;
bool public locked; //metadata lock
uint256 public maxSupply = 10000;
uint256 public saleStartTime = 1639980000;
uint256[3] public genesis = [1000, 5, .035 ether];
uint256[3] public pioneer = [3000, 10, .05 ether];
uint256[3] public builder = [8000, 10, .06 ether];
uint256[3] public dao = [10000, 10, .07 ether];
uint256 public maxDaoSupply = 2000;
bool public daoSaleOpen = false;
address[] private addressList = [
0xecf86Cf8689394ED484c5B62f8Dd78ccCc750d41, //h
0x75Ca74CF7238a8D8337ED8c45F584c220b176d55 //d
//0x33519535356F8877dA7a90bF522FCACA5B01a2A2 //n remove
];
uint256[] private shareList = [50, 50];
Counters.Counter private _tokenIds;
//----------- Reward System ----------- //only used in case of emergency
uint256 public rewardEndingTime = 0; //unix time
uint256 public maxRewardTokenID = 2000; //can claim if you have < this tokenID
uint256 public maxFreeNFTperID = 1;
mapping(uint256 => uint256) public claimedPerID;
modifier onlyDev() {
}
constructor() ERC721("Honey Badger Clan", "HBCD") PaymentSplitter(addressList, shareList) {
}
function buyGenesis(uint256 qty) external payable {
}
function buyPioneer(uint256 qty) external payable {
require(block.timestamp >= saleStartTime, "not live");
require(<FILL_ME>)
require(qty <= pioneer[1], "pioneer qty <=10");
require(pioneer[2] * qty == msg.value, "pioneer price not correct");
_mintTokens(qty, msg.sender);
}
function buyBuilder(uint256 qty) external payable {
}
function buyDao(uint256 qty) external payable {
}
function _mintTokens(uint256 qty, address to) private {
}
// if reward system is active
function claimReward(uint256 nftID) external {
}
// admin can mint them for giveaways, airdrops,use from web2 etc
function eCommerceMint(uint256 qty, address to) external onlyOwner {
}
function adminMint(uint256 qty, address to) external onlyOwner {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) external view returns (bool) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyDev {
}
function setContractURI(string memory newuri) external onlyDev {
}
function contractURI() public view returns (string memory) {
}
function reclaimERC20(IERC20 erc20Token) external onlyOwner {
}
function reclaimERC721(IERC721 erc721Token, uint256 id) external onlyOwner {
}
function reclaimERC1155(IERC1155 erc1155Token, uint256 id, uint256 amount) external onlyOwner {
}
//in unix
function setSaleStartTime(uint256 _saleStartTime) external onlyOwner {
}
function decreaseMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
// and for the eternity!
function lockBaseURIandContractURI() external onlyDev {
}
//if newTime is in the future, start the reward system [only owner]
function setRewardEndingTime(uint256 newTime) external onlyOwner {
}
//can claim if < maxRewardTokenID
function setMaxRewardTokenID(uint256 newMax) external onlyOwner {
}
//after voting chage price [10000,10,.07 ether];
function setDaoPrice(uint256 price) external onlyOwner {
}
//max qty / tran
function setDaoTranQty(uint256 newQty) external onlyOwner {
}
//how many tokens are available for dao sale
function setDaoMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setAllowDaoSale(bool allowDaoSale) external onlyOwner {
}
}
| _tokenIds.current()+qty>genesis[0]&&_tokenIds.current()+qty<=pioneer[0],"pioneer sale not live" | 387,403 | _tokenIds.current()+qty>genesis[0]&&_tokenIds.current()+qty<=pioneer[0] |
"pioneer price not correct" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract HoneyBadgers is ERC721Enumerable, Ownable, PaymentSplitter {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
string public _contractBaseURI =
"https://metadata-live.realitics.info/v1/metadata/";
string public _contractURI =
"https://ipfs.io/ipfs/QmRCvbVG2X2waXszFiWS3TkHCKJcMg76G7EPJkmZJJ5Mdw";
address private devWallet;
bool public locked; //metadata lock
uint256 public maxSupply = 10000;
uint256 public saleStartTime = 1639980000;
uint256[3] public genesis = [1000, 5, .035 ether];
uint256[3] public pioneer = [3000, 10, .05 ether];
uint256[3] public builder = [8000, 10, .06 ether];
uint256[3] public dao = [10000, 10, .07 ether];
uint256 public maxDaoSupply = 2000;
bool public daoSaleOpen = false;
address[] private addressList = [
0xecf86Cf8689394ED484c5B62f8Dd78ccCc750d41, //h
0x75Ca74CF7238a8D8337ED8c45F584c220b176d55 //d
//0x33519535356F8877dA7a90bF522FCACA5B01a2A2 //n remove
];
uint256[] private shareList = [50, 50];
Counters.Counter private _tokenIds;
//----------- Reward System ----------- //only used in case of emergency
uint256 public rewardEndingTime = 0; //unix time
uint256 public maxRewardTokenID = 2000; //can claim if you have < this tokenID
uint256 public maxFreeNFTperID = 1;
mapping(uint256 => uint256) public claimedPerID;
modifier onlyDev() {
}
constructor() ERC721("Honey Badger Clan", "HBCD") PaymentSplitter(addressList, shareList) {
}
function buyGenesis(uint256 qty) external payable {
}
function buyPioneer(uint256 qty) external payable {
require(block.timestamp >= saleStartTime, "not live");
require(
_tokenIds.current() + qty > genesis[0] &&
_tokenIds.current() + qty <= pioneer[0], "pioneer sale not live"
);
require(qty <= pioneer[1], "pioneer qty <=10");
require(<FILL_ME>)
_mintTokens(qty, msg.sender);
}
function buyBuilder(uint256 qty) external payable {
}
function buyDao(uint256 qty) external payable {
}
function _mintTokens(uint256 qty, address to) private {
}
// if reward system is active
function claimReward(uint256 nftID) external {
}
// admin can mint them for giveaways, airdrops,use from web2 etc
function eCommerceMint(uint256 qty, address to) external onlyOwner {
}
function adminMint(uint256 qty, address to) external onlyOwner {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) external view returns (bool) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyDev {
}
function setContractURI(string memory newuri) external onlyDev {
}
function contractURI() public view returns (string memory) {
}
function reclaimERC20(IERC20 erc20Token) external onlyOwner {
}
function reclaimERC721(IERC721 erc721Token, uint256 id) external onlyOwner {
}
function reclaimERC1155(IERC1155 erc1155Token, uint256 id, uint256 amount) external onlyOwner {
}
//in unix
function setSaleStartTime(uint256 _saleStartTime) external onlyOwner {
}
function decreaseMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
// and for the eternity!
function lockBaseURIandContractURI() external onlyDev {
}
//if newTime is in the future, start the reward system [only owner]
function setRewardEndingTime(uint256 newTime) external onlyOwner {
}
//can claim if < maxRewardTokenID
function setMaxRewardTokenID(uint256 newMax) external onlyOwner {
}
//after voting chage price [10000,10,.07 ether];
function setDaoPrice(uint256 price) external onlyOwner {
}
//max qty / tran
function setDaoTranQty(uint256 newQty) external onlyOwner {
}
//how many tokens are available for dao sale
function setDaoMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setAllowDaoSale(bool allowDaoSale) external onlyOwner {
}
}
| pioneer[2]*qty==msg.value,"pioneer price not correct" | 387,403 | pioneer[2]*qty==msg.value |
"builder sale not live" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract HoneyBadgers is ERC721Enumerable, Ownable, PaymentSplitter {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
string public _contractBaseURI =
"https://metadata-live.realitics.info/v1/metadata/";
string public _contractURI =
"https://ipfs.io/ipfs/QmRCvbVG2X2waXszFiWS3TkHCKJcMg76G7EPJkmZJJ5Mdw";
address private devWallet;
bool public locked; //metadata lock
uint256 public maxSupply = 10000;
uint256 public saleStartTime = 1639980000;
uint256[3] public genesis = [1000, 5, .035 ether];
uint256[3] public pioneer = [3000, 10, .05 ether];
uint256[3] public builder = [8000, 10, .06 ether];
uint256[3] public dao = [10000, 10, .07 ether];
uint256 public maxDaoSupply = 2000;
bool public daoSaleOpen = false;
address[] private addressList = [
0xecf86Cf8689394ED484c5B62f8Dd78ccCc750d41, //h
0x75Ca74CF7238a8D8337ED8c45F584c220b176d55 //d
//0x33519535356F8877dA7a90bF522FCACA5B01a2A2 //n remove
];
uint256[] private shareList = [50, 50];
Counters.Counter private _tokenIds;
//----------- Reward System ----------- //only used in case of emergency
uint256 public rewardEndingTime = 0; //unix time
uint256 public maxRewardTokenID = 2000; //can claim if you have < this tokenID
uint256 public maxFreeNFTperID = 1;
mapping(uint256 => uint256) public claimedPerID;
modifier onlyDev() {
}
constructor() ERC721("Honey Badger Clan", "HBCD") PaymentSplitter(addressList, shareList) {
}
function buyGenesis(uint256 qty) external payable {
}
function buyPioneer(uint256 qty) external payable {
}
function buyBuilder(uint256 qty) external payable {
require(block.timestamp >= saleStartTime, "not live");
require(<FILL_ME>)
require(qty <= builder[1], "builder qty <=10");
require(builder[2] * qty == msg.value, "builder price not correct");
_mintTokens(qty, msg.sender);
}
function buyDao(uint256 qty) external payable {
}
function _mintTokens(uint256 qty, address to) private {
}
// if reward system is active
function claimReward(uint256 nftID) external {
}
// admin can mint them for giveaways, airdrops,use from web2 etc
function eCommerceMint(uint256 qty, address to) external onlyOwner {
}
function adminMint(uint256 qty, address to) external onlyOwner {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) external view returns (bool) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyDev {
}
function setContractURI(string memory newuri) external onlyDev {
}
function contractURI() public view returns (string memory) {
}
function reclaimERC20(IERC20 erc20Token) external onlyOwner {
}
function reclaimERC721(IERC721 erc721Token, uint256 id) external onlyOwner {
}
function reclaimERC1155(IERC1155 erc1155Token, uint256 id, uint256 amount) external onlyOwner {
}
//in unix
function setSaleStartTime(uint256 _saleStartTime) external onlyOwner {
}
function decreaseMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
// and for the eternity!
function lockBaseURIandContractURI() external onlyDev {
}
//if newTime is in the future, start the reward system [only owner]
function setRewardEndingTime(uint256 newTime) external onlyOwner {
}
//can claim if < maxRewardTokenID
function setMaxRewardTokenID(uint256 newMax) external onlyOwner {
}
//after voting chage price [10000,10,.07 ether];
function setDaoPrice(uint256 price) external onlyOwner {
}
//max qty / tran
function setDaoTranQty(uint256 newQty) external onlyOwner {
}
//how many tokens are available for dao sale
function setDaoMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setAllowDaoSale(bool allowDaoSale) external onlyOwner {
}
}
| _tokenIds.current()+qty>pioneer[0]&&_tokenIds.current()+qty<=builder[0],"builder sale not live" | 387,403 | _tokenIds.current()+qty>pioneer[0]&&_tokenIds.current()+qty<=builder[0] |
"builder price not correct" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract HoneyBadgers is ERC721Enumerable, Ownable, PaymentSplitter {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
string public _contractBaseURI =
"https://metadata-live.realitics.info/v1/metadata/";
string public _contractURI =
"https://ipfs.io/ipfs/QmRCvbVG2X2waXszFiWS3TkHCKJcMg76G7EPJkmZJJ5Mdw";
address private devWallet;
bool public locked; //metadata lock
uint256 public maxSupply = 10000;
uint256 public saleStartTime = 1639980000;
uint256[3] public genesis = [1000, 5, .035 ether];
uint256[3] public pioneer = [3000, 10, .05 ether];
uint256[3] public builder = [8000, 10, .06 ether];
uint256[3] public dao = [10000, 10, .07 ether];
uint256 public maxDaoSupply = 2000;
bool public daoSaleOpen = false;
address[] private addressList = [
0xecf86Cf8689394ED484c5B62f8Dd78ccCc750d41, //h
0x75Ca74CF7238a8D8337ED8c45F584c220b176d55 //d
//0x33519535356F8877dA7a90bF522FCACA5B01a2A2 //n remove
];
uint256[] private shareList = [50, 50];
Counters.Counter private _tokenIds;
//----------- Reward System ----------- //only used in case of emergency
uint256 public rewardEndingTime = 0; //unix time
uint256 public maxRewardTokenID = 2000; //can claim if you have < this tokenID
uint256 public maxFreeNFTperID = 1;
mapping(uint256 => uint256) public claimedPerID;
modifier onlyDev() {
}
constructor() ERC721("Honey Badger Clan", "HBCD") PaymentSplitter(addressList, shareList) {
}
function buyGenesis(uint256 qty) external payable {
}
function buyPioneer(uint256 qty) external payable {
}
function buyBuilder(uint256 qty) external payable {
require(block.timestamp >= saleStartTime, "not live");
require(
_tokenIds.current() + qty > pioneer[0] &&
_tokenIds.current() + qty <= builder[0], "builder sale not live"
);
require(qty <= builder[1], "builder qty <=10");
require(<FILL_ME>)
_mintTokens(qty, msg.sender);
}
function buyDao(uint256 qty) external payable {
}
function _mintTokens(uint256 qty, address to) private {
}
// if reward system is active
function claimReward(uint256 nftID) external {
}
// admin can mint them for giveaways, airdrops,use from web2 etc
function eCommerceMint(uint256 qty, address to) external onlyOwner {
}
function adminMint(uint256 qty, address to) external onlyOwner {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) external view returns (bool) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyDev {
}
function setContractURI(string memory newuri) external onlyDev {
}
function contractURI() public view returns (string memory) {
}
function reclaimERC20(IERC20 erc20Token) external onlyOwner {
}
function reclaimERC721(IERC721 erc721Token, uint256 id) external onlyOwner {
}
function reclaimERC1155(IERC1155 erc1155Token, uint256 id, uint256 amount) external onlyOwner {
}
//in unix
function setSaleStartTime(uint256 _saleStartTime) external onlyOwner {
}
function decreaseMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
// and for the eternity!
function lockBaseURIandContractURI() external onlyDev {
}
//if newTime is in the future, start the reward system [only owner]
function setRewardEndingTime(uint256 newTime) external onlyOwner {
}
//can claim if < maxRewardTokenID
function setMaxRewardTokenID(uint256 newMax) external onlyOwner {
}
//after voting chage price [10000,10,.07 ether];
function setDaoPrice(uint256 price) external onlyOwner {
}
//max qty / tran
function setDaoTranQty(uint256 newQty) external onlyOwner {
}
//how many tokens are available for dao sale
function setDaoMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setAllowDaoSale(bool allowDaoSale) external onlyOwner {
}
}
| builder[2]*qty==msg.value,"builder price not correct" | 387,403 | builder[2]*qty==msg.value |
"dao sale not live" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract HoneyBadgers is ERC721Enumerable, Ownable, PaymentSplitter {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
string public _contractBaseURI =
"https://metadata-live.realitics.info/v1/metadata/";
string public _contractURI =
"https://ipfs.io/ipfs/QmRCvbVG2X2waXszFiWS3TkHCKJcMg76G7EPJkmZJJ5Mdw";
address private devWallet;
bool public locked; //metadata lock
uint256 public maxSupply = 10000;
uint256 public saleStartTime = 1639980000;
uint256[3] public genesis = [1000, 5, .035 ether];
uint256[3] public pioneer = [3000, 10, .05 ether];
uint256[3] public builder = [8000, 10, .06 ether];
uint256[3] public dao = [10000, 10, .07 ether];
uint256 public maxDaoSupply = 2000;
bool public daoSaleOpen = false;
address[] private addressList = [
0xecf86Cf8689394ED484c5B62f8Dd78ccCc750d41, //h
0x75Ca74CF7238a8D8337ED8c45F584c220b176d55 //d
//0x33519535356F8877dA7a90bF522FCACA5B01a2A2 //n remove
];
uint256[] private shareList = [50, 50];
Counters.Counter private _tokenIds;
//----------- Reward System ----------- //only used in case of emergency
uint256 public rewardEndingTime = 0; //unix time
uint256 public maxRewardTokenID = 2000; //can claim if you have < this tokenID
uint256 public maxFreeNFTperID = 1;
mapping(uint256 => uint256) public claimedPerID;
modifier onlyDev() {
}
constructor() ERC721("Honey Badger Clan", "HBCD") PaymentSplitter(addressList, shareList) {
}
function buyGenesis(uint256 qty) external payable {
}
function buyPioneer(uint256 qty) external payable {
}
function buyBuilder(uint256 qty) external payable {
}
function buyDao(uint256 qty) external payable {
require(block.timestamp >= saleStartTime, "not live");
require(<FILL_ME>)
require(daoSaleOpen, "dao sale not open");
require(qty <= dao[1], "quantity not correct");
require(dao[2] * qty <= msg.value, "dao price not correct");
require(
(_tokenIds.current() - builder[0]) + qty <= maxDaoSupply,"public sale out of stock"
);
_mintTokens(qty, msg.sender);
}
function _mintTokens(uint256 qty, address to) private {
}
// if reward system is active
function claimReward(uint256 nftID) external {
}
// admin can mint them for giveaways, airdrops,use from web2 etc
function eCommerceMint(uint256 qty, address to) external onlyOwner {
}
function adminMint(uint256 qty, address to) external onlyOwner {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) external view returns (bool) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyDev {
}
function setContractURI(string memory newuri) external onlyDev {
}
function contractURI() public view returns (string memory) {
}
function reclaimERC20(IERC20 erc20Token) external onlyOwner {
}
function reclaimERC721(IERC721 erc721Token, uint256 id) external onlyOwner {
}
function reclaimERC1155(IERC1155 erc1155Token, uint256 id, uint256 amount) external onlyOwner {
}
//in unix
function setSaleStartTime(uint256 _saleStartTime) external onlyOwner {
}
function decreaseMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
// and for the eternity!
function lockBaseURIandContractURI() external onlyDev {
}
//if newTime is in the future, start the reward system [only owner]
function setRewardEndingTime(uint256 newTime) external onlyOwner {
}
//can claim if < maxRewardTokenID
function setMaxRewardTokenID(uint256 newMax) external onlyOwner {
}
//after voting chage price [10000,10,.07 ether];
function setDaoPrice(uint256 price) external onlyOwner {
}
//max qty / tran
function setDaoTranQty(uint256 newQty) external onlyOwner {
}
//how many tokens are available for dao sale
function setDaoMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setAllowDaoSale(bool allowDaoSale) external onlyOwner {
}
}
| _tokenIds.current()+qty>builder[0]&&_tokenIds.current()+qty<=dao[0],"dao sale not live" | 387,403 | _tokenIds.current()+qty>builder[0]&&_tokenIds.current()+qty<=dao[0] |
"dao price not correct" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract HoneyBadgers is ERC721Enumerable, Ownable, PaymentSplitter {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
string public _contractBaseURI =
"https://metadata-live.realitics.info/v1/metadata/";
string public _contractURI =
"https://ipfs.io/ipfs/QmRCvbVG2X2waXszFiWS3TkHCKJcMg76G7EPJkmZJJ5Mdw";
address private devWallet;
bool public locked; //metadata lock
uint256 public maxSupply = 10000;
uint256 public saleStartTime = 1639980000;
uint256[3] public genesis = [1000, 5, .035 ether];
uint256[3] public pioneer = [3000, 10, .05 ether];
uint256[3] public builder = [8000, 10, .06 ether];
uint256[3] public dao = [10000, 10, .07 ether];
uint256 public maxDaoSupply = 2000;
bool public daoSaleOpen = false;
address[] private addressList = [
0xecf86Cf8689394ED484c5B62f8Dd78ccCc750d41, //h
0x75Ca74CF7238a8D8337ED8c45F584c220b176d55 //d
//0x33519535356F8877dA7a90bF522FCACA5B01a2A2 //n remove
];
uint256[] private shareList = [50, 50];
Counters.Counter private _tokenIds;
//----------- Reward System ----------- //only used in case of emergency
uint256 public rewardEndingTime = 0; //unix time
uint256 public maxRewardTokenID = 2000; //can claim if you have < this tokenID
uint256 public maxFreeNFTperID = 1;
mapping(uint256 => uint256) public claimedPerID;
modifier onlyDev() {
}
constructor() ERC721("Honey Badger Clan", "HBCD") PaymentSplitter(addressList, shareList) {
}
function buyGenesis(uint256 qty) external payable {
}
function buyPioneer(uint256 qty) external payable {
}
function buyBuilder(uint256 qty) external payable {
}
function buyDao(uint256 qty) external payable {
require(block.timestamp >= saleStartTime, "not live");
require(
_tokenIds.current() + qty > builder[0] &&
_tokenIds.current() + qty <= dao[0], "dao sale not live"
);
require(daoSaleOpen, "dao sale not open");
require(qty <= dao[1], "quantity not correct");
require(<FILL_ME>)
require(
(_tokenIds.current() - builder[0]) + qty <= maxDaoSupply,"public sale out of stock"
);
_mintTokens(qty, msg.sender);
}
function _mintTokens(uint256 qty, address to) private {
}
// if reward system is active
function claimReward(uint256 nftID) external {
}
// admin can mint them for giveaways, airdrops,use from web2 etc
function eCommerceMint(uint256 qty, address to) external onlyOwner {
}
function adminMint(uint256 qty, address to) external onlyOwner {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) external view returns (bool) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyDev {
}
function setContractURI(string memory newuri) external onlyDev {
}
function contractURI() public view returns (string memory) {
}
function reclaimERC20(IERC20 erc20Token) external onlyOwner {
}
function reclaimERC721(IERC721 erc721Token, uint256 id) external onlyOwner {
}
function reclaimERC1155(IERC1155 erc1155Token, uint256 id, uint256 amount) external onlyOwner {
}
//in unix
function setSaleStartTime(uint256 _saleStartTime) external onlyOwner {
}
function decreaseMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
// and for the eternity!
function lockBaseURIandContractURI() external onlyDev {
}
//if newTime is in the future, start the reward system [only owner]
function setRewardEndingTime(uint256 newTime) external onlyOwner {
}
//can claim if < maxRewardTokenID
function setMaxRewardTokenID(uint256 newMax) external onlyOwner {
}
//after voting chage price [10000,10,.07 ether];
function setDaoPrice(uint256 price) external onlyOwner {
}
//max qty / tran
function setDaoTranQty(uint256 newQty) external onlyOwner {
}
//how many tokens are available for dao sale
function setDaoMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setAllowDaoSale(bool allowDaoSale) external onlyOwner {
}
}
| dao[2]*qty<=msg.value,"dao price not correct" | 387,403 | dao[2]*qty<=msg.value |
"public sale out of stock" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract HoneyBadgers is ERC721Enumerable, Ownable, PaymentSplitter {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
string public _contractBaseURI =
"https://metadata-live.realitics.info/v1/metadata/";
string public _contractURI =
"https://ipfs.io/ipfs/QmRCvbVG2X2waXszFiWS3TkHCKJcMg76G7EPJkmZJJ5Mdw";
address private devWallet;
bool public locked; //metadata lock
uint256 public maxSupply = 10000;
uint256 public saleStartTime = 1639980000;
uint256[3] public genesis = [1000, 5, .035 ether];
uint256[3] public pioneer = [3000, 10, .05 ether];
uint256[3] public builder = [8000, 10, .06 ether];
uint256[3] public dao = [10000, 10, .07 ether];
uint256 public maxDaoSupply = 2000;
bool public daoSaleOpen = false;
address[] private addressList = [
0xecf86Cf8689394ED484c5B62f8Dd78ccCc750d41, //h
0x75Ca74CF7238a8D8337ED8c45F584c220b176d55 //d
//0x33519535356F8877dA7a90bF522FCACA5B01a2A2 //n remove
];
uint256[] private shareList = [50, 50];
Counters.Counter private _tokenIds;
//----------- Reward System ----------- //only used in case of emergency
uint256 public rewardEndingTime = 0; //unix time
uint256 public maxRewardTokenID = 2000; //can claim if you have < this tokenID
uint256 public maxFreeNFTperID = 1;
mapping(uint256 => uint256) public claimedPerID;
modifier onlyDev() {
}
constructor() ERC721("Honey Badger Clan", "HBCD") PaymentSplitter(addressList, shareList) {
}
function buyGenesis(uint256 qty) external payable {
}
function buyPioneer(uint256 qty) external payable {
}
function buyBuilder(uint256 qty) external payable {
}
function buyDao(uint256 qty) external payable {
require(block.timestamp >= saleStartTime, "not live");
require(
_tokenIds.current() + qty > builder[0] &&
_tokenIds.current() + qty <= dao[0], "dao sale not live"
);
require(daoSaleOpen, "dao sale not open");
require(qty <= dao[1], "quantity not correct");
require(dao[2] * qty <= msg.value, "dao price not correct");
require(<FILL_ME>)
_mintTokens(qty, msg.sender);
}
function _mintTokens(uint256 qty, address to) private {
}
// if reward system is active
function claimReward(uint256 nftID) external {
}
// admin can mint them for giveaways, airdrops,use from web2 etc
function eCommerceMint(uint256 qty, address to) external onlyOwner {
}
function adminMint(uint256 qty, address to) external onlyOwner {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) external view returns (bool) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyDev {
}
function setContractURI(string memory newuri) external onlyDev {
}
function contractURI() public view returns (string memory) {
}
function reclaimERC20(IERC20 erc20Token) external onlyOwner {
}
function reclaimERC721(IERC721 erc721Token, uint256 id) external onlyOwner {
}
function reclaimERC1155(IERC1155 erc1155Token, uint256 id, uint256 amount) external onlyOwner {
}
//in unix
function setSaleStartTime(uint256 _saleStartTime) external onlyOwner {
}
function decreaseMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
// and for the eternity!
function lockBaseURIandContractURI() external onlyDev {
}
//if newTime is in the future, start the reward system [only owner]
function setRewardEndingTime(uint256 newTime) external onlyOwner {
}
//can claim if < maxRewardTokenID
function setMaxRewardTokenID(uint256 newMax) external onlyOwner {
}
//after voting chage price [10000,10,.07 ether];
function setDaoPrice(uint256 price) external onlyOwner {
}
//max qty / tran
function setDaoTranQty(uint256 newQty) external onlyOwner {
}
//how many tokens are available for dao sale
function setDaoMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setAllowDaoSale(bool allowDaoSale) external onlyOwner {
}
}
| (_tokenIds.current()-builder[0])+qty<=maxDaoSupply,"public sale out of stock" | 387,403 | (_tokenIds.current()-builder[0])+qty<=maxDaoSupply |
"you already claimed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract HoneyBadgers is ERC721Enumerable, Ownable, PaymentSplitter {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
string public _contractBaseURI =
"https://metadata-live.realitics.info/v1/metadata/";
string public _contractURI =
"https://ipfs.io/ipfs/QmRCvbVG2X2waXszFiWS3TkHCKJcMg76G7EPJkmZJJ5Mdw";
address private devWallet;
bool public locked; //metadata lock
uint256 public maxSupply = 10000;
uint256 public saleStartTime = 1639980000;
uint256[3] public genesis = [1000, 5, .035 ether];
uint256[3] public pioneer = [3000, 10, .05 ether];
uint256[3] public builder = [8000, 10, .06 ether];
uint256[3] public dao = [10000, 10, .07 ether];
uint256 public maxDaoSupply = 2000;
bool public daoSaleOpen = false;
address[] private addressList = [
0xecf86Cf8689394ED484c5B62f8Dd78ccCc750d41, //h
0x75Ca74CF7238a8D8337ED8c45F584c220b176d55 //d
//0x33519535356F8877dA7a90bF522FCACA5B01a2A2 //n remove
];
uint256[] private shareList = [50, 50];
Counters.Counter private _tokenIds;
//----------- Reward System ----------- //only used in case of emergency
uint256 public rewardEndingTime = 0; //unix time
uint256 public maxRewardTokenID = 2000; //can claim if you have < this tokenID
uint256 public maxFreeNFTperID = 1;
mapping(uint256 => uint256) public claimedPerID;
modifier onlyDev() {
}
constructor() ERC721("Honey Badger Clan", "HBCD") PaymentSplitter(addressList, shareList) {
}
function buyGenesis(uint256 qty) external payable {
}
function buyPioneer(uint256 qty) external payable {
}
function buyBuilder(uint256 qty) external payable {
}
function buyDao(uint256 qty) external payable {
}
function _mintTokens(uint256 qty, address to) private {
}
// if reward system is active
function claimReward(uint256 nftID) external {
require(rewardEndingTime >= block.timestamp, "reward period not active");
require(rewardEndingTime != 0, "reward period not set");
require(<FILL_ME>)
require(block.timestamp >= saleStartTime, "sale not live");
require(ownerOf(nftID) == msg.sender, "ownership required");
require(nftID <= maxRewardTokenID, "nftID not in range");
claimedPerID[nftID] = claimedPerID[nftID] + 1; //increase the claimedPerID
_tokenIds.increment();
_safeMint(msg.sender, _tokenIds.current());
}
// admin can mint them for giveaways, airdrops,use from web2 etc
function eCommerceMint(uint256 qty, address to) external onlyOwner {
}
function adminMint(uint256 qty, address to) external onlyOwner {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) external view returns (bool) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyDev {
}
function setContractURI(string memory newuri) external onlyDev {
}
function contractURI() public view returns (string memory) {
}
function reclaimERC20(IERC20 erc20Token) external onlyOwner {
}
function reclaimERC721(IERC721 erc721Token, uint256 id) external onlyOwner {
}
function reclaimERC1155(IERC1155 erc1155Token, uint256 id, uint256 amount) external onlyOwner {
}
//in unix
function setSaleStartTime(uint256 _saleStartTime) external onlyOwner {
}
function decreaseMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
// and for the eternity!
function lockBaseURIandContractURI() external onlyDev {
}
//if newTime is in the future, start the reward system [only owner]
function setRewardEndingTime(uint256 newTime) external onlyOwner {
}
//can claim if < maxRewardTokenID
function setMaxRewardTokenID(uint256 newMax) external onlyOwner {
}
//after voting chage price [10000,10,.07 ether];
function setDaoPrice(uint256 price) external onlyOwner {
}
//max qty / tran
function setDaoTranQty(uint256 newQty) external onlyOwner {
}
//how many tokens are available for dao sale
function setDaoMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setAllowDaoSale(bool allowDaoSale) external onlyOwner {
}
}
| claimedPerID[nftID]<maxFreeNFTperID,"you already claimed" | 387,403 | claimedPerID[nftID]<maxFreeNFTperID |
"ownership required" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract HoneyBadgers is ERC721Enumerable, Ownable, PaymentSplitter {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
string public _contractBaseURI =
"https://metadata-live.realitics.info/v1/metadata/";
string public _contractURI =
"https://ipfs.io/ipfs/QmRCvbVG2X2waXszFiWS3TkHCKJcMg76G7EPJkmZJJ5Mdw";
address private devWallet;
bool public locked; //metadata lock
uint256 public maxSupply = 10000;
uint256 public saleStartTime = 1639980000;
uint256[3] public genesis = [1000, 5, .035 ether];
uint256[3] public pioneer = [3000, 10, .05 ether];
uint256[3] public builder = [8000, 10, .06 ether];
uint256[3] public dao = [10000, 10, .07 ether];
uint256 public maxDaoSupply = 2000;
bool public daoSaleOpen = false;
address[] private addressList = [
0xecf86Cf8689394ED484c5B62f8Dd78ccCc750d41, //h
0x75Ca74CF7238a8D8337ED8c45F584c220b176d55 //d
//0x33519535356F8877dA7a90bF522FCACA5B01a2A2 //n remove
];
uint256[] private shareList = [50, 50];
Counters.Counter private _tokenIds;
//----------- Reward System ----------- //only used in case of emergency
uint256 public rewardEndingTime = 0; //unix time
uint256 public maxRewardTokenID = 2000; //can claim if you have < this tokenID
uint256 public maxFreeNFTperID = 1;
mapping(uint256 => uint256) public claimedPerID;
modifier onlyDev() {
}
constructor() ERC721("Honey Badger Clan", "HBCD") PaymentSplitter(addressList, shareList) {
}
function buyGenesis(uint256 qty) external payable {
}
function buyPioneer(uint256 qty) external payable {
}
function buyBuilder(uint256 qty) external payable {
}
function buyDao(uint256 qty) external payable {
}
function _mintTokens(uint256 qty, address to) private {
}
// if reward system is active
function claimReward(uint256 nftID) external {
require(rewardEndingTime >= block.timestamp, "reward period not active");
require(rewardEndingTime != 0, "reward period not set");
require(claimedPerID[nftID] < maxFreeNFTperID, "you already claimed");
require(block.timestamp >= saleStartTime, "sale not live");
require(<FILL_ME>)
require(nftID <= maxRewardTokenID, "nftID not in range");
claimedPerID[nftID] = claimedPerID[nftID] + 1; //increase the claimedPerID
_tokenIds.increment();
_safeMint(msg.sender, _tokenIds.current());
}
// admin can mint them for giveaways, airdrops,use from web2 etc
function eCommerceMint(uint256 qty, address to) external onlyOwner {
}
function adminMint(uint256 qty, address to) external onlyOwner {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) external view returns (bool) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyDev {
}
function setContractURI(string memory newuri) external onlyDev {
}
function contractURI() public view returns (string memory) {
}
function reclaimERC20(IERC20 erc20Token) external onlyOwner {
}
function reclaimERC721(IERC721 erc721Token, uint256 id) external onlyOwner {
}
function reclaimERC1155(IERC1155 erc1155Token, uint256 id, uint256 amount) external onlyOwner {
}
//in unix
function setSaleStartTime(uint256 _saleStartTime) external onlyOwner {
}
function decreaseMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
// and for the eternity!
function lockBaseURIandContractURI() external onlyDev {
}
//if newTime is in the future, start the reward system [only owner]
function setRewardEndingTime(uint256 newTime) external onlyOwner {
}
//can claim if < maxRewardTokenID
function setMaxRewardTokenID(uint256 newMax) external onlyOwner {
}
//after voting chage price [10000,10,.07 ether];
function setDaoPrice(uint256 price) external onlyOwner {
}
//max qty / tran
function setDaoTranQty(uint256 newQty) external onlyOwner {
}
//how many tokens are available for dao sale
function setDaoMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setAllowDaoSale(bool allowDaoSale) external onlyOwner {
}
}
| ownerOf(nftID)==msg.sender,"ownership required" | 387,403 | ownerOf(nftID)==msg.sender |
"out of stock" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract HoneyBadgers is ERC721Enumerable, Ownable, PaymentSplitter {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
string public _contractBaseURI =
"https://metadata-live.realitics.info/v1/metadata/";
string public _contractURI =
"https://ipfs.io/ipfs/QmRCvbVG2X2waXszFiWS3TkHCKJcMg76G7EPJkmZJJ5Mdw";
address private devWallet;
bool public locked; //metadata lock
uint256 public maxSupply = 10000;
uint256 public saleStartTime = 1639980000;
uint256[3] public genesis = [1000, 5, .035 ether];
uint256[3] public pioneer = [3000, 10, .05 ether];
uint256[3] public builder = [8000, 10, .06 ether];
uint256[3] public dao = [10000, 10, .07 ether];
uint256 public maxDaoSupply = 2000;
bool public daoSaleOpen = false;
address[] private addressList = [
0xecf86Cf8689394ED484c5B62f8Dd78ccCc750d41, //h
0x75Ca74CF7238a8D8337ED8c45F584c220b176d55 //d
//0x33519535356F8877dA7a90bF522FCACA5B01a2A2 //n remove
];
uint256[] private shareList = [50, 50];
Counters.Counter private _tokenIds;
//----------- Reward System ----------- //only used in case of emergency
uint256 public rewardEndingTime = 0; //unix time
uint256 public maxRewardTokenID = 2000; //can claim if you have < this tokenID
uint256 public maxFreeNFTperID = 1;
mapping(uint256 => uint256) public claimedPerID;
modifier onlyDev() {
}
constructor() ERC721("Honey Badger Clan", "HBCD") PaymentSplitter(addressList, shareList) {
}
function buyGenesis(uint256 qty) external payable {
}
function buyPioneer(uint256 qty) external payable {
}
function buyBuilder(uint256 qty) external payable {
}
function buyDao(uint256 qty) external payable {
}
function _mintTokens(uint256 qty, address to) private {
}
// if reward system is active
function claimReward(uint256 nftID) external {
}
// admin can mint them for giveaways, airdrops,use from web2 etc
function eCommerceMint(uint256 qty, address to) external onlyOwner {
require(qty <= 10, "no more than 10");
require(<FILL_ME>)
_mintTokens(qty, to);
}
function adminMint(uint256 qty, address to) external onlyOwner {
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) external view returns (bool) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyDev {
}
function setContractURI(string memory newuri) external onlyDev {
}
function contractURI() public view returns (string memory) {
}
function reclaimERC20(IERC20 erc20Token) external onlyOwner {
}
function reclaimERC721(IERC721 erc721Token, uint256 id) external onlyOwner {
}
function reclaimERC1155(IERC1155 erc1155Token, uint256 id, uint256 amount) external onlyOwner {
}
//in unix
function setSaleStartTime(uint256 _saleStartTime) external onlyOwner {
}
function decreaseMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
// and for the eternity!
function lockBaseURIandContractURI() external onlyDev {
}
//if newTime is in the future, start the reward system [only owner]
function setRewardEndingTime(uint256 newTime) external onlyOwner {
}
//can claim if < maxRewardTokenID
function setMaxRewardTokenID(uint256 newMax) external onlyOwner {
}
//after voting chage price [10000,10,.07 ether];
function setDaoPrice(uint256 price) external onlyOwner {
}
//max qty / tran
function setDaoTranQty(uint256 newQty) external onlyOwner {
}
//how many tokens are available for dao sale
function setDaoMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setAllowDaoSale(bool allowDaoSale) external onlyOwner {
}
}
| _tokenIds.current()+qty<=maxSupply,"out of stock" | 387,403 | _tokenIds.current()+qty<=maxSupply |
"!voter" | // SPDX-License-Identifier: MIT
pragma solidity ^0.6.7;
pragma experimental ABIEncoderV2;
import "../lib/safe-math.sol";
import "../lib/erc20.sol";
import "../interfaces/univ3/IUniswapV3PositionsNFT.sol";
import "../interfaces/backscratcher/FraxGauge.sol";
interface IProxy {
function execute(
address to,
uint256 value,
bytes calldata data
) external returns (bool, bytes memory);
function increaseAmount(uint256) external;
}
library SafeProxy {
function safeExecute(
IProxy proxy,
address to,
uint256 value,
bytes memory data
) internal {
}
}
contract StrategyProxy {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
using SafeProxy for IProxy;
IProxy public proxy;
address public veFxsVault;
// address public constant gaugeFXSRewardsDistributor =
// 0x278dC748edA1d8eFEf1aDFB518542612b49Fcd34;
IUniswapV3PositionsNFT public constant nftManager =
IUniswapV3PositionsNFT(0xC36442b4a4522E871399CD717aBDD847Ab11FE88);
address public constant fxs = address(0x3432B6A60D23Ca0dFCa7761B7ab56459D9C964D0);
address public constant rewards = address(0x3432B6A60D23Ca0dFCa7761B7ab56459D9C964D0);
address public gauge = address(0x3669C421b77340B2979d1A00a792CC2ee0FcE737);
address public feeDistribution = 0xc6764e58b36e26b08Fd1d2AeD4538c02171fA872;
// gauge => strategies
mapping(address => address) public strategies;
mapping(address => bool) public voters;
address public governance;
// TODO How much FXS tokens to give to backscratcher?
uint256 public keepFXS = 1000;
uint256 public constant keepFXSMax = 10000;
constructor() public {
}
function setGovernance(address _governance) external {
}
function setKeepFXS(uint256 _keepFXS) external {
}
function setFXSVault(address _vault) external {
}
function setLocker(address _proxy) external {
}
function setGauge(address _gauge) external {
}
function setFeeDistribution(address _feeDistribution) external {
}
function approveStrategy(address _gauge, address _strategy) external {
}
function revokeStrategy(address _gauge) external {
}
function approveVoter(address _voter) external {
}
function revokeVoter(address _voter) external {
}
function lock() external {
}
function vote(address _gauge, uint256 _amount) public {
require(<FILL_ME>)
proxy.safeExecute(
gauge,
0,
abi.encodeWithSignature("vote_for_gauge_weights(address,uint256)", _gauge, _amount)
);
}
function withdrawV3(
address _gauge,
uint256 _tokenId,
address[] memory _rewardTokens
) public returns (uint256) {
}
function withdrawV2(
address _gauge,
address _token,
bytes32 _kek_id,
address[] memory _rewardTokens
) public returns (uint256) {
}
function balanceOf(address _gauge) public view returns (uint256) {
}
function lockedNFTsOf(address _gauge) public view returns (LockedNFT[] memory) {
}
function lockedStakesOf(address _gauge) public view returns (LockedStake[] memory) {
}
function withdrawAllV3(address _gauge, address[] calldata _rewardTokens) external returns (uint256 amount) {
}
function withdrawAllV2(
address _gauge,
address _token,
address[] calldata _rewardTokens
) external returns (uint256 amount) {
}
function depositV3(
address _gauge,
uint256 _tokenId,
uint256 _secs
) external {
}
function depositV2(
address _gauge,
address _token,
uint256 _secs
) external {
}
function harvest(address _gauge, address[] calldata _tokens) external {
}
function claim(address recipient) external {
}
function claimRewards(address _gauge, address _token) external {
}
function onERC721Received(
address,
address,
uint256,
bytes memory
) public pure returns (bytes4) {
}
// **** Emergency functions ****
function execute(address _target, bytes memory _data) public payable returns (bytes memory response) {
}
}
| voters[msg.sender],"!voter" | 387,440 | voters[msg.sender] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.