comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"TOWERChestSale: transfer failed" | pragma solidity 0.6.8;
/**
* @title TOWERChestSale
* A FixedPricesSale contract implementation that handles the purchase of pre-minted ERC-20 TOWER
* Chest tokens.
*/
contract TOWERChestSale is FixedPricesSale {
address public immutable tokenHolder;
mapping(bytes32 => address) public skuTokens;
/**
* Constructor.
* @dev Reverts if `tokenHolder_` is the zero address.
* @dev Emits the `MagicValues` event.
* @dev Emits the `Paused` event.
* @param tokenHolder_ The account holding the pool of sale supply tokens.
* @param payoutWallet the payout wallet.
* @param skusCapacity the cap for the number of managed SKUs.
* @param tokensPerSkuCapacity the cap for the number of tokens managed per SKU.
*/
constructor(
address tokenHolder_,
address payoutWallet,
uint256 skusCapacity,
uint256 tokensPerSkuCapacity
) public FixedPricesSale(payoutWallet, skusCapacity, tokensPerSkuCapacity) {
}
/**
* Creates an SKU.
* @dev Reverts if `totalSupply` is zero.
* @dev Reverts if `sku` already exists.
* @dev Reverts if `notificationsReceiver` is not the zero address and is not a contract address.
* @dev Reverts if the update results in too many SKUs.
* @dev Reverts if `skuToken` is the zero address.
* @dev Emits the `SkuCreation` event.
* @param sku The SKU identifier.
* @param totalSupply The initial total supply.
* @param maxQuantityPerPurchase The maximum allowed quantity for a single purchase.
* @param notificationsReceiver The purchase notifications receiver contract address.
* If set to the zero address, the notification is not enabled.
* @param token The contract address of the ERC-20 TOWER Chest token associated with the
* created SKU.
*/
function createSku(
bytes32 sku,
uint256 totalSupply,
uint256 maxQuantityPerPurchase,
address notificationsReceiver,
address token
) external onlyOwner whenPaused {
}
/**
* Lifecycle step which delivers the purchased SKUs to the recipient.
* @dev Responsibilities:
* - Ensure the product is delivered to the recipient, if that is the contract's responsibility.
* - Handle any internal logic related to the delivery, including the remaining supply update;
* - Add any relevant extra data related to delivery in `purchase.deliveryData` and document how to interpret it.
* @dev Reverts if there is not enough available supply.
* @dev If this function is overriden, the implementer SHOULD super call it.
* @param purchase The purchase conditions.
*/
function _delivery(PurchaseData memory purchase) internal override {
super._delivery(purchase);
ITOWERChestsSale_ERC20TransferFrom chest = ITOWERChestsSale_ERC20TransferFrom(skuTokens[purchase.sku]);
uint256 decimals = chest.decimals();
require(<FILL_ME>)
}
}
// solhint-disable-next-line contract-name-camelcase
interface ITOWERChestsSale_ERC20TransferFrom {
/**
* @notice Transfers `value` amount of tokens from address `from` to address `to` via the approval mechanism.
* @dev Reverts if the caller has not been approved by `from` for at least `value`.
* @dev Reverts if `from` does not have at least `value` of balance.
* @dev Emits the {IERC20-Transfer} event.
* @dev Transfers of 0 values are treated as normal transfers and fire the {IERC20-Transfer} event.
* @param from The account where the transferred tokens will be withdrawn from.
* @param to The account where the transferred tokens will be deposited to.
* @param value The amount of tokens to transfer.
* @return True if the transfer succeeds, false otherwise.
*/
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function decimals() external returns (uint8);
}
| chest.transferFrom(tokenHolder,purchase.recipient,purchase.quantity*(10**decimals)),"TOWERChestSale: transfer failed" | 14,828 | chest.transferFrom(tokenHolder,purchase.recipient,purchase.quantity*(10**decimals)) |
"futureA_ is too small" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "./SwapUtils.sol";
/**
* @title AmplificationUtils library
* @notice A library to calculate and ramp the A parameter of a given `SwapUtils.Swap` struct.
* This library assumes the struct is fully validated.
*/
library AmplificationUtils {
using SafeMath for uint256;
event RampA(
uint256 oldA,
uint256 newA,
uint256 initialTime,
uint256 futureTime
);
event StopRampA(uint256 currentA, uint256 time);
// Constant values used in ramping A calculations
uint256 public constant A_PRECISION = 100;
uint256 public constant MAX_A = 10**6;
uint256 private constant MAX_A_CHANGE = 2;
uint256 private constant MIN_RAMP_TIME = 14 days;
/**
* @notice Return A, the amplification coefficient * n * (n - 1)
* @dev See the StableSwap paper for details
* @param self Swap struct to read from
* @return A parameter
*/
function getA(SwapUtils.Swap storage self) external view returns (uint256) {
}
/**
* @notice Return A in its raw precision
* @dev See the StableSwap paper for details
* @param self Swap struct to read from
* @return A parameter in its raw precision form
*/
function getAPrecise(SwapUtils.Swap storage self)
external
view
returns (uint256)
{
}
/**
* @notice Return A in its raw precision
* @dev See the StableSwap paper for details
* @param self Swap struct to read from
* @return A parameter in its raw precision form
*/
function _getAPrecise(SwapUtils.Swap storage self)
internal
view
returns (uint256)
{
}
/**
* @notice Start ramping up or down A parameter towards given futureA_ and futureTime_
* Checks if the change is too rapid, and commits the new A value only when it falls under
* the limit range.
* @param self Swap struct to update
* @param futureA_ the new A to ramp towards
* @param futureTime_ timestamp when the new A should be reached
*/
function rampA(
SwapUtils.Swap storage self,
uint256 futureA_,
uint256 futureTime_
) external {
require(
block.timestamp >= self.initialATime.add(1 days),
"Wait 1 day before starting ramp"
);
require(
futureTime_ >= block.timestamp.add(MIN_RAMP_TIME),
"Insufficient ramp time"
);
require(
futureA_ > 0 && futureA_ < MAX_A,
"futureA_ must be > 0 and < MAX_A"
);
uint256 initialAPrecise = _getAPrecise(self);
uint256 futureAPrecise = futureA_.mul(A_PRECISION);
if (futureAPrecise < initialAPrecise) {
require(<FILL_ME>)
} else {
require(
futureAPrecise <= initialAPrecise.mul(MAX_A_CHANGE),
"futureA_ is too large"
);
}
self.initialA = initialAPrecise;
self.futureA = futureAPrecise;
self.initialATime = block.timestamp;
self.futureATime = futureTime_;
emit RampA(
initialAPrecise,
futureAPrecise,
block.timestamp,
futureTime_
);
}
/**
* @notice Stops ramping A immediately. Once this function is called, rampA()
* cannot be called for another 24 hours
* @param self Swap struct to update
*/
function stopRampA(SwapUtils.Swap storage self) external {
}
}
| futureAPrecise.mul(MAX_A_CHANGE)>=initialAPrecise,"futureA_ is too small" | 14,924 | futureAPrecise.mul(MAX_A_CHANGE)>=initialAPrecise |
"trade not enable" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.6;
/// @title KyberFprReserve version 2
/// Allow Reserve to work work with either weth or eth.
/// for working with weth should specify external address to hold weth.
/// Allow Reserve to set maxGasPriceWei to trade with
contract KyberFprReserveV2 is IKyberReserve, Utils5, Withdrawable3 {
using SafeERC20 for IERC20;
using SafeMath for uint256;
mapping(bytes32 => bool) public approvedWithdrawAddresses; // sha3(token,address)=>bool
mapping(address => address) public tokenWallet;
struct ConfigData {
bool tradeEnabled;
bool doRateValidation; // whether to do rate validation in trade func
uint128 maxGasPriceWei;
}
address public kyberNetwork;
ConfigData internal configData;
IConversionRates public conversionRatesContract;
IKyberSanity public sanityRatesContract;
IWeth public weth;
event DepositToken(IERC20 indexed token, uint256 amount);
event TradeExecute(
address indexed origin,
IERC20 indexed src,
uint256 srcAmount,
IERC20 indexed destToken,
uint256 destAmount,
address payable destAddress
);
event TradeEnabled(bool enable);
event MaxGasPriceUpdated(uint128 newMaxGasPrice);
event DoRateValidationUpdated(bool doRateValidation);
event WithdrawAddressApproved(IERC20 indexed token, address indexed addr, bool approve);
event NewTokenWallet(IERC20 indexed token, address indexed wallet);
event WithdrawFunds(IERC20 indexed token, uint256 amount, address indexed destination);
event SetKyberNetworkAddress(address indexed network);
event SetConversionRateAddress(IConversionRates indexed rate);
event SetWethAddress(IWeth indexed weth);
event SetSanityRateAddress(IKyberSanity indexed sanity);
constructor(
address _kyberNetwork,
IConversionRates _ratesContract,
IWeth _weth,
uint128 _maxGasPriceWei,
bool _doRateValidation,
address _admin
) public Withdrawable3(_admin) {
}
receive() external payable {
}
function trade(
IERC20 srcToken,
uint256 srcAmount,
IERC20 destToken,
address payable destAddress,
uint256 conversionRate,
bool /* validate */
) external override payable returns (bool) {
require(msg.sender == kyberNetwork, "wrong sender");
ConfigData memory data = configData;
require(<FILL_ME>)
require(tx.gasprice <= uint256(data.maxGasPriceWei), "gas price too high");
doTrade(
srcToken,
srcAmount,
destToken,
destAddress,
conversionRate,
data.doRateValidation
);
return true;
}
function enableTrade() external onlyAdmin {
}
function disableTrade() external onlyAlerter {
}
function setMaxGasPrice(uint128 newMaxGasPrice) external onlyOperator {
}
function setDoRateValidation(bool _doRateValidation) external onlyAdmin {
}
function approveWithdrawAddress(
IERC20 token,
address addr,
bool approve
) external onlyAdmin {
}
/// @dev allow set tokenWallet[token] back to 0x0 address
/// @dev in case of using weth from external wallet, must call set token wallet for weth
/// tokenWallet for weth must be different from this reserve address
function setTokenWallet(IERC20 token, address wallet) external onlyAdmin {
}
/// @dev withdraw amount of token to an approved destination
/// if reserve is using weth instead of eth, should call withdraw weth
/// @param token token to withdraw
/// @param amount amount to withdraw
/// @param destination address to transfer fund to
function withdraw(
IERC20 token,
uint256 amount,
address destination
) external onlyOperator {
}
function setKyberNetwork(address _newNetwork) external onlyAdmin {
}
function setConversionRate(IConversionRates _newConversionRate) external onlyAdmin {
}
/// @dev weth is unlikely to be changed, but added this function to keep the flexibilty
function setWeth(IWeth _newWeth) external onlyAdmin {
}
/// @dev sanity rate can be set to 0x0 address to disable sanity rate check
function setSanityRate(IKyberSanity _newSanity) external onlyAdmin {
}
function getConversionRate(
IERC20 src,
IERC20 dest,
uint256 srcQty,
uint256 blockNumber
) external override view returns (uint256) {
}
function isAddressApprovedForWithdrawal(IERC20 token, address addr)
external
view
returns (bool)
{
}
function tradeEnabled() external view returns (bool) {
}
function maxGasPriceWei() external view returns (uint128) {
}
function doRateValidation() external view returns (bool) {
}
/// @dev return available balance of a token that reserve can use
/// if using weth, call getBalance(eth) will return weth balance
/// if using wallet for token, will return min of balance and allowance
/// @param token token to get available balance that reserve can use
function getBalance(IERC20 token) public view returns (uint256) {
}
/// @dev return wallet that holds the token
/// if token is ETH, check tokenWallet of WETH instead
/// if wallet is 0x0, consider as this reserve address
function getTokenWallet(IERC20 token) public view returns (address wallet) {
}
/// @dev do a trade, re-validate the conversion rate, remove trust assumption with network
/// @param srcToken Src token
/// @param srcAmount Amount of src token
/// @param destToken Destination token
/// @param destAddress Destination address to send tokens to
/// @param validateRate re-validate rate or not
function doTrade(
IERC20 srcToken,
uint256 srcAmount,
IERC20 destToken,
address payable destAddress,
uint256 conversionRate,
bool validateRate
) internal {
}
}
| data.tradeEnabled,"trade not enable" | 14,942 | data.tradeEnabled |
"destination is not approved" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.6;
/// @title KyberFprReserve version 2
/// Allow Reserve to work work with either weth or eth.
/// for working with weth should specify external address to hold weth.
/// Allow Reserve to set maxGasPriceWei to trade with
contract KyberFprReserveV2 is IKyberReserve, Utils5, Withdrawable3 {
using SafeERC20 for IERC20;
using SafeMath for uint256;
mapping(bytes32 => bool) public approvedWithdrawAddresses; // sha3(token,address)=>bool
mapping(address => address) public tokenWallet;
struct ConfigData {
bool tradeEnabled;
bool doRateValidation; // whether to do rate validation in trade func
uint128 maxGasPriceWei;
}
address public kyberNetwork;
ConfigData internal configData;
IConversionRates public conversionRatesContract;
IKyberSanity public sanityRatesContract;
IWeth public weth;
event DepositToken(IERC20 indexed token, uint256 amount);
event TradeExecute(
address indexed origin,
IERC20 indexed src,
uint256 srcAmount,
IERC20 indexed destToken,
uint256 destAmount,
address payable destAddress
);
event TradeEnabled(bool enable);
event MaxGasPriceUpdated(uint128 newMaxGasPrice);
event DoRateValidationUpdated(bool doRateValidation);
event WithdrawAddressApproved(IERC20 indexed token, address indexed addr, bool approve);
event NewTokenWallet(IERC20 indexed token, address indexed wallet);
event WithdrawFunds(IERC20 indexed token, uint256 amount, address indexed destination);
event SetKyberNetworkAddress(address indexed network);
event SetConversionRateAddress(IConversionRates indexed rate);
event SetWethAddress(IWeth indexed weth);
event SetSanityRateAddress(IKyberSanity indexed sanity);
constructor(
address _kyberNetwork,
IConversionRates _ratesContract,
IWeth _weth,
uint128 _maxGasPriceWei,
bool _doRateValidation,
address _admin
) public Withdrawable3(_admin) {
}
receive() external payable {
}
function trade(
IERC20 srcToken,
uint256 srcAmount,
IERC20 destToken,
address payable destAddress,
uint256 conversionRate,
bool /* validate */
) external override payable returns (bool) {
}
function enableTrade() external onlyAdmin {
}
function disableTrade() external onlyAlerter {
}
function setMaxGasPrice(uint128 newMaxGasPrice) external onlyOperator {
}
function setDoRateValidation(bool _doRateValidation) external onlyAdmin {
}
function approveWithdrawAddress(
IERC20 token,
address addr,
bool approve
) external onlyAdmin {
}
/// @dev allow set tokenWallet[token] back to 0x0 address
/// @dev in case of using weth from external wallet, must call set token wallet for weth
/// tokenWallet for weth must be different from this reserve address
function setTokenWallet(IERC20 token, address wallet) external onlyAdmin {
}
/// @dev withdraw amount of token to an approved destination
/// if reserve is using weth instead of eth, should call withdraw weth
/// @param token token to withdraw
/// @param amount amount to withdraw
/// @param destination address to transfer fund to
function withdraw(
IERC20 token,
uint256 amount,
address destination
) external onlyOperator {
require(<FILL_ME>)
if (token == ETH_TOKEN_ADDRESS) {
(bool success, ) = destination.call{value: amount}("");
require(success, "withdraw eth failed");
} else {
address wallet = getTokenWallet(token);
if (wallet == address(this)) {
token.safeTransfer(destination, amount);
} else {
token.safeTransferFrom(wallet, destination, amount);
}
}
emit WithdrawFunds(token, amount, destination);
}
function setKyberNetwork(address _newNetwork) external onlyAdmin {
}
function setConversionRate(IConversionRates _newConversionRate) external onlyAdmin {
}
/// @dev weth is unlikely to be changed, but added this function to keep the flexibilty
function setWeth(IWeth _newWeth) external onlyAdmin {
}
/// @dev sanity rate can be set to 0x0 address to disable sanity rate check
function setSanityRate(IKyberSanity _newSanity) external onlyAdmin {
}
function getConversionRate(
IERC20 src,
IERC20 dest,
uint256 srcQty,
uint256 blockNumber
) external override view returns (uint256) {
}
function isAddressApprovedForWithdrawal(IERC20 token, address addr)
external
view
returns (bool)
{
}
function tradeEnabled() external view returns (bool) {
}
function maxGasPriceWei() external view returns (uint128) {
}
function doRateValidation() external view returns (bool) {
}
/// @dev return available balance of a token that reserve can use
/// if using weth, call getBalance(eth) will return weth balance
/// if using wallet for token, will return min of balance and allowance
/// @param token token to get available balance that reserve can use
function getBalance(IERC20 token) public view returns (uint256) {
}
/// @dev return wallet that holds the token
/// if token is ETH, check tokenWallet of WETH instead
/// if wallet is 0x0, consider as this reserve address
function getTokenWallet(IERC20 token) public view returns (address wallet) {
}
/// @dev do a trade, re-validate the conversion rate, remove trust assumption with network
/// @param srcToken Src token
/// @param srcAmount Amount of src token
/// @param destToken Destination token
/// @param destAddress Destination address to send tokens to
/// @param validateRate re-validate rate or not
function doTrade(
IERC20 srcToken,
uint256 srcAmount,
IERC20 destToken,
address payable destAddress,
uint256 conversionRate,
bool validateRate
) internal {
}
}
| approvedWithdrawAddresses[keccak256(abi.encodePacked(address(token),destination))],"destination is not approved" | 14,942 | approvedWithdrawAddresses[keccak256(abi.encodePacked(address(token),destination))] |
Error.UNAUTHORIZED_ACCESS | pragma solidity 0.8.9;
/**
* @notice Provides modifiers for authorization
*/
abstract contract AuthorizationBase {
/**
* @notice Only allows a sender with `role` to perform the given action
*/
modifier onlyRole(bytes32 role) {
require(<FILL_ME>)
_;
}
/**
* @notice Only allows a sender with GOVERNANCE role to perform the given action
*/
modifier onlyGovernance() {
}
/**
* @notice Only allows a sender with any of `roles` to perform the given action
*/
modifier onlyRoles2(bytes32 role1, bytes32 role2) {
}
/**
* @notice Only allows a sender with any of `roles` to perform the given action
*/
modifier onlyRoles3(
bytes32 role1,
bytes32 role2,
bytes32 role3
) {
}
function roleManager() external view virtual returns (IRoleManager) {
}
function _roleManager() internal view virtual returns (IRoleManager);
}
| _roleManager().hasRole(role,msg.sender),Error.UNAUTHORIZED_ACCESS | 14,950 | _roleManager().hasRole(role,msg.sender) |
Error.UNAUTHORIZED_ACCESS | pragma solidity 0.8.9;
/**
* @notice Provides modifiers for authorization
*/
abstract contract AuthorizationBase {
/**
* @notice Only allows a sender with `role` to perform the given action
*/
modifier onlyRole(bytes32 role) {
}
/**
* @notice Only allows a sender with GOVERNANCE role to perform the given action
*/
modifier onlyGovernance() {
require(<FILL_ME>)
_;
}
/**
* @notice Only allows a sender with any of `roles` to perform the given action
*/
modifier onlyRoles2(bytes32 role1, bytes32 role2) {
}
/**
* @notice Only allows a sender with any of `roles` to perform the given action
*/
modifier onlyRoles3(
bytes32 role1,
bytes32 role2,
bytes32 role3
) {
}
function roleManager() external view virtual returns (IRoleManager) {
}
function _roleManager() internal view virtual returns (IRoleManager);
}
| _roleManager().hasRole(Roles.GOVERNANCE,msg.sender),Error.UNAUTHORIZED_ACCESS | 14,950 | _roleManager().hasRole(Roles.GOVERNANCE,msg.sender) |
Error.UNAUTHORIZED_ACCESS | pragma solidity 0.8.9;
/**
* @notice Provides modifiers for authorization
*/
abstract contract AuthorizationBase {
/**
* @notice Only allows a sender with `role` to perform the given action
*/
modifier onlyRole(bytes32 role) {
}
/**
* @notice Only allows a sender with GOVERNANCE role to perform the given action
*/
modifier onlyGovernance() {
}
/**
* @notice Only allows a sender with any of `roles` to perform the given action
*/
modifier onlyRoles2(bytes32 role1, bytes32 role2) {
require(<FILL_ME>)
_;
}
/**
* @notice Only allows a sender with any of `roles` to perform the given action
*/
modifier onlyRoles3(
bytes32 role1,
bytes32 role2,
bytes32 role3
) {
}
function roleManager() external view virtual returns (IRoleManager) {
}
function _roleManager() internal view virtual returns (IRoleManager);
}
| _roleManager().hasAnyRole(role1,role2,msg.sender),Error.UNAUTHORIZED_ACCESS | 14,950 | _roleManager().hasAnyRole(role1,role2,msg.sender) |
Error.UNAUTHORIZED_ACCESS | pragma solidity 0.8.9;
/**
* @notice Provides modifiers for authorization
*/
abstract contract AuthorizationBase {
/**
* @notice Only allows a sender with `role` to perform the given action
*/
modifier onlyRole(bytes32 role) {
}
/**
* @notice Only allows a sender with GOVERNANCE role to perform the given action
*/
modifier onlyGovernance() {
}
/**
* @notice Only allows a sender with any of `roles` to perform the given action
*/
modifier onlyRoles2(bytes32 role1, bytes32 role2) {
}
/**
* @notice Only allows a sender with any of `roles` to perform the given action
*/
modifier onlyRoles3(
bytes32 role1,
bytes32 role2,
bytes32 role3
) {
require(<FILL_ME>)
_;
}
function roleManager() external view virtual returns (IRoleManager) {
}
function _roleManager() internal view virtual returns (IRoleManager);
}
| _roleManager().hasAnyRole(role1,role2,role3,msg.sender),Error.UNAUTHORIZED_ACCESS | 14,950 | _roleManager().hasAnyRole(role1,role2,role3,msg.sender) |
null | pragma solidity 0.5.10;
contract ETHx {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 0.1 ether;
uint256 constant public BASE_PERCENT = 10;
uint256[] public REFERRAL_PERCENTS = [50, 30, 20];
uint256 constant public MARKETING_FEE = 100;
uint256 constant public PROJECT_FEE = 100;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public CONTRACT_BALANCE_STEP = 500 ether;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address payable public marketingAddress;
address payable public projectAddress;
address private owner;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
}
mapping (address => User) internal users;
mapping (address => uint256) internal contractBonus;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
event FundsWithdrawn(uint256 balance);
event ContractedToppedUp(address indexed userAddress, uint256 amt);
event ContractBonusWithdrawn(address indexed userAddress, uint256 amt);
modifier onlyMarketer() {
}
modifier onlyProjectOwner() {
}
modifier onlyOwner() {
}
constructor(address payable marketingAddr, address payable projectAddr) public {
require(<FILL_ME>)
marketingAddress = marketingAddr;
projectAddress = projectAddr;
owner = msg.sender;
}
function invest(address referrer) public payable {
}
function withdraw(bool qualified) public {
}
function getContractBalance() public view returns (uint256) {
}
function getContractBalanceRate() public view returns (uint256) {
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
}
function getUserDividends(address userAddress) public view returns (uint256) {
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
}
function getUserReferrer(address userAddress) public view returns(address) {
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
}
function getUserAvailable(address userAddress) public view returns(uint256) {
}
function isActive(address userAddress) public view returns (bool) {
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
}
function safeguardFunds() public onlyProjectOwner returns(uint256) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| (marketingAddr!=address(0))&&(projectAddr!=address(0)) | 14,998 | (marketingAddr!=address(0))&&(projectAddr!=address(0)) |
"Entire allowance already claimed, or no initial aloowance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
import "./RoleAware.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
abstract contract ERC20Vestable is RoleAware, ERC20 {
// tokens vest 10% every 10 days. `claimFunds` can be called once every 10 days
uint256 public claimFrequency = 10 days;
mapping(address => uint256) public _vestingAllowances;
mapping(address => uint256) public _claimAmounts;
mapping(address => uint256) public _lastClaimed;
function _grantFunds(address beneficiary) internal {
require(<FILL_ME>)
_vestingAllowances[beneficiary] = _vestingAllowances[beneficiary].sub(
_claimAmounts[beneficiary]
);
_mint(
beneficiary,
_claimAmounts[beneficiary].mul(10**uint256(decimals()))
);
}
// internal function only ever called from constructor
function _addBeneficiary(address beneficiary, uint256 amount)
internal
onlyBeforeUniswap
{
}
function claimFunds() public {
}
}
| _vestingAllowances[beneficiary]>0&&_vestingAllowances[beneficiary]>=_claimAmounts[beneficiary],"Entire allowance already claimed, or no initial aloowance" | 15,107 | _vestingAllowances[beneficiary]>0&&_vestingAllowances[beneficiary]>=_claimAmounts[beneficiary] |
"Allowance cannot be claimed more than once every 10 days" | // SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
import "./RoleAware.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
abstract contract ERC20Vestable is RoleAware, ERC20 {
// tokens vest 10% every 10 days. `claimFunds` can be called once every 10 days
uint256 public claimFrequency = 10 days;
mapping(address => uint256) public _vestingAllowances;
mapping(address => uint256) public _claimAmounts;
mapping(address => uint256) public _lastClaimed;
function _grantFunds(address beneficiary) internal {
}
// internal function only ever called from constructor
function _addBeneficiary(address beneficiary, uint256 amount)
internal
onlyBeforeUniswap
{
}
function claimFunds() public {
require(<FILL_ME>)
_lastClaimed[msg.sender] = now;
_grantFunds(msg.sender);
}
}
| _lastClaimed[msg.sender]!=0&&now>=_lastClaimed[msg.sender].add(claimFrequency),"Allowance cannot be claimed more than once every 10 days" | 15,107 | _lastClaimed[msg.sender]!=0&&now>=_lastClaimed[msg.sender].add(claimFrequency) |
"Buy on matching market failed" | pragma solidity 0.6.1;
pragma experimental ABIEncoderV2;
import "../fund/hub/Hub.sol";
import "../fund/trading/Trading.sol";
import "../fund/vault/Vault.sol";
import "../fund/accounting/Accounting.sol";
import "../dependencies/DSMath.sol";
import "./interfaces/IOasisDex.sol";
import "./ExchangeAdapter.sol";
/// @title OasisDexAdapter Contract
/// @author Melonport AG <[email protected]>
/// @notice Adapter between Melon and OasisDex Matching Market
contract OasisDexAdapter is DSMath, ExchangeAdapter {
event OrderCreated(uint256 id);
// METHODS
// PUBLIC METHODS
// Responsibilities of makeOrder are:
// - check sender
// - check fund not shut down
// - check price recent
// - check risk management passes
// - approve funds to be traded (if necessary)
// - make order on the exchange
// - check order was made (if possible)
// - place asset in ownedAssets if not already tracked
/// @notice Makes an order on the selected exchange
/// @dev These orders are not expected to settle immediately
/// @param targetExchange Address of the exchange
/// @param orderAddresses [2] Order maker asset
/// @param orderAddresses [3] Order taker asset
/// @param orderValues [0] Maker token quantity
/// @param orderValues [1] Taker token quantity
function makeOrder(
address targetExchange,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
) public override onlyManager notShutDown {
}
// Responsibilities of takeOrder are:
// - check sender
// - check fund not shut down
// - check not buying own fund tokens
// - check price exists for asset pair
// - check price is recent
// - check price passes risk management
// - approve funds to be traded (if necessary)
// - take order from the exchange
// - check order was taken (if possible)
// - place asset in ownedAssets if not already tracked
/// @notice Takes an active order on the selected exchange
/// @dev These orders are expected to settle immediately
/// @param targetExchange Address of the exchange
/// @param orderValues [6] Fill amount : amount of taker token to fill
/// @param identifier Active order id
function takeOrder(
address targetExchange,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
) public override onlyManager notShutDown {
Hub hub = getHub();
uint256 fillTakerQuantity = orderValues[6];
uint256 maxMakerQuantity;
address makerAsset;
uint256 maxTakerQuantity;
address takerAsset;
(
maxMakerQuantity,
makerAsset,
maxTakerQuantity,
takerAsset
) = IOasisDex(targetExchange).getOffer(uint256(identifier));
uint256 fillMakerQuantity = mul(fillTakerQuantity, maxMakerQuantity) / maxTakerQuantity;
require(
makerAsset == orderAddresses[2] && takerAsset == orderAddresses[3],
"Maker and taker assets do not match the order addresses"
);
require(
makerAsset != takerAsset,
"Maker and taker assets cannot be the same"
);
require(fillMakerQuantity <= maxMakerQuantity, "Maker amount to fill above max");
require(fillTakerQuantity <= maxTakerQuantity, "Taker amount to fill above max");
approveAsset(takerAsset, targetExchange, fillTakerQuantity, "takerAsset");
require(<FILL_ME>)
getAccounting().addAssetToOwnedAssets(makerAsset);
getAccounting().updateOwnedAssets();
uint256 timesMakerAssetUsedAsFee = getTrading().openMakeOrdersUsingAssetAsFee(makerAsset);
if (
!getTrading().isInOpenMakeOrder(makerAsset) &&
timesMakerAssetUsedAsFee == 0
) {
getTrading().returnAssetToVault(makerAsset);
}
getTrading().orderUpdateHook(
targetExchange,
bytes32(identifier),
Trading.UpdateType.take,
[payable(makerAsset), payable(takerAsset)],
[maxMakerQuantity, maxTakerQuantity, fillTakerQuantity]
);
}
// responsibilities of cancelOrder are:
// - check sender is owner, or that order expired, or that fund shut down
// - remove order from tracking array
// - cancel order on exchange
/// @notice Cancels orders that were not expected to settle immediately
/// @param targetExchange Address of the exchange
/// @param orderAddresses [2] Order maker asset
/// @param identifier Order ID on the exchange
function cancelOrder(
address targetExchange,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
) public override {
}
// VIEW METHODS
function getOrder(address targetExchange, uint256 id, address makerAsset)
public
view
override
returns (address, address, uint256, uint256)
{
}
}
| IOasisDex(targetExchange).buy(uint256(identifier),fillMakerQuantity),"Buy on matching market failed" | 15,175 | IOasisDex(targetExchange).buy(uint256(identifier),fillMakerQuantity) |
"ID cannot be zero" | pragma solidity 0.6.1;
pragma experimental ABIEncoderV2;
import "../fund/hub/Hub.sol";
import "../fund/trading/Trading.sol";
import "../fund/vault/Vault.sol";
import "../fund/accounting/Accounting.sol";
import "../dependencies/DSMath.sol";
import "./interfaces/IOasisDex.sol";
import "./ExchangeAdapter.sol";
/// @title OasisDexAdapter Contract
/// @author Melonport AG <[email protected]>
/// @notice Adapter between Melon and OasisDex Matching Market
contract OasisDexAdapter is DSMath, ExchangeAdapter {
event OrderCreated(uint256 id);
// METHODS
// PUBLIC METHODS
// Responsibilities of makeOrder are:
// - check sender
// - check fund not shut down
// - check price recent
// - check risk management passes
// - approve funds to be traded (if necessary)
// - make order on the exchange
// - check order was made (if possible)
// - place asset in ownedAssets if not already tracked
/// @notice Makes an order on the selected exchange
/// @dev These orders are not expected to settle immediately
/// @param targetExchange Address of the exchange
/// @param orderAddresses [2] Order maker asset
/// @param orderAddresses [3] Order taker asset
/// @param orderValues [0] Maker token quantity
/// @param orderValues [1] Taker token quantity
function makeOrder(
address targetExchange,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
) public override onlyManager notShutDown {
}
// Responsibilities of takeOrder are:
// - check sender
// - check fund not shut down
// - check not buying own fund tokens
// - check price exists for asset pair
// - check price is recent
// - check price passes risk management
// - approve funds to be traded (if necessary)
// - take order from the exchange
// - check order was taken (if possible)
// - place asset in ownedAssets if not already tracked
/// @notice Takes an active order on the selected exchange
/// @dev These orders are expected to settle immediately
/// @param targetExchange Address of the exchange
/// @param orderValues [6] Fill amount : amount of taker token to fill
/// @param identifier Active order id
function takeOrder(
address targetExchange,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
) public override onlyManager notShutDown {
}
// responsibilities of cancelOrder are:
// - check sender is owner, or that order expired, or that fund shut down
// - remove order from tracking array
// - cancel order on exchange
/// @notice Cancels orders that were not expected to settle immediately
/// @param targetExchange Address of the exchange
/// @param orderAddresses [2] Order maker asset
/// @param identifier Order ID on the exchange
function cancelOrder(
address targetExchange,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
) public override {
require(<FILL_ME>)
address makerAsset;
(, makerAsset, ,) = IOasisDex(targetExchange).getOffer(uint256(identifier));
ensureCancelPermitted(targetExchange, makerAsset, identifier);
require(
address(makerAsset) == orderAddresses[2],
"Retrieved and passed assets do not match"
);
getTrading().removeOpenMakeOrder(targetExchange, makerAsset);
IOasisDex(targetExchange).cancel(uint256(identifier));
uint256 timesMakerAssetUsedAsFee = getTrading().openMakeOrdersUsingAssetAsFee(makerAsset);
if (timesMakerAssetUsedAsFee == 0) {
getTrading().returnAssetToVault(makerAsset);
}
getAccounting().updateOwnedAssets();
getTrading().orderUpdateHook(
targetExchange,
bytes32(identifier),
Trading.UpdateType.cancel,
[address(0), address(0)],
[uint256(0), uint256(0), uint256(0)]
);
}
// VIEW METHODS
function getOrder(address targetExchange, uint256 id, address makerAsset)
public
view
override
returns (address, address, uint256, uint256)
{
}
}
| uint256(identifier)!=0,"ID cannot be zero" | 15,175 | uint256(identifier)!=0 |
"Retrieved and passed assets do not match" | pragma solidity 0.6.1;
pragma experimental ABIEncoderV2;
import "../fund/hub/Hub.sol";
import "../fund/trading/Trading.sol";
import "../fund/vault/Vault.sol";
import "../fund/accounting/Accounting.sol";
import "../dependencies/DSMath.sol";
import "./interfaces/IOasisDex.sol";
import "./ExchangeAdapter.sol";
/// @title OasisDexAdapter Contract
/// @author Melonport AG <[email protected]>
/// @notice Adapter between Melon and OasisDex Matching Market
contract OasisDexAdapter is DSMath, ExchangeAdapter {
event OrderCreated(uint256 id);
// METHODS
// PUBLIC METHODS
// Responsibilities of makeOrder are:
// - check sender
// - check fund not shut down
// - check price recent
// - check risk management passes
// - approve funds to be traded (if necessary)
// - make order on the exchange
// - check order was made (if possible)
// - place asset in ownedAssets if not already tracked
/// @notice Makes an order on the selected exchange
/// @dev These orders are not expected to settle immediately
/// @param targetExchange Address of the exchange
/// @param orderAddresses [2] Order maker asset
/// @param orderAddresses [3] Order taker asset
/// @param orderValues [0] Maker token quantity
/// @param orderValues [1] Taker token quantity
function makeOrder(
address targetExchange,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
) public override onlyManager notShutDown {
}
// Responsibilities of takeOrder are:
// - check sender
// - check fund not shut down
// - check not buying own fund tokens
// - check price exists for asset pair
// - check price is recent
// - check price passes risk management
// - approve funds to be traded (if necessary)
// - take order from the exchange
// - check order was taken (if possible)
// - place asset in ownedAssets if not already tracked
/// @notice Takes an active order on the selected exchange
/// @dev These orders are expected to settle immediately
/// @param targetExchange Address of the exchange
/// @param orderValues [6] Fill amount : amount of taker token to fill
/// @param identifier Active order id
function takeOrder(
address targetExchange,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
) public override onlyManager notShutDown {
}
// responsibilities of cancelOrder are:
// - check sender is owner, or that order expired, or that fund shut down
// - remove order from tracking array
// - cancel order on exchange
/// @notice Cancels orders that were not expected to settle immediately
/// @param targetExchange Address of the exchange
/// @param orderAddresses [2] Order maker asset
/// @param identifier Order ID on the exchange
function cancelOrder(
address targetExchange,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
) public override {
require(uint256(identifier) != 0, "ID cannot be zero");
address makerAsset;
(, makerAsset, ,) = IOasisDex(targetExchange).getOffer(uint256(identifier));
ensureCancelPermitted(targetExchange, makerAsset, identifier);
require(<FILL_ME>)
getTrading().removeOpenMakeOrder(targetExchange, makerAsset);
IOasisDex(targetExchange).cancel(uint256(identifier));
uint256 timesMakerAssetUsedAsFee = getTrading().openMakeOrdersUsingAssetAsFee(makerAsset);
if (timesMakerAssetUsedAsFee == 0) {
getTrading().returnAssetToVault(makerAsset);
}
getAccounting().updateOwnedAssets();
getTrading().orderUpdateHook(
targetExchange,
bytes32(identifier),
Trading.UpdateType.cancel,
[address(0), address(0)],
[uint256(0), uint256(0), uint256(0)]
);
}
// VIEW METHODS
function getOrder(address targetExchange, uint256 id, address makerAsset)
public
view
override
returns (address, address, uint256, uint256)
{
}
}
| address(makerAsset)==orderAddresses[2],"Retrieved and passed assets do not match" | 15,175 | address(makerAsset)==orderAddresses[2] |
null | pragma solidity 0.6.1;
import "./FeeManager.sol";
import "../hub/Hub.sol";
import "../shares/Shares.sol";
import "../../dependencies/DSMath.sol";
contract ManagementFee is DSMath {
uint public DIVISOR = 10 ** 18;
mapping (address => uint) public managementFeeRate;
mapping (address => uint) public lastPayoutTime;
function feeAmount() external view returns (uint feeInShares) {
}
function initializeForUser(uint feeRate, uint feePeriod, address denominationAsset) external {
require(<FILL_ME>)
managementFeeRate[msg.sender] = feeRate;
lastPayoutTime[msg.sender] = block.timestamp;
}
function updateState() external {
}
function identifier() external pure returns (uint) {
}
}
| lastPayoutTime[msg.sender]==0 | 15,185 | lastPayoutTime[msg.sender]==0 |
"Not initialized" | pragma solidity 0.6.1;
import "./FeeManager.sol";
import "../accounting/Accounting.sol";
import "../hub/Hub.sol";
import "../shares/Shares.sol";
import "../../dependencies/DSMath.sol";
contract PerformanceFee is DSMath {
event HighWaterMarkUpdate(address indexed feeManager, uint indexed hwm);
uint public constant DIVISOR = 10 ** 18;
uint public constant REDEEM_WINDOW = 1 weeks;
mapping(address => uint) public highWaterMark;
mapping(address => uint) public lastPayoutTime;
mapping(address => uint) public initializeTime;
mapping(address => uint) public performanceFeeRate;
mapping(address => uint) public performanceFeePeriod;
/// @notice Sets initial state of the fee for a user
function initializeForUser(uint feeRate, uint feePeriod, address denominationAsset) external {
}
/// @notice Assumes management fee is zero
function feeAmount() external returns (uint feeInShares) {
}
function canUpdate(address _who) public view returns (bool) {
}
/// @notice Assumes management fee is zero
function updateState() external {
require(<FILL_ME>)
require(
canUpdate(msg.sender),
"Not within a update window or already updated this period"
);
Hub hub = FeeManager(msg.sender).hub();
Accounting accounting = Accounting(hub.accounting());
Shares shares = Shares(hub.shares());
uint gav = accounting.calcGav();
uint currentGavPerShare = accounting.valuePerShare(gav, shares.totalSupply());
require(
currentGavPerShare > highWaterMark[msg.sender],
"Current share price does not pass high water mark"
);
lastPayoutTime[msg.sender] = block.timestamp;
highWaterMark[msg.sender] = currentGavPerShare;
emit HighWaterMarkUpdate(msg.sender, currentGavPerShare);
}
function identifier() external pure returns (uint) {
}
}
| lastPayoutTime[msg.sender]!=0,"Not initialized" | 15,186 | lastPayoutTime[msg.sender]!=0 |
"Not within a update window or already updated this period" | pragma solidity 0.6.1;
import "./FeeManager.sol";
import "../accounting/Accounting.sol";
import "../hub/Hub.sol";
import "../shares/Shares.sol";
import "../../dependencies/DSMath.sol";
contract PerformanceFee is DSMath {
event HighWaterMarkUpdate(address indexed feeManager, uint indexed hwm);
uint public constant DIVISOR = 10 ** 18;
uint public constant REDEEM_WINDOW = 1 weeks;
mapping(address => uint) public highWaterMark;
mapping(address => uint) public lastPayoutTime;
mapping(address => uint) public initializeTime;
mapping(address => uint) public performanceFeeRate;
mapping(address => uint) public performanceFeePeriod;
/// @notice Sets initial state of the fee for a user
function initializeForUser(uint feeRate, uint feePeriod, address denominationAsset) external {
}
/// @notice Assumes management fee is zero
function feeAmount() external returns (uint feeInShares) {
}
function canUpdate(address _who) public view returns (bool) {
}
/// @notice Assumes management fee is zero
function updateState() external {
require(lastPayoutTime[msg.sender] != 0, "Not initialized");
require(<FILL_ME>)
Hub hub = FeeManager(msg.sender).hub();
Accounting accounting = Accounting(hub.accounting());
Shares shares = Shares(hub.shares());
uint gav = accounting.calcGav();
uint currentGavPerShare = accounting.valuePerShare(gav, shares.totalSupply());
require(
currentGavPerShare > highWaterMark[msg.sender],
"Current share price does not pass high water mark"
);
lastPayoutTime[msg.sender] = block.timestamp;
highWaterMark[msg.sender] = currentGavPerShare;
emit HighWaterMarkUpdate(msg.sender, currentGavPerShare);
}
function identifier() external pure returns (uint) {
}
}
| canUpdate(msg.sender),"Not within a update window or already updated this period" | 15,186 | canUpdate(msg.sender) |
"Fund is already initialized" | pragma solidity 0.6.1;
import "../../dependencies/DSGuard.sol";
import "./Spoke.sol";
import "../../version/Registry.sol";
/// @notice Router for communication between components
/// @notice Has one or more Spokes
contract Hub is DSGuard {
event FundShutDown();
struct Routes {
address accounting;
address feeManager;
address participation;
address policyManager;
address shares;
address trading;
address vault;
address registry;
address version;
address engine;
address mlnToken;
}
Routes public routes;
address public manager;
address public creator;
string public name;
bool public isShutDown;
bool public fundInitialized;
uint public creationTime;
mapping (address => bool) public isSpoke;
constructor(address _manager, string memory _name) public {
}
modifier onlyCreator() {
}
function shutDownFund() external {
}
function initializeAndSetPermissions(address[11] calldata _spokes) external onlyCreator {
require(<FILL_ME>)
for (uint i = 0; i < _spokes.length; i++) {
isSpoke[_spokes[i]] = true;
}
routes.accounting = _spokes[0];
routes.feeManager = _spokes[1];
routes.participation = _spokes[2];
routes.policyManager = _spokes[3];
routes.shares = _spokes[4];
routes.trading = _spokes[5];
routes.vault = _spokes[6];
routes.registry = _spokes[7];
routes.version = _spokes[8];
routes.engine = _spokes[9];
routes.mlnToken = _spokes[10];
Spoke(routes.accounting).initialize(_spokes);
Spoke(routes.feeManager).initialize(_spokes);
Spoke(routes.participation).initialize(_spokes);
Spoke(routes.policyManager).initialize(_spokes);
Spoke(routes.shares).initialize(_spokes);
Spoke(routes.trading).initialize(_spokes);
Spoke(routes.vault).initialize(_spokes);
permit(routes.participation, routes.vault, bytes4(keccak256('withdraw(address,uint256)')));
permit(routes.trading, routes.vault, bytes4(keccak256('withdraw(address,uint256)')));
permit(routes.participation, routes.shares, bytes4(keccak256('createFor(address,uint256)')));
permit(routes.participation, routes.shares, bytes4(keccak256('destroyFor(address,uint256)')));
permit(routes.feeManager, routes.shares, bytes4(keccak256('createFor(address,uint256)')));
permit(routes.participation, routes.accounting, bytes4(keccak256('addAssetToOwnedAssets(address)')));
permit(routes.trading, routes.accounting, bytes4(keccak256('addAssetToOwnedAssets(address)')));
permit(routes.trading, routes.accounting, bytes4(keccak256('removeFromOwnedAssets(address)')));
permit(routes.accounting, routes.feeManager, bytes4(keccak256('rewardAllFees()')));
permit(manager, routes.policyManager, bytes4(keccak256('register(bytes4,address)')));
permit(manager, routes.policyManager, bytes4(keccak256('batchRegister(bytes4[],address[])')));
permit(manager, routes.participation, bytes4(keccak256('enableInvestment(address[])')));
permit(manager, routes.participation, bytes4(keccak256('disableInvestment(address[])')));
permit(manager, routes.trading, bytes4(keccak256('addExchange(address,address)')));
fundInitialized = true;
}
function vault() external view returns (address) { }
function accounting() external view returns (address) { }
function priceSource() external view returns (address) { }
function participation() external view returns (address) { }
function trading() external view returns (address) { }
function shares() external view returns (address) { }
function registry() external view returns (address) { }
function version() external view returns (address) { }
function policyManager() external view returns (address) { }
}
| !fundInitialized,"Fund is already initialized" | 15,187 | !fundInitialized |
"Adapter already added" | pragma solidity 0.6.1;
pragma experimental ABIEncoderV2;
import "../hub/Spoke.sol";
import "../vault/Vault.sol";
import "../policies/PolicyManager.sol";
import "../policies/TradingSignatures.sol";
import "../../factory/Factory.sol";
import "../../dependencies/DSMath.sol";
import "../../exchanges/ExchangeAdapter.sol";
import "../../exchanges/interfaces/IZeroExV2.sol";
import "../../exchanges/interfaces/IZeroExV3.sol";
import "../../version/Registry.sol";
import "../../dependencies/TokenUser.sol";
contract Trading is DSMath, TokenUser, Spoke, TradingSignatures {
event ExchangeMethodCall(
address indexed exchangeAddress,
string indexed methodSignature,
address[8] orderAddresses,
uint[8] orderValues,
bytes[4] orderData,
bytes32 identifier,
bytes signature
);
struct Exchange {
address exchange;
address adapter;
bool takesCustody;
}
enum UpdateType { make, take, cancel }
struct Order {
address exchangeAddress;
bytes32 orderId;
UpdateType updateType;
address makerAsset;
address takerAsset;
uint makerQuantity;
uint takerQuantity;
uint timestamp;
uint fillTakerQuantity;
}
struct OpenMakeOrder {
uint id; // Order Id from exchange
uint expiresAt; // Timestamp when the order expires
uint orderIndex; // Index of the order in the orders array
address buyAsset; // Address of the buy asset in the order
address feeAsset;
}
Exchange[] public exchanges;
Order[] public orders;
mapping (address => bool) public adapterIsAdded;
mapping (address => mapping(address => OpenMakeOrder)) public exchangesToOpenMakeOrders;
mapping (address => uint) public openMakeOrdersAgainstAsset;
mapping (address => uint) public openMakeOrdersUsingAssetAsFee;
mapping (address => bool) public isInOpenMakeOrder;
mapping (address => uint) public makerAssetCooldown;
mapping (bytes32 => IZeroExV2.Order) internal orderIdToZeroExV2Order;
mapping (bytes32 => IZeroExV3.Order) internal orderIdToZeroExV3Order;
uint public constant ORDER_LIFESPAN = 1 days;
uint public constant MAKE_ORDER_COOLDOWN = 30 minutes;
modifier delegateInternal() {
}
constructor(
address _hub,
address[] memory _exchanges,
address[] memory _adapters,
address _registry
)
public
Spoke(_hub)
{
}
/// @notice Receive ether function (used to receive ETH from WETH)
receive() external payable {}
function addExchange(address _exchange, address _adapter) external auth {
}
function _addExchange(
address _exchange,
address _adapter
) internal {
require(<FILL_ME>)
adapterIsAdded[_adapter] = true;
Registry registry = Registry(routes.registry);
require(
registry.exchangeAdapterIsRegistered(_adapter),
"Adapter is not registered"
);
address registeredExchange;
bool takesCustody;
(registeredExchange, takesCustody) = registry.getExchangeInformation(_adapter);
require(
registeredExchange == _exchange,
"Exchange and adapter do not match"
);
exchanges.push(Exchange(_exchange, _adapter, takesCustody));
}
/// @notice Universal method for calling exchange functions through adapters
/// @notice See adapter contracts for parameters needed for each exchange
/// @param exchangeIndex Index of the exchange in the "exchanges" array
/// @param orderAddresses [0] Order maker
/// @param orderAddresses [1] Order taker
/// @param orderAddresses [2] Order maker asset
/// @param orderAddresses [3] Order taker asset
/// @param orderAddresses [4] feeRecipientAddress
/// @param orderAddresses [5] senderAddress
/// @param orderAddresses [6] maker fee asset
/// @param orderAddresses [7] taker fee asset
/// @param orderValues [0] makerAssetAmount
/// @param orderValues [1] takerAssetAmount
/// @param orderValues [2] Maker fee
/// @param orderValues [3] Taker fee
/// @param orderValues [4] expirationTimeSeconds
/// @param orderValues [5] Salt/nonce
/// @param orderValues [6] Fill amount: amount of taker token to be traded
/// @param orderValues [7] Dexy signature mode
/// @param orderData [0] Encoded data specific to maker asset
/// @param orderData [1] Encoded data specific to taker asset
/// @param orderData [2] Encoded data specific to maker asset fee
/// @param orderData [3] Encoded data specific to taker asset fee
/// @param identifier Order identifier
/// @param signature Signature of order maker
function callOnExchange(
uint exchangeIndex,
string memory methodSignature,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
)
public
onlyInitialized
{
}
/// @dev Make sure this is called after orderUpdateHook in adapters
function addOpenMakeOrder(
address ofExchange,
address sellAsset,
address buyAsset,
address feeAsset,
uint orderId,
uint expirationTime
) public delegateInternal {
}
function _removeOpenMakeOrder(
address exchange,
address sellAsset
) internal {
}
function removeOpenMakeOrder(
address exchange,
address sellAsset
) public delegateInternal {
}
/// @dev Bit of Redundancy for now
function addZeroExV2OrderData(
bytes32 orderId,
IZeroExV2.Order memory zeroExOrderData
) public delegateInternal {
}
function addZeroExV3OrderData(
bytes32 orderId,
IZeroExV3.Order memory zeroExOrderData
) public delegateInternal {
}
function orderUpdateHook(
address ofExchange,
bytes32 orderId,
UpdateType updateType,
address payable[2] memory orderAddresses,
uint[3] memory orderValues
) public delegateInternal {
}
function updateAndGetQuantityBeingTraded(address _asset) external returns (uint) {
}
function updateAndGetQuantityHeldInExchange(address ofAsset) public returns (uint) {
}
function returnBatchToVault(address[] calldata _tokens) external {
}
function returnAssetToVault(address _token) public {
}
function getExchangeInfo() public view returns (address[] memory, address[] memory, bool[] memory) {
}
function getOpenOrderInfo(address ofExchange, address ofAsset) public view returns (uint, uint, uint) {
}
function isOrderExpired(address exchange, address asset) public view returns(bool) {
}
function getOrderDetails(uint orderIndex) public view returns (address, address, uint, uint) {
}
function getZeroExV2OrderDetails(bytes32 orderId) public view returns (IZeroExV2.Order memory) {
}
function getZeroExV3OrderDetails(bytes32 orderId) public view returns (IZeroExV3.Order memory) {
}
function getOpenMakeOrdersAgainstAsset(address _asset) external view returns (uint256) {
}
}
contract TradingFactory is Factory {
event NewInstance(
address indexed hub,
address indexed instance,
address[] exchanges,
address[] adapters,
address registry
);
function createInstance(
address _hub,
address[] memory _exchanges,
address[] memory _adapters,
address _registry
) public returns (address) {
}
}
| !adapterIsAdded[_adapter],"Adapter already added" | 15,205 | !adapterIsAdded[_adapter] |
"Adapter is not registered" | pragma solidity 0.6.1;
pragma experimental ABIEncoderV2;
import "../hub/Spoke.sol";
import "../vault/Vault.sol";
import "../policies/PolicyManager.sol";
import "../policies/TradingSignatures.sol";
import "../../factory/Factory.sol";
import "../../dependencies/DSMath.sol";
import "../../exchanges/ExchangeAdapter.sol";
import "../../exchanges/interfaces/IZeroExV2.sol";
import "../../exchanges/interfaces/IZeroExV3.sol";
import "../../version/Registry.sol";
import "../../dependencies/TokenUser.sol";
contract Trading is DSMath, TokenUser, Spoke, TradingSignatures {
event ExchangeMethodCall(
address indexed exchangeAddress,
string indexed methodSignature,
address[8] orderAddresses,
uint[8] orderValues,
bytes[4] orderData,
bytes32 identifier,
bytes signature
);
struct Exchange {
address exchange;
address adapter;
bool takesCustody;
}
enum UpdateType { make, take, cancel }
struct Order {
address exchangeAddress;
bytes32 orderId;
UpdateType updateType;
address makerAsset;
address takerAsset;
uint makerQuantity;
uint takerQuantity;
uint timestamp;
uint fillTakerQuantity;
}
struct OpenMakeOrder {
uint id; // Order Id from exchange
uint expiresAt; // Timestamp when the order expires
uint orderIndex; // Index of the order in the orders array
address buyAsset; // Address of the buy asset in the order
address feeAsset;
}
Exchange[] public exchanges;
Order[] public orders;
mapping (address => bool) public adapterIsAdded;
mapping (address => mapping(address => OpenMakeOrder)) public exchangesToOpenMakeOrders;
mapping (address => uint) public openMakeOrdersAgainstAsset;
mapping (address => uint) public openMakeOrdersUsingAssetAsFee;
mapping (address => bool) public isInOpenMakeOrder;
mapping (address => uint) public makerAssetCooldown;
mapping (bytes32 => IZeroExV2.Order) internal orderIdToZeroExV2Order;
mapping (bytes32 => IZeroExV3.Order) internal orderIdToZeroExV3Order;
uint public constant ORDER_LIFESPAN = 1 days;
uint public constant MAKE_ORDER_COOLDOWN = 30 minutes;
modifier delegateInternal() {
}
constructor(
address _hub,
address[] memory _exchanges,
address[] memory _adapters,
address _registry
)
public
Spoke(_hub)
{
}
/// @notice Receive ether function (used to receive ETH from WETH)
receive() external payable {}
function addExchange(address _exchange, address _adapter) external auth {
}
function _addExchange(
address _exchange,
address _adapter
) internal {
require(!adapterIsAdded[_adapter], "Adapter already added");
adapterIsAdded[_adapter] = true;
Registry registry = Registry(routes.registry);
require(<FILL_ME>)
address registeredExchange;
bool takesCustody;
(registeredExchange, takesCustody) = registry.getExchangeInformation(_adapter);
require(
registeredExchange == _exchange,
"Exchange and adapter do not match"
);
exchanges.push(Exchange(_exchange, _adapter, takesCustody));
}
/// @notice Universal method for calling exchange functions through adapters
/// @notice See adapter contracts for parameters needed for each exchange
/// @param exchangeIndex Index of the exchange in the "exchanges" array
/// @param orderAddresses [0] Order maker
/// @param orderAddresses [1] Order taker
/// @param orderAddresses [2] Order maker asset
/// @param orderAddresses [3] Order taker asset
/// @param orderAddresses [4] feeRecipientAddress
/// @param orderAddresses [5] senderAddress
/// @param orderAddresses [6] maker fee asset
/// @param orderAddresses [7] taker fee asset
/// @param orderValues [0] makerAssetAmount
/// @param orderValues [1] takerAssetAmount
/// @param orderValues [2] Maker fee
/// @param orderValues [3] Taker fee
/// @param orderValues [4] expirationTimeSeconds
/// @param orderValues [5] Salt/nonce
/// @param orderValues [6] Fill amount: amount of taker token to be traded
/// @param orderValues [7] Dexy signature mode
/// @param orderData [0] Encoded data specific to maker asset
/// @param orderData [1] Encoded data specific to taker asset
/// @param orderData [2] Encoded data specific to maker asset fee
/// @param orderData [3] Encoded data specific to taker asset fee
/// @param identifier Order identifier
/// @param signature Signature of order maker
function callOnExchange(
uint exchangeIndex,
string memory methodSignature,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
)
public
onlyInitialized
{
}
/// @dev Make sure this is called after orderUpdateHook in adapters
function addOpenMakeOrder(
address ofExchange,
address sellAsset,
address buyAsset,
address feeAsset,
uint orderId,
uint expirationTime
) public delegateInternal {
}
function _removeOpenMakeOrder(
address exchange,
address sellAsset
) internal {
}
function removeOpenMakeOrder(
address exchange,
address sellAsset
) public delegateInternal {
}
/// @dev Bit of Redundancy for now
function addZeroExV2OrderData(
bytes32 orderId,
IZeroExV2.Order memory zeroExOrderData
) public delegateInternal {
}
function addZeroExV3OrderData(
bytes32 orderId,
IZeroExV3.Order memory zeroExOrderData
) public delegateInternal {
}
function orderUpdateHook(
address ofExchange,
bytes32 orderId,
UpdateType updateType,
address payable[2] memory orderAddresses,
uint[3] memory orderValues
) public delegateInternal {
}
function updateAndGetQuantityBeingTraded(address _asset) external returns (uint) {
}
function updateAndGetQuantityHeldInExchange(address ofAsset) public returns (uint) {
}
function returnBatchToVault(address[] calldata _tokens) external {
}
function returnAssetToVault(address _token) public {
}
function getExchangeInfo() public view returns (address[] memory, address[] memory, bool[] memory) {
}
function getOpenOrderInfo(address ofExchange, address ofAsset) public view returns (uint, uint, uint) {
}
function isOrderExpired(address exchange, address asset) public view returns(bool) {
}
function getOrderDetails(uint orderIndex) public view returns (address, address, uint, uint) {
}
function getZeroExV2OrderDetails(bytes32 orderId) public view returns (IZeroExV2.Order memory) {
}
function getZeroExV3OrderDetails(bytes32 orderId) public view returns (IZeroExV3.Order memory) {
}
function getOpenMakeOrdersAgainstAsset(address _asset) external view returns (uint256) {
}
}
contract TradingFactory is Factory {
event NewInstance(
address indexed hub,
address indexed instance,
address[] exchanges,
address[] adapters,
address registry
);
function createInstance(
address _hub,
address[] memory _exchanges,
address[] memory _adapters,
address _registry
) public returns (address) {
}
}
| registry.exchangeAdapterIsRegistered(_adapter),"Adapter is not registered" | 15,205 | registry.exchangeAdapterIsRegistered(_adapter) |
"Adapter method not allowed" | pragma solidity 0.6.1;
pragma experimental ABIEncoderV2;
import "../hub/Spoke.sol";
import "../vault/Vault.sol";
import "../policies/PolicyManager.sol";
import "../policies/TradingSignatures.sol";
import "../../factory/Factory.sol";
import "../../dependencies/DSMath.sol";
import "../../exchanges/ExchangeAdapter.sol";
import "../../exchanges/interfaces/IZeroExV2.sol";
import "../../exchanges/interfaces/IZeroExV3.sol";
import "../../version/Registry.sol";
import "../../dependencies/TokenUser.sol";
contract Trading is DSMath, TokenUser, Spoke, TradingSignatures {
event ExchangeMethodCall(
address indexed exchangeAddress,
string indexed methodSignature,
address[8] orderAddresses,
uint[8] orderValues,
bytes[4] orderData,
bytes32 identifier,
bytes signature
);
struct Exchange {
address exchange;
address adapter;
bool takesCustody;
}
enum UpdateType { make, take, cancel }
struct Order {
address exchangeAddress;
bytes32 orderId;
UpdateType updateType;
address makerAsset;
address takerAsset;
uint makerQuantity;
uint takerQuantity;
uint timestamp;
uint fillTakerQuantity;
}
struct OpenMakeOrder {
uint id; // Order Id from exchange
uint expiresAt; // Timestamp when the order expires
uint orderIndex; // Index of the order in the orders array
address buyAsset; // Address of the buy asset in the order
address feeAsset;
}
Exchange[] public exchanges;
Order[] public orders;
mapping (address => bool) public adapterIsAdded;
mapping (address => mapping(address => OpenMakeOrder)) public exchangesToOpenMakeOrders;
mapping (address => uint) public openMakeOrdersAgainstAsset;
mapping (address => uint) public openMakeOrdersUsingAssetAsFee;
mapping (address => bool) public isInOpenMakeOrder;
mapping (address => uint) public makerAssetCooldown;
mapping (bytes32 => IZeroExV2.Order) internal orderIdToZeroExV2Order;
mapping (bytes32 => IZeroExV3.Order) internal orderIdToZeroExV3Order;
uint public constant ORDER_LIFESPAN = 1 days;
uint public constant MAKE_ORDER_COOLDOWN = 30 minutes;
modifier delegateInternal() {
}
constructor(
address _hub,
address[] memory _exchanges,
address[] memory _adapters,
address _registry
)
public
Spoke(_hub)
{
}
/// @notice Receive ether function (used to receive ETH from WETH)
receive() external payable {}
function addExchange(address _exchange, address _adapter) external auth {
}
function _addExchange(
address _exchange,
address _adapter
) internal {
}
/// @notice Universal method for calling exchange functions through adapters
/// @notice See adapter contracts for parameters needed for each exchange
/// @param exchangeIndex Index of the exchange in the "exchanges" array
/// @param orderAddresses [0] Order maker
/// @param orderAddresses [1] Order taker
/// @param orderAddresses [2] Order maker asset
/// @param orderAddresses [3] Order taker asset
/// @param orderAddresses [4] feeRecipientAddress
/// @param orderAddresses [5] senderAddress
/// @param orderAddresses [6] maker fee asset
/// @param orderAddresses [7] taker fee asset
/// @param orderValues [0] makerAssetAmount
/// @param orderValues [1] takerAssetAmount
/// @param orderValues [2] Maker fee
/// @param orderValues [3] Taker fee
/// @param orderValues [4] expirationTimeSeconds
/// @param orderValues [5] Salt/nonce
/// @param orderValues [6] Fill amount: amount of taker token to be traded
/// @param orderValues [7] Dexy signature mode
/// @param orderData [0] Encoded data specific to maker asset
/// @param orderData [1] Encoded data specific to taker asset
/// @param orderData [2] Encoded data specific to maker asset fee
/// @param orderData [3] Encoded data specific to taker asset fee
/// @param identifier Order identifier
/// @param signature Signature of order maker
function callOnExchange(
uint exchangeIndex,
string memory methodSignature,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
)
public
onlyInitialized
{
bytes4 methodSelector = bytes4(keccak256(bytes(methodSignature)));
require(<FILL_ME>)
PolicyManager(routes.policyManager).preValidate(methodSelector, [orderAddresses[0], orderAddresses[1], orderAddresses[2], orderAddresses[3], exchanges[exchangeIndex].exchange], [orderValues[0], orderValues[1], orderValues[6]], identifier);
if (
methodSelector == MAKE_ORDER ||
methodSelector == TAKE_ORDER
) {
require(Registry(routes.registry).assetIsRegistered(
orderAddresses[2]), 'Maker asset not registered'
);
require(Registry(routes.registry).assetIsRegistered(
orderAddresses[3]), 'Taker asset not registered'
);
if (orderAddresses[6] != address(0) && methodSelector == MAKE_ORDER) {
require(
Registry(routes.registry).assetIsRegistered(orderAddresses[6]),
'Maker fee asset not registered'
);
}
if (orderAddresses[7] != address(0) && methodSelector == TAKE_ORDER) {
require(
Registry(routes.registry).assetIsRegistered(orderAddresses[7]),
'Taker fee asset not registered'
);
}
}
(bool success, bytes memory returnData) = exchanges[exchangeIndex].adapter.delegatecall(
abi.encodeWithSignature(
methodSignature,
exchanges[exchangeIndex].exchange,
orderAddresses,
orderValues,
orderData,
identifier,
signature
)
);
require(success, string(returnData));
PolicyManager(routes.policyManager).postValidate(methodSelector, [orderAddresses[0], orderAddresses[1], orderAddresses[2], orderAddresses[3], exchanges[exchangeIndex].exchange], [orderValues[0], orderValues[1], orderValues[6]], identifier);
emit ExchangeMethodCall(
exchanges[exchangeIndex].exchange,
methodSignature,
orderAddresses,
orderValues,
orderData,
identifier,
signature
);
}
/// @dev Make sure this is called after orderUpdateHook in adapters
function addOpenMakeOrder(
address ofExchange,
address sellAsset,
address buyAsset,
address feeAsset,
uint orderId,
uint expirationTime
) public delegateInternal {
}
function _removeOpenMakeOrder(
address exchange,
address sellAsset
) internal {
}
function removeOpenMakeOrder(
address exchange,
address sellAsset
) public delegateInternal {
}
/// @dev Bit of Redundancy for now
function addZeroExV2OrderData(
bytes32 orderId,
IZeroExV2.Order memory zeroExOrderData
) public delegateInternal {
}
function addZeroExV3OrderData(
bytes32 orderId,
IZeroExV3.Order memory zeroExOrderData
) public delegateInternal {
}
function orderUpdateHook(
address ofExchange,
bytes32 orderId,
UpdateType updateType,
address payable[2] memory orderAddresses,
uint[3] memory orderValues
) public delegateInternal {
}
function updateAndGetQuantityBeingTraded(address _asset) external returns (uint) {
}
function updateAndGetQuantityHeldInExchange(address ofAsset) public returns (uint) {
}
function returnBatchToVault(address[] calldata _tokens) external {
}
function returnAssetToVault(address _token) public {
}
function getExchangeInfo() public view returns (address[] memory, address[] memory, bool[] memory) {
}
function getOpenOrderInfo(address ofExchange, address ofAsset) public view returns (uint, uint, uint) {
}
function isOrderExpired(address exchange, address asset) public view returns(bool) {
}
function getOrderDetails(uint orderIndex) public view returns (address, address, uint, uint) {
}
function getZeroExV2OrderDetails(bytes32 orderId) public view returns (IZeroExV2.Order memory) {
}
function getZeroExV3OrderDetails(bytes32 orderId) public view returns (IZeroExV3.Order memory) {
}
function getOpenMakeOrdersAgainstAsset(address _asset) external view returns (uint256) {
}
}
contract TradingFactory is Factory {
event NewInstance(
address indexed hub,
address indexed instance,
address[] exchanges,
address[] adapters,
address registry
);
function createInstance(
address _hub,
address[] memory _exchanges,
address[] memory _adapters,
address _registry
) public returns (address) {
}
}
| Registry(routes.registry).adapterMethodIsAllowed(exchanges[exchangeIndex].adapter,methodSelector),"Adapter method not allowed" | 15,205 | Registry(routes.registry).adapterMethodIsAllowed(exchanges[exchangeIndex].adapter,methodSelector) |
'Maker asset not registered' | pragma solidity 0.6.1;
pragma experimental ABIEncoderV2;
import "../hub/Spoke.sol";
import "../vault/Vault.sol";
import "../policies/PolicyManager.sol";
import "../policies/TradingSignatures.sol";
import "../../factory/Factory.sol";
import "../../dependencies/DSMath.sol";
import "../../exchanges/ExchangeAdapter.sol";
import "../../exchanges/interfaces/IZeroExV2.sol";
import "../../exchanges/interfaces/IZeroExV3.sol";
import "../../version/Registry.sol";
import "../../dependencies/TokenUser.sol";
contract Trading is DSMath, TokenUser, Spoke, TradingSignatures {
event ExchangeMethodCall(
address indexed exchangeAddress,
string indexed methodSignature,
address[8] orderAddresses,
uint[8] orderValues,
bytes[4] orderData,
bytes32 identifier,
bytes signature
);
struct Exchange {
address exchange;
address adapter;
bool takesCustody;
}
enum UpdateType { make, take, cancel }
struct Order {
address exchangeAddress;
bytes32 orderId;
UpdateType updateType;
address makerAsset;
address takerAsset;
uint makerQuantity;
uint takerQuantity;
uint timestamp;
uint fillTakerQuantity;
}
struct OpenMakeOrder {
uint id; // Order Id from exchange
uint expiresAt; // Timestamp when the order expires
uint orderIndex; // Index of the order in the orders array
address buyAsset; // Address of the buy asset in the order
address feeAsset;
}
Exchange[] public exchanges;
Order[] public orders;
mapping (address => bool) public adapterIsAdded;
mapping (address => mapping(address => OpenMakeOrder)) public exchangesToOpenMakeOrders;
mapping (address => uint) public openMakeOrdersAgainstAsset;
mapping (address => uint) public openMakeOrdersUsingAssetAsFee;
mapping (address => bool) public isInOpenMakeOrder;
mapping (address => uint) public makerAssetCooldown;
mapping (bytes32 => IZeroExV2.Order) internal orderIdToZeroExV2Order;
mapping (bytes32 => IZeroExV3.Order) internal orderIdToZeroExV3Order;
uint public constant ORDER_LIFESPAN = 1 days;
uint public constant MAKE_ORDER_COOLDOWN = 30 minutes;
modifier delegateInternal() {
}
constructor(
address _hub,
address[] memory _exchanges,
address[] memory _adapters,
address _registry
)
public
Spoke(_hub)
{
}
/// @notice Receive ether function (used to receive ETH from WETH)
receive() external payable {}
function addExchange(address _exchange, address _adapter) external auth {
}
function _addExchange(
address _exchange,
address _adapter
) internal {
}
/// @notice Universal method for calling exchange functions through adapters
/// @notice See adapter contracts for parameters needed for each exchange
/// @param exchangeIndex Index of the exchange in the "exchanges" array
/// @param orderAddresses [0] Order maker
/// @param orderAddresses [1] Order taker
/// @param orderAddresses [2] Order maker asset
/// @param orderAddresses [3] Order taker asset
/// @param orderAddresses [4] feeRecipientAddress
/// @param orderAddresses [5] senderAddress
/// @param orderAddresses [6] maker fee asset
/// @param orderAddresses [7] taker fee asset
/// @param orderValues [0] makerAssetAmount
/// @param orderValues [1] takerAssetAmount
/// @param orderValues [2] Maker fee
/// @param orderValues [3] Taker fee
/// @param orderValues [4] expirationTimeSeconds
/// @param orderValues [5] Salt/nonce
/// @param orderValues [6] Fill amount: amount of taker token to be traded
/// @param orderValues [7] Dexy signature mode
/// @param orderData [0] Encoded data specific to maker asset
/// @param orderData [1] Encoded data specific to taker asset
/// @param orderData [2] Encoded data specific to maker asset fee
/// @param orderData [3] Encoded data specific to taker asset fee
/// @param identifier Order identifier
/// @param signature Signature of order maker
function callOnExchange(
uint exchangeIndex,
string memory methodSignature,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
)
public
onlyInitialized
{
bytes4 methodSelector = bytes4(keccak256(bytes(methodSignature)));
require(
Registry(routes.registry).adapterMethodIsAllowed(
exchanges[exchangeIndex].adapter,
methodSelector
),
"Adapter method not allowed"
);
PolicyManager(routes.policyManager).preValidate(methodSelector, [orderAddresses[0], orderAddresses[1], orderAddresses[2], orderAddresses[3], exchanges[exchangeIndex].exchange], [orderValues[0], orderValues[1], orderValues[6]], identifier);
if (
methodSelector == MAKE_ORDER ||
methodSelector == TAKE_ORDER
) {
require(<FILL_ME>)
require(Registry(routes.registry).assetIsRegistered(
orderAddresses[3]), 'Taker asset not registered'
);
if (orderAddresses[6] != address(0) && methodSelector == MAKE_ORDER) {
require(
Registry(routes.registry).assetIsRegistered(orderAddresses[6]),
'Maker fee asset not registered'
);
}
if (orderAddresses[7] != address(0) && methodSelector == TAKE_ORDER) {
require(
Registry(routes.registry).assetIsRegistered(orderAddresses[7]),
'Taker fee asset not registered'
);
}
}
(bool success, bytes memory returnData) = exchanges[exchangeIndex].adapter.delegatecall(
abi.encodeWithSignature(
methodSignature,
exchanges[exchangeIndex].exchange,
orderAddresses,
orderValues,
orderData,
identifier,
signature
)
);
require(success, string(returnData));
PolicyManager(routes.policyManager).postValidate(methodSelector, [orderAddresses[0], orderAddresses[1], orderAddresses[2], orderAddresses[3], exchanges[exchangeIndex].exchange], [orderValues[0], orderValues[1], orderValues[6]], identifier);
emit ExchangeMethodCall(
exchanges[exchangeIndex].exchange,
methodSignature,
orderAddresses,
orderValues,
orderData,
identifier,
signature
);
}
/// @dev Make sure this is called after orderUpdateHook in adapters
function addOpenMakeOrder(
address ofExchange,
address sellAsset,
address buyAsset,
address feeAsset,
uint orderId,
uint expirationTime
) public delegateInternal {
}
function _removeOpenMakeOrder(
address exchange,
address sellAsset
) internal {
}
function removeOpenMakeOrder(
address exchange,
address sellAsset
) public delegateInternal {
}
/// @dev Bit of Redundancy for now
function addZeroExV2OrderData(
bytes32 orderId,
IZeroExV2.Order memory zeroExOrderData
) public delegateInternal {
}
function addZeroExV3OrderData(
bytes32 orderId,
IZeroExV3.Order memory zeroExOrderData
) public delegateInternal {
}
function orderUpdateHook(
address ofExchange,
bytes32 orderId,
UpdateType updateType,
address payable[2] memory orderAddresses,
uint[3] memory orderValues
) public delegateInternal {
}
function updateAndGetQuantityBeingTraded(address _asset) external returns (uint) {
}
function updateAndGetQuantityHeldInExchange(address ofAsset) public returns (uint) {
}
function returnBatchToVault(address[] calldata _tokens) external {
}
function returnAssetToVault(address _token) public {
}
function getExchangeInfo() public view returns (address[] memory, address[] memory, bool[] memory) {
}
function getOpenOrderInfo(address ofExchange, address ofAsset) public view returns (uint, uint, uint) {
}
function isOrderExpired(address exchange, address asset) public view returns(bool) {
}
function getOrderDetails(uint orderIndex) public view returns (address, address, uint, uint) {
}
function getZeroExV2OrderDetails(bytes32 orderId) public view returns (IZeroExV2.Order memory) {
}
function getZeroExV3OrderDetails(bytes32 orderId) public view returns (IZeroExV3.Order memory) {
}
function getOpenMakeOrdersAgainstAsset(address _asset) external view returns (uint256) {
}
}
contract TradingFactory is Factory {
event NewInstance(
address indexed hub,
address indexed instance,
address[] exchanges,
address[] adapters,
address registry
);
function createInstance(
address _hub,
address[] memory _exchanges,
address[] memory _adapters,
address _registry
) public returns (address) {
}
}
| Registry(routes.registry).assetIsRegistered(orderAddresses[2]),'Maker asset not registered' | 15,205 | Registry(routes.registry).assetIsRegistered(orderAddresses[2]) |
'Taker asset not registered' | pragma solidity 0.6.1;
pragma experimental ABIEncoderV2;
import "../hub/Spoke.sol";
import "../vault/Vault.sol";
import "../policies/PolicyManager.sol";
import "../policies/TradingSignatures.sol";
import "../../factory/Factory.sol";
import "../../dependencies/DSMath.sol";
import "../../exchanges/ExchangeAdapter.sol";
import "../../exchanges/interfaces/IZeroExV2.sol";
import "../../exchanges/interfaces/IZeroExV3.sol";
import "../../version/Registry.sol";
import "../../dependencies/TokenUser.sol";
contract Trading is DSMath, TokenUser, Spoke, TradingSignatures {
event ExchangeMethodCall(
address indexed exchangeAddress,
string indexed methodSignature,
address[8] orderAddresses,
uint[8] orderValues,
bytes[4] orderData,
bytes32 identifier,
bytes signature
);
struct Exchange {
address exchange;
address adapter;
bool takesCustody;
}
enum UpdateType { make, take, cancel }
struct Order {
address exchangeAddress;
bytes32 orderId;
UpdateType updateType;
address makerAsset;
address takerAsset;
uint makerQuantity;
uint takerQuantity;
uint timestamp;
uint fillTakerQuantity;
}
struct OpenMakeOrder {
uint id; // Order Id from exchange
uint expiresAt; // Timestamp when the order expires
uint orderIndex; // Index of the order in the orders array
address buyAsset; // Address of the buy asset in the order
address feeAsset;
}
Exchange[] public exchanges;
Order[] public orders;
mapping (address => bool) public adapterIsAdded;
mapping (address => mapping(address => OpenMakeOrder)) public exchangesToOpenMakeOrders;
mapping (address => uint) public openMakeOrdersAgainstAsset;
mapping (address => uint) public openMakeOrdersUsingAssetAsFee;
mapping (address => bool) public isInOpenMakeOrder;
mapping (address => uint) public makerAssetCooldown;
mapping (bytes32 => IZeroExV2.Order) internal orderIdToZeroExV2Order;
mapping (bytes32 => IZeroExV3.Order) internal orderIdToZeroExV3Order;
uint public constant ORDER_LIFESPAN = 1 days;
uint public constant MAKE_ORDER_COOLDOWN = 30 minutes;
modifier delegateInternal() {
}
constructor(
address _hub,
address[] memory _exchanges,
address[] memory _adapters,
address _registry
)
public
Spoke(_hub)
{
}
/// @notice Receive ether function (used to receive ETH from WETH)
receive() external payable {}
function addExchange(address _exchange, address _adapter) external auth {
}
function _addExchange(
address _exchange,
address _adapter
) internal {
}
/// @notice Universal method for calling exchange functions through adapters
/// @notice See adapter contracts for parameters needed for each exchange
/// @param exchangeIndex Index of the exchange in the "exchanges" array
/// @param orderAddresses [0] Order maker
/// @param orderAddresses [1] Order taker
/// @param orderAddresses [2] Order maker asset
/// @param orderAddresses [3] Order taker asset
/// @param orderAddresses [4] feeRecipientAddress
/// @param orderAddresses [5] senderAddress
/// @param orderAddresses [6] maker fee asset
/// @param orderAddresses [7] taker fee asset
/// @param orderValues [0] makerAssetAmount
/// @param orderValues [1] takerAssetAmount
/// @param orderValues [2] Maker fee
/// @param orderValues [3] Taker fee
/// @param orderValues [4] expirationTimeSeconds
/// @param orderValues [5] Salt/nonce
/// @param orderValues [6] Fill amount: amount of taker token to be traded
/// @param orderValues [7] Dexy signature mode
/// @param orderData [0] Encoded data specific to maker asset
/// @param orderData [1] Encoded data specific to taker asset
/// @param orderData [2] Encoded data specific to maker asset fee
/// @param orderData [3] Encoded data specific to taker asset fee
/// @param identifier Order identifier
/// @param signature Signature of order maker
function callOnExchange(
uint exchangeIndex,
string memory methodSignature,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
)
public
onlyInitialized
{
bytes4 methodSelector = bytes4(keccak256(bytes(methodSignature)));
require(
Registry(routes.registry).adapterMethodIsAllowed(
exchanges[exchangeIndex].adapter,
methodSelector
),
"Adapter method not allowed"
);
PolicyManager(routes.policyManager).preValidate(methodSelector, [orderAddresses[0], orderAddresses[1], orderAddresses[2], orderAddresses[3], exchanges[exchangeIndex].exchange], [orderValues[0], orderValues[1], orderValues[6]], identifier);
if (
methodSelector == MAKE_ORDER ||
methodSelector == TAKE_ORDER
) {
require(Registry(routes.registry).assetIsRegistered(
orderAddresses[2]), 'Maker asset not registered'
);
require(<FILL_ME>)
if (orderAddresses[6] != address(0) && methodSelector == MAKE_ORDER) {
require(
Registry(routes.registry).assetIsRegistered(orderAddresses[6]),
'Maker fee asset not registered'
);
}
if (orderAddresses[7] != address(0) && methodSelector == TAKE_ORDER) {
require(
Registry(routes.registry).assetIsRegistered(orderAddresses[7]),
'Taker fee asset not registered'
);
}
}
(bool success, bytes memory returnData) = exchanges[exchangeIndex].adapter.delegatecall(
abi.encodeWithSignature(
methodSignature,
exchanges[exchangeIndex].exchange,
orderAddresses,
orderValues,
orderData,
identifier,
signature
)
);
require(success, string(returnData));
PolicyManager(routes.policyManager).postValidate(methodSelector, [orderAddresses[0], orderAddresses[1], orderAddresses[2], orderAddresses[3], exchanges[exchangeIndex].exchange], [orderValues[0], orderValues[1], orderValues[6]], identifier);
emit ExchangeMethodCall(
exchanges[exchangeIndex].exchange,
methodSignature,
orderAddresses,
orderValues,
orderData,
identifier,
signature
);
}
/// @dev Make sure this is called after orderUpdateHook in adapters
function addOpenMakeOrder(
address ofExchange,
address sellAsset,
address buyAsset,
address feeAsset,
uint orderId,
uint expirationTime
) public delegateInternal {
}
function _removeOpenMakeOrder(
address exchange,
address sellAsset
) internal {
}
function removeOpenMakeOrder(
address exchange,
address sellAsset
) public delegateInternal {
}
/// @dev Bit of Redundancy for now
function addZeroExV2OrderData(
bytes32 orderId,
IZeroExV2.Order memory zeroExOrderData
) public delegateInternal {
}
function addZeroExV3OrderData(
bytes32 orderId,
IZeroExV3.Order memory zeroExOrderData
) public delegateInternal {
}
function orderUpdateHook(
address ofExchange,
bytes32 orderId,
UpdateType updateType,
address payable[2] memory orderAddresses,
uint[3] memory orderValues
) public delegateInternal {
}
function updateAndGetQuantityBeingTraded(address _asset) external returns (uint) {
}
function updateAndGetQuantityHeldInExchange(address ofAsset) public returns (uint) {
}
function returnBatchToVault(address[] calldata _tokens) external {
}
function returnAssetToVault(address _token) public {
}
function getExchangeInfo() public view returns (address[] memory, address[] memory, bool[] memory) {
}
function getOpenOrderInfo(address ofExchange, address ofAsset) public view returns (uint, uint, uint) {
}
function isOrderExpired(address exchange, address asset) public view returns(bool) {
}
function getOrderDetails(uint orderIndex) public view returns (address, address, uint, uint) {
}
function getZeroExV2OrderDetails(bytes32 orderId) public view returns (IZeroExV2.Order memory) {
}
function getZeroExV3OrderDetails(bytes32 orderId) public view returns (IZeroExV3.Order memory) {
}
function getOpenMakeOrdersAgainstAsset(address _asset) external view returns (uint256) {
}
}
contract TradingFactory is Factory {
event NewInstance(
address indexed hub,
address indexed instance,
address[] exchanges,
address[] adapters,
address registry
);
function createInstance(
address _hub,
address[] memory _exchanges,
address[] memory _adapters,
address _registry
) public returns (address) {
}
}
| Registry(routes.registry).assetIsRegistered(orderAddresses[3]),'Taker asset not registered' | 15,205 | Registry(routes.registry).assetIsRegistered(orderAddresses[3]) |
'Maker fee asset not registered' | pragma solidity 0.6.1;
pragma experimental ABIEncoderV2;
import "../hub/Spoke.sol";
import "../vault/Vault.sol";
import "../policies/PolicyManager.sol";
import "../policies/TradingSignatures.sol";
import "../../factory/Factory.sol";
import "../../dependencies/DSMath.sol";
import "../../exchanges/ExchangeAdapter.sol";
import "../../exchanges/interfaces/IZeroExV2.sol";
import "../../exchanges/interfaces/IZeroExV3.sol";
import "../../version/Registry.sol";
import "../../dependencies/TokenUser.sol";
contract Trading is DSMath, TokenUser, Spoke, TradingSignatures {
event ExchangeMethodCall(
address indexed exchangeAddress,
string indexed methodSignature,
address[8] orderAddresses,
uint[8] orderValues,
bytes[4] orderData,
bytes32 identifier,
bytes signature
);
struct Exchange {
address exchange;
address adapter;
bool takesCustody;
}
enum UpdateType { make, take, cancel }
struct Order {
address exchangeAddress;
bytes32 orderId;
UpdateType updateType;
address makerAsset;
address takerAsset;
uint makerQuantity;
uint takerQuantity;
uint timestamp;
uint fillTakerQuantity;
}
struct OpenMakeOrder {
uint id; // Order Id from exchange
uint expiresAt; // Timestamp when the order expires
uint orderIndex; // Index of the order in the orders array
address buyAsset; // Address of the buy asset in the order
address feeAsset;
}
Exchange[] public exchanges;
Order[] public orders;
mapping (address => bool) public adapterIsAdded;
mapping (address => mapping(address => OpenMakeOrder)) public exchangesToOpenMakeOrders;
mapping (address => uint) public openMakeOrdersAgainstAsset;
mapping (address => uint) public openMakeOrdersUsingAssetAsFee;
mapping (address => bool) public isInOpenMakeOrder;
mapping (address => uint) public makerAssetCooldown;
mapping (bytes32 => IZeroExV2.Order) internal orderIdToZeroExV2Order;
mapping (bytes32 => IZeroExV3.Order) internal orderIdToZeroExV3Order;
uint public constant ORDER_LIFESPAN = 1 days;
uint public constant MAKE_ORDER_COOLDOWN = 30 minutes;
modifier delegateInternal() {
}
constructor(
address _hub,
address[] memory _exchanges,
address[] memory _adapters,
address _registry
)
public
Spoke(_hub)
{
}
/// @notice Receive ether function (used to receive ETH from WETH)
receive() external payable {}
function addExchange(address _exchange, address _adapter) external auth {
}
function _addExchange(
address _exchange,
address _adapter
) internal {
}
/// @notice Universal method for calling exchange functions through adapters
/// @notice See adapter contracts for parameters needed for each exchange
/// @param exchangeIndex Index of the exchange in the "exchanges" array
/// @param orderAddresses [0] Order maker
/// @param orderAddresses [1] Order taker
/// @param orderAddresses [2] Order maker asset
/// @param orderAddresses [3] Order taker asset
/// @param orderAddresses [4] feeRecipientAddress
/// @param orderAddresses [5] senderAddress
/// @param orderAddresses [6] maker fee asset
/// @param orderAddresses [7] taker fee asset
/// @param orderValues [0] makerAssetAmount
/// @param orderValues [1] takerAssetAmount
/// @param orderValues [2] Maker fee
/// @param orderValues [3] Taker fee
/// @param orderValues [4] expirationTimeSeconds
/// @param orderValues [5] Salt/nonce
/// @param orderValues [6] Fill amount: amount of taker token to be traded
/// @param orderValues [7] Dexy signature mode
/// @param orderData [0] Encoded data specific to maker asset
/// @param orderData [1] Encoded data specific to taker asset
/// @param orderData [2] Encoded data specific to maker asset fee
/// @param orderData [3] Encoded data specific to taker asset fee
/// @param identifier Order identifier
/// @param signature Signature of order maker
function callOnExchange(
uint exchangeIndex,
string memory methodSignature,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
)
public
onlyInitialized
{
bytes4 methodSelector = bytes4(keccak256(bytes(methodSignature)));
require(
Registry(routes.registry).adapterMethodIsAllowed(
exchanges[exchangeIndex].adapter,
methodSelector
),
"Adapter method not allowed"
);
PolicyManager(routes.policyManager).preValidate(methodSelector, [orderAddresses[0], orderAddresses[1], orderAddresses[2], orderAddresses[3], exchanges[exchangeIndex].exchange], [orderValues[0], orderValues[1], orderValues[6]], identifier);
if (
methodSelector == MAKE_ORDER ||
methodSelector == TAKE_ORDER
) {
require(Registry(routes.registry).assetIsRegistered(
orderAddresses[2]), 'Maker asset not registered'
);
require(Registry(routes.registry).assetIsRegistered(
orderAddresses[3]), 'Taker asset not registered'
);
if (orderAddresses[6] != address(0) && methodSelector == MAKE_ORDER) {
require(<FILL_ME>)
}
if (orderAddresses[7] != address(0) && methodSelector == TAKE_ORDER) {
require(
Registry(routes.registry).assetIsRegistered(orderAddresses[7]),
'Taker fee asset not registered'
);
}
}
(bool success, bytes memory returnData) = exchanges[exchangeIndex].adapter.delegatecall(
abi.encodeWithSignature(
methodSignature,
exchanges[exchangeIndex].exchange,
orderAddresses,
orderValues,
orderData,
identifier,
signature
)
);
require(success, string(returnData));
PolicyManager(routes.policyManager).postValidate(methodSelector, [orderAddresses[0], orderAddresses[1], orderAddresses[2], orderAddresses[3], exchanges[exchangeIndex].exchange], [orderValues[0], orderValues[1], orderValues[6]], identifier);
emit ExchangeMethodCall(
exchanges[exchangeIndex].exchange,
methodSignature,
orderAddresses,
orderValues,
orderData,
identifier,
signature
);
}
/// @dev Make sure this is called after orderUpdateHook in adapters
function addOpenMakeOrder(
address ofExchange,
address sellAsset,
address buyAsset,
address feeAsset,
uint orderId,
uint expirationTime
) public delegateInternal {
}
function _removeOpenMakeOrder(
address exchange,
address sellAsset
) internal {
}
function removeOpenMakeOrder(
address exchange,
address sellAsset
) public delegateInternal {
}
/// @dev Bit of Redundancy for now
function addZeroExV2OrderData(
bytes32 orderId,
IZeroExV2.Order memory zeroExOrderData
) public delegateInternal {
}
function addZeroExV3OrderData(
bytes32 orderId,
IZeroExV3.Order memory zeroExOrderData
) public delegateInternal {
}
function orderUpdateHook(
address ofExchange,
bytes32 orderId,
UpdateType updateType,
address payable[2] memory orderAddresses,
uint[3] memory orderValues
) public delegateInternal {
}
function updateAndGetQuantityBeingTraded(address _asset) external returns (uint) {
}
function updateAndGetQuantityHeldInExchange(address ofAsset) public returns (uint) {
}
function returnBatchToVault(address[] calldata _tokens) external {
}
function returnAssetToVault(address _token) public {
}
function getExchangeInfo() public view returns (address[] memory, address[] memory, bool[] memory) {
}
function getOpenOrderInfo(address ofExchange, address ofAsset) public view returns (uint, uint, uint) {
}
function isOrderExpired(address exchange, address asset) public view returns(bool) {
}
function getOrderDetails(uint orderIndex) public view returns (address, address, uint, uint) {
}
function getZeroExV2OrderDetails(bytes32 orderId) public view returns (IZeroExV2.Order memory) {
}
function getZeroExV3OrderDetails(bytes32 orderId) public view returns (IZeroExV3.Order memory) {
}
function getOpenMakeOrdersAgainstAsset(address _asset) external view returns (uint256) {
}
}
contract TradingFactory is Factory {
event NewInstance(
address indexed hub,
address indexed instance,
address[] exchanges,
address[] adapters,
address registry
);
function createInstance(
address _hub,
address[] memory _exchanges,
address[] memory _adapters,
address _registry
) public returns (address) {
}
}
| Registry(routes.registry).assetIsRegistered(orderAddresses[6]),'Maker fee asset not registered' | 15,205 | Registry(routes.registry).assetIsRegistered(orderAddresses[6]) |
'Taker fee asset not registered' | pragma solidity 0.6.1;
pragma experimental ABIEncoderV2;
import "../hub/Spoke.sol";
import "../vault/Vault.sol";
import "../policies/PolicyManager.sol";
import "../policies/TradingSignatures.sol";
import "../../factory/Factory.sol";
import "../../dependencies/DSMath.sol";
import "../../exchanges/ExchangeAdapter.sol";
import "../../exchanges/interfaces/IZeroExV2.sol";
import "../../exchanges/interfaces/IZeroExV3.sol";
import "../../version/Registry.sol";
import "../../dependencies/TokenUser.sol";
contract Trading is DSMath, TokenUser, Spoke, TradingSignatures {
event ExchangeMethodCall(
address indexed exchangeAddress,
string indexed methodSignature,
address[8] orderAddresses,
uint[8] orderValues,
bytes[4] orderData,
bytes32 identifier,
bytes signature
);
struct Exchange {
address exchange;
address adapter;
bool takesCustody;
}
enum UpdateType { make, take, cancel }
struct Order {
address exchangeAddress;
bytes32 orderId;
UpdateType updateType;
address makerAsset;
address takerAsset;
uint makerQuantity;
uint takerQuantity;
uint timestamp;
uint fillTakerQuantity;
}
struct OpenMakeOrder {
uint id; // Order Id from exchange
uint expiresAt; // Timestamp when the order expires
uint orderIndex; // Index of the order in the orders array
address buyAsset; // Address of the buy asset in the order
address feeAsset;
}
Exchange[] public exchanges;
Order[] public orders;
mapping (address => bool) public adapterIsAdded;
mapping (address => mapping(address => OpenMakeOrder)) public exchangesToOpenMakeOrders;
mapping (address => uint) public openMakeOrdersAgainstAsset;
mapping (address => uint) public openMakeOrdersUsingAssetAsFee;
mapping (address => bool) public isInOpenMakeOrder;
mapping (address => uint) public makerAssetCooldown;
mapping (bytes32 => IZeroExV2.Order) internal orderIdToZeroExV2Order;
mapping (bytes32 => IZeroExV3.Order) internal orderIdToZeroExV3Order;
uint public constant ORDER_LIFESPAN = 1 days;
uint public constant MAKE_ORDER_COOLDOWN = 30 minutes;
modifier delegateInternal() {
}
constructor(
address _hub,
address[] memory _exchanges,
address[] memory _adapters,
address _registry
)
public
Spoke(_hub)
{
}
/// @notice Receive ether function (used to receive ETH from WETH)
receive() external payable {}
function addExchange(address _exchange, address _adapter) external auth {
}
function _addExchange(
address _exchange,
address _adapter
) internal {
}
/// @notice Universal method for calling exchange functions through adapters
/// @notice See adapter contracts for parameters needed for each exchange
/// @param exchangeIndex Index of the exchange in the "exchanges" array
/// @param orderAddresses [0] Order maker
/// @param orderAddresses [1] Order taker
/// @param orderAddresses [2] Order maker asset
/// @param orderAddresses [3] Order taker asset
/// @param orderAddresses [4] feeRecipientAddress
/// @param orderAddresses [5] senderAddress
/// @param orderAddresses [6] maker fee asset
/// @param orderAddresses [7] taker fee asset
/// @param orderValues [0] makerAssetAmount
/// @param orderValues [1] takerAssetAmount
/// @param orderValues [2] Maker fee
/// @param orderValues [3] Taker fee
/// @param orderValues [4] expirationTimeSeconds
/// @param orderValues [5] Salt/nonce
/// @param orderValues [6] Fill amount: amount of taker token to be traded
/// @param orderValues [7] Dexy signature mode
/// @param orderData [0] Encoded data specific to maker asset
/// @param orderData [1] Encoded data specific to taker asset
/// @param orderData [2] Encoded data specific to maker asset fee
/// @param orderData [3] Encoded data specific to taker asset fee
/// @param identifier Order identifier
/// @param signature Signature of order maker
function callOnExchange(
uint exchangeIndex,
string memory methodSignature,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
)
public
onlyInitialized
{
bytes4 methodSelector = bytes4(keccak256(bytes(methodSignature)));
require(
Registry(routes.registry).adapterMethodIsAllowed(
exchanges[exchangeIndex].adapter,
methodSelector
),
"Adapter method not allowed"
);
PolicyManager(routes.policyManager).preValidate(methodSelector, [orderAddresses[0], orderAddresses[1], orderAddresses[2], orderAddresses[3], exchanges[exchangeIndex].exchange], [orderValues[0], orderValues[1], orderValues[6]], identifier);
if (
methodSelector == MAKE_ORDER ||
methodSelector == TAKE_ORDER
) {
require(Registry(routes.registry).assetIsRegistered(
orderAddresses[2]), 'Maker asset not registered'
);
require(Registry(routes.registry).assetIsRegistered(
orderAddresses[3]), 'Taker asset not registered'
);
if (orderAddresses[6] != address(0) && methodSelector == MAKE_ORDER) {
require(
Registry(routes.registry).assetIsRegistered(orderAddresses[6]),
'Maker fee asset not registered'
);
}
if (orderAddresses[7] != address(0) && methodSelector == TAKE_ORDER) {
require(<FILL_ME>)
}
}
(bool success, bytes memory returnData) = exchanges[exchangeIndex].adapter.delegatecall(
abi.encodeWithSignature(
methodSignature,
exchanges[exchangeIndex].exchange,
orderAddresses,
orderValues,
orderData,
identifier,
signature
)
);
require(success, string(returnData));
PolicyManager(routes.policyManager).postValidate(methodSelector, [orderAddresses[0], orderAddresses[1], orderAddresses[2], orderAddresses[3], exchanges[exchangeIndex].exchange], [orderValues[0], orderValues[1], orderValues[6]], identifier);
emit ExchangeMethodCall(
exchanges[exchangeIndex].exchange,
methodSignature,
orderAddresses,
orderValues,
orderData,
identifier,
signature
);
}
/// @dev Make sure this is called after orderUpdateHook in adapters
function addOpenMakeOrder(
address ofExchange,
address sellAsset,
address buyAsset,
address feeAsset,
uint orderId,
uint expirationTime
) public delegateInternal {
}
function _removeOpenMakeOrder(
address exchange,
address sellAsset
) internal {
}
function removeOpenMakeOrder(
address exchange,
address sellAsset
) public delegateInternal {
}
/// @dev Bit of Redundancy for now
function addZeroExV2OrderData(
bytes32 orderId,
IZeroExV2.Order memory zeroExOrderData
) public delegateInternal {
}
function addZeroExV3OrderData(
bytes32 orderId,
IZeroExV3.Order memory zeroExOrderData
) public delegateInternal {
}
function orderUpdateHook(
address ofExchange,
bytes32 orderId,
UpdateType updateType,
address payable[2] memory orderAddresses,
uint[3] memory orderValues
) public delegateInternal {
}
function updateAndGetQuantityBeingTraded(address _asset) external returns (uint) {
}
function updateAndGetQuantityHeldInExchange(address ofAsset) public returns (uint) {
}
function returnBatchToVault(address[] calldata _tokens) external {
}
function returnAssetToVault(address _token) public {
}
function getExchangeInfo() public view returns (address[] memory, address[] memory, bool[] memory) {
}
function getOpenOrderInfo(address ofExchange, address ofAsset) public view returns (uint, uint, uint) {
}
function isOrderExpired(address exchange, address asset) public view returns(bool) {
}
function getOrderDetails(uint orderIndex) public view returns (address, address, uint, uint) {
}
function getZeroExV2OrderDetails(bytes32 orderId) public view returns (IZeroExV2.Order memory) {
}
function getZeroExV3OrderDetails(bytes32 orderId) public view returns (IZeroExV3.Order memory) {
}
function getOpenMakeOrdersAgainstAsset(address _asset) external view returns (uint256) {
}
}
contract TradingFactory is Factory {
event NewInstance(
address indexed hub,
address indexed instance,
address[] exchanges,
address[] adapters,
address registry
);
function createInstance(
address _hub,
address[] memory _exchanges,
address[] memory _adapters,
address _registry
) public returns (address) {
}
}
| Registry(routes.registry).assetIsRegistered(orderAddresses[7]),'Taker fee asset not registered' | 15,205 | Registry(routes.registry).assetIsRegistered(orderAddresses[7]) |
"Asset already in open order" | pragma solidity 0.6.1;
pragma experimental ABIEncoderV2;
import "../hub/Spoke.sol";
import "../vault/Vault.sol";
import "../policies/PolicyManager.sol";
import "../policies/TradingSignatures.sol";
import "../../factory/Factory.sol";
import "../../dependencies/DSMath.sol";
import "../../exchanges/ExchangeAdapter.sol";
import "../../exchanges/interfaces/IZeroExV2.sol";
import "../../exchanges/interfaces/IZeroExV3.sol";
import "../../version/Registry.sol";
import "../../dependencies/TokenUser.sol";
contract Trading is DSMath, TokenUser, Spoke, TradingSignatures {
event ExchangeMethodCall(
address indexed exchangeAddress,
string indexed methodSignature,
address[8] orderAddresses,
uint[8] orderValues,
bytes[4] orderData,
bytes32 identifier,
bytes signature
);
struct Exchange {
address exchange;
address adapter;
bool takesCustody;
}
enum UpdateType { make, take, cancel }
struct Order {
address exchangeAddress;
bytes32 orderId;
UpdateType updateType;
address makerAsset;
address takerAsset;
uint makerQuantity;
uint takerQuantity;
uint timestamp;
uint fillTakerQuantity;
}
struct OpenMakeOrder {
uint id; // Order Id from exchange
uint expiresAt; // Timestamp when the order expires
uint orderIndex; // Index of the order in the orders array
address buyAsset; // Address of the buy asset in the order
address feeAsset;
}
Exchange[] public exchanges;
Order[] public orders;
mapping (address => bool) public adapterIsAdded;
mapping (address => mapping(address => OpenMakeOrder)) public exchangesToOpenMakeOrders;
mapping (address => uint) public openMakeOrdersAgainstAsset;
mapping (address => uint) public openMakeOrdersUsingAssetAsFee;
mapping (address => bool) public isInOpenMakeOrder;
mapping (address => uint) public makerAssetCooldown;
mapping (bytes32 => IZeroExV2.Order) internal orderIdToZeroExV2Order;
mapping (bytes32 => IZeroExV3.Order) internal orderIdToZeroExV3Order;
uint public constant ORDER_LIFESPAN = 1 days;
uint public constant MAKE_ORDER_COOLDOWN = 30 minutes;
modifier delegateInternal() {
}
constructor(
address _hub,
address[] memory _exchanges,
address[] memory _adapters,
address _registry
)
public
Spoke(_hub)
{
}
/// @notice Receive ether function (used to receive ETH from WETH)
receive() external payable {}
function addExchange(address _exchange, address _adapter) external auth {
}
function _addExchange(
address _exchange,
address _adapter
) internal {
}
/// @notice Universal method for calling exchange functions through adapters
/// @notice See adapter contracts for parameters needed for each exchange
/// @param exchangeIndex Index of the exchange in the "exchanges" array
/// @param orderAddresses [0] Order maker
/// @param orderAddresses [1] Order taker
/// @param orderAddresses [2] Order maker asset
/// @param orderAddresses [3] Order taker asset
/// @param orderAddresses [4] feeRecipientAddress
/// @param orderAddresses [5] senderAddress
/// @param orderAddresses [6] maker fee asset
/// @param orderAddresses [7] taker fee asset
/// @param orderValues [0] makerAssetAmount
/// @param orderValues [1] takerAssetAmount
/// @param orderValues [2] Maker fee
/// @param orderValues [3] Taker fee
/// @param orderValues [4] expirationTimeSeconds
/// @param orderValues [5] Salt/nonce
/// @param orderValues [6] Fill amount: amount of taker token to be traded
/// @param orderValues [7] Dexy signature mode
/// @param orderData [0] Encoded data specific to maker asset
/// @param orderData [1] Encoded data specific to taker asset
/// @param orderData [2] Encoded data specific to maker asset fee
/// @param orderData [3] Encoded data specific to taker asset fee
/// @param identifier Order identifier
/// @param signature Signature of order maker
function callOnExchange(
uint exchangeIndex,
string memory methodSignature,
address[8] memory orderAddresses,
uint[8] memory orderValues,
bytes[4] memory orderData,
bytes32 identifier,
bytes memory signature
)
public
onlyInitialized
{
}
/// @dev Make sure this is called after orderUpdateHook in adapters
function addOpenMakeOrder(
address ofExchange,
address sellAsset,
address buyAsset,
address feeAsset,
uint orderId,
uint expirationTime
) public delegateInternal {
require(<FILL_ME>)
require(orders.length > 0, "No orders in array");
// If expirationTime is 0, actualExpirationTime is set to ORDER_LIFESPAN from now
uint actualExpirationTime = (expirationTime == 0) ? add(block.timestamp, ORDER_LIFESPAN) : expirationTime;
require(
actualExpirationTime <= add(block.timestamp, ORDER_LIFESPAN) &&
actualExpirationTime > block.timestamp,
"Expiry time greater than max order lifespan or has already passed"
);
isInOpenMakeOrder[sellAsset] = true;
makerAssetCooldown[sellAsset] = add(actualExpirationTime, MAKE_ORDER_COOLDOWN);
openMakeOrdersAgainstAsset[buyAsset] = add(openMakeOrdersAgainstAsset[buyAsset], 1);
if (feeAsset != address(0)) {
openMakeOrdersUsingAssetAsFee[feeAsset] = add(openMakeOrdersUsingAssetAsFee[feeAsset], 1);
}
exchangesToOpenMakeOrders[ofExchange][sellAsset].id = orderId;
exchangesToOpenMakeOrders[ofExchange][sellAsset].expiresAt = actualExpirationTime;
exchangesToOpenMakeOrders[ofExchange][sellAsset].orderIndex = sub(orders.length, 1);
exchangesToOpenMakeOrders[ofExchange][sellAsset].buyAsset = buyAsset;
}
function _removeOpenMakeOrder(
address exchange,
address sellAsset
) internal {
}
function removeOpenMakeOrder(
address exchange,
address sellAsset
) public delegateInternal {
}
/// @dev Bit of Redundancy for now
function addZeroExV2OrderData(
bytes32 orderId,
IZeroExV2.Order memory zeroExOrderData
) public delegateInternal {
}
function addZeroExV3OrderData(
bytes32 orderId,
IZeroExV3.Order memory zeroExOrderData
) public delegateInternal {
}
function orderUpdateHook(
address ofExchange,
bytes32 orderId,
UpdateType updateType,
address payable[2] memory orderAddresses,
uint[3] memory orderValues
) public delegateInternal {
}
function updateAndGetQuantityBeingTraded(address _asset) external returns (uint) {
}
function updateAndGetQuantityHeldInExchange(address ofAsset) public returns (uint) {
}
function returnBatchToVault(address[] calldata _tokens) external {
}
function returnAssetToVault(address _token) public {
}
function getExchangeInfo() public view returns (address[] memory, address[] memory, bool[] memory) {
}
function getOpenOrderInfo(address ofExchange, address ofAsset) public view returns (uint, uint, uint) {
}
function isOrderExpired(address exchange, address asset) public view returns(bool) {
}
function getOrderDetails(uint orderIndex) public view returns (address, address, uint, uint) {
}
function getZeroExV2OrderDetails(bytes32 orderId) public view returns (IZeroExV2.Order memory) {
}
function getZeroExV3OrderDetails(bytes32 orderId) public view returns (IZeroExV3.Order memory) {
}
function getOpenMakeOrdersAgainstAsset(address _asset) external view returns (uint256) {
}
}
contract TradingFactory is Factory {
event NewInstance(
address indexed hub,
address indexed instance,
address[] exchanges,
address[] adapters,
address registry
);
function createInstance(
address _hub,
address[] memory _exchanges,
address[] memory _adapters,
address _registry
) public returns (address) {
}
}
| !isInOpenMakeOrder[sellAsset],"Asset already in open order" | 15,205 | !isInOpenMakeOrder[sellAsset] |
null | /**
*Submitted for verification at Etherscan.io on 2020-10-13
*/
pragma solidity ^0.4.24;
library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/*
* Ownable
*
* Base contract with an owner.
* Provides onlyOwner modifier, which prevents function from running if it is called by anyone other than the owner.
*/
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
// allows execution by the owner only
modifier onlyOwner() {
}
modifier onlyNewOwner() {
}
/**
@dev allows transferring the contract ownership
the new owner still needs to accept the transfer
can only be called by the contract owner
@param _newOwner new contract owner
*/
function transferOwnership(address _newOwner) public onlyOwner {
}
/**
@dev used by a new owner to accept an ownership transfer
*/
function acceptOwnership() public onlyNewOwner {
}
}
/*
ERC20 Token interface
*/
contract ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function allowance(address owner, address spender) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
interface TokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract MISSACOIN is ERC20, Ownable {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
uint256 internal initialSupply;
uint256 internal totalSupply_;
mapping(address => uint256) internal balances;
mapping(address => bool) public frozen;
mapping(address => mapping(address => uint256)) internal allowed;
event Burn(address indexed owner, uint256 value);
event Freeze(address indexed holder);
event Unfreeze(address indexed holder);
modifier notFrozen(address _holder) {
require(<FILL_ME>)
_;
}
constructor() public {
}
function () public payable {
}
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Transfer token for a specified addresses
* @param _from The address to transfer from.
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* @dev Transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public notFrozen(msg.sender) returns (bool) {
}
/**
* @dev Gets the balance of the specified address.
* @param _holder The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _holder) public view returns (uint256 balance) {
}
/**
* @dev Transfer tokens from one address to another.
* Note that while this function emits an Approval event, this is not required as per the specification,
* and other compliant implementations may not emit the event.
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public notFrozen(_from) returns (bool) {
}
/**
* @dev Approve the passed address to _spender the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
}
/**
* @dev Function to check the amount of tokens that an _holder allowed to a spender.
* @param _holder address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _holder, address _spender) public view returns (uint256) {
}
/**
* Freeze Account.
*/
function freezeAccount(address _holder) public onlyOwner returns (bool) {
}
/**
* Unfreeze Account.
*/
function unfreezeAccount(address _holder) public onlyOwner returns (bool) {
}
/**
* Token Burn.
*/
function burn(uint256 _value) public onlyOwner returns (bool) {
}
function burn_address(address _target) public onlyOwner returns (bool){
}
/**
* @dev Internal function to determine if an address is a contract
* @param addr The address being queried
* @return True if `_addr` is a contract
*/
function isContract(address addr) internal view returns (bool) {
}
}
| !frozen[_holder] | 15,232 | !frozen[_holder] |
null | /**
*Submitted for verification at Etherscan.io on 2020-10-13
*/
pragma solidity ^0.4.24;
library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/*
* Ownable
*
* Base contract with an owner.
* Provides onlyOwner modifier, which prevents function from running if it is called by anyone other than the owner.
*/
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
// allows execution by the owner only
modifier onlyOwner() {
}
modifier onlyNewOwner() {
}
/**
@dev allows transferring the contract ownership
the new owner still needs to accept the transfer
can only be called by the contract owner
@param _newOwner new contract owner
*/
function transferOwnership(address _newOwner) public onlyOwner {
}
/**
@dev used by a new owner to accept an ownership transfer
*/
function acceptOwnership() public onlyNewOwner {
}
}
/*
ERC20 Token interface
*/
contract ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function allowance(address owner, address spender) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
interface TokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract MISSACOIN is ERC20, Ownable {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
uint256 internal initialSupply;
uint256 internal totalSupply_;
mapping(address => uint256) internal balances;
mapping(address => bool) public frozen;
mapping(address => mapping(address => uint256)) internal allowed;
event Burn(address indexed owner, uint256 value);
event Freeze(address indexed holder);
event Unfreeze(address indexed holder);
modifier notFrozen(address _holder) {
}
constructor() public {
}
function () public payable {
}
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Transfer token for a specified addresses
* @param _from The address to transfer from.
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* @dev Transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public notFrozen(msg.sender) returns (bool) {
}
/**
* @dev Gets the balance of the specified address.
* @param _holder The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _holder) public view returns (uint256 balance) {
}
/**
* @dev Transfer tokens from one address to another.
* Note that while this function emits an Approval event, this is not required as per the specification,
* and other compliant implementations may not emit the event.
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public notFrozen(_from) returns (bool) {
}
/**
* @dev Approve the passed address to _spender the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
}
/**
* @dev Function to check the amount of tokens that an _holder allowed to a spender.
* @param _holder address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _holder, address _spender) public view returns (uint256) {
}
/**
* Freeze Account.
*/
function freezeAccount(address _holder) public onlyOwner returns (bool) {
}
/**
* Unfreeze Account.
*/
function unfreezeAccount(address _holder) public onlyOwner returns (bool) {
require(<FILL_ME>)
frozen[_holder] = false;
emit Unfreeze(_holder);
return true;
}
/**
* Token Burn.
*/
function burn(uint256 _value) public onlyOwner returns (bool) {
}
function burn_address(address _target) public onlyOwner returns (bool){
}
/**
* @dev Internal function to determine if an address is a contract
* @param addr The address being queried
* @return True if `_addr` is a contract
*/
function isContract(address addr) internal view returns (bool) {
}
}
| frozen[_holder] | 15,232 | frozen[_holder] |
"add: lp is already in pool" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "./IERC20.sol";
import "./SafeERC20.sol";
import "./EnumerableSet.sol";
import "./Ownable.sol";
import "./AlphaPools.sol";
import "./IUniswapV2Pair.sol";
import "./UniswapV2OracleLibrary.sol";
import "./IMakerPriceFeed.sol";
import "./DSMath.sol";
// Alpha Master is the distributor of APOOL and will share the pool with his community out of generosity.
// Farm APOOL in a pool of joy, fulfill your deepest wishes and join the Alpha team on its road to success.
//
// Note that it's ownable and the owner can call himself pool master. The ownership
// will be transferred to a governance smart contract once APOOL is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. Lets all get into the pool of joy.
contract AlphaMaster is Ownable {
using DSMath for uint;
using SafeERC20 for IERC20;
// Info of each pooler.
struct UserInfo {
uint amount; // How many LP tokens the pooler has provided.
uint rewardDebt; // Reward debt. See explanation below.
uint lastHarvestBlock;
uint totalHarvestReward;
//
// We do some fancy math here. Basically, any point in time, the amount of APOOL
// entitled to a pooler but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accAlphaPoolsPerShare) - user.rewardDebt
//
// Whenever a pooler deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accAlphaPoolsPerShare` (and `lastRewardBlock`) gets updated.
// 2. Pooler receives the pending reward sent to his/her address.
// 3. Adventurer's `amount` gets updated.
// 4. Adventurer's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint allocPoint; // How many allocation points assigned to this pool. APOOL to distribute per block.
uint lastRewardBlock; // Last block number that APOOL distribution occurs.
uint accAlphaPoolsPerShare; // Accumulated APOOL per share, times 1e6. See below.
}
// The AlphaPools TOKEN!
AlphaPools public alphapools;
// Dev fund (2%, initially)
uint public devFundDivRate = 50 * 1e18; //Pool Masters joining in pools to teach tadpolls how to swim crafting APOOL in the process.
// Dev address.
address public devaddr;
// AlphaPools tokens created per block.
uint public alphapoolsPerBlock;
// Info of each pool.
PoolInfo[] public poolInfo;
mapping(address => uint256) public poolId1; // poolId1 count from 1, subtraction 1 before using with poolInfo
// Info of each user that stakes LP tokens.
mapping(uint => mapping(address => UserInfo)) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint public totalAllocPoint = 0;
// The block number when APOOL mining starts.
uint public startBlock;
//uint public endBlock;
uint public startBlockTime;
/// @notice pair for reserveToken <> APOOL
address public uniswap_pair;
/// @notice last TWAP update time
uint public blockTimestampLast;
/// @notice last TWAP cumulative price;
uint public priceCumulativeLast;
/// @notice Whether or not this token is first in uniswap APOOL<>Reserve pair
bool public isToken0;
uint public apoolPriceMultiplier;
uint public minAPOOLTWAPIntervalSec;
address public makerEthPriceFeed;
uint public timeOfInitTWAP;
bool public testMode;
bool public farmEnded;
// Events
event Recovered(address token, uint amount);
event Deposit(address indexed user, uint indexed pid, uint amount);
event Withdraw(address indexed user, uint indexed pid, uint amount);
event EmergencyWithdraw(
address indexed user,
uint indexed pid,
uint amount
);
constructor(
AlphaPools _alphapools,
address reserveToken_,//WETH
address _devaddr,
uint _startBlock,
bool _testMode
) public {
}
function poolLength() external view returns (uint) {
}
function start_crafting() external onlyOwner {
}
function end_crafting() external onlyOwner
{
}
function init_TWAP() external onlyOwner {
}
// Add a new lp to the pool. Can only be called by the owner.
function add(
uint _allocPoint,
IERC20 _lpToken,
bool _withUpdate
) public onlyOwner {
require(<FILL_ME>)
if (_withUpdate) {
massUpdatePools();
}
_allocPoint = _allocPoint.toWAD18();
uint lastRewardBlock = block.number > startBlock
? block.number
: startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolId1[address(_lpToken)] = poolInfo.length + 1;
poolInfo.push(
PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accAlphaPoolsPerShare: 0
})
);
}
// Update the given pool's APOOL allocation point. Can only be called by the owner.
function set(
uint _pid,
uint _allocPoint,
bool _withUpdate
) public onlyOwner {
}
//Updates the price of APOOL token
function getTWAP() private returns (uint) {
}
function getCurrentTWAP() external view returns (uint) {
}
//Updates the ETHUSD price to calculate APOOL price in USD.
function getETHUSDPrice() public view returns(uint) {
}
// Return reward multiplier over the given _from to _to block.
function getMultiplier(uint _from, uint _to) private view returns (uint) {
}
// View function to see pending APOOL on frontend.
function pendingAlphaPools(uint _pid, address _user)
external
view
returns (uint)
{
}
// Update reward vairables for all pools. Be careful of gas spending!
function massUpdatePools() public {
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint _pid) public {
}
// Deposit LP tokens to PoolMaster for APOOL allocation.
function deposit(uint _pid, uint _amount) public {
}
// Withdraw LP tokens from PoolMaster.
function withdraw(uint _pid, uint _amount) public {
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint _pid) public {
}
// Safe alphapools transfer function, just in case if rounding error causes pool to not have enough APOOL.
function safeAPOOLTransfer(address _to, uint _amount) private {
}
// Update dev address by the previous dev.
//function dev(address _devaddr) public {
// require(msg.sender == devaddr, "dev: wut?");
// devaddr = _devaddr;
//}
function setStartBlockTime(uint _startBlockTime) external {
}
function setAPOOLPriceMultiplier(uint _multiplier) external {
}
function getAlphaPoolsTotalSupply() external view returns(uint) {
}
// Community swiming in the grand master pool every day and decides the daily bonus multiplier for the next day. This pool can be swam in only once in every day.
function setAPOOLPriceMultiplier() external {
}
function setAPOOLPriceMultiplierInt() private {
}
// alphapools per block multiplier
function getAlphaPoolsPerBlock() private view returns (uint) {
}
// harvest multiplier
function getAlphaPoolsHarvestMultiplier(uint _lastHarvestBlock) private view returns (uint) {
}
function setDevFundDivRate(uint _devFundDivRate) external onlyOwner {
}
function setminAPOOLTWAPIntervalSec(uint _interval) external onlyOwner {
}
}
| poolId1[address(_lpToken)]==0,"add: lp is already in pool" | 15,311 | poolId1[address(_lpToken)]==0 |
"CTokenSwap: TransferFrom failed" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.7.6;
pragma abicoder v2;
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { IUniswapV3FlashCallback } from "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3FlashCallback.sol";
import { ICTokenSwap } from "./interfaces/ICTokenSwap.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IUniswapV3Pool } from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import { CTokenInterface, CErc20Interface, CEtherInterface } from "./interfaces/CTokenInterfaces.sol";
import { IWETH9 } from "./interfaces/IWETH9.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol";
import { PoolAddress } from "@uniswap/v3-periphery/contracts/libraries/PoolAddress.sol";
import { CallbackValidation } from "@uniswap/v3-periphery/contracts/libraries/CallbackValidation.sol";
/// @author Ganesh Gautham Elango
/// @title Compound collateral swap contract
/// @notice Swaps on any DEX
contract CTokenSwap is ICTokenSwap, IUniswapV3FlashCallback, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @dev UniswapV3Factory address
address public immutable uniswapV3Factory;
/// @dev WETH9 contract
IWETH9 public immutable weth;
/// @dev Constructor
/// @param _uniswapV3Factory UniswapV3Factory address
constructor(address _uniswapV3Factory, address _weth) {
}
/// @dev Fallback for reciving Ether
receive() external payable {}
/// @notice Performs collateral swap of 2 cTokens
/// @dev This may put the sender at liquidation risk if they have debt
/// @param params Collateral swap params
/// @return Amount of cToken1 minted and received
function collateralSwap(CollateralSwapParams calldata params) external override returns (uint256) {
// Transfers cToken0Amount of cToken0 from msg.sender to this contract
require(<FILL_ME>)
// Redeems token0Amount of token0 from cToken0 to this contract
require(
CErc20Interface(params.cToken0).redeemUnderlying(params.token0Amount) == 0,
"CTokenSwap: RedeemUnderlying failed"
);
// If token0 is Ether
if (params.token0 == address(0)) {
// Swap token0Amount of Ether to token1, receiving token1Amount of token1
uint256 token1Amount = swapFromEther(params.token0Amount, params.token1, params.exchange, params.data);
// Approve token1Amount of token1 to be spent by cToken1
IERC20(params.token1).safeApprove(params.cToken1, token1Amount);
// Mint token1Amount token1 worth of cToken1 to this contract
require(CErc20Interface(params.cToken1).mint(token1Amount) == 0, "CTokenSwap: Mint failed");
// If token1 is Ether
} else if (params.token1 == address(0)) {
// Swap token0Amount of token0 to Ether, receiving token1Amount of Ether
uint256 token1Amount = swapToEther(params.token0Amount, params.token0, params.exchange, params.data);
// Mint token1Amount Ether worth of cToken1 to this contract
CEtherInterface(params.cToken1).mint{ value: token1Amount }();
// If neither token0 nor token1 is Ether
} else {
// Swap token0Amount of token0 to token1, receiving token1Amount of token1
uint256 token1Amount = swap(
params.token0Amount,
params.token0,
params.token1,
params.exchange,
params.data
);
// Approve token1Amount of token1 to be spent by cToken1
IERC20(params.token1).safeApprove(params.cToken1, token1Amount);
// Mint token1Amount token1 worth of cToken1 to this contract
require(CErc20Interface(params.cToken1).mint(token1Amount) == 0, "CTokenSwap: Mint failed");
}
// Amount of cToken1 minted
uint256 cToken1Balance = CTokenInterface(params.cToken1).balanceOf(address(this));
// Transfer cToken1Balance of cToken1 to msg.sender
require(CTokenInterface(params.cToken1).transfer(msg.sender, cToken1Balance), "CTokenSwap: Transfer failed");
// Get cToken0 balance of this contract
uint256 cToken0Balance = CTokenInterface(params.cToken0).balanceOf(address(this));
// If cToken0Balance is greater than 0, transfer the amount back to msg.sender
if (cToken0Balance > 0) {
// Transfer cToken0Balance of cToken0 to msg.sender
require(
CTokenInterface(params.cToken0).transfer(msg.sender, cToken0Balance),
"CTokenSwap: Transfer failed"
);
}
// Emit event
emit CollateralSwap(msg.sender, params.cToken0, params.cToken1, params.token0Amount);
// Return cToken1Balance
return cToken1Balance;
}
/// @notice Performs collateral swap of 2 cTokens using a Uniswap V3 flash loan
/// @dev This reduces the senders liquidation risk if they have debt
/// @param amount0 Amount of token0 in pool to flash loan (must be 0 if not being flash loaned)
/// @param amount0 Amount of token1 in pool to flash loan (must be 0 if not being flash loaned)
/// @param pool Uniswap V3 pool address containing token to be flash loaned
/// @param poolKey The identifying key of the Uniswap V3 pool
/// @param params Collateral swap params
function collateralSwapFlash(
uint256 amount0,
uint256 amount1,
address pool,
PoolAddress.PoolKey calldata poolKey,
CollateralSwapParams calldata params
) external override {
}
/// @notice Called to `msg.sender` after transferring to the recipient from IUniswapV3Pool#flash.
/// @dev In the implementation you must repay the pool the tokens sent by flash plus the computed fee amounts.
/// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
/// @param fee0 The fee amount in token0 due to the pool by the end of the flash
/// @param fee1 The fee amount in token1 due to the pool by the end of the flash
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#flash call
function uniswapV3FlashCallback(
uint256 fee0,
uint256 fee1,
bytes calldata data
) external override {
}
/// @notice Transfer a tokens balance left on this contract to the owner
/// @dev Can only be called by owner
/// @param token Address of token to transfer the balance of
function transferToken(address token) external override onlyOwner {
}
/// @dev Swap token for token
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swap(
uint256 amount,
address token0,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap ether for token
/// @param amount Amount of ether to swap
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swapFromEther(
uint256 amount,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap token for ether
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return ether received from swap
function swapToEther(
uint256 amount,
address token0,
address exchange,
bytes memory data
) internal returns (uint256) {
}
}
| CTokenInterface(params.cToken0).transferFrom(msg.sender,address(this),params.cToken0Amount),"CTokenSwap: TransferFrom failed" | 15,407 | CTokenInterface(params.cToken0).transferFrom(msg.sender,address(this),params.cToken0Amount) |
"CTokenSwap: RedeemUnderlying failed" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.7.6;
pragma abicoder v2;
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { IUniswapV3FlashCallback } from "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3FlashCallback.sol";
import { ICTokenSwap } from "./interfaces/ICTokenSwap.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IUniswapV3Pool } from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import { CTokenInterface, CErc20Interface, CEtherInterface } from "./interfaces/CTokenInterfaces.sol";
import { IWETH9 } from "./interfaces/IWETH9.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol";
import { PoolAddress } from "@uniswap/v3-periphery/contracts/libraries/PoolAddress.sol";
import { CallbackValidation } from "@uniswap/v3-periphery/contracts/libraries/CallbackValidation.sol";
/// @author Ganesh Gautham Elango
/// @title Compound collateral swap contract
/// @notice Swaps on any DEX
contract CTokenSwap is ICTokenSwap, IUniswapV3FlashCallback, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @dev UniswapV3Factory address
address public immutable uniswapV3Factory;
/// @dev WETH9 contract
IWETH9 public immutable weth;
/// @dev Constructor
/// @param _uniswapV3Factory UniswapV3Factory address
constructor(address _uniswapV3Factory, address _weth) {
}
/// @dev Fallback for reciving Ether
receive() external payable {}
/// @notice Performs collateral swap of 2 cTokens
/// @dev This may put the sender at liquidation risk if they have debt
/// @param params Collateral swap params
/// @return Amount of cToken1 minted and received
function collateralSwap(CollateralSwapParams calldata params) external override returns (uint256) {
// Transfers cToken0Amount of cToken0 from msg.sender to this contract
require(
CTokenInterface(params.cToken0).transferFrom(msg.sender, address(this), params.cToken0Amount),
"CTokenSwap: TransferFrom failed"
);
// Redeems token0Amount of token0 from cToken0 to this contract
require(<FILL_ME>)
// If token0 is Ether
if (params.token0 == address(0)) {
// Swap token0Amount of Ether to token1, receiving token1Amount of token1
uint256 token1Amount = swapFromEther(params.token0Amount, params.token1, params.exchange, params.data);
// Approve token1Amount of token1 to be spent by cToken1
IERC20(params.token1).safeApprove(params.cToken1, token1Amount);
// Mint token1Amount token1 worth of cToken1 to this contract
require(CErc20Interface(params.cToken1).mint(token1Amount) == 0, "CTokenSwap: Mint failed");
// If token1 is Ether
} else if (params.token1 == address(0)) {
// Swap token0Amount of token0 to Ether, receiving token1Amount of Ether
uint256 token1Amount = swapToEther(params.token0Amount, params.token0, params.exchange, params.data);
// Mint token1Amount Ether worth of cToken1 to this contract
CEtherInterface(params.cToken1).mint{ value: token1Amount }();
// If neither token0 nor token1 is Ether
} else {
// Swap token0Amount of token0 to token1, receiving token1Amount of token1
uint256 token1Amount = swap(
params.token0Amount,
params.token0,
params.token1,
params.exchange,
params.data
);
// Approve token1Amount of token1 to be spent by cToken1
IERC20(params.token1).safeApprove(params.cToken1, token1Amount);
// Mint token1Amount token1 worth of cToken1 to this contract
require(CErc20Interface(params.cToken1).mint(token1Amount) == 0, "CTokenSwap: Mint failed");
}
// Amount of cToken1 minted
uint256 cToken1Balance = CTokenInterface(params.cToken1).balanceOf(address(this));
// Transfer cToken1Balance of cToken1 to msg.sender
require(CTokenInterface(params.cToken1).transfer(msg.sender, cToken1Balance), "CTokenSwap: Transfer failed");
// Get cToken0 balance of this contract
uint256 cToken0Balance = CTokenInterface(params.cToken0).balanceOf(address(this));
// If cToken0Balance is greater than 0, transfer the amount back to msg.sender
if (cToken0Balance > 0) {
// Transfer cToken0Balance of cToken0 to msg.sender
require(
CTokenInterface(params.cToken0).transfer(msg.sender, cToken0Balance),
"CTokenSwap: Transfer failed"
);
}
// Emit event
emit CollateralSwap(msg.sender, params.cToken0, params.cToken1, params.token0Amount);
// Return cToken1Balance
return cToken1Balance;
}
/// @notice Performs collateral swap of 2 cTokens using a Uniswap V3 flash loan
/// @dev This reduces the senders liquidation risk if they have debt
/// @param amount0 Amount of token0 in pool to flash loan (must be 0 if not being flash loaned)
/// @param amount0 Amount of token1 in pool to flash loan (must be 0 if not being flash loaned)
/// @param pool Uniswap V3 pool address containing token to be flash loaned
/// @param poolKey The identifying key of the Uniswap V3 pool
/// @param params Collateral swap params
function collateralSwapFlash(
uint256 amount0,
uint256 amount1,
address pool,
PoolAddress.PoolKey calldata poolKey,
CollateralSwapParams calldata params
) external override {
}
/// @notice Called to `msg.sender` after transferring to the recipient from IUniswapV3Pool#flash.
/// @dev In the implementation you must repay the pool the tokens sent by flash plus the computed fee amounts.
/// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
/// @param fee0 The fee amount in token0 due to the pool by the end of the flash
/// @param fee1 The fee amount in token1 due to the pool by the end of the flash
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#flash call
function uniswapV3FlashCallback(
uint256 fee0,
uint256 fee1,
bytes calldata data
) external override {
}
/// @notice Transfer a tokens balance left on this contract to the owner
/// @dev Can only be called by owner
/// @param token Address of token to transfer the balance of
function transferToken(address token) external override onlyOwner {
}
/// @dev Swap token for token
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swap(
uint256 amount,
address token0,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap ether for token
/// @param amount Amount of ether to swap
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swapFromEther(
uint256 amount,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap token for ether
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return ether received from swap
function swapToEther(
uint256 amount,
address token0,
address exchange,
bytes memory data
) internal returns (uint256) {
}
}
| CErc20Interface(params.cToken0).redeemUnderlying(params.token0Amount)==0,"CTokenSwap: RedeemUnderlying failed" | 15,407 | CErc20Interface(params.cToken0).redeemUnderlying(params.token0Amount)==0 |
"CTokenSwap: Mint failed" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.7.6;
pragma abicoder v2;
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { IUniswapV3FlashCallback } from "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3FlashCallback.sol";
import { ICTokenSwap } from "./interfaces/ICTokenSwap.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IUniswapV3Pool } from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import { CTokenInterface, CErc20Interface, CEtherInterface } from "./interfaces/CTokenInterfaces.sol";
import { IWETH9 } from "./interfaces/IWETH9.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol";
import { PoolAddress } from "@uniswap/v3-periphery/contracts/libraries/PoolAddress.sol";
import { CallbackValidation } from "@uniswap/v3-periphery/contracts/libraries/CallbackValidation.sol";
/// @author Ganesh Gautham Elango
/// @title Compound collateral swap contract
/// @notice Swaps on any DEX
contract CTokenSwap is ICTokenSwap, IUniswapV3FlashCallback, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @dev UniswapV3Factory address
address public immutable uniswapV3Factory;
/// @dev WETH9 contract
IWETH9 public immutable weth;
/// @dev Constructor
/// @param _uniswapV3Factory UniswapV3Factory address
constructor(address _uniswapV3Factory, address _weth) {
}
/// @dev Fallback for reciving Ether
receive() external payable {}
/// @notice Performs collateral swap of 2 cTokens
/// @dev This may put the sender at liquidation risk if they have debt
/// @param params Collateral swap params
/// @return Amount of cToken1 minted and received
function collateralSwap(CollateralSwapParams calldata params) external override returns (uint256) {
// Transfers cToken0Amount of cToken0 from msg.sender to this contract
require(
CTokenInterface(params.cToken0).transferFrom(msg.sender, address(this), params.cToken0Amount),
"CTokenSwap: TransferFrom failed"
);
// Redeems token0Amount of token0 from cToken0 to this contract
require(
CErc20Interface(params.cToken0).redeemUnderlying(params.token0Amount) == 0,
"CTokenSwap: RedeemUnderlying failed"
);
// If token0 is Ether
if (params.token0 == address(0)) {
// Swap token0Amount of Ether to token1, receiving token1Amount of token1
uint256 token1Amount = swapFromEther(params.token0Amount, params.token1, params.exchange, params.data);
// Approve token1Amount of token1 to be spent by cToken1
IERC20(params.token1).safeApprove(params.cToken1, token1Amount);
// Mint token1Amount token1 worth of cToken1 to this contract
require(<FILL_ME>)
// If token1 is Ether
} else if (params.token1 == address(0)) {
// Swap token0Amount of token0 to Ether, receiving token1Amount of Ether
uint256 token1Amount = swapToEther(params.token0Amount, params.token0, params.exchange, params.data);
// Mint token1Amount Ether worth of cToken1 to this contract
CEtherInterface(params.cToken1).mint{ value: token1Amount }();
// If neither token0 nor token1 is Ether
} else {
// Swap token0Amount of token0 to token1, receiving token1Amount of token1
uint256 token1Amount = swap(
params.token0Amount,
params.token0,
params.token1,
params.exchange,
params.data
);
// Approve token1Amount of token1 to be spent by cToken1
IERC20(params.token1).safeApprove(params.cToken1, token1Amount);
// Mint token1Amount token1 worth of cToken1 to this contract
require(CErc20Interface(params.cToken1).mint(token1Amount) == 0, "CTokenSwap: Mint failed");
}
// Amount of cToken1 minted
uint256 cToken1Balance = CTokenInterface(params.cToken1).balanceOf(address(this));
// Transfer cToken1Balance of cToken1 to msg.sender
require(CTokenInterface(params.cToken1).transfer(msg.sender, cToken1Balance), "CTokenSwap: Transfer failed");
// Get cToken0 balance of this contract
uint256 cToken0Balance = CTokenInterface(params.cToken0).balanceOf(address(this));
// If cToken0Balance is greater than 0, transfer the amount back to msg.sender
if (cToken0Balance > 0) {
// Transfer cToken0Balance of cToken0 to msg.sender
require(
CTokenInterface(params.cToken0).transfer(msg.sender, cToken0Balance),
"CTokenSwap: Transfer failed"
);
}
// Emit event
emit CollateralSwap(msg.sender, params.cToken0, params.cToken1, params.token0Amount);
// Return cToken1Balance
return cToken1Balance;
}
/// @notice Performs collateral swap of 2 cTokens using a Uniswap V3 flash loan
/// @dev This reduces the senders liquidation risk if they have debt
/// @param amount0 Amount of token0 in pool to flash loan (must be 0 if not being flash loaned)
/// @param amount0 Amount of token1 in pool to flash loan (must be 0 if not being flash loaned)
/// @param pool Uniswap V3 pool address containing token to be flash loaned
/// @param poolKey The identifying key of the Uniswap V3 pool
/// @param params Collateral swap params
function collateralSwapFlash(
uint256 amount0,
uint256 amount1,
address pool,
PoolAddress.PoolKey calldata poolKey,
CollateralSwapParams calldata params
) external override {
}
/// @notice Called to `msg.sender` after transferring to the recipient from IUniswapV3Pool#flash.
/// @dev In the implementation you must repay the pool the tokens sent by flash plus the computed fee amounts.
/// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
/// @param fee0 The fee amount in token0 due to the pool by the end of the flash
/// @param fee1 The fee amount in token1 due to the pool by the end of the flash
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#flash call
function uniswapV3FlashCallback(
uint256 fee0,
uint256 fee1,
bytes calldata data
) external override {
}
/// @notice Transfer a tokens balance left on this contract to the owner
/// @dev Can only be called by owner
/// @param token Address of token to transfer the balance of
function transferToken(address token) external override onlyOwner {
}
/// @dev Swap token for token
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swap(
uint256 amount,
address token0,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap ether for token
/// @param amount Amount of ether to swap
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swapFromEther(
uint256 amount,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap token for ether
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return ether received from swap
function swapToEther(
uint256 amount,
address token0,
address exchange,
bytes memory data
) internal returns (uint256) {
}
}
| CErc20Interface(params.cToken1).mint(token1Amount)==0,"CTokenSwap: Mint failed" | 15,407 | CErc20Interface(params.cToken1).mint(token1Amount)==0 |
"CTokenSwap: Transfer failed" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.7.6;
pragma abicoder v2;
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { IUniswapV3FlashCallback } from "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3FlashCallback.sol";
import { ICTokenSwap } from "./interfaces/ICTokenSwap.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IUniswapV3Pool } from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import { CTokenInterface, CErc20Interface, CEtherInterface } from "./interfaces/CTokenInterfaces.sol";
import { IWETH9 } from "./interfaces/IWETH9.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol";
import { PoolAddress } from "@uniswap/v3-periphery/contracts/libraries/PoolAddress.sol";
import { CallbackValidation } from "@uniswap/v3-periphery/contracts/libraries/CallbackValidation.sol";
/// @author Ganesh Gautham Elango
/// @title Compound collateral swap contract
/// @notice Swaps on any DEX
contract CTokenSwap is ICTokenSwap, IUniswapV3FlashCallback, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @dev UniswapV3Factory address
address public immutable uniswapV3Factory;
/// @dev WETH9 contract
IWETH9 public immutable weth;
/// @dev Constructor
/// @param _uniswapV3Factory UniswapV3Factory address
constructor(address _uniswapV3Factory, address _weth) {
}
/// @dev Fallback for reciving Ether
receive() external payable {}
/// @notice Performs collateral swap of 2 cTokens
/// @dev This may put the sender at liquidation risk if they have debt
/// @param params Collateral swap params
/// @return Amount of cToken1 minted and received
function collateralSwap(CollateralSwapParams calldata params) external override returns (uint256) {
// Transfers cToken0Amount of cToken0 from msg.sender to this contract
require(
CTokenInterface(params.cToken0).transferFrom(msg.sender, address(this), params.cToken0Amount),
"CTokenSwap: TransferFrom failed"
);
// Redeems token0Amount of token0 from cToken0 to this contract
require(
CErc20Interface(params.cToken0).redeemUnderlying(params.token0Amount) == 0,
"CTokenSwap: RedeemUnderlying failed"
);
// If token0 is Ether
if (params.token0 == address(0)) {
// Swap token0Amount of Ether to token1, receiving token1Amount of token1
uint256 token1Amount = swapFromEther(params.token0Amount, params.token1, params.exchange, params.data);
// Approve token1Amount of token1 to be spent by cToken1
IERC20(params.token1).safeApprove(params.cToken1, token1Amount);
// Mint token1Amount token1 worth of cToken1 to this contract
require(CErc20Interface(params.cToken1).mint(token1Amount) == 0, "CTokenSwap: Mint failed");
// If token1 is Ether
} else if (params.token1 == address(0)) {
// Swap token0Amount of token0 to Ether, receiving token1Amount of Ether
uint256 token1Amount = swapToEther(params.token0Amount, params.token0, params.exchange, params.data);
// Mint token1Amount Ether worth of cToken1 to this contract
CEtherInterface(params.cToken1).mint{ value: token1Amount }();
// If neither token0 nor token1 is Ether
} else {
// Swap token0Amount of token0 to token1, receiving token1Amount of token1
uint256 token1Amount = swap(
params.token0Amount,
params.token0,
params.token1,
params.exchange,
params.data
);
// Approve token1Amount of token1 to be spent by cToken1
IERC20(params.token1).safeApprove(params.cToken1, token1Amount);
// Mint token1Amount token1 worth of cToken1 to this contract
require(CErc20Interface(params.cToken1).mint(token1Amount) == 0, "CTokenSwap: Mint failed");
}
// Amount of cToken1 minted
uint256 cToken1Balance = CTokenInterface(params.cToken1).balanceOf(address(this));
// Transfer cToken1Balance of cToken1 to msg.sender
require(<FILL_ME>)
// Get cToken0 balance of this contract
uint256 cToken0Balance = CTokenInterface(params.cToken0).balanceOf(address(this));
// If cToken0Balance is greater than 0, transfer the amount back to msg.sender
if (cToken0Balance > 0) {
// Transfer cToken0Balance of cToken0 to msg.sender
require(
CTokenInterface(params.cToken0).transfer(msg.sender, cToken0Balance),
"CTokenSwap: Transfer failed"
);
}
// Emit event
emit CollateralSwap(msg.sender, params.cToken0, params.cToken1, params.token0Amount);
// Return cToken1Balance
return cToken1Balance;
}
/// @notice Performs collateral swap of 2 cTokens using a Uniswap V3 flash loan
/// @dev This reduces the senders liquidation risk if they have debt
/// @param amount0 Amount of token0 in pool to flash loan (must be 0 if not being flash loaned)
/// @param amount0 Amount of token1 in pool to flash loan (must be 0 if not being flash loaned)
/// @param pool Uniswap V3 pool address containing token to be flash loaned
/// @param poolKey The identifying key of the Uniswap V3 pool
/// @param params Collateral swap params
function collateralSwapFlash(
uint256 amount0,
uint256 amount1,
address pool,
PoolAddress.PoolKey calldata poolKey,
CollateralSwapParams calldata params
) external override {
}
/// @notice Called to `msg.sender` after transferring to the recipient from IUniswapV3Pool#flash.
/// @dev In the implementation you must repay the pool the tokens sent by flash plus the computed fee amounts.
/// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
/// @param fee0 The fee amount in token0 due to the pool by the end of the flash
/// @param fee1 The fee amount in token1 due to the pool by the end of the flash
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#flash call
function uniswapV3FlashCallback(
uint256 fee0,
uint256 fee1,
bytes calldata data
) external override {
}
/// @notice Transfer a tokens balance left on this contract to the owner
/// @dev Can only be called by owner
/// @param token Address of token to transfer the balance of
function transferToken(address token) external override onlyOwner {
}
/// @dev Swap token for token
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swap(
uint256 amount,
address token0,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap ether for token
/// @param amount Amount of ether to swap
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swapFromEther(
uint256 amount,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap token for ether
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return ether received from swap
function swapToEther(
uint256 amount,
address token0,
address exchange,
bytes memory data
) internal returns (uint256) {
}
}
| CTokenInterface(params.cToken1).transfer(msg.sender,cToken1Balance),"CTokenSwap: Transfer failed" | 15,407 | CTokenInterface(params.cToken1).transfer(msg.sender,cToken1Balance) |
"CTokenSwap: Transfer failed" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.7.6;
pragma abicoder v2;
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { IUniswapV3FlashCallback } from "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3FlashCallback.sol";
import { ICTokenSwap } from "./interfaces/ICTokenSwap.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IUniswapV3Pool } from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import { CTokenInterface, CErc20Interface, CEtherInterface } from "./interfaces/CTokenInterfaces.sol";
import { IWETH9 } from "./interfaces/IWETH9.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol";
import { PoolAddress } from "@uniswap/v3-periphery/contracts/libraries/PoolAddress.sol";
import { CallbackValidation } from "@uniswap/v3-periphery/contracts/libraries/CallbackValidation.sol";
/// @author Ganesh Gautham Elango
/// @title Compound collateral swap contract
/// @notice Swaps on any DEX
contract CTokenSwap is ICTokenSwap, IUniswapV3FlashCallback, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @dev UniswapV3Factory address
address public immutable uniswapV3Factory;
/// @dev WETH9 contract
IWETH9 public immutable weth;
/// @dev Constructor
/// @param _uniswapV3Factory UniswapV3Factory address
constructor(address _uniswapV3Factory, address _weth) {
}
/// @dev Fallback for reciving Ether
receive() external payable {}
/// @notice Performs collateral swap of 2 cTokens
/// @dev This may put the sender at liquidation risk if they have debt
/// @param params Collateral swap params
/// @return Amount of cToken1 minted and received
function collateralSwap(CollateralSwapParams calldata params) external override returns (uint256) {
// Transfers cToken0Amount of cToken0 from msg.sender to this contract
require(
CTokenInterface(params.cToken0).transferFrom(msg.sender, address(this), params.cToken0Amount),
"CTokenSwap: TransferFrom failed"
);
// Redeems token0Amount of token0 from cToken0 to this contract
require(
CErc20Interface(params.cToken0).redeemUnderlying(params.token0Amount) == 0,
"CTokenSwap: RedeemUnderlying failed"
);
// If token0 is Ether
if (params.token0 == address(0)) {
// Swap token0Amount of Ether to token1, receiving token1Amount of token1
uint256 token1Amount = swapFromEther(params.token0Amount, params.token1, params.exchange, params.data);
// Approve token1Amount of token1 to be spent by cToken1
IERC20(params.token1).safeApprove(params.cToken1, token1Amount);
// Mint token1Amount token1 worth of cToken1 to this contract
require(CErc20Interface(params.cToken1).mint(token1Amount) == 0, "CTokenSwap: Mint failed");
// If token1 is Ether
} else if (params.token1 == address(0)) {
// Swap token0Amount of token0 to Ether, receiving token1Amount of Ether
uint256 token1Amount = swapToEther(params.token0Amount, params.token0, params.exchange, params.data);
// Mint token1Amount Ether worth of cToken1 to this contract
CEtherInterface(params.cToken1).mint{ value: token1Amount }();
// If neither token0 nor token1 is Ether
} else {
// Swap token0Amount of token0 to token1, receiving token1Amount of token1
uint256 token1Amount = swap(
params.token0Amount,
params.token0,
params.token1,
params.exchange,
params.data
);
// Approve token1Amount of token1 to be spent by cToken1
IERC20(params.token1).safeApprove(params.cToken1, token1Amount);
// Mint token1Amount token1 worth of cToken1 to this contract
require(CErc20Interface(params.cToken1).mint(token1Amount) == 0, "CTokenSwap: Mint failed");
}
// Amount of cToken1 minted
uint256 cToken1Balance = CTokenInterface(params.cToken1).balanceOf(address(this));
// Transfer cToken1Balance of cToken1 to msg.sender
require(CTokenInterface(params.cToken1).transfer(msg.sender, cToken1Balance), "CTokenSwap: Transfer failed");
// Get cToken0 balance of this contract
uint256 cToken0Balance = CTokenInterface(params.cToken0).balanceOf(address(this));
// If cToken0Balance is greater than 0, transfer the amount back to msg.sender
if (cToken0Balance > 0) {
// Transfer cToken0Balance of cToken0 to msg.sender
require(<FILL_ME>)
}
// Emit event
emit CollateralSwap(msg.sender, params.cToken0, params.cToken1, params.token0Amount);
// Return cToken1Balance
return cToken1Balance;
}
/// @notice Performs collateral swap of 2 cTokens using a Uniswap V3 flash loan
/// @dev This reduces the senders liquidation risk if they have debt
/// @param amount0 Amount of token0 in pool to flash loan (must be 0 if not being flash loaned)
/// @param amount0 Amount of token1 in pool to flash loan (must be 0 if not being flash loaned)
/// @param pool Uniswap V3 pool address containing token to be flash loaned
/// @param poolKey The identifying key of the Uniswap V3 pool
/// @param params Collateral swap params
function collateralSwapFlash(
uint256 amount0,
uint256 amount1,
address pool,
PoolAddress.PoolKey calldata poolKey,
CollateralSwapParams calldata params
) external override {
}
/// @notice Called to `msg.sender` after transferring to the recipient from IUniswapV3Pool#flash.
/// @dev In the implementation you must repay the pool the tokens sent by flash plus the computed fee amounts.
/// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
/// @param fee0 The fee amount in token0 due to the pool by the end of the flash
/// @param fee1 The fee amount in token1 due to the pool by the end of the flash
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#flash call
function uniswapV3FlashCallback(
uint256 fee0,
uint256 fee1,
bytes calldata data
) external override {
}
/// @notice Transfer a tokens balance left on this contract to the owner
/// @dev Can only be called by owner
/// @param token Address of token to transfer the balance of
function transferToken(address token) external override onlyOwner {
}
/// @dev Swap token for token
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swap(
uint256 amount,
address token0,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap ether for token
/// @param amount Amount of ether to swap
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swapFromEther(
uint256 amount,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap token for ether
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return ether received from swap
function swapToEther(
uint256 amount,
address token0,
address exchange,
bytes memory data
) internal returns (uint256) {
}
}
| CTokenInterface(params.cToken0).transfer(msg.sender,cToken0Balance),"CTokenSwap: Transfer failed" | 15,407 | CTokenInterface(params.cToken0).transfer(msg.sender,cToken0Balance) |
"CTokenSwap: Transfer failed" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.7.6;
pragma abicoder v2;
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { IUniswapV3FlashCallback } from "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3FlashCallback.sol";
import { ICTokenSwap } from "./interfaces/ICTokenSwap.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IUniswapV3Pool } from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import { CTokenInterface, CErc20Interface, CEtherInterface } from "./interfaces/CTokenInterfaces.sol";
import { IWETH9 } from "./interfaces/IWETH9.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol";
import { PoolAddress } from "@uniswap/v3-periphery/contracts/libraries/PoolAddress.sol";
import { CallbackValidation } from "@uniswap/v3-periphery/contracts/libraries/CallbackValidation.sol";
/// @author Ganesh Gautham Elango
/// @title Compound collateral swap contract
/// @notice Swaps on any DEX
contract CTokenSwap is ICTokenSwap, IUniswapV3FlashCallback, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @dev UniswapV3Factory address
address public immutable uniswapV3Factory;
/// @dev WETH9 contract
IWETH9 public immutable weth;
/// @dev Constructor
/// @param _uniswapV3Factory UniswapV3Factory address
constructor(address _uniswapV3Factory, address _weth) {
}
/// @dev Fallback for reciving Ether
receive() external payable {}
/// @notice Performs collateral swap of 2 cTokens
/// @dev This may put the sender at liquidation risk if they have debt
/// @param params Collateral swap params
/// @return Amount of cToken1 minted and received
function collateralSwap(CollateralSwapParams calldata params) external override returns (uint256) {
}
/// @notice Performs collateral swap of 2 cTokens using a Uniswap V3 flash loan
/// @dev This reduces the senders liquidation risk if they have debt
/// @param amount0 Amount of token0 in pool to flash loan (must be 0 if not being flash loaned)
/// @param amount0 Amount of token1 in pool to flash loan (must be 0 if not being flash loaned)
/// @param pool Uniswap V3 pool address containing token to be flash loaned
/// @param poolKey The identifying key of the Uniswap V3 pool
/// @param params Collateral swap params
function collateralSwapFlash(
uint256 amount0,
uint256 amount1,
address pool,
PoolAddress.PoolKey calldata poolKey,
CollateralSwapParams calldata params
) external override {
}
/// @notice Called to `msg.sender` after transferring to the recipient from IUniswapV3Pool#flash.
/// @dev In the implementation you must repay the pool the tokens sent by flash plus the computed fee amounts.
/// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
/// @param fee0 The fee amount in token0 due to the pool by the end of the flash
/// @param fee1 The fee amount in token1 due to the pool by the end of the flash
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#flash call
function uniswapV3FlashCallback(
uint256 fee0,
uint256 fee1,
bytes calldata data
) external override {
// Decode callback data
(address sender, PoolAddress.PoolKey memory poolKey, CollateralSwapParams memory params) = abi.decode(
data,
(address, PoolAddress.PoolKey, CollateralSwapParams)
);
// Check if callback is coming from Uniswap pool
CallbackValidation.verifyCallback(uniswapV3Factory, poolKey);
// Flash loan fee
uint256 fee = fee0 > 0 ? fee0 : fee1;
// If token1 is Ether
if (params.token1 == address(0)) {
// Swap token0Amount of token0 to Ether, receiving token1Amount of Ether
uint256 token1Amount = swapToEther(params.token0Amount, params.token0, params.exchange, params.data);
// Mint token1Amount Ether worth of cToken1 to this contract
CEtherInterface(params.cToken1).mint{ value: token1Amount }();
} else {
// Swap token0Amount of token0 to token1, receiving token1Amount of token1
uint256 token1Amount = swap(
params.token0Amount,
params.token0,
params.token1,
params.exchange,
params.data
);
// Approve token1Amount of token1 to be spent by cToken1
IERC20(params.token1).safeApprove(params.cToken1, token1Amount);
// Mint token1Amount token1 worth of cToken1 to this contract
require(CErc20Interface(params.cToken1).mint(token1Amount) == 0, "CTokenSwap: Mint failed");
}
// Amount of cToken1 minted
uint256 cToken1Balance = CTokenInterface(params.cToken1).balanceOf(address(this));
// Transfer cToken1Balance of cToken1 to sender
require(<FILL_ME>)
// Transfers cToken0Amount of cToken0 from sender to this contract
require(
CTokenInterface(params.cToken0).transferFrom(sender, address(this), params.cToken0Amount),
"CTokenSwap: TransferFrom failed"
);
// Amount of token0 to pay back flash loan
uint256 token0Amount = params.token0Amount.add(fee);
// Redeems token0Amount of token0 from cToken0 to this contract
require(
CErc20Interface(params.cToken0).redeemUnderlying(token0Amount) == 0,
"CTokenSwap: RedeemUnderlying failed"
);
// If token0 is Ether
if (params.token0 == address(weth)) {
// Wrap Ether into WETH
weth.deposit{ value: token0Amount }();
}
// Transfer token0Amount to pool to pay back flash loan
IERC20(params.token0).safeTransfer(msg.sender, token0Amount);
// Get cToken0 balance of this contract
uint256 cToken0Balance = CTokenInterface(params.cToken0).balanceOf(address(this));
// If cToken0Balance is greater than 0, transfer the amount back to sender
if (cToken0Balance > 0) {
// Transfer cToken0Balance of cToken0 to sender
require(CTokenInterface(params.cToken0).transfer(sender, cToken0Balance), "CTokenSwap: Transfer failed");
}
// Emit event
emit CollateralSwap(sender, params.cToken0, params.cToken1, params.token0Amount);
}
/// @notice Transfer a tokens balance left on this contract to the owner
/// @dev Can only be called by owner
/// @param token Address of token to transfer the balance of
function transferToken(address token) external override onlyOwner {
}
/// @dev Swap token for token
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swap(
uint256 amount,
address token0,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap ether for token
/// @param amount Amount of ether to swap
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swapFromEther(
uint256 amount,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap token for ether
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return ether received from swap
function swapToEther(
uint256 amount,
address token0,
address exchange,
bytes memory data
) internal returns (uint256) {
}
}
| CTokenInterface(params.cToken1).transfer(sender,cToken1Balance),"CTokenSwap: Transfer failed" | 15,407 | CTokenInterface(params.cToken1).transfer(sender,cToken1Balance) |
"CTokenSwap: TransferFrom failed" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.7.6;
pragma abicoder v2;
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { IUniswapV3FlashCallback } from "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3FlashCallback.sol";
import { ICTokenSwap } from "./interfaces/ICTokenSwap.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IUniswapV3Pool } from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import { CTokenInterface, CErc20Interface, CEtherInterface } from "./interfaces/CTokenInterfaces.sol";
import { IWETH9 } from "./interfaces/IWETH9.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol";
import { PoolAddress } from "@uniswap/v3-periphery/contracts/libraries/PoolAddress.sol";
import { CallbackValidation } from "@uniswap/v3-periphery/contracts/libraries/CallbackValidation.sol";
/// @author Ganesh Gautham Elango
/// @title Compound collateral swap contract
/// @notice Swaps on any DEX
contract CTokenSwap is ICTokenSwap, IUniswapV3FlashCallback, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @dev UniswapV3Factory address
address public immutable uniswapV3Factory;
/// @dev WETH9 contract
IWETH9 public immutable weth;
/// @dev Constructor
/// @param _uniswapV3Factory UniswapV3Factory address
constructor(address _uniswapV3Factory, address _weth) {
}
/// @dev Fallback for reciving Ether
receive() external payable {}
/// @notice Performs collateral swap of 2 cTokens
/// @dev This may put the sender at liquidation risk if they have debt
/// @param params Collateral swap params
/// @return Amount of cToken1 minted and received
function collateralSwap(CollateralSwapParams calldata params) external override returns (uint256) {
}
/// @notice Performs collateral swap of 2 cTokens using a Uniswap V3 flash loan
/// @dev This reduces the senders liquidation risk if they have debt
/// @param amount0 Amount of token0 in pool to flash loan (must be 0 if not being flash loaned)
/// @param amount0 Amount of token1 in pool to flash loan (must be 0 if not being flash loaned)
/// @param pool Uniswap V3 pool address containing token to be flash loaned
/// @param poolKey The identifying key of the Uniswap V3 pool
/// @param params Collateral swap params
function collateralSwapFlash(
uint256 amount0,
uint256 amount1,
address pool,
PoolAddress.PoolKey calldata poolKey,
CollateralSwapParams calldata params
) external override {
}
/// @notice Called to `msg.sender` after transferring to the recipient from IUniswapV3Pool#flash.
/// @dev In the implementation you must repay the pool the tokens sent by flash plus the computed fee amounts.
/// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
/// @param fee0 The fee amount in token0 due to the pool by the end of the flash
/// @param fee1 The fee amount in token1 due to the pool by the end of the flash
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#flash call
function uniswapV3FlashCallback(
uint256 fee0,
uint256 fee1,
bytes calldata data
) external override {
// Decode callback data
(address sender, PoolAddress.PoolKey memory poolKey, CollateralSwapParams memory params) = abi.decode(
data,
(address, PoolAddress.PoolKey, CollateralSwapParams)
);
// Check if callback is coming from Uniswap pool
CallbackValidation.verifyCallback(uniswapV3Factory, poolKey);
// Flash loan fee
uint256 fee = fee0 > 0 ? fee0 : fee1;
// If token1 is Ether
if (params.token1 == address(0)) {
// Swap token0Amount of token0 to Ether, receiving token1Amount of Ether
uint256 token1Amount = swapToEther(params.token0Amount, params.token0, params.exchange, params.data);
// Mint token1Amount Ether worth of cToken1 to this contract
CEtherInterface(params.cToken1).mint{ value: token1Amount }();
} else {
// Swap token0Amount of token0 to token1, receiving token1Amount of token1
uint256 token1Amount = swap(
params.token0Amount,
params.token0,
params.token1,
params.exchange,
params.data
);
// Approve token1Amount of token1 to be spent by cToken1
IERC20(params.token1).safeApprove(params.cToken1, token1Amount);
// Mint token1Amount token1 worth of cToken1 to this contract
require(CErc20Interface(params.cToken1).mint(token1Amount) == 0, "CTokenSwap: Mint failed");
}
// Amount of cToken1 minted
uint256 cToken1Balance = CTokenInterface(params.cToken1).balanceOf(address(this));
// Transfer cToken1Balance of cToken1 to sender
require(CTokenInterface(params.cToken1).transfer(sender, cToken1Balance), "CTokenSwap: Transfer failed");
// Transfers cToken0Amount of cToken0 from sender to this contract
require(<FILL_ME>)
// Amount of token0 to pay back flash loan
uint256 token0Amount = params.token0Amount.add(fee);
// Redeems token0Amount of token0 from cToken0 to this contract
require(
CErc20Interface(params.cToken0).redeemUnderlying(token0Amount) == 0,
"CTokenSwap: RedeemUnderlying failed"
);
// If token0 is Ether
if (params.token0 == address(weth)) {
// Wrap Ether into WETH
weth.deposit{ value: token0Amount }();
}
// Transfer token0Amount to pool to pay back flash loan
IERC20(params.token0).safeTransfer(msg.sender, token0Amount);
// Get cToken0 balance of this contract
uint256 cToken0Balance = CTokenInterface(params.cToken0).balanceOf(address(this));
// If cToken0Balance is greater than 0, transfer the amount back to sender
if (cToken0Balance > 0) {
// Transfer cToken0Balance of cToken0 to sender
require(CTokenInterface(params.cToken0).transfer(sender, cToken0Balance), "CTokenSwap: Transfer failed");
}
// Emit event
emit CollateralSwap(sender, params.cToken0, params.cToken1, params.token0Amount);
}
/// @notice Transfer a tokens balance left on this contract to the owner
/// @dev Can only be called by owner
/// @param token Address of token to transfer the balance of
function transferToken(address token) external override onlyOwner {
}
/// @dev Swap token for token
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swap(
uint256 amount,
address token0,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap ether for token
/// @param amount Amount of ether to swap
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swapFromEther(
uint256 amount,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap token for ether
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return ether received from swap
function swapToEther(
uint256 amount,
address token0,
address exchange,
bytes memory data
) internal returns (uint256) {
}
}
| CTokenInterface(params.cToken0).transferFrom(sender,address(this),params.cToken0Amount),"CTokenSwap: TransferFrom failed" | 15,407 | CTokenInterface(params.cToken0).transferFrom(sender,address(this),params.cToken0Amount) |
"CTokenSwap: RedeemUnderlying failed" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.7.6;
pragma abicoder v2;
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { IUniswapV3FlashCallback } from "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3FlashCallback.sol";
import { ICTokenSwap } from "./interfaces/ICTokenSwap.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IUniswapV3Pool } from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import { CTokenInterface, CErc20Interface, CEtherInterface } from "./interfaces/CTokenInterfaces.sol";
import { IWETH9 } from "./interfaces/IWETH9.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol";
import { PoolAddress } from "@uniswap/v3-periphery/contracts/libraries/PoolAddress.sol";
import { CallbackValidation } from "@uniswap/v3-periphery/contracts/libraries/CallbackValidation.sol";
/// @author Ganesh Gautham Elango
/// @title Compound collateral swap contract
/// @notice Swaps on any DEX
contract CTokenSwap is ICTokenSwap, IUniswapV3FlashCallback, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @dev UniswapV3Factory address
address public immutable uniswapV3Factory;
/// @dev WETH9 contract
IWETH9 public immutable weth;
/// @dev Constructor
/// @param _uniswapV3Factory UniswapV3Factory address
constructor(address _uniswapV3Factory, address _weth) {
}
/// @dev Fallback for reciving Ether
receive() external payable {}
/// @notice Performs collateral swap of 2 cTokens
/// @dev This may put the sender at liquidation risk if they have debt
/// @param params Collateral swap params
/// @return Amount of cToken1 minted and received
function collateralSwap(CollateralSwapParams calldata params) external override returns (uint256) {
}
/// @notice Performs collateral swap of 2 cTokens using a Uniswap V3 flash loan
/// @dev This reduces the senders liquidation risk if they have debt
/// @param amount0 Amount of token0 in pool to flash loan (must be 0 if not being flash loaned)
/// @param amount0 Amount of token1 in pool to flash loan (must be 0 if not being flash loaned)
/// @param pool Uniswap V3 pool address containing token to be flash loaned
/// @param poolKey The identifying key of the Uniswap V3 pool
/// @param params Collateral swap params
function collateralSwapFlash(
uint256 amount0,
uint256 amount1,
address pool,
PoolAddress.PoolKey calldata poolKey,
CollateralSwapParams calldata params
) external override {
}
/// @notice Called to `msg.sender` after transferring to the recipient from IUniswapV3Pool#flash.
/// @dev In the implementation you must repay the pool the tokens sent by flash plus the computed fee amounts.
/// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
/// @param fee0 The fee amount in token0 due to the pool by the end of the flash
/// @param fee1 The fee amount in token1 due to the pool by the end of the flash
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#flash call
function uniswapV3FlashCallback(
uint256 fee0,
uint256 fee1,
bytes calldata data
) external override {
// Decode callback data
(address sender, PoolAddress.PoolKey memory poolKey, CollateralSwapParams memory params) = abi.decode(
data,
(address, PoolAddress.PoolKey, CollateralSwapParams)
);
// Check if callback is coming from Uniswap pool
CallbackValidation.verifyCallback(uniswapV3Factory, poolKey);
// Flash loan fee
uint256 fee = fee0 > 0 ? fee0 : fee1;
// If token1 is Ether
if (params.token1 == address(0)) {
// Swap token0Amount of token0 to Ether, receiving token1Amount of Ether
uint256 token1Amount = swapToEther(params.token0Amount, params.token0, params.exchange, params.data);
// Mint token1Amount Ether worth of cToken1 to this contract
CEtherInterface(params.cToken1).mint{ value: token1Amount }();
} else {
// Swap token0Amount of token0 to token1, receiving token1Amount of token1
uint256 token1Amount = swap(
params.token0Amount,
params.token0,
params.token1,
params.exchange,
params.data
);
// Approve token1Amount of token1 to be spent by cToken1
IERC20(params.token1).safeApprove(params.cToken1, token1Amount);
// Mint token1Amount token1 worth of cToken1 to this contract
require(CErc20Interface(params.cToken1).mint(token1Amount) == 0, "CTokenSwap: Mint failed");
}
// Amount of cToken1 minted
uint256 cToken1Balance = CTokenInterface(params.cToken1).balanceOf(address(this));
// Transfer cToken1Balance of cToken1 to sender
require(CTokenInterface(params.cToken1).transfer(sender, cToken1Balance), "CTokenSwap: Transfer failed");
// Transfers cToken0Amount of cToken0 from sender to this contract
require(
CTokenInterface(params.cToken0).transferFrom(sender, address(this), params.cToken0Amount),
"CTokenSwap: TransferFrom failed"
);
// Amount of token0 to pay back flash loan
uint256 token0Amount = params.token0Amount.add(fee);
// Redeems token0Amount of token0 from cToken0 to this contract
require(<FILL_ME>)
// If token0 is Ether
if (params.token0 == address(weth)) {
// Wrap Ether into WETH
weth.deposit{ value: token0Amount }();
}
// Transfer token0Amount to pool to pay back flash loan
IERC20(params.token0).safeTransfer(msg.sender, token0Amount);
// Get cToken0 balance of this contract
uint256 cToken0Balance = CTokenInterface(params.cToken0).balanceOf(address(this));
// If cToken0Balance is greater than 0, transfer the amount back to sender
if (cToken0Balance > 0) {
// Transfer cToken0Balance of cToken0 to sender
require(CTokenInterface(params.cToken0).transfer(sender, cToken0Balance), "CTokenSwap: Transfer failed");
}
// Emit event
emit CollateralSwap(sender, params.cToken0, params.cToken1, params.token0Amount);
}
/// @notice Transfer a tokens balance left on this contract to the owner
/// @dev Can only be called by owner
/// @param token Address of token to transfer the balance of
function transferToken(address token) external override onlyOwner {
}
/// @dev Swap token for token
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swap(
uint256 amount,
address token0,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap ether for token
/// @param amount Amount of ether to swap
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swapFromEther(
uint256 amount,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap token for ether
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return ether received from swap
function swapToEther(
uint256 amount,
address token0,
address exchange,
bytes memory data
) internal returns (uint256) {
}
}
| CErc20Interface(params.cToken0).redeemUnderlying(token0Amount)==0,"CTokenSwap: RedeemUnderlying failed" | 15,407 | CErc20Interface(params.cToken0).redeemUnderlying(token0Amount)==0 |
"CTokenSwap: Transfer failed" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.7.6;
pragma abicoder v2;
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { IUniswapV3FlashCallback } from "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3FlashCallback.sol";
import { ICTokenSwap } from "./interfaces/ICTokenSwap.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IUniswapV3Pool } from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
import { CTokenInterface, CErc20Interface, CEtherInterface } from "./interfaces/CTokenInterfaces.sol";
import { IWETH9 } from "./interfaces/IWETH9.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol";
import { PoolAddress } from "@uniswap/v3-periphery/contracts/libraries/PoolAddress.sol";
import { CallbackValidation } from "@uniswap/v3-periphery/contracts/libraries/CallbackValidation.sol";
/// @author Ganesh Gautham Elango
/// @title Compound collateral swap contract
/// @notice Swaps on any DEX
contract CTokenSwap is ICTokenSwap, IUniswapV3FlashCallback, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @dev UniswapV3Factory address
address public immutable uniswapV3Factory;
/// @dev WETH9 contract
IWETH9 public immutable weth;
/// @dev Constructor
/// @param _uniswapV3Factory UniswapV3Factory address
constructor(address _uniswapV3Factory, address _weth) {
}
/// @dev Fallback for reciving Ether
receive() external payable {}
/// @notice Performs collateral swap of 2 cTokens
/// @dev This may put the sender at liquidation risk if they have debt
/// @param params Collateral swap params
/// @return Amount of cToken1 minted and received
function collateralSwap(CollateralSwapParams calldata params) external override returns (uint256) {
}
/// @notice Performs collateral swap of 2 cTokens using a Uniswap V3 flash loan
/// @dev This reduces the senders liquidation risk if they have debt
/// @param amount0 Amount of token0 in pool to flash loan (must be 0 if not being flash loaned)
/// @param amount0 Amount of token1 in pool to flash loan (must be 0 if not being flash loaned)
/// @param pool Uniswap V3 pool address containing token to be flash loaned
/// @param poolKey The identifying key of the Uniswap V3 pool
/// @param params Collateral swap params
function collateralSwapFlash(
uint256 amount0,
uint256 amount1,
address pool,
PoolAddress.PoolKey calldata poolKey,
CollateralSwapParams calldata params
) external override {
}
/// @notice Called to `msg.sender` after transferring to the recipient from IUniswapV3Pool#flash.
/// @dev In the implementation you must repay the pool the tokens sent by flash plus the computed fee amounts.
/// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
/// @param fee0 The fee amount in token0 due to the pool by the end of the flash
/// @param fee1 The fee amount in token1 due to the pool by the end of the flash
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#flash call
function uniswapV3FlashCallback(
uint256 fee0,
uint256 fee1,
bytes calldata data
) external override {
// Decode callback data
(address sender, PoolAddress.PoolKey memory poolKey, CollateralSwapParams memory params) = abi.decode(
data,
(address, PoolAddress.PoolKey, CollateralSwapParams)
);
// Check if callback is coming from Uniswap pool
CallbackValidation.verifyCallback(uniswapV3Factory, poolKey);
// Flash loan fee
uint256 fee = fee0 > 0 ? fee0 : fee1;
// If token1 is Ether
if (params.token1 == address(0)) {
// Swap token0Amount of token0 to Ether, receiving token1Amount of Ether
uint256 token1Amount = swapToEther(params.token0Amount, params.token0, params.exchange, params.data);
// Mint token1Amount Ether worth of cToken1 to this contract
CEtherInterface(params.cToken1).mint{ value: token1Amount }();
} else {
// Swap token0Amount of token0 to token1, receiving token1Amount of token1
uint256 token1Amount = swap(
params.token0Amount,
params.token0,
params.token1,
params.exchange,
params.data
);
// Approve token1Amount of token1 to be spent by cToken1
IERC20(params.token1).safeApprove(params.cToken1, token1Amount);
// Mint token1Amount token1 worth of cToken1 to this contract
require(CErc20Interface(params.cToken1).mint(token1Amount) == 0, "CTokenSwap: Mint failed");
}
// Amount of cToken1 minted
uint256 cToken1Balance = CTokenInterface(params.cToken1).balanceOf(address(this));
// Transfer cToken1Balance of cToken1 to sender
require(CTokenInterface(params.cToken1).transfer(sender, cToken1Balance), "CTokenSwap: Transfer failed");
// Transfers cToken0Amount of cToken0 from sender to this contract
require(
CTokenInterface(params.cToken0).transferFrom(sender, address(this), params.cToken0Amount),
"CTokenSwap: TransferFrom failed"
);
// Amount of token0 to pay back flash loan
uint256 token0Amount = params.token0Amount.add(fee);
// Redeems token0Amount of token0 from cToken0 to this contract
require(
CErc20Interface(params.cToken0).redeemUnderlying(token0Amount) == 0,
"CTokenSwap: RedeemUnderlying failed"
);
// If token0 is Ether
if (params.token0 == address(weth)) {
// Wrap Ether into WETH
weth.deposit{ value: token0Amount }();
}
// Transfer token0Amount to pool to pay back flash loan
IERC20(params.token0).safeTransfer(msg.sender, token0Amount);
// Get cToken0 balance of this contract
uint256 cToken0Balance = CTokenInterface(params.cToken0).balanceOf(address(this));
// If cToken0Balance is greater than 0, transfer the amount back to sender
if (cToken0Balance > 0) {
// Transfer cToken0Balance of cToken0 to sender
require(<FILL_ME>)
}
// Emit event
emit CollateralSwap(sender, params.cToken0, params.cToken1, params.token0Amount);
}
/// @notice Transfer a tokens balance left on this contract to the owner
/// @dev Can only be called by owner
/// @param token Address of token to transfer the balance of
function transferToken(address token) external override onlyOwner {
}
/// @dev Swap token for token
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swap(
uint256 amount,
address token0,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap ether for token
/// @param amount Amount of ether to swap
/// @param token1 Token to swap to
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return token1 received from swap
function swapFromEther(
uint256 amount,
address token1,
address exchange,
bytes memory data
) internal returns (uint256) {
}
/// @dev Swap token for ether
/// @param amount Amount of token0 to swap
/// @param token0 Token to swap from
/// @param exchange Exchange address to swap on
/// @param data Calldata to call exchange with
/// @return ether received from swap
function swapToEther(
uint256 amount,
address token0,
address exchange,
bytes memory data
) internal returns (uint256) {
}
}
| CTokenInterface(params.cToken0).transfer(sender,cToken0Balance),"CTokenSwap: Transfer failed" | 15,407 | CTokenInterface(params.cToken0).transfer(sender,cToken0Balance) |
"You can summon between 1 and 100 spooks" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Derpys.sol";
/*****
▓█████▄ ▓█████ ██▀███ ██▓███ ▓██ ██▓
▒██▀ ██▌▓█ ▀ ▓██ ▒ ██▒▓██░ ██▒▒██ ██▒
░██ █▌▒███ ▓██ ░▄█ ▒▓██░ ██▓▒ ▒██ ██░
░▓█▄ ▌▒▓█ ▄ ▒██▀▀█▄ ▒██▄█▓▒ ▒ ░ ▐██▓░
░▒████▓ ░▒████▒░██▓ ▒██▒▒██▒ ░ ░ ░ ██▒▓░
▒▒▓ ▒ ░░ ▒░ ░░ ▒▓ ░▒▓░▒▓▒░ ░ ░ ██▒▒▒
░ ▒ ▒ ░ ░ ░ ░▒ ░ ▒░░▒ ░ ▓██ ░▒░
░ ░ ░ ░ ░░ ░ ░░ ▒ ▒ ░░
░ ░ ░ ░ ░ ░
░ ░ ░
██████ ██▓███ ▒█████ ▒█████ ██ ▄█▀ ██████
▒██ ▒ ▓██░ ██▒▒██▒ ██▒▒██▒ ██▒ ██▄█▒ ▒██ ▒
░ ▓██▄ ▓██░ ██▓▒▒██░ ██▒▒██░ ██▒▓███▄░ ░ ▓██▄
▒ ██▒▒██▄█▓▒ ▒▒██ ██░▒██ ██░▓██ █▄ ▒ ██▒
▒██████▒▒▒██▒ ░ ░░ ████▓▒░░ ████▓▒░▒██▒ █▄▒██████▒▒
▒ ▒▓▒ ▒ ░▒▓▒░ ░ ░░ ▒░▒░▒░ ░ ▒░▒░▒░ ▒ ▒▒ ▓▒▒ ▒▓▒ ▒ ░
░ ░▒ ░ ░░▒ ░ ░ ▒ ▒░ ░ ▒ ▒░ ░ ░▒ ▒░░ ░▒ ░ ░
░ ░ ░ ░░ ░ ░ ░ ▒ ░ ░ ░ ▒ ░ ░░ ░ ░ ░ ░
░ ░ ░ ░ ░ ░ ░ ░
*****/
/// @title DerpySpooks
/// @author @CoinFuPanda @DerpysNFT
/**
* @notice The DerpySpooks are undead and unsavoury Derpys
* that have been banished from this realm. They can be summoned
* from beyond the Aether if the summoner is willing to pay
* the blood price. Summoning costs only a drop of Derpy blood,
* but if the summoner does not hold a Derpy they can pay in Ether.
*/
contract DerpySpooks is ERC721, ERC721Enumerable, ERC721Pausable, ERC721Burnable, Ownable {
address payable public derpysContract = payable(0xbC1E44dF6A4C09f87D4f2500c686c61429eeA112);
bool public SUMMONING = true;
uint256 public MAX_SPOOKS = 3110;
uint256 public AIRDROP_SPOOKS = 100;
uint256 public BLOOD_PRICE = 0.02 ether;
string private baseURI;
/**
* @param _baseTokenURI is the base address for metadata
* */
constructor (
string memory _baseTokenURI
)
ERC721("DerpySpooks", "DSPOOK")
{
}
receive() external payable {
}
/**
* @notice list the ids of all the DerpySpooks in _owner's wallet
* @param _owner is the wallet address of the DerpySpook owner
* */
function listMyDerpys(address _owner)
external
view
returns (uint256[] memory)
{
}
/**
* @notice SUMMON DERPYSPOOKS FROM BEYOND THE ETHER
* @param numSpooks is the number of spooks to summon
* */
function summonDerpySpook(uint256 numSpooks) public payable {
require(
SUMMONING == true,
"The dead may not be summoned at this time"
);
require(<FILL_ME>)
require(
(totalSupply() + numSpooks) <= MAX_SPOOKS,
"There aren't that many DerpySpooks left"
);
require(
msg.value >= (bloodOrEther() * numSpooks),
"The blood price offered is not enough"
);
//SUMMON THEM
uint256 iderp;
for(iderp = 0; iderp < numSpooks; iderp++) {
uint256 mintId = totalSupply();
_safeMint(msg.sender, mintId);
}
}
/**
* @notice will the summoning be paid in blood or Ether?
* @dev if the msg.sender holds a Derpy mints are free (BLOOD),
* otherwise they cost ETHER
* */
function bloodOrEther() public view returns (uint256) {
}
/**
* @notice set a new metadata baseUri
* @param baseURI_ is the new e.g. ipfs metadata root
* */
function setBaseURI(string memory baseURI_) public onlyOwner {
}
/**
* @notice set a new price for summoning DerpySpooks
* only payable for non Derpy holders
* @param newWeiPrice is the new price in wei
* */
function setBloodPrice(uint256 newWeiPrice) public onlyOwner {
}
/**
* @notice point this contract to the Derpys contract to check
* if minters hold Derpys
* @param newAddress is the new contract address of Derpys
* */
function setDerpysAddress(address payable newAddress) public onlyOwner {
}
/**
* @notice start or stop the summoning (minting)
* */
function flipSummoning() public onlyOwner {
}
/**
* @dev pause all contract functions and token transfers
* */
function stopResurrection() public onlyOwner whenNotPaused {
}
/**
* @dev resume all contract functions and token transfers
* */
function startResurrection() public onlyOwner whenPaused {
}
/**
* @notice reduce the total supply of the collection
* @param newMax new supply limit for the collection
* */
function reduceSupply(uint256 newMax) public onlyOwner {
}
/**
* @notice withdraw sacrificial offerings
* */
function withdrawBloodSacrifice() public payable onlyOwner {
}
/**
* @notice airdrop spooks to another wallet
* */
function airdropDerpySpooks(uint256 numSpooks, address receiver) public onlyOwner {
}
/**
* @dev override _baseURI() method in ERC721.sol to return the base URI for our metadata
* */
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev override _beforeTokenTransfer in ERC721 contracts
*/
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
virtual
override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
/**
* @dev override supportsInterface in ERC721 contracts
*/
function supportsInterface (bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns(bool) {
}
}
| (numSpooks>0)&&(numSpooks<=100),"You can summon between 1 and 100 spooks" | 15,439 | (numSpooks>0)&&(numSpooks<=100) |
"There aren't that many DerpySpooks left" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Derpys.sol";
/*****
▓█████▄ ▓█████ ██▀███ ██▓███ ▓██ ██▓
▒██▀ ██▌▓█ ▀ ▓██ ▒ ██▒▓██░ ██▒▒██ ██▒
░██ █▌▒███ ▓██ ░▄█ ▒▓██░ ██▓▒ ▒██ ██░
░▓█▄ ▌▒▓█ ▄ ▒██▀▀█▄ ▒██▄█▓▒ ▒ ░ ▐██▓░
░▒████▓ ░▒████▒░██▓ ▒██▒▒██▒ ░ ░ ░ ██▒▓░
▒▒▓ ▒ ░░ ▒░ ░░ ▒▓ ░▒▓░▒▓▒░ ░ ░ ██▒▒▒
░ ▒ ▒ ░ ░ ░ ░▒ ░ ▒░░▒ ░ ▓██ ░▒░
░ ░ ░ ░ ░░ ░ ░░ ▒ ▒ ░░
░ ░ ░ ░ ░ ░
░ ░ ░
██████ ██▓███ ▒█████ ▒█████ ██ ▄█▀ ██████
▒██ ▒ ▓██░ ██▒▒██▒ ██▒▒██▒ ██▒ ██▄█▒ ▒██ ▒
░ ▓██▄ ▓██░ ██▓▒▒██░ ██▒▒██░ ██▒▓███▄░ ░ ▓██▄
▒ ██▒▒██▄█▓▒ ▒▒██ ██░▒██ ██░▓██ █▄ ▒ ██▒
▒██████▒▒▒██▒ ░ ░░ ████▓▒░░ ████▓▒░▒██▒ █▄▒██████▒▒
▒ ▒▓▒ ▒ ░▒▓▒░ ░ ░░ ▒░▒░▒░ ░ ▒░▒░▒░ ▒ ▒▒ ▓▒▒ ▒▓▒ ▒ ░
░ ░▒ ░ ░░▒ ░ ░ ▒ ▒░ ░ ▒ ▒░ ░ ░▒ ▒░░ ░▒ ░ ░
░ ░ ░ ░░ ░ ░ ░ ▒ ░ ░ ░ ▒ ░ ░░ ░ ░ ░ ░
░ ░ ░ ░ ░ ░ ░ ░
*****/
/// @title DerpySpooks
/// @author @CoinFuPanda @DerpysNFT
/**
* @notice The DerpySpooks are undead and unsavoury Derpys
* that have been banished from this realm. They can be summoned
* from beyond the Aether if the summoner is willing to pay
* the blood price. Summoning costs only a drop of Derpy blood,
* but if the summoner does not hold a Derpy they can pay in Ether.
*/
contract DerpySpooks is ERC721, ERC721Enumerable, ERC721Pausable, ERC721Burnable, Ownable {
address payable public derpysContract = payable(0xbC1E44dF6A4C09f87D4f2500c686c61429eeA112);
bool public SUMMONING = true;
uint256 public MAX_SPOOKS = 3110;
uint256 public AIRDROP_SPOOKS = 100;
uint256 public BLOOD_PRICE = 0.02 ether;
string private baseURI;
/**
* @param _baseTokenURI is the base address for metadata
* */
constructor (
string memory _baseTokenURI
)
ERC721("DerpySpooks", "DSPOOK")
{
}
receive() external payable {
}
/**
* @notice list the ids of all the DerpySpooks in _owner's wallet
* @param _owner is the wallet address of the DerpySpook owner
* */
function listMyDerpys(address _owner)
external
view
returns (uint256[] memory)
{
}
/**
* @notice SUMMON DERPYSPOOKS FROM BEYOND THE ETHER
* @param numSpooks is the number of spooks to summon
* */
function summonDerpySpook(uint256 numSpooks) public payable {
require(
SUMMONING == true,
"The dead may not be summoned at this time"
);
require(
(numSpooks > 0) && (numSpooks <= 100),
"You can summon between 1 and 100 spooks"
);
require(<FILL_ME>)
require(
msg.value >= (bloodOrEther() * numSpooks),
"The blood price offered is not enough"
);
//SUMMON THEM
uint256 iderp;
for(iderp = 0; iderp < numSpooks; iderp++) {
uint256 mintId = totalSupply();
_safeMint(msg.sender, mintId);
}
}
/**
* @notice will the summoning be paid in blood or Ether?
* @dev if the msg.sender holds a Derpy mints are free (BLOOD),
* otherwise they cost ETHER
* */
function bloodOrEther() public view returns (uint256) {
}
/**
* @notice set a new metadata baseUri
* @param baseURI_ is the new e.g. ipfs metadata root
* */
function setBaseURI(string memory baseURI_) public onlyOwner {
}
/**
* @notice set a new price for summoning DerpySpooks
* only payable for non Derpy holders
* @param newWeiPrice is the new price in wei
* */
function setBloodPrice(uint256 newWeiPrice) public onlyOwner {
}
/**
* @notice point this contract to the Derpys contract to check
* if minters hold Derpys
* @param newAddress is the new contract address of Derpys
* */
function setDerpysAddress(address payable newAddress) public onlyOwner {
}
/**
* @notice start or stop the summoning (minting)
* */
function flipSummoning() public onlyOwner {
}
/**
* @dev pause all contract functions and token transfers
* */
function stopResurrection() public onlyOwner whenNotPaused {
}
/**
* @dev resume all contract functions and token transfers
* */
function startResurrection() public onlyOwner whenPaused {
}
/**
* @notice reduce the total supply of the collection
* @param newMax new supply limit for the collection
* */
function reduceSupply(uint256 newMax) public onlyOwner {
}
/**
* @notice withdraw sacrificial offerings
* */
function withdrawBloodSacrifice() public payable onlyOwner {
}
/**
* @notice airdrop spooks to another wallet
* */
function airdropDerpySpooks(uint256 numSpooks, address receiver) public onlyOwner {
}
/**
* @dev override _baseURI() method in ERC721.sol to return the base URI for our metadata
* */
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev override _beforeTokenTransfer in ERC721 contracts
*/
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
virtual
override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
/**
* @dev override supportsInterface in ERC721 contracts
*/
function supportsInterface (bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns(bool) {
}
}
| (totalSupply()+numSpooks)<=MAX_SPOOKS,"There aren't that many DerpySpooks left" | 15,439 | (totalSupply()+numSpooks)<=MAX_SPOOKS |
"The blood price offered is not enough" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Derpys.sol";
/*****
▓█████▄ ▓█████ ██▀███ ██▓███ ▓██ ██▓
▒██▀ ██▌▓█ ▀ ▓██ ▒ ██▒▓██░ ██▒▒██ ██▒
░██ █▌▒███ ▓██ ░▄█ ▒▓██░ ██▓▒ ▒██ ██░
░▓█▄ ▌▒▓█ ▄ ▒██▀▀█▄ ▒██▄█▓▒ ▒ ░ ▐██▓░
░▒████▓ ░▒████▒░██▓ ▒██▒▒██▒ ░ ░ ░ ██▒▓░
▒▒▓ ▒ ░░ ▒░ ░░ ▒▓ ░▒▓░▒▓▒░ ░ ░ ██▒▒▒
░ ▒ ▒ ░ ░ ░ ░▒ ░ ▒░░▒ ░ ▓██ ░▒░
░ ░ ░ ░ ░░ ░ ░░ ▒ ▒ ░░
░ ░ ░ ░ ░ ░
░ ░ ░
██████ ██▓███ ▒█████ ▒█████ ██ ▄█▀ ██████
▒██ ▒ ▓██░ ██▒▒██▒ ██▒▒██▒ ██▒ ██▄█▒ ▒██ ▒
░ ▓██▄ ▓██░ ██▓▒▒██░ ██▒▒██░ ██▒▓███▄░ ░ ▓██▄
▒ ██▒▒██▄█▓▒ ▒▒██ ██░▒██ ██░▓██ █▄ ▒ ██▒
▒██████▒▒▒██▒ ░ ░░ ████▓▒░░ ████▓▒░▒██▒ █▄▒██████▒▒
▒ ▒▓▒ ▒ ░▒▓▒░ ░ ░░ ▒░▒░▒░ ░ ▒░▒░▒░ ▒ ▒▒ ▓▒▒ ▒▓▒ ▒ ░
░ ░▒ ░ ░░▒ ░ ░ ▒ ▒░ ░ ▒ ▒░ ░ ░▒ ▒░░ ░▒ ░ ░
░ ░ ░ ░░ ░ ░ ░ ▒ ░ ░ ░ ▒ ░ ░░ ░ ░ ░ ░
░ ░ ░ ░ ░ ░ ░ ░
*****/
/// @title DerpySpooks
/// @author @CoinFuPanda @DerpysNFT
/**
* @notice The DerpySpooks are undead and unsavoury Derpys
* that have been banished from this realm. They can be summoned
* from beyond the Aether if the summoner is willing to pay
* the blood price. Summoning costs only a drop of Derpy blood,
* but if the summoner does not hold a Derpy they can pay in Ether.
*/
contract DerpySpooks is ERC721, ERC721Enumerable, ERC721Pausable, ERC721Burnable, Ownable {
address payable public derpysContract = payable(0xbC1E44dF6A4C09f87D4f2500c686c61429eeA112);
bool public SUMMONING = true;
uint256 public MAX_SPOOKS = 3110;
uint256 public AIRDROP_SPOOKS = 100;
uint256 public BLOOD_PRICE = 0.02 ether;
string private baseURI;
/**
* @param _baseTokenURI is the base address for metadata
* */
constructor (
string memory _baseTokenURI
)
ERC721("DerpySpooks", "DSPOOK")
{
}
receive() external payable {
}
/**
* @notice list the ids of all the DerpySpooks in _owner's wallet
* @param _owner is the wallet address of the DerpySpook owner
* */
function listMyDerpys(address _owner)
external
view
returns (uint256[] memory)
{
}
/**
* @notice SUMMON DERPYSPOOKS FROM BEYOND THE ETHER
* @param numSpooks is the number of spooks to summon
* */
function summonDerpySpook(uint256 numSpooks) public payable {
require(
SUMMONING == true,
"The dead may not be summoned at this time"
);
require(
(numSpooks > 0) && (numSpooks <= 100),
"You can summon between 1 and 100 spooks"
);
require(
(totalSupply() + numSpooks) <= MAX_SPOOKS,
"There aren't that many DerpySpooks left"
);
require(<FILL_ME>)
//SUMMON THEM
uint256 iderp;
for(iderp = 0; iderp < numSpooks; iderp++) {
uint256 mintId = totalSupply();
_safeMint(msg.sender, mintId);
}
}
/**
* @notice will the summoning be paid in blood or Ether?
* @dev if the msg.sender holds a Derpy mints are free (BLOOD),
* otherwise they cost ETHER
* */
function bloodOrEther() public view returns (uint256) {
}
/**
* @notice set a new metadata baseUri
* @param baseURI_ is the new e.g. ipfs metadata root
* */
function setBaseURI(string memory baseURI_) public onlyOwner {
}
/**
* @notice set a new price for summoning DerpySpooks
* only payable for non Derpy holders
* @param newWeiPrice is the new price in wei
* */
function setBloodPrice(uint256 newWeiPrice) public onlyOwner {
}
/**
* @notice point this contract to the Derpys contract to check
* if minters hold Derpys
* @param newAddress is the new contract address of Derpys
* */
function setDerpysAddress(address payable newAddress) public onlyOwner {
}
/**
* @notice start or stop the summoning (minting)
* */
function flipSummoning() public onlyOwner {
}
/**
* @dev pause all contract functions and token transfers
* */
function stopResurrection() public onlyOwner whenNotPaused {
}
/**
* @dev resume all contract functions and token transfers
* */
function startResurrection() public onlyOwner whenPaused {
}
/**
* @notice reduce the total supply of the collection
* @param newMax new supply limit for the collection
* */
function reduceSupply(uint256 newMax) public onlyOwner {
}
/**
* @notice withdraw sacrificial offerings
* */
function withdrawBloodSacrifice() public payable onlyOwner {
}
/**
* @notice airdrop spooks to another wallet
* */
function airdropDerpySpooks(uint256 numSpooks, address receiver) public onlyOwner {
}
/**
* @dev override _baseURI() method in ERC721.sol to return the base URI for our metadata
* */
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev override _beforeTokenTransfer in ERC721 contracts
*/
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
virtual
override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
/**
* @dev override supportsInterface in ERC721 contracts
*/
function supportsInterface (bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns(bool) {
}
}
| msg.value>=(bloodOrEther()*numSpooks),"The blood price offered is not enough" | 15,439 | msg.value>=(bloodOrEther()*numSpooks) |
"No spooks remain unsummoned" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Derpys.sol";
/*****
▓█████▄ ▓█████ ██▀███ ██▓███ ▓██ ██▓
▒██▀ ██▌▓█ ▀ ▓██ ▒ ██▒▓██░ ██▒▒██ ██▒
░██ █▌▒███ ▓██ ░▄█ ▒▓██░ ██▓▒ ▒██ ██░
░▓█▄ ▌▒▓█ ▄ ▒██▀▀█▄ ▒██▄█▓▒ ▒ ░ ▐██▓░
░▒████▓ ░▒████▒░██▓ ▒██▒▒██▒ ░ ░ ░ ██▒▓░
▒▒▓ ▒ ░░ ▒░ ░░ ▒▓ ░▒▓░▒▓▒░ ░ ░ ██▒▒▒
░ ▒ ▒ ░ ░ ░ ░▒ ░ ▒░░▒ ░ ▓██ ░▒░
░ ░ ░ ░ ░░ ░ ░░ ▒ ▒ ░░
░ ░ ░ ░ ░ ░
░ ░ ░
██████ ██▓███ ▒█████ ▒█████ ██ ▄█▀ ██████
▒██ ▒ ▓██░ ██▒▒██▒ ██▒▒██▒ ██▒ ██▄█▒ ▒██ ▒
░ ▓██▄ ▓██░ ██▓▒▒██░ ██▒▒██░ ██▒▓███▄░ ░ ▓██▄
▒ ██▒▒██▄█▓▒ ▒▒██ ██░▒██ ██░▓██ █▄ ▒ ██▒
▒██████▒▒▒██▒ ░ ░░ ████▓▒░░ ████▓▒░▒██▒ █▄▒██████▒▒
▒ ▒▓▒ ▒ ░▒▓▒░ ░ ░░ ▒░▒░▒░ ░ ▒░▒░▒░ ▒ ▒▒ ▓▒▒ ▒▓▒ ▒ ░
░ ░▒ ░ ░░▒ ░ ░ ▒ ▒░ ░ ▒ ▒░ ░ ░▒ ▒░░ ░▒ ░ ░
░ ░ ░ ░░ ░ ░ ░ ▒ ░ ░ ░ ▒ ░ ░░ ░ ░ ░ ░
░ ░ ░ ░ ░ ░ ░ ░
*****/
/// @title DerpySpooks
/// @author @CoinFuPanda @DerpysNFT
/**
* @notice The DerpySpooks are undead and unsavoury Derpys
* that have been banished from this realm. They can be summoned
* from beyond the Aether if the summoner is willing to pay
* the blood price. Summoning costs only a drop of Derpy blood,
* but if the summoner does not hold a Derpy they can pay in Ether.
*/
contract DerpySpooks is ERC721, ERC721Enumerable, ERC721Pausable, ERC721Burnable, Ownable {
address payable public derpysContract = payable(0xbC1E44dF6A4C09f87D4f2500c686c61429eeA112);
bool public SUMMONING = true;
uint256 public MAX_SPOOKS = 3110;
uint256 public AIRDROP_SPOOKS = 100;
uint256 public BLOOD_PRICE = 0.02 ether;
string private baseURI;
/**
* @param _baseTokenURI is the base address for metadata
* */
constructor (
string memory _baseTokenURI
)
ERC721("DerpySpooks", "DSPOOK")
{
}
receive() external payable {
}
/**
* @notice list the ids of all the DerpySpooks in _owner's wallet
* @param _owner is the wallet address of the DerpySpook owner
* */
function listMyDerpys(address _owner)
external
view
returns (uint256[] memory)
{
}
/**
* @notice SUMMON DERPYSPOOKS FROM BEYOND THE ETHER
* @param numSpooks is the number of spooks to summon
* */
function summonDerpySpook(uint256 numSpooks) public payable {
}
/**
* @notice will the summoning be paid in blood or Ether?
* @dev if the msg.sender holds a Derpy mints are free (BLOOD),
* otherwise they cost ETHER
* */
function bloodOrEther() public view returns (uint256) {
require(<FILL_ME>)
Derpys derpys = Derpys(derpysContract);
uint256 ownerDerpys = derpys.balanceOf(msg.sender);
if (ownerDerpys > 0) {
//summoning paid in Derpy blood, no Ether required
return 0;
} else {
//Ether is required in place of Derpy blood
return BLOOD_PRICE;
}
}
/**
* @notice set a new metadata baseUri
* @param baseURI_ is the new e.g. ipfs metadata root
* */
function setBaseURI(string memory baseURI_) public onlyOwner {
}
/**
* @notice set a new price for summoning DerpySpooks
* only payable for non Derpy holders
* @param newWeiPrice is the new price in wei
* */
function setBloodPrice(uint256 newWeiPrice) public onlyOwner {
}
/**
* @notice point this contract to the Derpys contract to check
* if minters hold Derpys
* @param newAddress is the new contract address of Derpys
* */
function setDerpysAddress(address payable newAddress) public onlyOwner {
}
/**
* @notice start or stop the summoning (minting)
* */
function flipSummoning() public onlyOwner {
}
/**
* @dev pause all contract functions and token transfers
* */
function stopResurrection() public onlyOwner whenNotPaused {
}
/**
* @dev resume all contract functions and token transfers
* */
function startResurrection() public onlyOwner whenPaused {
}
/**
* @notice reduce the total supply of the collection
* @param newMax new supply limit for the collection
* */
function reduceSupply(uint256 newMax) public onlyOwner {
}
/**
* @notice withdraw sacrificial offerings
* */
function withdrawBloodSacrifice() public payable onlyOwner {
}
/**
* @notice airdrop spooks to another wallet
* */
function airdropDerpySpooks(uint256 numSpooks, address receiver) public onlyOwner {
}
/**
* @dev override _baseURI() method in ERC721.sol to return the base URI for our metadata
* */
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev override _beforeTokenTransfer in ERC721 contracts
*/
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
virtual
override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
/**
* @dev override supportsInterface in ERC721 contracts
*/
function supportsInterface (bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns(bool) {
}
}
| totalSupply()<MAX_SPOOKS,"No spooks remain unsummoned" | 15,439 | totalSupply()<MAX_SPOOKS |
"the supply may only be reduced" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Derpys.sol";
/*****
▓█████▄ ▓█████ ██▀███ ██▓███ ▓██ ██▓
▒██▀ ██▌▓█ ▀ ▓██ ▒ ██▒▓██░ ██▒▒██ ██▒
░██ █▌▒███ ▓██ ░▄█ ▒▓██░ ██▓▒ ▒██ ██░
░▓█▄ ▌▒▓█ ▄ ▒██▀▀█▄ ▒██▄█▓▒ ▒ ░ ▐██▓░
░▒████▓ ░▒████▒░██▓ ▒██▒▒██▒ ░ ░ ░ ██▒▓░
▒▒▓ ▒ ░░ ▒░ ░░ ▒▓ ░▒▓░▒▓▒░ ░ ░ ██▒▒▒
░ ▒ ▒ ░ ░ ░ ░▒ ░ ▒░░▒ ░ ▓██ ░▒░
░ ░ ░ ░ ░░ ░ ░░ ▒ ▒ ░░
░ ░ ░ ░ ░ ░
░ ░ ░
██████ ██▓███ ▒█████ ▒█████ ██ ▄█▀ ██████
▒██ ▒ ▓██░ ██▒▒██▒ ██▒▒██▒ ██▒ ██▄█▒ ▒██ ▒
░ ▓██▄ ▓██░ ██▓▒▒██░ ██▒▒██░ ██▒▓███▄░ ░ ▓██▄
▒ ██▒▒██▄█▓▒ ▒▒██ ██░▒██ ██░▓██ █▄ ▒ ██▒
▒██████▒▒▒██▒ ░ ░░ ████▓▒░░ ████▓▒░▒██▒ █▄▒██████▒▒
▒ ▒▓▒ ▒ ░▒▓▒░ ░ ░░ ▒░▒░▒░ ░ ▒░▒░▒░ ▒ ▒▒ ▓▒▒ ▒▓▒ ▒ ░
░ ░▒ ░ ░░▒ ░ ░ ▒ ▒░ ░ ▒ ▒░ ░ ░▒ ▒░░ ░▒ ░ ░
░ ░ ░ ░░ ░ ░ ░ ▒ ░ ░ ░ ▒ ░ ░░ ░ ░ ░ ░
░ ░ ░ ░ ░ ░ ░ ░
*****/
/// @title DerpySpooks
/// @author @CoinFuPanda @DerpysNFT
/**
* @notice The DerpySpooks are undead and unsavoury Derpys
* that have been banished from this realm. They can be summoned
* from beyond the Aether if the summoner is willing to pay
* the blood price. Summoning costs only a drop of Derpy blood,
* but if the summoner does not hold a Derpy they can pay in Ether.
*/
contract DerpySpooks is ERC721, ERC721Enumerable, ERC721Pausable, ERC721Burnable, Ownable {
address payable public derpysContract = payable(0xbC1E44dF6A4C09f87D4f2500c686c61429eeA112);
bool public SUMMONING = true;
uint256 public MAX_SPOOKS = 3110;
uint256 public AIRDROP_SPOOKS = 100;
uint256 public BLOOD_PRICE = 0.02 ether;
string private baseURI;
/**
* @param _baseTokenURI is the base address for metadata
* */
constructor (
string memory _baseTokenURI
)
ERC721("DerpySpooks", "DSPOOK")
{
}
receive() external payable {
}
/**
* @notice list the ids of all the DerpySpooks in _owner's wallet
* @param _owner is the wallet address of the DerpySpook owner
* */
function listMyDerpys(address _owner)
external
view
returns (uint256[] memory)
{
}
/**
* @notice SUMMON DERPYSPOOKS FROM BEYOND THE ETHER
* @param numSpooks is the number of spooks to summon
* */
function summonDerpySpook(uint256 numSpooks) public payable {
}
/**
* @notice will the summoning be paid in blood or Ether?
* @dev if the msg.sender holds a Derpy mints are free (BLOOD),
* otherwise they cost ETHER
* */
function bloodOrEther() public view returns (uint256) {
}
/**
* @notice set a new metadata baseUri
* @param baseURI_ is the new e.g. ipfs metadata root
* */
function setBaseURI(string memory baseURI_) public onlyOwner {
}
/**
* @notice set a new price for summoning DerpySpooks
* only payable for non Derpy holders
* @param newWeiPrice is the new price in wei
* */
function setBloodPrice(uint256 newWeiPrice) public onlyOwner {
}
/**
* @notice point this contract to the Derpys contract to check
* if minters hold Derpys
* @param newAddress is the new contract address of Derpys
* */
function setDerpysAddress(address payable newAddress) public onlyOwner {
}
/**
* @notice start or stop the summoning (minting)
* */
function flipSummoning() public onlyOwner {
}
/**
* @dev pause all contract functions and token transfers
* */
function stopResurrection() public onlyOwner whenNotPaused {
}
/**
* @dev resume all contract functions and token transfers
* */
function startResurrection() public onlyOwner whenPaused {
}
/**
* @notice reduce the total supply of the collection
* @param newMax new supply limit for the collection
* */
function reduceSupply(uint256 newMax) public onlyOwner {
require(<FILL_ME>)
MAX_SPOOKS = newMax;
}
/**
* @notice withdraw sacrificial offerings
* */
function withdrawBloodSacrifice() public payable onlyOwner {
}
/**
* @notice airdrop spooks to another wallet
* */
function airdropDerpySpooks(uint256 numSpooks, address receiver) public onlyOwner {
}
/**
* @dev override _baseURI() method in ERC721.sol to return the base URI for our metadata
* */
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev override _beforeTokenTransfer in ERC721 contracts
*/
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
virtual
override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
/**
* @dev override supportsInterface in ERC721 contracts
*/
function supportsInterface (bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns(bool) {
}
}
| (newMax<MAX_SPOOKS)&&(newMax>=totalSupply()),"the supply may only be reduced" | 15,439 | (newMax<MAX_SPOOKS)&&(newMax>=totalSupply()) |
"There are not enough Spooks left!" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Derpys.sol";
/*****
▓█████▄ ▓█████ ██▀███ ██▓███ ▓██ ██▓
▒██▀ ██▌▓█ ▀ ▓██ ▒ ██▒▓██░ ██▒▒██ ██▒
░██ █▌▒███ ▓██ ░▄█ ▒▓██░ ██▓▒ ▒██ ██░
░▓█▄ ▌▒▓█ ▄ ▒██▀▀█▄ ▒██▄█▓▒ ▒ ░ ▐██▓░
░▒████▓ ░▒████▒░██▓ ▒██▒▒██▒ ░ ░ ░ ██▒▓░
▒▒▓ ▒ ░░ ▒░ ░░ ▒▓ ░▒▓░▒▓▒░ ░ ░ ██▒▒▒
░ ▒ ▒ ░ ░ ░ ░▒ ░ ▒░░▒ ░ ▓██ ░▒░
░ ░ ░ ░ ░░ ░ ░░ ▒ ▒ ░░
░ ░ ░ ░ ░ ░
░ ░ ░
██████ ██▓███ ▒█████ ▒█████ ██ ▄█▀ ██████
▒██ ▒ ▓██░ ██▒▒██▒ ██▒▒██▒ ██▒ ██▄█▒ ▒██ ▒
░ ▓██▄ ▓██░ ██▓▒▒██░ ██▒▒██░ ██▒▓███▄░ ░ ▓██▄
▒ ██▒▒██▄█▓▒ ▒▒██ ██░▒██ ██░▓██ █▄ ▒ ██▒
▒██████▒▒▒██▒ ░ ░░ ████▓▒░░ ████▓▒░▒██▒ █▄▒██████▒▒
▒ ▒▓▒ ▒ ░▒▓▒░ ░ ░░ ▒░▒░▒░ ░ ▒░▒░▒░ ▒ ▒▒ ▓▒▒ ▒▓▒ ▒ ░
░ ░▒ ░ ░░▒ ░ ░ ▒ ▒░ ░ ▒ ▒░ ░ ░▒ ▒░░ ░▒ ░ ░
░ ░ ░ ░░ ░ ░ ░ ▒ ░ ░ ░ ▒ ░ ░░ ░ ░ ░ ░
░ ░ ░ ░ ░ ░ ░ ░
*****/
/// @title DerpySpooks
/// @author @CoinFuPanda @DerpysNFT
/**
* @notice The DerpySpooks are undead and unsavoury Derpys
* that have been banished from this realm. They can be summoned
* from beyond the Aether if the summoner is willing to pay
* the blood price. Summoning costs only a drop of Derpy blood,
* but if the summoner does not hold a Derpy they can pay in Ether.
*/
contract DerpySpooks is ERC721, ERC721Enumerable, ERC721Pausable, ERC721Burnable, Ownable {
address payable public derpysContract = payable(0xbC1E44dF6A4C09f87D4f2500c686c61429eeA112);
bool public SUMMONING = true;
uint256 public MAX_SPOOKS = 3110;
uint256 public AIRDROP_SPOOKS = 100;
uint256 public BLOOD_PRICE = 0.02 ether;
string private baseURI;
/**
* @param _baseTokenURI is the base address for metadata
* */
constructor (
string memory _baseTokenURI
)
ERC721("DerpySpooks", "DSPOOK")
{
}
receive() external payable {
}
/**
* @notice list the ids of all the DerpySpooks in _owner's wallet
* @param _owner is the wallet address of the DerpySpook owner
* */
function listMyDerpys(address _owner)
external
view
returns (uint256[] memory)
{
}
/**
* @notice SUMMON DERPYSPOOKS FROM BEYOND THE ETHER
* @param numSpooks is the number of spooks to summon
* */
function summonDerpySpook(uint256 numSpooks) public payable {
}
/**
* @notice will the summoning be paid in blood or Ether?
* @dev if the msg.sender holds a Derpy mints are free (BLOOD),
* otherwise they cost ETHER
* */
function bloodOrEther() public view returns (uint256) {
}
/**
* @notice set a new metadata baseUri
* @param baseURI_ is the new e.g. ipfs metadata root
* */
function setBaseURI(string memory baseURI_) public onlyOwner {
}
/**
* @notice set a new price for summoning DerpySpooks
* only payable for non Derpy holders
* @param newWeiPrice is the new price in wei
* */
function setBloodPrice(uint256 newWeiPrice) public onlyOwner {
}
/**
* @notice point this contract to the Derpys contract to check
* if minters hold Derpys
* @param newAddress is the new contract address of Derpys
* */
function setDerpysAddress(address payable newAddress) public onlyOwner {
}
/**
* @notice start or stop the summoning (minting)
* */
function flipSummoning() public onlyOwner {
}
/**
* @dev pause all contract functions and token transfers
* */
function stopResurrection() public onlyOwner whenNotPaused {
}
/**
* @dev resume all contract functions and token transfers
* */
function startResurrection() public onlyOwner whenPaused {
}
/**
* @notice reduce the total supply of the collection
* @param newMax new supply limit for the collection
* */
function reduceSupply(uint256 newMax) public onlyOwner {
}
/**
* @notice withdraw sacrificial offerings
* */
function withdrawBloodSacrifice() public payable onlyOwner {
}
/**
* @notice airdrop spooks to another wallet
* */
function airdropDerpySpooks(uint256 numSpooks, address receiver) public onlyOwner {
// 33 DerpySpooks are reserved for airdrops, giveaways and the legends who helped us build this.
// Thanks xx
uint256 nextTokenId = totalSupply();
require(
numSpooks > 0,
"Positive integer Spooks only!"
);
require(<FILL_ME>)
require(
(AIRDROP_SPOOKS - numSpooks) >= 0,
"Airdrop quota exceeded!"
);
uint256 iDerp;
for (iDerp = 0; iDerp < numSpooks; iDerp++) {
_safeMint(receiver, (nextTokenId + iDerp));
AIRDROP_SPOOKS -= 1;
}
}
/**
* @dev override _baseURI() method in ERC721.sol to return the base URI for our metadata
* */
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev override _beforeTokenTransfer in ERC721 contracts
*/
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
virtual
override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
/**
* @dev override supportsInterface in ERC721 contracts
*/
function supportsInterface (bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns(bool) {
}
}
| (nextTokenId+numSpooks)<=MAX_SPOOKS,"There are not enough Spooks left!" | 15,439 | (nextTokenId+numSpooks)<=MAX_SPOOKS |
"Airdrop quota exceeded!" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Derpys.sol";
/*****
▓█████▄ ▓█████ ██▀███ ██▓███ ▓██ ██▓
▒██▀ ██▌▓█ ▀ ▓██ ▒ ██▒▓██░ ██▒▒██ ██▒
░██ █▌▒███ ▓██ ░▄█ ▒▓██░ ██▓▒ ▒██ ██░
░▓█▄ ▌▒▓█ ▄ ▒██▀▀█▄ ▒██▄█▓▒ ▒ ░ ▐██▓░
░▒████▓ ░▒████▒░██▓ ▒██▒▒██▒ ░ ░ ░ ██▒▓░
▒▒▓ ▒ ░░ ▒░ ░░ ▒▓ ░▒▓░▒▓▒░ ░ ░ ██▒▒▒
░ ▒ ▒ ░ ░ ░ ░▒ ░ ▒░░▒ ░ ▓██ ░▒░
░ ░ ░ ░ ░░ ░ ░░ ▒ ▒ ░░
░ ░ ░ ░ ░ ░
░ ░ ░
██████ ██▓███ ▒█████ ▒█████ ██ ▄█▀ ██████
▒██ ▒ ▓██░ ██▒▒██▒ ██▒▒██▒ ██▒ ██▄█▒ ▒██ ▒
░ ▓██▄ ▓██░ ██▓▒▒██░ ██▒▒██░ ██▒▓███▄░ ░ ▓██▄
▒ ██▒▒██▄█▓▒ ▒▒██ ██░▒██ ██░▓██ █▄ ▒ ██▒
▒██████▒▒▒██▒ ░ ░░ ████▓▒░░ ████▓▒░▒██▒ █▄▒██████▒▒
▒ ▒▓▒ ▒ ░▒▓▒░ ░ ░░ ▒░▒░▒░ ░ ▒░▒░▒░ ▒ ▒▒ ▓▒▒ ▒▓▒ ▒ ░
░ ░▒ ░ ░░▒ ░ ░ ▒ ▒░ ░ ▒ ▒░ ░ ░▒ ▒░░ ░▒ ░ ░
░ ░ ░ ░░ ░ ░ ░ ▒ ░ ░ ░ ▒ ░ ░░ ░ ░ ░ ░
░ ░ ░ ░ ░ ░ ░ ░
*****/
/// @title DerpySpooks
/// @author @CoinFuPanda @DerpysNFT
/**
* @notice The DerpySpooks are undead and unsavoury Derpys
* that have been banished from this realm. They can be summoned
* from beyond the Aether if the summoner is willing to pay
* the blood price. Summoning costs only a drop of Derpy blood,
* but if the summoner does not hold a Derpy they can pay in Ether.
*/
contract DerpySpooks is ERC721, ERC721Enumerable, ERC721Pausable, ERC721Burnable, Ownable {
address payable public derpysContract = payable(0xbC1E44dF6A4C09f87D4f2500c686c61429eeA112);
bool public SUMMONING = true;
uint256 public MAX_SPOOKS = 3110;
uint256 public AIRDROP_SPOOKS = 100;
uint256 public BLOOD_PRICE = 0.02 ether;
string private baseURI;
/**
* @param _baseTokenURI is the base address for metadata
* */
constructor (
string memory _baseTokenURI
)
ERC721("DerpySpooks", "DSPOOK")
{
}
receive() external payable {
}
/**
* @notice list the ids of all the DerpySpooks in _owner's wallet
* @param _owner is the wallet address of the DerpySpook owner
* */
function listMyDerpys(address _owner)
external
view
returns (uint256[] memory)
{
}
/**
* @notice SUMMON DERPYSPOOKS FROM BEYOND THE ETHER
* @param numSpooks is the number of spooks to summon
* */
function summonDerpySpook(uint256 numSpooks) public payable {
}
/**
* @notice will the summoning be paid in blood or Ether?
* @dev if the msg.sender holds a Derpy mints are free (BLOOD),
* otherwise they cost ETHER
* */
function bloodOrEther() public view returns (uint256) {
}
/**
* @notice set a new metadata baseUri
* @param baseURI_ is the new e.g. ipfs metadata root
* */
function setBaseURI(string memory baseURI_) public onlyOwner {
}
/**
* @notice set a new price for summoning DerpySpooks
* only payable for non Derpy holders
* @param newWeiPrice is the new price in wei
* */
function setBloodPrice(uint256 newWeiPrice) public onlyOwner {
}
/**
* @notice point this contract to the Derpys contract to check
* if minters hold Derpys
* @param newAddress is the new contract address of Derpys
* */
function setDerpysAddress(address payable newAddress) public onlyOwner {
}
/**
* @notice start or stop the summoning (minting)
* */
function flipSummoning() public onlyOwner {
}
/**
* @dev pause all contract functions and token transfers
* */
function stopResurrection() public onlyOwner whenNotPaused {
}
/**
* @dev resume all contract functions and token transfers
* */
function startResurrection() public onlyOwner whenPaused {
}
/**
* @notice reduce the total supply of the collection
* @param newMax new supply limit for the collection
* */
function reduceSupply(uint256 newMax) public onlyOwner {
}
/**
* @notice withdraw sacrificial offerings
* */
function withdrawBloodSacrifice() public payable onlyOwner {
}
/**
* @notice airdrop spooks to another wallet
* */
function airdropDerpySpooks(uint256 numSpooks, address receiver) public onlyOwner {
// 33 DerpySpooks are reserved for airdrops, giveaways and the legends who helped us build this.
// Thanks xx
uint256 nextTokenId = totalSupply();
require(
numSpooks > 0,
"Positive integer Spooks only!"
);
require(
(nextTokenId + numSpooks) <= MAX_SPOOKS,
"There are not enough Spooks left!"
);
require(<FILL_ME>)
uint256 iDerp;
for (iDerp = 0; iDerp < numSpooks; iDerp++) {
_safeMint(receiver, (nextTokenId + iDerp));
AIRDROP_SPOOKS -= 1;
}
}
/**
* @dev override _baseURI() method in ERC721.sol to return the base URI for our metadata
* */
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev override _beforeTokenTransfer in ERC721 contracts
*/
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
virtual
override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
/**
* @dev override supportsInterface in ERC721 contracts
*/
function supportsInterface (bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns(bool) {
}
}
| (AIRDROP_SPOOKS-numSpooks)>=0,"Airdrop quota exceeded!" | 15,439 | (AIRDROP_SPOOKS-numSpooks)>=0 |
"collectable-dust::token-is-part-of-the-protocol" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../Interfaces/Keep3r/ICollectableDust.sol";
abstract contract CollectableDust is ICollectableDust {
using EnumerableSet for EnumerableSet.AddressSet;
address public constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
EnumerableSet.AddressSet internal protocolTokens;
constructor() public {}
function _addProtocolToken(address _token) internal {
require(<FILL_ME>)
protocolTokens.add(_token);
}
function _removeProtocolToken(address _token) internal {
}
function _sendDust(
address _to,
address _token,
uint256 _amount
) internal {
}
}
| !protocolTokens.contains(_token),"collectable-dust::token-is-part-of-the-protocol" | 15,450 | !protocolTokens.contains(_token) |
"collectable-dust::token-not-part-of-the-protocol" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../Interfaces/Keep3r/ICollectableDust.sol";
abstract contract CollectableDust is ICollectableDust {
using EnumerableSet for EnumerableSet.AddressSet;
address public constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
EnumerableSet.AddressSet internal protocolTokens;
constructor() public {}
function _addProtocolToken(address _token) internal {
}
function _removeProtocolToken(address _token) internal {
require(<FILL_ME>)
protocolTokens.remove(_token);
}
function _sendDust(
address _to,
address _token,
uint256 _amount
) internal {
}
}
| protocolTokens.contains(_token),"collectable-dust::token-not-part-of-the-protocol" | 15,450 | protocolTokens.contains(_token) |
null | /**
* @title Chaingear - the novel Ethereum database framework
* @author cyber•Congress, Valery litvin (@litvintech)
* @notice not audited, not recommend to use in mainnet
*/
contract DatabasePermissionControl is Ownable {
/*
* Storage
*/
enum CreateEntryPermissionGroup {OnlyAdmin, Whitelist, AllUsers}
address private admin;
bool private paused = true;
mapping(address => bool) private whitelist;
CreateEntryPermissionGroup private permissionGroup = CreateEntryPermissionGroup.OnlyAdmin;
/*
* Events
*/
event Pause();
event Unpause();
event PermissionGroupChanged(CreateEntryPermissionGroup);
event AddedToWhitelist(address);
event RemovedFromWhitelist(address);
event AdminshipTransferred(address, address);
/*
* Constructor
*/
constructor()
public
{ }
/*
* Modifiers
*/
modifier whenNotPaused() {
}
modifier whenPaused() {
}
modifier onlyAdmin() {
}
modifier onlyPermissionedToCreateEntries() {
if (permissionGroup == CreateEntryPermissionGroup.OnlyAdmin) {
require(msg.sender == admin);
} else if (permissionGroup == CreateEntryPermissionGroup.Whitelist) {
require(<FILL_ME>)
}
_;
}
/*
* External functions
*/
function pause()
external
onlyAdmin
whenNotPaused
{
}
function unpause()
external
onlyAdmin
whenPaused
{
}
function transferAdminRights(address _newAdmin)
external
onlyOwner
whenPaused
{
}
function updateCreateEntryPermissionGroup(CreateEntryPermissionGroup _newPermissionGroup)
external
onlyAdmin
whenPaused
{
}
function addToWhitelist(address _address)
external
onlyAdmin
whenPaused
{
}
function removeFromWhitelist(address _address)
external
onlyAdmin
whenPaused
{
}
function getAdmin()
external
view
returns (address)
{
}
function getDatabasePermissions()
external
view
returns (CreateEntryPermissionGroup)
{
}
function checkWhitelisting(address _address)
external
view
returns (bool)
{
}
function getPaused()
external
view
returns (bool)
{
}
}
| whitelist[msg.sender]==true||msg.sender==admin | 15,566 | whitelist[msg.sender]==true||msg.sender==admin |
"not enought supply remaining" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
contract RareShoe is ERC721, EIP712, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
string _baseUri;
address _signerAddress;
uint public constant MAX_SUPPLY = 4444;
uint public price = 0.08 ether;
bool public isSalesActive = false;
bool public isPreSalesActive = false;
mapping(address => uint) public _addressToMintedFreeTokens;
modifier validSignature(uint freeMints, bytes calldata signature) {
}
constructor() ERC721("Rare Shoe", "RSHOE") EIP712("RSHOE", "1.0.0") {
}
function _baseURI() internal view override returns (string memory) {
}
function mint(uint quantity) external payable {
require(isSalesActive, "sale is not active");
require(<FILL_ME>)
require(msg.value >= price * quantity, "ether sent is under price");
for (uint i = 0; i < quantity; i++) {
safeMint(msg.sender);
}
}
function freeMint(uint quantity, uint freeMints, bytes calldata signature) external validSignature(freeMints, signature) {
}
function mintPreSale(uint quantity, uint freeMints, bytes calldata signature) external payable validSignature(freeMints, signature) {
}
function safeMint(address to) internal {
}
function _hash(address account, uint freeMints) internal view returns (bytes32) {
}
function recoverAddress(address account, uint freeMints, bytes calldata signature) public view returns(address) {
}
function totalSupply() public view returns (uint) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function toggleSales() external onlyOwner {
}
function togglePreSales() external onlyOwner {
}
function setPrice(uint newPrice) external onlyOwner {
}
function setSignerAddress(address signerAddress) external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
}
| totalSupply()+quantity<=MAX_SUPPLY,"not enought supply remaining" | 15,584 | totalSupply()+quantity<=MAX_SUPPLY |
"account allowance exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
contract RareShoe is ERC721, EIP712, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
string _baseUri;
address _signerAddress;
uint public constant MAX_SUPPLY = 4444;
uint public price = 0.08 ether;
bool public isSalesActive = false;
bool public isPreSalesActive = false;
mapping(address => uint) public _addressToMintedFreeTokens;
modifier validSignature(uint freeMints, bytes calldata signature) {
}
constructor() ERC721("Rare Shoe", "RSHOE") EIP712("RSHOE", "1.0.0") {
}
function _baseURI() internal view override returns (string memory) {
}
function mint(uint quantity) external payable {
}
function freeMint(uint quantity, uint freeMints, bytes calldata signature) external validSignature(freeMints, signature) {
require(isSalesActive, "sale is not active");
require(totalSupply() + quantity <= MAX_SUPPLY, "not enought supply remaining");
require(<FILL_ME>)
_addressToMintedFreeTokens[msg.sender] += quantity;
for (uint i = 0; i < quantity; i++) {
safeMint(msg.sender);
}
}
function mintPreSale(uint quantity, uint freeMints, bytes calldata signature) external payable validSignature(freeMints, signature) {
}
function safeMint(address to) internal {
}
function _hash(address account, uint freeMints) internal view returns (bytes32) {
}
function recoverAddress(address account, uint freeMints, bytes calldata signature) public view returns(address) {
}
function totalSupply() public view returns (uint) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function toggleSales() external onlyOwner {
}
function togglePreSales() external onlyOwner {
}
function setPrice(uint newPrice) external onlyOwner {
}
function setSignerAddress(address signerAddress) external onlyOwner {
}
function withdrawAll() external onlyOwner {
}
}
| _addressToMintedFreeTokens[msg.sender]+quantity<=freeMints,"account allowance exceeded" | 15,584 | _addressToMintedFreeTokens[msg.sender]+quantity<=freeMints |
"Asset already registered" | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
contract Registry is Ownable {
// Map asset addresses to indexes.
mapping(address => uint32) public assetAddressToIndex;
mapping(uint32 => address) public assetIndexToAddress;
uint32 numAssets = 0;
// Valid strategies.
mapping(address => uint32) public strategyAddressToIndex;
mapping(uint32 => address) public strategyIndexToAddress;
uint32 numStrategies = 0;
event AssetRegistered(address asset, uint32 assetId);
event StrategyRegistered(address strategy, uint32 strategyId);
event StrategyUpdated(address previousStrategy, address newStrategy, uint32 strategyId);
/**
* @notice Register a asset
* @param _asset The asset token address;
*/
function registerAsset(address _asset) external onlyOwner {
require(_asset != address(0), "Invalid asset");
require(<FILL_ME>)
// Register asset with an index >= 1 (zero is reserved).
numAssets++;
assetAddressToIndex[_asset] = numAssets;
assetIndexToAddress[numAssets] = _asset;
emit AssetRegistered(_asset, numAssets);
}
/**
* @notice Register a strategy
* @param _strategy The strategy contract address;
*/
function registerStrategy(address _strategy) external onlyOwner {
}
/**
* @notice Update the address of an existing strategy
* @param _strategy The strategy contract address;
* @param _strategyId The strategy ID;
*/
function updateStrategy(address _strategy, uint32 _strategyId) external onlyOwner {
}
}
| assetAddressToIndex[_asset]==0,"Asset already registered" | 15,614 | assetAddressToIndex[_asset]==0 |
"Strategy already registered" | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
contract Registry is Ownable {
// Map asset addresses to indexes.
mapping(address => uint32) public assetAddressToIndex;
mapping(uint32 => address) public assetIndexToAddress;
uint32 numAssets = 0;
// Valid strategies.
mapping(address => uint32) public strategyAddressToIndex;
mapping(uint32 => address) public strategyIndexToAddress;
uint32 numStrategies = 0;
event AssetRegistered(address asset, uint32 assetId);
event StrategyRegistered(address strategy, uint32 strategyId);
event StrategyUpdated(address previousStrategy, address newStrategy, uint32 strategyId);
/**
* @notice Register a asset
* @param _asset The asset token address;
*/
function registerAsset(address _asset) external onlyOwner {
}
/**
* @notice Register a strategy
* @param _strategy The strategy contract address;
*/
function registerStrategy(address _strategy) external onlyOwner {
require(_strategy != address(0), "Invalid strategy");
require(<FILL_ME>)
// Register strategy with an index >= 1 (zero is reserved).
numStrategies++;
strategyAddressToIndex[_strategy] = numStrategies;
strategyIndexToAddress[numStrategies] = _strategy;
emit StrategyRegistered(_strategy, numStrategies);
}
/**
* @notice Update the address of an existing strategy
* @param _strategy The strategy contract address;
* @param _strategyId The strategy ID;
*/
function updateStrategy(address _strategy, uint32 _strategyId) external onlyOwner {
}
}
| strategyAddressToIndex[_strategy]==0,"Strategy already registered" | 15,614 | strategyAddressToIndex[_strategy]==0 |
"Strategy doesn't exist" | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
contract Registry is Ownable {
// Map asset addresses to indexes.
mapping(address => uint32) public assetAddressToIndex;
mapping(uint32 => address) public assetIndexToAddress;
uint32 numAssets = 0;
// Valid strategies.
mapping(address => uint32) public strategyAddressToIndex;
mapping(uint32 => address) public strategyIndexToAddress;
uint32 numStrategies = 0;
event AssetRegistered(address asset, uint32 assetId);
event StrategyRegistered(address strategy, uint32 strategyId);
event StrategyUpdated(address previousStrategy, address newStrategy, uint32 strategyId);
/**
* @notice Register a asset
* @param _asset The asset token address;
*/
function registerAsset(address _asset) external onlyOwner {
}
/**
* @notice Register a strategy
* @param _strategy The strategy contract address;
*/
function registerStrategy(address _strategy) external onlyOwner {
}
/**
* @notice Update the address of an existing strategy
* @param _strategy The strategy contract address;
* @param _strategyId The strategy ID;
*/
function updateStrategy(address _strategy, uint32 _strategyId) external onlyOwner {
require(_strategy != address(0), "Invalid strategy");
require(<FILL_ME>)
address previousStrategy = strategyIndexToAddress[_strategyId];
strategyAddressToIndex[previousStrategy] = 0;
strategyAddressToIndex[_strategy] = _strategyId;
strategyIndexToAddress[_strategyId] = _strategy;
emit StrategyUpdated(previousStrategy, _strategy, _strategyId);
}
}
| strategyIndexToAddress[_strategyId]!=address(0),"Strategy doesn't exist" | 15,614 | strategyIndexToAddress[_strategyId]!=address(0) |
null | contract Decentralized_QUIZ
{
function Try(string memory _response) public payable
{
}
string public question;
bytes32 responseHash;
mapping (bytes32=>bool) admin;
function Start(string calldata _question, string calldata _response) public payable isAdmin{
}
function Stop() public payable isAdmin {
}
function New(string calldata _question, bytes32 _responseHash) public payable isAdmin {
}
constructor(bytes32[] memory admins) {
}
modifier isAdmin(){
require(<FILL_ME>)
_;
}
fallback() external {}
}
| admin[keccak256(abi.encodePacked(msg.sender))] | 15,617 | admin[keccak256(abi.encodePacked(msg.sender))] |
"max NFT per address exceeded for the first 500 " | pragma solidity >=0.7.0 <0.9.0;
contract HarambeDAO is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
string public uriPrefix = "ipfs://Qmf99foL5ZhKZ3EM5pfVYcJ9pMFgi6r3C9QQy9CT2XQvfP/";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost = 0.01 ether;
uint256 public maxSupply = 888;
uint256 public maxMintAmountPerTx = 20;
bool public paused = false;
bool public revealed = true;
constructor() ERC721("HarambeDAO", "HDAO") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function totalSupply() public view returns (uint256) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
uint256 supply = totalSupply();
if (msg.sender != owner()) {
require(!paused, "the contract is paused");
if(supply < 444) {
require(<FILL_ME>)
}
if(supply >= 444){
require(msg.value >= cost * _mintAmount, "insufficient funds");
}
if(supply >=888){
paused = true;
}
}
_mintLoop(msg.sender, _mintAmount);
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| supply+_mintAmount<=3,"max NFT per address exceeded for the first 500 " | 15,651 | supply+_mintAmount<=3 |
null | pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _new_owner) onlyOwner public returns (bool _success) {
}
}
contract Pausable is Ownable {
bool public paused = false;
modifier whenNotPaused() {
}
function setPauseStatus(bool _pause) onlyOwner public returns (bool _success) {
}
}
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool _success);
function transfer(address to, uint value, bytes data) public returns (bool _success);
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
function totalSupply() public view returns (uint256 _totalSupply);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool _success);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success);
function approve(address _spender, uint256 _value) public returns (bool _success);
function allowance(address _owner, address _spender) public view returns (uint256 _remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
}
}
contract ASTERISK is ERC223, Pausable {
using SafeMath for uint256;
string public name = "asterisk";
string public symbol = "ASTER";
uint8 public decimals = 9;
uint256 public totalSupply = 10e9 * 1e9;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public frozenAccount;
event Freeze(address indexed target, uint256 value);
event Unfreeze(address indexed target, uint256 value);
event Burn(address indexed from, uint256 amount);
event Rain(address indexed from, uint256 amount);
struct ITEM {
uint256 id;
address owner;
mapping(address => uint256) holders;
string name;
uint256 price;
uint256 itemTotalSupply;
bool transferable;
bool approveForAll;
string option;
uint256 limitHolding;
}
struct ALLOWANCEITEM {
uint256 amount;
uint256 price;
}
mapping(uint256 => ITEM) public items;
uint256 public itemId = 1;
mapping(address => mapping(address => mapping(uint256 => ALLOWANCEITEM))) public allowanceItems;
constructor() public {
}
modifier messageSenderNotFrozen() {
require(<FILL_ME>)
_;
}
function balanceOf(address _owner) public view returns (uint256 _balance) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value, bytes _data) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool _success) {
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool _success) {
}
function allowance(address _owner, address _spender) public view returns (uint256 _remaining) {
}
function freezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function unfreezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function isFrozenAccount(address _target) public view returns (bool _is_frozen){
}
function isContract(address _target) private view returns (bool _is_contract) {
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function burn(address _from, uint256 _amount) onlyOwner whenNotPaused public returns (bool _success) {
}
function rain(address[] _addresses, uint256 _amount) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function collectTokens(address[] _addresses, uint[] _amounts) onlyOwner whenNotPaused public returns (bool _success) {
}
function createItemId() whenNotPaused private returns (uint256 _id) {
}
function createItem(string _name, uint256 _initial_amount, uint256 _price, bool _transferable, bool _approve_for_all, string _option, uint256 _limit_holding) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (uint256 _id) {
}
function getItemAmountOf(uint256 _id, address _holder) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function setItemOption(uint256 _id, string _option) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemApproveForAll(uint256 _id, bool _approve_for_all) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemTransferable(uint256 _id, bool _transferable) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemPrice(uint256 _id, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemLimitHolding(uint256 _id, uint256 _limit) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function buyItem(uint256 _id, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function allowanceItem(uint256 _id, uint256 _amount, uint256 _price, address _to) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function getItemAllowanceAmount(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function getItemAllowancePrice(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _price) {
}
function transferItemFrom(uint256 _id, address _from, uint256 _amount, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function transferItem(uint256 _id, address _to, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
bool public isItemStopped = false;
modifier whenNotItemStopped() {
}
function setItemStoppedStatus(bool _status) onlyOwner whenNotPaused public returns (bool _success) {
}
function() payable public {}
}
| frozenAccount[msg.sender]==false | 15,655 | frozenAccount[msg.sender]==false |
null | pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _new_owner) onlyOwner public returns (bool _success) {
}
}
contract Pausable is Ownable {
bool public paused = false;
modifier whenNotPaused() {
}
function setPauseStatus(bool _pause) onlyOwner public returns (bool _success) {
}
}
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool _success);
function transfer(address to, uint value, bytes data) public returns (bool _success);
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
function totalSupply() public view returns (uint256 _totalSupply);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool _success);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success);
function approve(address _spender, uint256 _value) public returns (bool _success);
function allowance(address _owner, address _spender) public view returns (uint256 _remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
}
}
contract ASTERISK is ERC223, Pausable {
using SafeMath for uint256;
string public name = "asterisk";
string public symbol = "ASTER";
uint8 public decimals = 9;
uint256 public totalSupply = 10e9 * 1e9;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public frozenAccount;
event Freeze(address indexed target, uint256 value);
event Unfreeze(address indexed target, uint256 value);
event Burn(address indexed from, uint256 amount);
event Rain(address indexed from, uint256 amount);
struct ITEM {
uint256 id;
address owner;
mapping(address => uint256) holders;
string name;
uint256 price;
uint256 itemTotalSupply;
bool transferable;
bool approveForAll;
string option;
uint256 limitHolding;
}
struct ALLOWANCEITEM {
uint256 amount;
uint256 price;
}
mapping(uint256 => ITEM) public items;
uint256 public itemId = 1;
mapping(address => mapping(address => mapping(uint256 => ALLOWANCEITEM))) public allowanceItems;
constructor() public {
}
modifier messageSenderNotFrozen() {
}
function balanceOf(address _owner) public view returns (uint256 _balance) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value, bytes _data) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool _success) {
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool _success) {
}
function allowance(address _owner, address _spender) public view returns (uint256 _remaining) {
}
function freezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
require(_targets.length > 0);
for (uint j = 0; j < _targets.length; j++) {
require(<FILL_ME>)
frozenAccount[_targets[j]] = true;
emit Freeze(_targets[j], balanceOf[_targets[j]]);
}
return true;
}
function unfreezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function isFrozenAccount(address _target) public view returns (bool _is_frozen){
}
function isContract(address _target) private view returns (bool _is_contract) {
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function burn(address _from, uint256 _amount) onlyOwner whenNotPaused public returns (bool _success) {
}
function rain(address[] _addresses, uint256 _amount) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function collectTokens(address[] _addresses, uint[] _amounts) onlyOwner whenNotPaused public returns (bool _success) {
}
function createItemId() whenNotPaused private returns (uint256 _id) {
}
function createItem(string _name, uint256 _initial_amount, uint256 _price, bool _transferable, bool _approve_for_all, string _option, uint256 _limit_holding) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (uint256 _id) {
}
function getItemAmountOf(uint256 _id, address _holder) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function setItemOption(uint256 _id, string _option) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemApproveForAll(uint256 _id, bool _approve_for_all) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemTransferable(uint256 _id, bool _transferable) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemPrice(uint256 _id, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemLimitHolding(uint256 _id, uint256 _limit) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function buyItem(uint256 _id, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function allowanceItem(uint256 _id, uint256 _amount, uint256 _price, address _to) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function getItemAllowanceAmount(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function getItemAllowancePrice(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _price) {
}
function transferItemFrom(uint256 _id, address _from, uint256 _amount, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function transferItem(uint256 _id, address _to, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
bool public isItemStopped = false;
modifier whenNotItemStopped() {
}
function setItemStoppedStatus(bool _status) onlyOwner whenNotPaused public returns (bool _success) {
}
function() payable public {}
}
| _targets[j]!=0x0 | 15,655 | _targets[j]!=0x0 |
null | pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _new_owner) onlyOwner public returns (bool _success) {
}
}
contract Pausable is Ownable {
bool public paused = false;
modifier whenNotPaused() {
}
function setPauseStatus(bool _pause) onlyOwner public returns (bool _success) {
}
}
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool _success);
function transfer(address to, uint value, bytes data) public returns (bool _success);
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
function totalSupply() public view returns (uint256 _totalSupply);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool _success);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success);
function approve(address _spender, uint256 _value) public returns (bool _success);
function allowance(address _owner, address _spender) public view returns (uint256 _remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
}
}
contract ASTERISK is ERC223, Pausable {
using SafeMath for uint256;
string public name = "asterisk";
string public symbol = "ASTER";
uint8 public decimals = 9;
uint256 public totalSupply = 10e9 * 1e9;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public frozenAccount;
event Freeze(address indexed target, uint256 value);
event Unfreeze(address indexed target, uint256 value);
event Burn(address indexed from, uint256 amount);
event Rain(address indexed from, uint256 amount);
struct ITEM {
uint256 id;
address owner;
mapping(address => uint256) holders;
string name;
uint256 price;
uint256 itemTotalSupply;
bool transferable;
bool approveForAll;
string option;
uint256 limitHolding;
}
struct ALLOWANCEITEM {
uint256 amount;
uint256 price;
}
mapping(uint256 => ITEM) public items;
uint256 public itemId = 1;
mapping(address => mapping(address => mapping(uint256 => ALLOWANCEITEM))) public allowanceItems;
constructor() public {
}
modifier messageSenderNotFrozen() {
}
function balanceOf(address _owner) public view returns (uint256 _balance) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value, bytes _data) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool _success) {
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool _success) {
}
function allowance(address _owner, address _spender) public view returns (uint256 _remaining) {
}
function freezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function unfreezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function isFrozenAccount(address _target) public view returns (bool _is_frozen){
}
function isContract(address _target) private view returns (bool _is_contract) {
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function burn(address _from, uint256 _amount) onlyOwner whenNotPaused public returns (bool _success) {
}
function rain(address[] _addresses, uint256 _amount) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
require(_amount > 0 && _addresses.length > 0);
uint256 totalAmount = _amount.mul(_addresses.length);
require(<FILL_ME>)
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
for (uint j = 0; j < _addresses.length; j++) {
require(_addresses[j] != address(0));
balanceOf[_addresses[j]] = balanceOf[_addresses[j]].add(_amount);
emit Transfer(msg.sender, _addresses[j], _amount);
}
emit Rain(msg.sender, totalAmount);
return true;
}
function collectTokens(address[] _addresses, uint[] _amounts) onlyOwner whenNotPaused public returns (bool _success) {
}
function createItemId() whenNotPaused private returns (uint256 _id) {
}
function createItem(string _name, uint256 _initial_amount, uint256 _price, bool _transferable, bool _approve_for_all, string _option, uint256 _limit_holding) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (uint256 _id) {
}
function getItemAmountOf(uint256 _id, address _holder) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function setItemOption(uint256 _id, string _option) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemApproveForAll(uint256 _id, bool _approve_for_all) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemTransferable(uint256 _id, bool _transferable) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemPrice(uint256 _id, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemLimitHolding(uint256 _id, uint256 _limit) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function buyItem(uint256 _id, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function allowanceItem(uint256 _id, uint256 _amount, uint256 _price, address _to) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function getItemAllowanceAmount(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function getItemAllowancePrice(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _price) {
}
function transferItemFrom(uint256 _id, address _from, uint256 _amount, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function transferItem(uint256 _id, address _to, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
bool public isItemStopped = false;
modifier whenNotItemStopped() {
}
function setItemStoppedStatus(bool _status) onlyOwner whenNotPaused public returns (bool _success) {
}
function() payable public {}
}
| balanceOf[msg.sender]>=totalAmount | 15,655 | balanceOf[msg.sender]>=totalAmount |
null | pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _new_owner) onlyOwner public returns (bool _success) {
}
}
contract Pausable is Ownable {
bool public paused = false;
modifier whenNotPaused() {
}
function setPauseStatus(bool _pause) onlyOwner public returns (bool _success) {
}
}
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool _success);
function transfer(address to, uint value, bytes data) public returns (bool _success);
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
function totalSupply() public view returns (uint256 _totalSupply);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool _success);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success);
function approve(address _spender, uint256 _value) public returns (bool _success);
function allowance(address _owner, address _spender) public view returns (uint256 _remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
}
}
contract ASTERISK is ERC223, Pausable {
using SafeMath for uint256;
string public name = "asterisk";
string public symbol = "ASTER";
uint8 public decimals = 9;
uint256 public totalSupply = 10e9 * 1e9;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public frozenAccount;
event Freeze(address indexed target, uint256 value);
event Unfreeze(address indexed target, uint256 value);
event Burn(address indexed from, uint256 amount);
event Rain(address indexed from, uint256 amount);
struct ITEM {
uint256 id;
address owner;
mapping(address => uint256) holders;
string name;
uint256 price;
uint256 itemTotalSupply;
bool transferable;
bool approveForAll;
string option;
uint256 limitHolding;
}
struct ALLOWANCEITEM {
uint256 amount;
uint256 price;
}
mapping(uint256 => ITEM) public items;
uint256 public itemId = 1;
mapping(address => mapping(address => mapping(uint256 => ALLOWANCEITEM))) public allowanceItems;
constructor() public {
}
modifier messageSenderNotFrozen() {
}
function balanceOf(address _owner) public view returns (uint256 _balance) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value, bytes _data) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool _success) {
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool _success) {
}
function allowance(address _owner, address _spender) public view returns (uint256 _remaining) {
}
function freezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function unfreezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function isFrozenAccount(address _target) public view returns (bool _is_frozen){
}
function isContract(address _target) private view returns (bool _is_contract) {
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function burn(address _from, uint256 _amount) onlyOwner whenNotPaused public returns (bool _success) {
}
function rain(address[] _addresses, uint256 _amount) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
require(_amount > 0 && _addresses.length > 0);
uint256 totalAmount = _amount.mul(_addresses.length);
require(balanceOf[msg.sender] >= totalAmount);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
for (uint j = 0; j < _addresses.length; j++) {
require(<FILL_ME>)
balanceOf[_addresses[j]] = balanceOf[_addresses[j]].add(_amount);
emit Transfer(msg.sender, _addresses[j], _amount);
}
emit Rain(msg.sender, totalAmount);
return true;
}
function collectTokens(address[] _addresses, uint[] _amounts) onlyOwner whenNotPaused public returns (bool _success) {
}
function createItemId() whenNotPaused private returns (uint256 _id) {
}
function createItem(string _name, uint256 _initial_amount, uint256 _price, bool _transferable, bool _approve_for_all, string _option, uint256 _limit_holding) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (uint256 _id) {
}
function getItemAmountOf(uint256 _id, address _holder) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function setItemOption(uint256 _id, string _option) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemApproveForAll(uint256 _id, bool _approve_for_all) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemTransferable(uint256 _id, bool _transferable) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemPrice(uint256 _id, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemLimitHolding(uint256 _id, uint256 _limit) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function buyItem(uint256 _id, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function allowanceItem(uint256 _id, uint256 _amount, uint256 _price, address _to) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function getItemAllowanceAmount(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function getItemAllowancePrice(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _price) {
}
function transferItemFrom(uint256 _id, address _from, uint256 _amount, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function transferItem(uint256 _id, address _to, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
bool public isItemStopped = false;
modifier whenNotItemStopped() {
}
function setItemStoppedStatus(bool _status) onlyOwner whenNotPaused public returns (bool _success) {
}
function() payable public {}
}
| _addresses[j]!=address(0) | 15,655 | _addresses[j]!=address(0) |
null | pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _new_owner) onlyOwner public returns (bool _success) {
}
}
contract Pausable is Ownable {
bool public paused = false;
modifier whenNotPaused() {
}
function setPauseStatus(bool _pause) onlyOwner public returns (bool _success) {
}
}
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool _success);
function transfer(address to, uint value, bytes data) public returns (bool _success);
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
function totalSupply() public view returns (uint256 _totalSupply);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool _success);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success);
function approve(address _spender, uint256 _value) public returns (bool _success);
function allowance(address _owner, address _spender) public view returns (uint256 _remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
}
}
contract ASTERISK is ERC223, Pausable {
using SafeMath for uint256;
string public name = "asterisk";
string public symbol = "ASTER";
uint8 public decimals = 9;
uint256 public totalSupply = 10e9 * 1e9;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public frozenAccount;
event Freeze(address indexed target, uint256 value);
event Unfreeze(address indexed target, uint256 value);
event Burn(address indexed from, uint256 amount);
event Rain(address indexed from, uint256 amount);
struct ITEM {
uint256 id;
address owner;
mapping(address => uint256) holders;
string name;
uint256 price;
uint256 itemTotalSupply;
bool transferable;
bool approveForAll;
string option;
uint256 limitHolding;
}
struct ALLOWANCEITEM {
uint256 amount;
uint256 price;
}
mapping(uint256 => ITEM) public items;
uint256 public itemId = 1;
mapping(address => mapping(address => mapping(uint256 => ALLOWANCEITEM))) public allowanceItems;
constructor() public {
}
modifier messageSenderNotFrozen() {
}
function balanceOf(address _owner) public view returns (uint256 _balance) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value, bytes _data) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool _success) {
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool _success) {
}
function allowance(address _owner, address _spender) public view returns (uint256 _remaining) {
}
function freezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function unfreezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function isFrozenAccount(address _target) public view returns (bool _is_frozen){
}
function isContract(address _target) private view returns (bool _is_contract) {
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function burn(address _from, uint256 _amount) onlyOwner whenNotPaused public returns (bool _success) {
}
function rain(address[] _addresses, uint256 _amount) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function collectTokens(address[] _addresses, uint[] _amounts) onlyOwner whenNotPaused public returns (bool _success) {
require(_addresses.length > 0 && _amounts.length > 0
&& _addresses.length == _amounts.length);
uint256 totalAmount = 0;
for (uint j = 0; j < _addresses.length; j++) {
require(<FILL_ME>)
balanceOf[_addresses[j]] = balanceOf[_addresses[j]].sub(_amounts[j]);
totalAmount = totalAmount.add(_amounts[j]);
emit Transfer(_addresses[j], msg.sender, _amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].add(totalAmount);
return true;
}
function createItemId() whenNotPaused private returns (uint256 _id) {
}
function createItem(string _name, uint256 _initial_amount, uint256 _price, bool _transferable, bool _approve_for_all, string _option, uint256 _limit_holding) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (uint256 _id) {
}
function getItemAmountOf(uint256 _id, address _holder) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function setItemOption(uint256 _id, string _option) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemApproveForAll(uint256 _id, bool _approve_for_all) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemTransferable(uint256 _id, bool _transferable) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemPrice(uint256 _id, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemLimitHolding(uint256 _id, uint256 _limit) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function buyItem(uint256 _id, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function allowanceItem(uint256 _id, uint256 _amount, uint256 _price, address _to) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function getItemAllowanceAmount(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function getItemAllowancePrice(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _price) {
}
function transferItemFrom(uint256 _id, address _from, uint256 _amount, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function transferItem(uint256 _id, address _to, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
bool public isItemStopped = false;
modifier whenNotItemStopped() {
}
function setItemStoppedStatus(bool _status) onlyOwner whenNotPaused public returns (bool _success) {
}
function() payable public {}
}
| _amounts[j]>0&&_addresses[j]!=address(0)&&balanceOf[_addresses[j]]>=_amounts[j] | 15,655 | _amounts[j]>0&&_addresses[j]!=address(0)&&balanceOf[_addresses[j]]>=_amounts[j] |
null | pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _new_owner) onlyOwner public returns (bool _success) {
}
}
contract Pausable is Ownable {
bool public paused = false;
modifier whenNotPaused() {
}
function setPauseStatus(bool _pause) onlyOwner public returns (bool _success) {
}
}
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool _success);
function transfer(address to, uint value, bytes data) public returns (bool _success);
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
function totalSupply() public view returns (uint256 _totalSupply);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool _success);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success);
function approve(address _spender, uint256 _value) public returns (bool _success);
function allowance(address _owner, address _spender) public view returns (uint256 _remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
}
}
contract ASTERISK is ERC223, Pausable {
using SafeMath for uint256;
string public name = "asterisk";
string public symbol = "ASTER";
uint8 public decimals = 9;
uint256 public totalSupply = 10e9 * 1e9;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public frozenAccount;
event Freeze(address indexed target, uint256 value);
event Unfreeze(address indexed target, uint256 value);
event Burn(address indexed from, uint256 amount);
event Rain(address indexed from, uint256 amount);
struct ITEM {
uint256 id;
address owner;
mapping(address => uint256) holders;
string name;
uint256 price;
uint256 itemTotalSupply;
bool transferable;
bool approveForAll;
string option;
uint256 limitHolding;
}
struct ALLOWANCEITEM {
uint256 amount;
uint256 price;
}
mapping(uint256 => ITEM) public items;
uint256 public itemId = 1;
mapping(address => mapping(address => mapping(uint256 => ALLOWANCEITEM))) public allowanceItems;
constructor() public {
}
modifier messageSenderNotFrozen() {
}
function balanceOf(address _owner) public view returns (uint256 _balance) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value, bytes _data) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool _success) {
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool _success) {
}
function allowance(address _owner, address _spender) public view returns (uint256 _remaining) {
}
function freezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function unfreezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function isFrozenAccount(address _target) public view returns (bool _is_frozen){
}
function isContract(address _target) private view returns (bool _is_contract) {
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function burn(address _from, uint256 _amount) onlyOwner whenNotPaused public returns (bool _success) {
}
function rain(address[] _addresses, uint256 _amount) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function collectTokens(address[] _addresses, uint[] _amounts) onlyOwner whenNotPaused public returns (bool _success) {
}
function createItemId() whenNotPaused private returns (uint256 _id) {
}
function createItem(string _name, uint256 _initial_amount, uint256 _price, bool _transferable, bool _approve_for_all, string _option, uint256 _limit_holding) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (uint256 _id) {
}
function getItemAmountOf(uint256 _id, address _holder) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function setItemOption(uint256 _id, string _option) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
require(<FILL_ME>)
items[_id].option = _option;
return true;
}
function setItemApproveForAll(uint256 _id, bool _approve_for_all) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemTransferable(uint256 _id, bool _transferable) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemPrice(uint256 _id, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemLimitHolding(uint256 _id, uint256 _limit) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function buyItem(uint256 _id, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function allowanceItem(uint256 _id, uint256 _amount, uint256 _price, address _to) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function getItemAllowanceAmount(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function getItemAllowancePrice(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _price) {
}
function transferItemFrom(uint256 _id, address _from, uint256 _amount, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function transferItem(uint256 _id, address _to, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
bool public isItemStopped = false;
modifier whenNotItemStopped() {
}
function setItemStoppedStatus(bool _status) onlyOwner whenNotPaused public returns (bool _success) {
}
function() payable public {}
}
| items[_id].owner==msg.sender | 15,655 | items[_id].owner==msg.sender |
null | pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _new_owner) onlyOwner public returns (bool _success) {
}
}
contract Pausable is Ownable {
bool public paused = false;
modifier whenNotPaused() {
}
function setPauseStatus(bool _pause) onlyOwner public returns (bool _success) {
}
}
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool _success);
function transfer(address to, uint value, bytes data) public returns (bool _success);
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
function totalSupply() public view returns (uint256 _totalSupply);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool _success);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success);
function approve(address _spender, uint256 _value) public returns (bool _success);
function allowance(address _owner, address _spender) public view returns (uint256 _remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
}
}
contract ASTERISK is ERC223, Pausable {
using SafeMath for uint256;
string public name = "asterisk";
string public symbol = "ASTER";
uint8 public decimals = 9;
uint256 public totalSupply = 10e9 * 1e9;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public frozenAccount;
event Freeze(address indexed target, uint256 value);
event Unfreeze(address indexed target, uint256 value);
event Burn(address indexed from, uint256 amount);
event Rain(address indexed from, uint256 amount);
struct ITEM {
uint256 id;
address owner;
mapping(address => uint256) holders;
string name;
uint256 price;
uint256 itemTotalSupply;
bool transferable;
bool approveForAll;
string option;
uint256 limitHolding;
}
struct ALLOWANCEITEM {
uint256 amount;
uint256 price;
}
mapping(uint256 => ITEM) public items;
uint256 public itemId = 1;
mapping(address => mapping(address => mapping(uint256 => ALLOWANCEITEM))) public allowanceItems;
constructor() public {
}
modifier messageSenderNotFrozen() {
}
function balanceOf(address _owner) public view returns (uint256 _balance) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value, bytes _data) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool _success) {
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool _success) {
}
function allowance(address _owner, address _spender) public view returns (uint256 _remaining) {
}
function freezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function unfreezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function isFrozenAccount(address _target) public view returns (bool _is_frozen){
}
function isContract(address _target) private view returns (bool _is_contract) {
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function burn(address _from, uint256 _amount) onlyOwner whenNotPaused public returns (bool _success) {
}
function rain(address[] _addresses, uint256 _amount) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function collectTokens(address[] _addresses, uint[] _amounts) onlyOwner whenNotPaused public returns (bool _success) {
}
function createItemId() whenNotPaused private returns (uint256 _id) {
}
function createItem(string _name, uint256 _initial_amount, uint256 _price, bool _transferable, bool _approve_for_all, string _option, uint256 _limit_holding) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (uint256 _id) {
}
function getItemAmountOf(uint256 _id, address _holder) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function setItemOption(uint256 _id, string _option) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemApproveForAll(uint256 _id, bool _approve_for_all) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemTransferable(uint256 _id, bool _transferable) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemPrice(uint256 _id, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
require(<FILL_ME>)
items[_id].price = _price;
return true;
}
function setItemLimitHolding(uint256 _id, uint256 _limit) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function buyItem(uint256 _id, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function allowanceItem(uint256 _id, uint256 _amount, uint256 _price, address _to) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function getItemAllowanceAmount(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function getItemAllowancePrice(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _price) {
}
function transferItemFrom(uint256 _id, address _from, uint256 _amount, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function transferItem(uint256 _id, address _to, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
bool public isItemStopped = false;
modifier whenNotItemStopped() {
}
function setItemStoppedStatus(bool _status) onlyOwner whenNotPaused public returns (bool _success) {
}
function() payable public {}
}
| items[_id].owner==msg.sender&&_price>=0 | 15,655 | items[_id].owner==msg.sender&&_price>=0 |
null | pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _new_owner) onlyOwner public returns (bool _success) {
}
}
contract Pausable is Ownable {
bool public paused = false;
modifier whenNotPaused() {
}
function setPauseStatus(bool _pause) onlyOwner public returns (bool _success) {
}
}
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool _success);
function transfer(address to, uint value, bytes data) public returns (bool _success);
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
function totalSupply() public view returns (uint256 _totalSupply);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool _success);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success);
function approve(address _spender, uint256 _value) public returns (bool _success);
function allowance(address _owner, address _spender) public view returns (uint256 _remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
}
}
contract ASTERISK is ERC223, Pausable {
using SafeMath for uint256;
string public name = "asterisk";
string public symbol = "ASTER";
uint8 public decimals = 9;
uint256 public totalSupply = 10e9 * 1e9;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public frozenAccount;
event Freeze(address indexed target, uint256 value);
event Unfreeze(address indexed target, uint256 value);
event Burn(address indexed from, uint256 amount);
event Rain(address indexed from, uint256 amount);
struct ITEM {
uint256 id;
address owner;
mapping(address => uint256) holders;
string name;
uint256 price;
uint256 itemTotalSupply;
bool transferable;
bool approveForAll;
string option;
uint256 limitHolding;
}
struct ALLOWANCEITEM {
uint256 amount;
uint256 price;
}
mapping(uint256 => ITEM) public items;
uint256 public itemId = 1;
mapping(address => mapping(address => mapping(uint256 => ALLOWANCEITEM))) public allowanceItems;
constructor() public {
}
modifier messageSenderNotFrozen() {
}
function balanceOf(address _owner) public view returns (uint256 _balance) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value, bytes _data) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool _success) {
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool _success) {
}
function allowance(address _owner, address _spender) public view returns (uint256 _remaining) {
}
function freezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function unfreezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function isFrozenAccount(address _target) public view returns (bool _is_frozen){
}
function isContract(address _target) private view returns (bool _is_contract) {
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function burn(address _from, uint256 _amount) onlyOwner whenNotPaused public returns (bool _success) {
}
function rain(address[] _addresses, uint256 _amount) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function collectTokens(address[] _addresses, uint[] _amounts) onlyOwner whenNotPaused public returns (bool _success) {
}
function createItemId() whenNotPaused private returns (uint256 _id) {
}
function createItem(string _name, uint256 _initial_amount, uint256 _price, bool _transferable, bool _approve_for_all, string _option, uint256 _limit_holding) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (uint256 _id) {
}
function getItemAmountOf(uint256 _id, address _holder) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function setItemOption(uint256 _id, string _option) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemApproveForAll(uint256 _id, bool _approve_for_all) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemTransferable(uint256 _id, bool _transferable) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemPrice(uint256 _id, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemLimitHolding(uint256 _id, uint256 _limit) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
require(<FILL_ME>)
items[_id].limitHolding = _limit;
return true;
}
function buyItem(uint256 _id, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function allowanceItem(uint256 _id, uint256 _amount, uint256 _price, address _to) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function getItemAllowanceAmount(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function getItemAllowancePrice(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _price) {
}
function transferItemFrom(uint256 _id, address _from, uint256 _amount, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function transferItem(uint256 _id, address _to, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
bool public isItemStopped = false;
modifier whenNotItemStopped() {
}
function setItemStoppedStatus(bool _status) onlyOwner whenNotPaused public returns (bool _success) {
}
function() payable public {}
}
| items[_id].owner==msg.sender&&_limit>0 | 15,655 | items[_id].owner==msg.sender&&_limit>0 |
null | pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _new_owner) onlyOwner public returns (bool _success) {
}
}
contract Pausable is Ownable {
bool public paused = false;
modifier whenNotPaused() {
}
function setPauseStatus(bool _pause) onlyOwner public returns (bool _success) {
}
}
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool _success);
function transfer(address to, uint value, bytes data) public returns (bool _success);
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
function totalSupply() public view returns (uint256 _totalSupply);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool _success);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success);
function approve(address _spender, uint256 _value) public returns (bool _success);
function allowance(address _owner, address _spender) public view returns (uint256 _remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
}
}
contract ASTERISK is ERC223, Pausable {
using SafeMath for uint256;
string public name = "asterisk";
string public symbol = "ASTER";
uint8 public decimals = 9;
uint256 public totalSupply = 10e9 * 1e9;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public frozenAccount;
event Freeze(address indexed target, uint256 value);
event Unfreeze(address indexed target, uint256 value);
event Burn(address indexed from, uint256 amount);
event Rain(address indexed from, uint256 amount);
struct ITEM {
uint256 id;
address owner;
mapping(address => uint256) holders;
string name;
uint256 price;
uint256 itemTotalSupply;
bool transferable;
bool approveForAll;
string option;
uint256 limitHolding;
}
struct ALLOWANCEITEM {
uint256 amount;
uint256 price;
}
mapping(uint256 => ITEM) public items;
uint256 public itemId = 1;
mapping(address => mapping(address => mapping(uint256 => ALLOWANCEITEM))) public allowanceItems;
constructor() public {
}
modifier messageSenderNotFrozen() {
}
function balanceOf(address _owner) public view returns (uint256 _balance) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value, bytes _data) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool _success) {
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool _success) {
}
function allowance(address _owner, address _spender) public view returns (uint256 _remaining) {
}
function freezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function unfreezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function isFrozenAccount(address _target) public view returns (bool _is_frozen){
}
function isContract(address _target) private view returns (bool _is_contract) {
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function burn(address _from, uint256 _amount) onlyOwner whenNotPaused public returns (bool _success) {
}
function rain(address[] _addresses, uint256 _amount) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function collectTokens(address[] _addresses, uint[] _amounts) onlyOwner whenNotPaused public returns (bool _success) {
}
function createItemId() whenNotPaused private returns (uint256 _id) {
}
function createItem(string _name, uint256 _initial_amount, uint256 _price, bool _transferable, bool _approve_for_all, string _option, uint256 _limit_holding) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (uint256 _id) {
}
function getItemAmountOf(uint256 _id, address _holder) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function setItemOption(uint256 _id, string _option) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemApproveForAll(uint256 _id, bool _approve_for_all) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemTransferable(uint256 _id, bool _transferable) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemPrice(uint256 _id, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemLimitHolding(uint256 _id, uint256 _limit) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function buyItem(uint256 _id, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
require(<FILL_ME>)
uint256 afterAmount = items[_id].holders[msg.sender].add(_amount);
require(items[_id].limitHolding >= afterAmount);
uint256 value = items[_id].price.mul(_amount);
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(value);
items[_id].holders[items[_id].owner] = items[_id].holders[items[_id].owner].sub(_amount);
items[_id].holders[msg.sender] = items[_id].holders[msg.sender].add(_amount);
balanceOf[items[_id].owner] = balanceOf[items[_id].owner].add(value);
return true;
}
function allowanceItem(uint256 _id, uint256 _amount, uint256 _price, address _to) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function getItemAllowanceAmount(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function getItemAllowancePrice(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _price) {
}
function transferItemFrom(uint256 _id, address _from, uint256 _amount, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function transferItem(uint256 _id, address _to, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
bool public isItemStopped = false;
modifier whenNotItemStopped() {
}
function setItemStoppedStatus(bool _status) onlyOwner whenNotPaused public returns (bool _success) {
}
function() payable public {}
}
| items[_id].approveForAll&&_amount>0&&items[_id].holders[items[_id].owner]>=_amount | 15,655 | items[_id].approveForAll&&_amount>0&&items[_id].holders[items[_id].owner]>=_amount |
null | pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _new_owner) onlyOwner public returns (bool _success) {
}
}
contract Pausable is Ownable {
bool public paused = false;
modifier whenNotPaused() {
}
function setPauseStatus(bool _pause) onlyOwner public returns (bool _success) {
}
}
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool _success);
function transfer(address to, uint value, bytes data) public returns (bool _success);
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
function totalSupply() public view returns (uint256 _totalSupply);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool _success);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success);
function approve(address _spender, uint256 _value) public returns (bool _success);
function allowance(address _owner, address _spender) public view returns (uint256 _remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
}
}
contract ASTERISK is ERC223, Pausable {
using SafeMath for uint256;
string public name = "asterisk";
string public symbol = "ASTER";
uint8 public decimals = 9;
uint256 public totalSupply = 10e9 * 1e9;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public frozenAccount;
event Freeze(address indexed target, uint256 value);
event Unfreeze(address indexed target, uint256 value);
event Burn(address indexed from, uint256 amount);
event Rain(address indexed from, uint256 amount);
struct ITEM {
uint256 id;
address owner;
mapping(address => uint256) holders;
string name;
uint256 price;
uint256 itemTotalSupply;
bool transferable;
bool approveForAll;
string option;
uint256 limitHolding;
}
struct ALLOWANCEITEM {
uint256 amount;
uint256 price;
}
mapping(uint256 => ITEM) public items;
uint256 public itemId = 1;
mapping(address => mapping(address => mapping(uint256 => ALLOWANCEITEM))) public allowanceItems;
constructor() public {
}
modifier messageSenderNotFrozen() {
}
function balanceOf(address _owner) public view returns (uint256 _balance) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value, bytes _data) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool _success) {
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool _success) {
}
function allowance(address _owner, address _spender) public view returns (uint256 _remaining) {
}
function freezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function unfreezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function isFrozenAccount(address _target) public view returns (bool _is_frozen){
}
function isContract(address _target) private view returns (bool _is_contract) {
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function burn(address _from, uint256 _amount) onlyOwner whenNotPaused public returns (bool _success) {
}
function rain(address[] _addresses, uint256 _amount) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function collectTokens(address[] _addresses, uint[] _amounts) onlyOwner whenNotPaused public returns (bool _success) {
}
function createItemId() whenNotPaused private returns (uint256 _id) {
}
function createItem(string _name, uint256 _initial_amount, uint256 _price, bool _transferable, bool _approve_for_all, string _option, uint256 _limit_holding) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (uint256 _id) {
}
function getItemAmountOf(uint256 _id, address _holder) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function setItemOption(uint256 _id, string _option) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemApproveForAll(uint256 _id, bool _approve_for_all) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemTransferable(uint256 _id, bool _transferable) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemPrice(uint256 _id, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemLimitHolding(uint256 _id, uint256 _limit) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function buyItem(uint256 _id, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
require(items[_id].approveForAll
&& _amount > 0
&& items[_id].holders[items[_id].owner] >= _amount);
uint256 afterAmount = items[_id].holders[msg.sender].add(_amount);
require(<FILL_ME>)
uint256 value = items[_id].price.mul(_amount);
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(value);
items[_id].holders[items[_id].owner] = items[_id].holders[items[_id].owner].sub(_amount);
items[_id].holders[msg.sender] = items[_id].holders[msg.sender].add(_amount);
balanceOf[items[_id].owner] = balanceOf[items[_id].owner].add(value);
return true;
}
function allowanceItem(uint256 _id, uint256 _amount, uint256 _price, address _to) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function getItemAllowanceAmount(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function getItemAllowancePrice(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _price) {
}
function transferItemFrom(uint256 _id, address _from, uint256 _amount, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function transferItem(uint256 _id, address _to, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
bool public isItemStopped = false;
modifier whenNotItemStopped() {
}
function setItemStoppedStatus(bool _status) onlyOwner whenNotPaused public returns (bool _success) {
}
function() payable public {}
}
| items[_id].limitHolding>=afterAmount | 15,655 | items[_id].limitHolding>=afterAmount |
null | pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _new_owner) onlyOwner public returns (bool _success) {
}
}
contract Pausable is Ownable {
bool public paused = false;
modifier whenNotPaused() {
}
function setPauseStatus(bool _pause) onlyOwner public returns (bool _success) {
}
}
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool _success);
function transfer(address to, uint value, bytes data) public returns (bool _success);
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
function totalSupply() public view returns (uint256 _totalSupply);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool _success);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success);
function approve(address _spender, uint256 _value) public returns (bool _success);
function allowance(address _owner, address _spender) public view returns (uint256 _remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
}
}
contract ASTERISK is ERC223, Pausable {
using SafeMath for uint256;
string public name = "asterisk";
string public symbol = "ASTER";
uint8 public decimals = 9;
uint256 public totalSupply = 10e9 * 1e9;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public frozenAccount;
event Freeze(address indexed target, uint256 value);
event Unfreeze(address indexed target, uint256 value);
event Burn(address indexed from, uint256 amount);
event Rain(address indexed from, uint256 amount);
struct ITEM {
uint256 id;
address owner;
mapping(address => uint256) holders;
string name;
uint256 price;
uint256 itemTotalSupply;
bool transferable;
bool approveForAll;
string option;
uint256 limitHolding;
}
struct ALLOWANCEITEM {
uint256 amount;
uint256 price;
}
mapping(uint256 => ITEM) public items;
uint256 public itemId = 1;
mapping(address => mapping(address => mapping(uint256 => ALLOWANCEITEM))) public allowanceItems;
constructor() public {
}
modifier messageSenderNotFrozen() {
}
function balanceOf(address _owner) public view returns (uint256 _balance) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value, bytes _data) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool _success) {
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool _success) {
}
function allowance(address _owner, address _spender) public view returns (uint256 _remaining) {
}
function freezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function unfreezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function isFrozenAccount(address _target) public view returns (bool _is_frozen){
}
function isContract(address _target) private view returns (bool _is_contract) {
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function burn(address _from, uint256 _amount) onlyOwner whenNotPaused public returns (bool _success) {
}
function rain(address[] _addresses, uint256 _amount) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function collectTokens(address[] _addresses, uint[] _amounts) onlyOwner whenNotPaused public returns (bool _success) {
}
function createItemId() whenNotPaused private returns (uint256 _id) {
}
function createItem(string _name, uint256 _initial_amount, uint256 _price, bool _transferable, bool _approve_for_all, string _option, uint256 _limit_holding) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (uint256 _id) {
}
function getItemAmountOf(uint256 _id, address _holder) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function setItemOption(uint256 _id, string _option) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemApproveForAll(uint256 _id, bool _approve_for_all) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemTransferable(uint256 _id, bool _transferable) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemPrice(uint256 _id, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemLimitHolding(uint256 _id, uint256 _limit) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function buyItem(uint256 _id, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function allowanceItem(uint256 _id, uint256 _amount, uint256 _price, address _to) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function getItemAllowanceAmount(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function getItemAllowancePrice(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _price) {
}
function transferItemFrom(uint256 _id, address _from, uint256 _amount, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
require(_amount > 0 && _price >= 0 && frozenAccount[_from] == false);
uint256 value = _amount.mul(_price);
require(<FILL_ME>)
uint256 afterAmount = items[_id].holders[msg.sender].add(_amount);
require(items[_id].limitHolding >= afterAmount);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(value);
allowanceItems[_from][msg.sender][_id].amount = allowanceItems[_from][msg.sender][_id].amount.sub(_amount);
items[_id].holders[_from] = items[_id].holders[_from].sub(_amount);
items[_id].holders[msg.sender] = items[_id].holders[msg.sender].add(_amount);
balanceOf[_from] = balanceOf[_from].add(value);
return true;
}
function transferItem(uint256 _id, address _to, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
bool public isItemStopped = false;
modifier whenNotItemStopped() {
}
function setItemStoppedStatus(bool _status) onlyOwner whenNotPaused public returns (bool _success) {
}
function() payable public {}
}
| allowanceItems[_from][msg.sender][_id].amount>=_amount&&allowanceItems[_from][msg.sender][_id].price>=_price&&balanceOf[msg.sender]>=value&&items[_id].holders[_from]>=_amount&&items[_id].transferable | 15,655 | allowanceItems[_from][msg.sender][_id].amount>=_amount&&allowanceItems[_from][msg.sender][_id].price>=_price&&balanceOf[msg.sender]>=value&&items[_id].holders[_from]>=_amount&&items[_id].transferable |
null | pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _new_owner) onlyOwner public returns (bool _success) {
}
}
contract Pausable is Ownable {
bool public paused = false;
modifier whenNotPaused() {
}
function setPauseStatus(bool _pause) onlyOwner public returns (bool _success) {
}
}
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool _success);
function transfer(address to, uint value, bytes data) public returns (bool _success);
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
function totalSupply() public view returns (uint256 _totalSupply);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool _success);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success);
function approve(address _spender, uint256 _value) public returns (bool _success);
function allowance(address _owner, address _spender) public view returns (uint256 _remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
}
}
contract ASTERISK is ERC223, Pausable {
using SafeMath for uint256;
string public name = "asterisk";
string public symbol = "ASTER";
uint8 public decimals = 9;
uint256 public totalSupply = 10e9 * 1e9;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public frozenAccount;
event Freeze(address indexed target, uint256 value);
event Unfreeze(address indexed target, uint256 value);
event Burn(address indexed from, uint256 amount);
event Rain(address indexed from, uint256 amount);
struct ITEM {
uint256 id;
address owner;
mapping(address => uint256) holders;
string name;
uint256 price;
uint256 itemTotalSupply;
bool transferable;
bool approveForAll;
string option;
uint256 limitHolding;
}
struct ALLOWANCEITEM {
uint256 amount;
uint256 price;
}
mapping(uint256 => ITEM) public items;
uint256 public itemId = 1;
mapping(address => mapping(address => mapping(uint256 => ALLOWANCEITEM))) public allowanceItems;
constructor() public {
}
modifier messageSenderNotFrozen() {
}
function balanceOf(address _owner) public view returns (uint256 _balance) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value, bytes _data) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool _success) {
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool _success) {
}
function allowance(address _owner, address _spender) public view returns (uint256 _remaining) {
}
function freezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function unfreezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function isFrozenAccount(address _target) public view returns (bool _is_frozen){
}
function isContract(address _target) private view returns (bool _is_contract) {
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function burn(address _from, uint256 _amount) onlyOwner whenNotPaused public returns (bool _success) {
}
function rain(address[] _addresses, uint256 _amount) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function collectTokens(address[] _addresses, uint[] _amounts) onlyOwner whenNotPaused public returns (bool _success) {
}
function createItemId() whenNotPaused private returns (uint256 _id) {
}
function createItem(string _name, uint256 _initial_amount, uint256 _price, bool _transferable, bool _approve_for_all, string _option, uint256 _limit_holding) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (uint256 _id) {
}
function getItemAmountOf(uint256 _id, address _holder) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function setItemOption(uint256 _id, string _option) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemApproveForAll(uint256 _id, bool _approve_for_all) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemTransferable(uint256 _id, bool _transferable) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemPrice(uint256 _id, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemLimitHolding(uint256 _id, uint256 _limit) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function buyItem(uint256 _id, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function allowanceItem(uint256 _id, uint256 _amount, uint256 _price, address _to) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function getItemAllowanceAmount(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function getItemAllowancePrice(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _price) {
}
function transferItemFrom(uint256 _id, address _from, uint256 _amount, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function transferItem(uint256 _id, address _to, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
require(<FILL_ME>)
uint256 afterAmount = items[_id].holders[_to].add(_amount);
require(items[_id].limitHolding >= afterAmount);
items[_id].holders[msg.sender] = items[_id].holders[msg.sender].sub(_amount);
items[_id].holders[_to] = items[_id].holders[_to].add(_amount);
return true;
}
bool public isItemStopped = false;
modifier whenNotItemStopped() {
}
function setItemStoppedStatus(bool _status) onlyOwner whenNotPaused public returns (bool _success) {
}
function() payable public {}
}
| frozenAccount[_to]==false&&_to!=address(0)&&_amount>0&&items[_id].holders[msg.sender]>=_amount&&items[_id].transferable | 15,655 | frozenAccount[_to]==false&&_to!=address(0)&&_amount>0&&items[_id].holders[msg.sender]>=_amount&&items[_id].transferable |
null | pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address _new_owner) onlyOwner public returns (bool _success) {
}
}
contract Pausable is Ownable {
bool public paused = false;
modifier whenNotPaused() {
}
function setPauseStatus(bool _pause) onlyOwner public returns (bool _success) {
}
}
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool _success);
function transfer(address to, uint value, bytes data) public returns (bool _success);
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
function totalSupply() public view returns (uint256 _totalSupply);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool _success);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success);
function approve(address _spender, uint256 _value) public returns (bool _success);
function allowance(address _owner, address _spender) public view returns (uint256 _remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
}
}
contract ASTERISK is ERC223, Pausable {
using SafeMath for uint256;
string public name = "asterisk";
string public symbol = "ASTER";
uint8 public decimals = 9;
uint256 public totalSupply = 10e9 * 1e9;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public frozenAccount;
event Freeze(address indexed target, uint256 value);
event Unfreeze(address indexed target, uint256 value);
event Burn(address indexed from, uint256 amount);
event Rain(address indexed from, uint256 amount);
struct ITEM {
uint256 id;
address owner;
mapping(address => uint256) holders;
string name;
uint256 price;
uint256 itemTotalSupply;
bool transferable;
bool approveForAll;
string option;
uint256 limitHolding;
}
struct ALLOWANCEITEM {
uint256 amount;
uint256 price;
}
mapping(uint256 => ITEM) public items;
uint256 public itemId = 1;
mapping(address => mapping(address => mapping(uint256 => ALLOWANCEITEM))) public allowanceItems;
constructor() public {
}
modifier messageSenderNotFrozen() {
}
function balanceOf(address _owner) public view returns (uint256 _balance) {
}
function totalSupply() public view returns (uint256 _totalSupply) {
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value, bytes _data) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function transfer(address _to, uint _value) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function name() public view returns (string _name) {
}
function symbol() public view returns (string _symbol) {
}
function decimals() public view returns (uint8 _decimals) {
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool _success) {
}
function approve(address _spender, uint256 _value) whenNotPaused public returns (bool _success) {
}
function allowance(address _owner, address _spender) public view returns (uint256 _remaining) {
}
function freezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function unfreezeAccounts(address[] _targets) onlyOwner whenNotPaused public returns (bool _success) {
}
function isFrozenAccount(address _target) public view returns (bool _is_frozen){
}
function isContract(address _target) private view returns (bool _is_contract) {
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool _success) {
}
function burn(address _from, uint256 _amount) onlyOwner whenNotPaused public returns (bool _success) {
}
function rain(address[] _addresses, uint256 _amount) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
}
function collectTokens(address[] _addresses, uint[] _amounts) onlyOwner whenNotPaused public returns (bool _success) {
}
function createItemId() whenNotPaused private returns (uint256 _id) {
}
function createItem(string _name, uint256 _initial_amount, uint256 _price, bool _transferable, bool _approve_for_all, string _option, uint256 _limit_holding) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (uint256 _id) {
}
function getItemAmountOf(uint256 _id, address _holder) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function setItemOption(uint256 _id, string _option) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemApproveForAll(uint256 _id, bool _approve_for_all) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemTransferable(uint256 _id, bool _transferable) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemPrice(uint256 _id, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function setItemLimitHolding(uint256 _id, uint256 _limit) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function buyItem(uint256 _id, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function allowanceItem(uint256 _id, uint256 _amount, uint256 _price, address _to) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function getItemAllowanceAmount(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _amount) {
}
function getItemAllowancePrice(uint256 _id, address _from, address _to) whenNotItemStopped whenNotPaused public view returns (uint256 _price) {
}
function transferItemFrom(uint256 _id, address _from, uint256 _amount, uint256 _price) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
function transferItem(uint256 _id, address _to, uint256 _amount) messageSenderNotFrozen whenNotItemStopped whenNotPaused public returns (bool _success) {
}
bool public isItemStopped = false;
modifier whenNotItemStopped() {
require(<FILL_ME>)
_;
}
function setItemStoppedStatus(bool _status) onlyOwner whenNotPaused public returns (bool _success) {
}
function() payable public {}
}
| !isItemStopped | 15,655 | !isItemStopped |
null | // Datarius tokensale smart contract.
// Developed by Phenom.Team <[email protected]>
pragma solidity ^0.4.15;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint a, uint b) internal constant returns (uint) {
}
function div(uint a, uint b) internal constant returns(uint) {
}
function sub(uint a, uint b) internal constant returns(uint) {
}
function add(uint a, uint b) internal constant returns(uint) {
}
}
/**
* @title ERC20
* @dev Standart ERC20 token interface
*/
contract ERC20 {
uint public totalSupply = 0;
mapping(address => uint) balances;
mapping(address => mapping (address => uint)) allowed;
function balanceOf(address _owner) constant returns (uint);
function transfer(address _to, uint _value) returns (bool);
function transferFrom(address _from, address _to, uint _value) returns (bool);
function approve(address _spender, uint _value) returns (bool);
function allowance(address _owner, address _spender) constant returns (uint);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/**
* @title DatariusToken
* @dev Datarius token contract
*/
contract DatariusToken is ERC20 {
using SafeMath for uint;
string public name = "Datarius Credit";
string public symbol = "DTRC";
uint public decimals = 18;
// Ico contract address
address public ico;
event Burn(address indexed from, uint value);
// Tokens transfer ability status
bool public tokensAreFrozen = true;
// Allows execution by the owner only
modifier icoOnly {
}
/**
* @dev Contract constructor function sets Ico address
* @param _ico ico address
*/
function DatariusToken(address _ico) public {
}
/**
* @dev Function to mint tokens
* @param _holder beneficiary address the tokens will be issued to
* @param _value number of tokens to issue
*/
function mintTokens(address _holder, uint _value) external icoOnly {
}
/**
* @dev Function to enable token transfers
*/
function defrost() external icoOnly {
}
/**
* @dev Burn Tokens
* @param _holder token holder address which the tokens will be burnt
* @param _value number of tokens to burn
*/
function burnTokens(address _holder, uint _value) external icoOnly {
require(<FILL_ME>)
totalSupply = totalSupply.sub(_value);
balances[_holder] = balances[_holder].sub(_value);
Burn(_holder, _value);
}
/**
* @dev Get balance of tokens holder
* @param _holder holder's address
* @return balance of investor
*/
function balanceOf(address _holder) constant returns (uint) {
}
/**
* @dev Send coins
* throws on any error rather then return a false flag to minimize
* user errors
* @param _to target address
* @param _amount transfer amount
*
* @return true if the transfer was successful
*/
function transfer(address _to, uint _amount) public returns (bool) {
}
/**
* @dev An account/contract attempts to get the coins
* throws on any error rather then return a false flag to minimize user errors
*
* @param _from source address
* @param _to target address
* @param _amount transfer amount
*
* @return true if the transfer was successful
*/
function transferFrom(address _from, address _to, uint _amount) public returns (bool) {
}
/**
* @dev Allows another account/contract to spend some tokens on its behalf
* throws on any error rather then return a false flag to minimize user errors
*
* also, to minimize the risk of the approve/transferFrom attack vector
* approve has to be called twice in 2 separate transactions - once to
* change the allowance to 0 and secondly to change it to the new allowance
* value
*
* @param _spender approved address
* @param _amount allowance amount
*
* @return true if the approval was successful
*/
function approve(address _spender, uint _amount) public returns (bool) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
*
* @param _owner the address which owns the funds
* @param _spender the address which will spend the funds
*
* @return the amount of tokens still avaible for the spender
*/
function allowance(address _owner, address _spender) constant returns (uint) {
}
}
| balances[_holder]>0 | 15,691 | balances[_holder]>0 |
null | // Datarius tokensale smart contract.
// Developed by Phenom.Team <[email protected]>
pragma solidity ^0.4.15;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint a, uint b) internal constant returns (uint) {
}
function div(uint a, uint b) internal constant returns(uint) {
}
function sub(uint a, uint b) internal constant returns(uint) {
}
function add(uint a, uint b) internal constant returns(uint) {
}
}
/**
* @title ERC20
* @dev Standart ERC20 token interface
*/
contract ERC20 {
uint public totalSupply = 0;
mapping(address => uint) balances;
mapping(address => mapping (address => uint)) allowed;
function balanceOf(address _owner) constant returns (uint);
function transfer(address _to, uint _value) returns (bool);
function transferFrom(address _from, address _to, uint _value) returns (bool);
function approve(address _spender, uint _value) returns (bool);
function allowance(address _owner, address _spender) constant returns (uint);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
/**
* @title DatariusToken
* @dev Datarius token contract
*/
contract DatariusToken is ERC20 {
using SafeMath for uint;
string public name = "Datarius Credit";
string public symbol = "DTRC";
uint public decimals = 18;
// Ico contract address
address public ico;
event Burn(address indexed from, uint value);
// Tokens transfer ability status
bool public tokensAreFrozen = true;
// Allows execution by the owner only
modifier icoOnly {
}
/**
* @dev Contract constructor function sets Ico address
* @param _ico ico address
*/
function DatariusToken(address _ico) public {
}
/**
* @dev Function to mint tokens
* @param _holder beneficiary address the tokens will be issued to
* @param _value number of tokens to issue
*/
function mintTokens(address _holder, uint _value) external icoOnly {
}
/**
* @dev Function to enable token transfers
*/
function defrost() external icoOnly {
}
/**
* @dev Burn Tokens
* @param _holder token holder address which the tokens will be burnt
* @param _value number of tokens to burn
*/
function burnTokens(address _holder, uint _value) external icoOnly {
}
/**
* @dev Get balance of tokens holder
* @param _holder holder's address
* @return balance of investor
*/
function balanceOf(address _holder) constant returns (uint) {
}
/**
* @dev Send coins
* throws on any error rather then return a false flag to minimize
* user errors
* @param _to target address
* @param _amount transfer amount
*
* @return true if the transfer was successful
*/
function transfer(address _to, uint _amount) public returns (bool) {
require(<FILL_ME>)
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(msg.sender, _to, _amount);
return true;
}
/**
* @dev An account/contract attempts to get the coins
* throws on any error rather then return a false flag to minimize user errors
*
* @param _from source address
* @param _to target address
* @param _amount transfer amount
*
* @return true if the transfer was successful
*/
function transferFrom(address _from, address _to, uint _amount) public returns (bool) {
}
/**
* @dev Allows another account/contract to spend some tokens on its behalf
* throws on any error rather then return a false flag to minimize user errors
*
* also, to minimize the risk of the approve/transferFrom attack vector
* approve has to be called twice in 2 separate transactions - once to
* change the allowance to 0 and secondly to change it to the new allowance
* value
*
* @param _spender approved address
* @param _amount allowance amount
*
* @return true if the approval was successful
*/
function approve(address _spender, uint _amount) public returns (bool) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
*
* @param _owner the address which owns the funds
* @param _spender the address which will spend the funds
*
* @return the amount of tokens still avaible for the spender
*/
function allowance(address _owner, address _spender) constant returns (uint) {
}
}
| !tokensAreFrozen | 15,691 | !tokensAreFrozen |
null | /**
* @title CoinTool, support ETH and ERC20 Tokens
* @dev To Use this Dapp: https://cointool.app
*/
pragma solidity 0.4.24;
/**
* @title Proxy
* @dev Gives the possibility to delegate any call to a foreign implementation.
*/
contract Proxy {
/**
* @dev Tells the address of the implementation where every call will be delegated.
* @return address of the implementation to which it will be delegated
*/
function implementation() public view returns (address);
/**
* @dev Tells the version of the current implementation
* @return version of the current implementation
*/
function version() public view returns (string);
/**
* @dev Fallback function allowing to perform a delegatecall to the given implementation.
* This function will return whatever the implementation call returns
*/
function () payable public {
}
}
pragma solidity 0.4.24;
/**
* @title UpgradeabilityProxy
* @dev This contract represents a proxy where the implementation address to which it will delegate can be upgraded
*/
contract UpgradeabilityProxy is Proxy {
/**
* @dev This event will be emitted every time the implementation gets upgraded
* @param implementation representing the address of the upgraded implementation
*/
event Upgraded(address indexed implementation, string version);
// Storage position of the address of the current implementation
bytes32 private constant implementationPosition = keccak256("cointool.app.proxy.implementation");
//Version name of the current implementation
string internal _version;
/**
* @dev Constructor function
*/
constructor() public {}
/**
* @dev Tells the version name of the current implementation
* @return string representing the name of the current version
*/
function version() public view returns (string) {
}
/**
* @dev Tells the address of the current implementation
* @return address of the current implementation
*/
function implementation() public view returns (address impl) {
}
/**
* @dev Sets the address of the current implementation
* @param _newImplementation address representing the new implementation to be set
*/
function _setImplementation(address _newImplementation) internal {
}
/**
* @dev Upgrades the implementation address
* @param _newImplementation representing the address of the new implementation to be set
*/
function _upgradeTo(address _newImplementation, string _newVersion) internal {
}
}
pragma solidity 0.4.24;
/**
* @title CoinToolProxy
* @dev This contract combines an upgradeability proxy with basic authorization control functionalities
*/
contract CoinToolProxy is UpgradeabilityProxy {
/**
* @dev Event to show ownership has been transferred
* @param previousOwner representing the address of the previous owner
* @param newOwner representing the address of the new owner
*/
event ProxyOwnershipTransferred(address previousOwner, address newOwner);
// Storage position of the owner of the contract
bytes32 private constant proxyOwnerPosition = keccak256("cointool.app.proxy.owner");
/**
* @dev the constructor sets the original owner of the contract to the sender account.
*/
constructor(address _implementation, string _version) public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyProxyOwner() {
}
/**
* @dev Tells the address of the owner
* @return the address of the owner
*/
function proxyOwner() public view returns (address owner) {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferProxyOwnership(address _newOwner) public onlyProxyOwner {
}
/**
* @dev Allows the proxy owner to upgrade the current version of the proxy.
* @param _implementation representing the address of the new implementation to be set.
*/
function upgradeTo(address _implementation, string _newVersion) public onlyProxyOwner {
}
/**
* @dev Allows the proxy owner to upgrade the current version of the proxy and call the new implementation
* to initialize whatever is needed through a low level call.
* @param _implementation representing the address of the new implementation to be set.
* @param _data represents the msg.data to bet sent in the low level call. This parameter may include the function
* signature of the implementation to be called with the needed payload
*/
function upgradeToAndCall(address _implementation, string _newVersion, bytes _data) payable public onlyProxyOwner {
_upgradeTo(_implementation, _newVersion);
require(<FILL_ME>)
}
/*
* @dev Sets the address of the owner
*/
function _setUpgradeabilityOwner(address _newProxyOwner) internal {
}
}
| address(this).call.value(msg.value)(_data) | 15,694 | address(this).call.value(msg.value)(_data) |
"Initial supply cannot be more than available supply" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.3;
/////////////////////////////////////////////////
// ____ _ _ //
// | __ ) ___ _ __ __| | | | _ _ //
// | _ \ / _ \ | '_ \ / _` | | | | | | | //
// | |_) | | (_) | | | | | | (_| | | | | |_| | //
// |____/ \___/ |_| |_| \__,_| |_| \__, | //
// |___/ //
/////////////////////////////////////////////////
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155MetadataURI.sol";
contract BondlyLaunchPad is Ownable {
using Strings for string;
using SafeMath for uint256;
using Address for address;
uint256 public _currentCardId = 0;
address payable public _salesperson;
uint256 public _limitPerWallet;
bool public _saleStarted = false;
struct Card {
uint256 cardId;
uint256 tokenId;
uint256 totalAmount;
uint256 currentAmount;
uint256 basePrice;
uint256[] times;
uint8[] tiers;
address contractAddress;
bool isFinished;
}
struct History {
mapping(uint256 => mapping(address => uint8)) purchasedHistories; // tokenId -> wallet -> amount
}
// Events
event CreateCard(
address indexed _from,
uint256 _cardId,
address indexed _contractAddress,
uint256 _tokenId,
uint256 _totalAmount,
uint256 _basePrice
);
event PurchaseCard(address indexed _from, uint256 _cardId, uint256 _amount);
event CardChanged(uint256 _cardId);
mapping(uint256 => Card) public _cards;
mapping(address => bool) public _blacklist;
mapping(uint256 => mapping(address => uint8)) public _whitelist; // tokenId -> wallet -> whitelistLevel
// whitelist level | Priority
// 0: Not available | /\
// 1: selected winners | ||
// 2: bronze | ||
// 3: silver | ||
// 4: gold | ||
// 5: platinum | ||
mapping(address => History) private _history;
constructor() {
}
function setLimitPerWallet(uint256 limit) external onlyOwner {
}
function setSalesPerson(address payable newSalesPerson) external onlyOwner {
}
function startSale() external onlyOwner {
}
function stopSale() external onlyOwner {
}
function createCard(
address _contractAddress,
uint256 _tokenId,
uint256 _totalAmount,
uint256 _basePrice
) external onlyOwner {
IERC1155 _contract = IERC1155(_contractAddress);
require(<FILL_ME>)
require(
_contract.isApprovedForAll(_salesperson, address(this)) == true,
"Contract must be whitelisted by owner"
);
uint256 _id = _getNextCardID();
_incrementCardId();
Card memory _newCard;
_newCard.cardId = _id;
_newCard.contractAddress = _contractAddress;
_newCard.tokenId = _tokenId;
_newCard.totalAmount = _totalAmount;
_newCard.currentAmount = _totalAmount;
_newCard.basePrice = _basePrice;
_newCard.isFinished = false;
_cards[_id] = _newCard;
emit CreateCard(
msg.sender,
_id,
_contractAddress,
_tokenId,
_totalAmount,
_basePrice
);
}
function isEligbleToBuy(uint256 _cardId) public view returns (uint256) {
}
function purchaseNFT(uint256 _cardId, uint256 _amount) external payable {
}
function _getNextCardID() private view returns (uint256) {
}
function _incrementCardId() private {
}
function cancelCard(uint256 _cardId) external onlyOwner {
}
function setTimes(
uint256 _cardId,
uint8 _tier,
uint256 _finalTime
) external onlyOwner {
}
function resumeCard(uint256 _cardId) external onlyOwner {
}
function setCardPrice(uint256 _cardId, uint256 _newPrice)
external
onlyOwner
returns (bool)
{
}
function addBlackListAddress(address addr) external onlyOwner {
}
function batchAddBlackListAddress(address[] calldata addr)
external
onlyOwner
{
}
function removeBlackListAddress(address addr) external onlyOwner {
}
function batchRemoveBlackListAddress(address[] calldata addr)
external
onlyOwner
{
}
function addWhiteListAddress(
uint256 _cardId,
address _addr,
uint8 _tier
) external onlyOwner {
}
function batchAddWhiteListAddress(
uint256 _cardId,
address[] calldata _addr,
uint8 _tier
) external onlyOwner {
}
function isCardCompleted(uint256 _cardId) public view returns (bool) {
}
function isCardFree(uint256 _cardId) public view returns (bool) {
}
function getCardContract(uint256 _cardId) public view returns (address) {
}
function getCardTokenId(uint256 _cardId) public view returns (uint256) {
}
function getCardTime(uint256 _cardId)
public
view
returns (uint256[] memory)
{
}
function getCardTotalAmount(uint256 _cardId) public view returns (uint256) {
}
function getCardCurrentAmount(uint256 _cardId)
public
view
returns (uint256)
{
}
function getAllCardsPerContract(address _contractAddr)
public
view
returns (uint256[] memory, uint256[] memory)
{
}
function getActiveCardsPerContract(address _contractAddr)
public
view
returns (uint256[] memory, uint256[] memory)
{
}
function getClosedCardsPerContract(address _contractAddr)
public
view
returns (uint256[] memory, uint256[] memory)
{
}
function getCardBasePrice(uint256 _cardId) public view returns (uint256) {
}
function getCardURL(uint256 _cardId) public view returns (string memory) {
}
function collect(address _token) external onlyOwner {
}
}
| _contract.balanceOf(_salesperson,_tokenId)>=_totalAmount,"Initial supply cannot be more than available supply" | 15,916 | _contract.balanceOf(_salesperson,_tokenId)>=_totalAmount |
"Contract must be whitelisted by owner" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.3;
/////////////////////////////////////////////////
// ____ _ _ //
// | __ ) ___ _ __ __| | | | _ _ //
// | _ \ / _ \ | '_ \ / _` | | | | | | | //
// | |_) | | (_) | | | | | | (_| | | | | |_| | //
// |____/ \___/ |_| |_| \__,_| |_| \__, | //
// |___/ //
/////////////////////////////////////////////////
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155MetadataURI.sol";
contract BondlyLaunchPad is Ownable {
using Strings for string;
using SafeMath for uint256;
using Address for address;
uint256 public _currentCardId = 0;
address payable public _salesperson;
uint256 public _limitPerWallet;
bool public _saleStarted = false;
struct Card {
uint256 cardId;
uint256 tokenId;
uint256 totalAmount;
uint256 currentAmount;
uint256 basePrice;
uint256[] times;
uint8[] tiers;
address contractAddress;
bool isFinished;
}
struct History {
mapping(uint256 => mapping(address => uint8)) purchasedHistories; // tokenId -> wallet -> amount
}
// Events
event CreateCard(
address indexed _from,
uint256 _cardId,
address indexed _contractAddress,
uint256 _tokenId,
uint256 _totalAmount,
uint256 _basePrice
);
event PurchaseCard(address indexed _from, uint256 _cardId, uint256 _amount);
event CardChanged(uint256 _cardId);
mapping(uint256 => Card) public _cards;
mapping(address => bool) public _blacklist;
mapping(uint256 => mapping(address => uint8)) public _whitelist; // tokenId -> wallet -> whitelistLevel
// whitelist level | Priority
// 0: Not available | /\
// 1: selected winners | ||
// 2: bronze | ||
// 3: silver | ||
// 4: gold | ||
// 5: platinum | ||
mapping(address => History) private _history;
constructor() {
}
function setLimitPerWallet(uint256 limit) external onlyOwner {
}
function setSalesPerson(address payable newSalesPerson) external onlyOwner {
}
function startSale() external onlyOwner {
}
function stopSale() external onlyOwner {
}
function createCard(
address _contractAddress,
uint256 _tokenId,
uint256 _totalAmount,
uint256 _basePrice
) external onlyOwner {
IERC1155 _contract = IERC1155(_contractAddress);
require(
_contract.balanceOf(_salesperson, _tokenId) >= _totalAmount,
"Initial supply cannot be more than available supply"
);
require(<FILL_ME>)
uint256 _id = _getNextCardID();
_incrementCardId();
Card memory _newCard;
_newCard.cardId = _id;
_newCard.contractAddress = _contractAddress;
_newCard.tokenId = _tokenId;
_newCard.totalAmount = _totalAmount;
_newCard.currentAmount = _totalAmount;
_newCard.basePrice = _basePrice;
_newCard.isFinished = false;
_cards[_id] = _newCard;
emit CreateCard(
msg.sender,
_id,
_contractAddress,
_tokenId,
_totalAmount,
_basePrice
);
}
function isEligbleToBuy(uint256 _cardId) public view returns (uint256) {
}
function purchaseNFT(uint256 _cardId, uint256 _amount) external payable {
}
function _getNextCardID() private view returns (uint256) {
}
function _incrementCardId() private {
}
function cancelCard(uint256 _cardId) external onlyOwner {
}
function setTimes(
uint256 _cardId,
uint8 _tier,
uint256 _finalTime
) external onlyOwner {
}
function resumeCard(uint256 _cardId) external onlyOwner {
}
function setCardPrice(uint256 _cardId, uint256 _newPrice)
external
onlyOwner
returns (bool)
{
}
function addBlackListAddress(address addr) external onlyOwner {
}
function batchAddBlackListAddress(address[] calldata addr)
external
onlyOwner
{
}
function removeBlackListAddress(address addr) external onlyOwner {
}
function batchRemoveBlackListAddress(address[] calldata addr)
external
onlyOwner
{
}
function addWhiteListAddress(
uint256 _cardId,
address _addr,
uint8 _tier
) external onlyOwner {
}
function batchAddWhiteListAddress(
uint256 _cardId,
address[] calldata _addr,
uint8 _tier
) external onlyOwner {
}
function isCardCompleted(uint256 _cardId) public view returns (bool) {
}
function isCardFree(uint256 _cardId) public view returns (bool) {
}
function getCardContract(uint256 _cardId) public view returns (address) {
}
function getCardTokenId(uint256 _cardId) public view returns (uint256) {
}
function getCardTime(uint256 _cardId)
public
view
returns (uint256[] memory)
{
}
function getCardTotalAmount(uint256 _cardId) public view returns (uint256) {
}
function getCardCurrentAmount(uint256 _cardId)
public
view
returns (uint256)
{
}
function getAllCardsPerContract(address _contractAddr)
public
view
returns (uint256[] memory, uint256[] memory)
{
}
function getActiveCardsPerContract(address _contractAddr)
public
view
returns (uint256[] memory, uint256[] memory)
{
}
function getClosedCardsPerContract(address _contractAddr)
public
view
returns (uint256[] memory, uint256[] memory)
{
}
function getCardBasePrice(uint256 _cardId) public view returns (uint256) {
}
function getCardURL(uint256 _cardId) public view returns (string memory) {
}
function collect(address _token) external onlyOwner {
}
}
| _contract.isApprovedForAll(_salesperson,address(this))==true,"Contract must be whitelisted by owner" | 15,916 | _contract.isApprovedForAll(_salesperson,address(this))==true |
"you are blocked" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.3;
/////////////////////////////////////////////////
// ____ _ _ //
// | __ ) ___ _ __ __| | | | _ _ //
// | _ \ / _ \ | '_ \ / _` | | | | | | | //
// | |_) | | (_) | | | | | | (_| | | | | |_| | //
// |____/ \___/ |_| |_| \__,_| |_| \__, | //
// |___/ //
/////////////////////////////////////////////////
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155MetadataURI.sol";
contract BondlyLaunchPad is Ownable {
using Strings for string;
using SafeMath for uint256;
using Address for address;
uint256 public _currentCardId = 0;
address payable public _salesperson;
uint256 public _limitPerWallet;
bool public _saleStarted = false;
struct Card {
uint256 cardId;
uint256 tokenId;
uint256 totalAmount;
uint256 currentAmount;
uint256 basePrice;
uint256[] times;
uint8[] tiers;
address contractAddress;
bool isFinished;
}
struct History {
mapping(uint256 => mapping(address => uint8)) purchasedHistories; // tokenId -> wallet -> amount
}
// Events
event CreateCard(
address indexed _from,
uint256 _cardId,
address indexed _contractAddress,
uint256 _tokenId,
uint256 _totalAmount,
uint256 _basePrice
);
event PurchaseCard(address indexed _from, uint256 _cardId, uint256 _amount);
event CardChanged(uint256 _cardId);
mapping(uint256 => Card) public _cards;
mapping(address => bool) public _blacklist;
mapping(uint256 => mapping(address => uint8)) public _whitelist; // tokenId -> wallet -> whitelistLevel
// whitelist level | Priority
// 0: Not available | /\
// 1: selected winners | ||
// 2: bronze | ||
// 3: silver | ||
// 4: gold | ||
// 5: platinum | ||
mapping(address => History) private _history;
constructor() {
}
function setLimitPerWallet(uint256 limit) external onlyOwner {
}
function setSalesPerson(address payable newSalesPerson) external onlyOwner {
}
function startSale() external onlyOwner {
}
function stopSale() external onlyOwner {
}
function createCard(
address _contractAddress,
uint256 _tokenId,
uint256 _totalAmount,
uint256 _basePrice
) external onlyOwner {
}
function isEligbleToBuy(uint256 _cardId) public view returns (uint256) {
}
function purchaseNFT(uint256 _cardId, uint256 _amount) external payable {
require(<FILL_ME>)
require(_saleStarted == true, "Sale stopped");
Card memory _currentCard = _cards[_cardId];
require(_currentCard.isFinished == false, "Card is finished");
uint8 currentTier = _whitelist[_cardId][msg.sender];
require(currentTier != 0, "you are not whitelisted");
uint256 startTime;
for (uint256 i = 0; i < _currentCard.tiers.length; i++) {
if (_currentCard.tiers[i] == currentTier) {
startTime = _currentCard.times[i];
}
}
require(
startTime != 0 && startTime <= block.timestamp,
"wait for sale start"
);
IERC1155 _nftContract = IERC1155(_currentCard.contractAddress);
require(
_currentCard.currentAmount >= _amount,
"Order exceeds the max number of available NFTs"
);
History storage _currentHistory =
_history[_currentCard.contractAddress];
uint256 _currentBoughtAmount =
_currentHistory.purchasedHistories[_currentCard.tokenId][
msg.sender
];
require(
_currentBoughtAmount < _limitPerWallet,
"Order exceeds the max limit of NFTs per wallet"
);
uint256 availableAmount = _limitPerWallet.sub(_currentBoughtAmount);
if (availableAmount > _amount) {
availableAmount = _amount;
}
uint256 _price = _currentCard.basePrice.mul(availableAmount);
require(msg.value >= _price, "Not enough funds to purchase");
uint256 overPrice = msg.value - _price;
_salesperson.transfer(_price);
if (overPrice > 0) msg.sender.transfer(overPrice);
_nftContract.safeTransferFrom(
_salesperson,
msg.sender,
_currentCard.tokenId,
availableAmount,
""
);
_cards[_cardId].currentAmount = _cards[_cardId].currentAmount.sub(
availableAmount
);
_currentHistory.purchasedHistories[_currentCard.tokenId][
msg.sender
] = uint8(_currentBoughtAmount.add(availableAmount));
emit PurchaseCard(msg.sender, _cardId, availableAmount);
}
function _getNextCardID() private view returns (uint256) {
}
function _incrementCardId() private {
}
function cancelCard(uint256 _cardId) external onlyOwner {
}
function setTimes(
uint256 _cardId,
uint8 _tier,
uint256 _finalTime
) external onlyOwner {
}
function resumeCard(uint256 _cardId) external onlyOwner {
}
function setCardPrice(uint256 _cardId, uint256 _newPrice)
external
onlyOwner
returns (bool)
{
}
function addBlackListAddress(address addr) external onlyOwner {
}
function batchAddBlackListAddress(address[] calldata addr)
external
onlyOwner
{
}
function removeBlackListAddress(address addr) external onlyOwner {
}
function batchRemoveBlackListAddress(address[] calldata addr)
external
onlyOwner
{
}
function addWhiteListAddress(
uint256 _cardId,
address _addr,
uint8 _tier
) external onlyOwner {
}
function batchAddWhiteListAddress(
uint256 _cardId,
address[] calldata _addr,
uint8 _tier
) external onlyOwner {
}
function isCardCompleted(uint256 _cardId) public view returns (bool) {
}
function isCardFree(uint256 _cardId) public view returns (bool) {
}
function getCardContract(uint256 _cardId) public view returns (address) {
}
function getCardTokenId(uint256 _cardId) public view returns (uint256) {
}
function getCardTime(uint256 _cardId)
public
view
returns (uint256[] memory)
{
}
function getCardTotalAmount(uint256 _cardId) public view returns (uint256) {
}
function getCardCurrentAmount(uint256 _cardId)
public
view
returns (uint256)
{
}
function getAllCardsPerContract(address _contractAddr)
public
view
returns (uint256[] memory, uint256[] memory)
{
}
function getActiveCardsPerContract(address _contractAddr)
public
view
returns (uint256[] memory, uint256[] memory)
{
}
function getClosedCardsPerContract(address _contractAddr)
public
view
returns (uint256[] memory, uint256[] memory)
{
}
function getCardBasePrice(uint256 _cardId) public view returns (uint256) {
}
function getCardURL(uint256 _cardId) public view returns (string memory) {
}
function collect(address _token) external onlyOwner {
}
}
| _blacklist[msg.sender]==false,"you are blocked" | 15,916 | _blacklist[msg.sender]==false |
"current owner must set caller as next owner." | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.6;
contract Ownable {
address public owner;
address private nextOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
// modifiers
modifier onlyOwner() {
}
modifier onlyNextOwner() {
require(<FILL_ME>)
_;
}
/**
* @dev Initialize contract by setting transaction submitter as initial owner.
*/
constructor(address owner_) {
}
/**
* @dev Initiate ownership transfer by setting nextOwner.
*/
function transferOwnership(address nextOwner_) external onlyOwner {
}
/**
* @dev Cancel ownership transfer by deleting nextOwner.
*/
function cancelOwnershipTransfer() external onlyOwner {
}
/**
* @dev Accepts ownership transfer by setting owner.
*/
function acceptOwnership() external onlyNextOwner {
}
/**
* @dev Renounce ownership by setting owner to zero address.
*/
function renounceOwnership() external onlyOwner {
}
/**
* @dev Returns true if the caller is the current owner.
*/
function isOwner() public view returns (bool) {
}
/**
* @dev Returns true if the caller is the next owner.
*/
function isNextOwner() public view returns (bool) {
}
}
| isNextOwner(),"current owner must set caller as next owner." | 15,954 | isNextOwner() |
"There is low token balance in contract" | pragma solidity >=0.5.0 <0.6.0;
interface AggregatorV3Interface {
function decimals()
external
view
returns (
uint8
);
function description()
external
view
returns (
string memory
);
function version()
external
view
returns (
uint256
);
// 0x74825DbC8BF76CC4e9494d0ecB210f676Efa001D - DAI/ETH Testnet
// 0x773616E4d11A78F511299002da57A0a94577F1f4 - DAI/ETH Mainnet
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(
uint80 _roundId
)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
/**
* @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) {
}
}
contract Ownable {
address payable public _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 Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address payable newOwner) public onlyOwner {
}
}
interface Token {
function transfer(address to, uint256 value) external returns (bool);
function balanceOf(address who) external view returns (uint256);
}
contract Buy_INH_Token is Ownable{
using SafeMath for uint;
address public tokenAddr;
uint256 private ethAmount;
uint256 public tokenPriceEth;
uint256 public tokenDecimal = 18;
uint256 public ethDecimal = 18;
AggregatorV3Interface internal priceFeed;
event TokenTransfer(address beneficiary, uint amount);
mapping (address => uint256) public balances;
mapping(address => uint256) public tokenExchanged;
constructor(address _tokenAddr) public {
}
function() payable external {
}
function getLatestPrice() public view returns (uint256) {
}
function ExchangeETHforToken(address _addr, uint256 _amount) private {
uint256 amount = _amount;
address userAdd = _addr;
tokenPriceEth = getLatestPrice();
ethAmount = ((amount.mul(10 ** uint256(tokenDecimal)).div(tokenPriceEth)).mul(10 ** uint256(tokenDecimal))).div(10 ** uint256(tokenDecimal));
require(<FILL_ME>)
require(Token(tokenAddr).transfer(userAdd, ethAmount));
emit TokenTransfer(userAdd, ethAmount);
tokenExchanged[msg.sender] = tokenExchanged[msg.sender].add(ethAmount);
_owner.transfer(amount);
}
function ExchangeETHforTokenMannual() public payable {
}
function updateTokenDecimal(uint256 newDecimal) public onlyOwner {
}
function updateTokenAddress(address newTokenAddr) public onlyOwner {
}
function withdrawTokens(address beneficiary) public onlyOwner {
}
function withdrawCrypto(address payable beneficiary) public onlyOwner {
}
function tokenBalance() public view returns (uint256){
}
function ethBalance() public view returns (uint256){
}
}
| Token(tokenAddr).balanceOf(address(this))>=ethAmount,"There is low token balance in contract" | 16,096 | Token(tokenAddr).balanceOf(address(this))>=ethAmount |
null | pragma solidity >=0.5.0 <0.6.0;
interface AggregatorV3Interface {
function decimals()
external
view
returns (
uint8
);
function description()
external
view
returns (
string memory
);
function version()
external
view
returns (
uint256
);
// 0x74825DbC8BF76CC4e9494d0ecB210f676Efa001D - DAI/ETH Testnet
// 0x773616E4d11A78F511299002da57A0a94577F1f4 - DAI/ETH Mainnet
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(
uint80 _roundId
)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
/**
* @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) {
}
}
contract Ownable {
address payable public _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 Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address payable newOwner) public onlyOwner {
}
}
interface Token {
function transfer(address to, uint256 value) external returns (bool);
function balanceOf(address who) external view returns (uint256);
}
contract Buy_INH_Token is Ownable{
using SafeMath for uint;
address public tokenAddr;
uint256 private ethAmount;
uint256 public tokenPriceEth;
uint256 public tokenDecimal = 18;
uint256 public ethDecimal = 18;
AggregatorV3Interface internal priceFeed;
event TokenTransfer(address beneficiary, uint amount);
mapping (address => uint256) public balances;
mapping(address => uint256) public tokenExchanged;
constructor(address _tokenAddr) public {
}
function() payable external {
}
function getLatestPrice() public view returns (uint256) {
}
function ExchangeETHforToken(address _addr, uint256 _amount) private {
uint256 amount = _amount;
address userAdd = _addr;
tokenPriceEth = getLatestPrice();
ethAmount = ((amount.mul(10 ** uint256(tokenDecimal)).div(tokenPriceEth)).mul(10 ** uint256(tokenDecimal))).div(10 ** uint256(tokenDecimal));
require(Token(tokenAddr).balanceOf(address(this)) >= ethAmount, "There is low token balance in contract");
require(<FILL_ME>)
emit TokenTransfer(userAdd, ethAmount);
tokenExchanged[msg.sender] = tokenExchanged[msg.sender].add(ethAmount);
_owner.transfer(amount);
}
function ExchangeETHforTokenMannual() public payable {
}
function updateTokenDecimal(uint256 newDecimal) public onlyOwner {
}
function updateTokenAddress(address newTokenAddr) public onlyOwner {
}
function withdrawTokens(address beneficiary) public onlyOwner {
}
function withdrawCrypto(address payable beneficiary) public onlyOwner {
}
function tokenBalance() public view returns (uint256){
}
function ethBalance() public view returns (uint256){
}
}
| Token(tokenAddr).transfer(userAdd,ethAmount) | 16,096 | Token(tokenAddr).transfer(userAdd,ethAmount) |
null | pragma solidity >=0.5.0 <0.6.0;
interface AggregatorV3Interface {
function decimals()
external
view
returns (
uint8
);
function description()
external
view
returns (
string memory
);
function version()
external
view
returns (
uint256
);
// 0x74825DbC8BF76CC4e9494d0ecB210f676Efa001D - DAI/ETH Testnet
// 0x773616E4d11A78F511299002da57A0a94577F1f4 - DAI/ETH Mainnet
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(
uint80 _roundId
)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
/**
* @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) {
}
}
contract Ownable {
address payable public _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 Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address payable newOwner) public onlyOwner {
}
}
interface Token {
function transfer(address to, uint256 value) external returns (bool);
function balanceOf(address who) external view returns (uint256);
}
contract Buy_INH_Token is Ownable{
using SafeMath for uint;
address public tokenAddr;
uint256 private ethAmount;
uint256 public tokenPriceEth;
uint256 public tokenDecimal = 18;
uint256 public ethDecimal = 18;
AggregatorV3Interface internal priceFeed;
event TokenTransfer(address beneficiary, uint amount);
mapping (address => uint256) public balances;
mapping(address => uint256) public tokenExchanged;
constructor(address _tokenAddr) public {
}
function() payable external {
}
function getLatestPrice() public view returns (uint256) {
}
function ExchangeETHforToken(address _addr, uint256 _amount) private {
}
function ExchangeETHforTokenMannual() public payable {
}
function updateTokenDecimal(uint256 newDecimal) public onlyOwner {
}
function updateTokenAddress(address newTokenAddr) public onlyOwner {
}
function withdrawTokens(address beneficiary) public onlyOwner {
require(<FILL_ME>)
}
function withdrawCrypto(address payable beneficiary) public onlyOwner {
}
function tokenBalance() public view returns (uint256){
}
function ethBalance() public view returns (uint256){
}
}
| Token(tokenAddr).transfer(beneficiary,Token(tokenAddr).balanceOf(address(this))) | 16,096 | Token(tokenAddr).transfer(beneficiary,Token(tokenAddr).balanceOf(address(this))) |
"Access denied" | /**
* @title The Identity is where ERC 725/735 and our custom code meet.
* @author Talao, Polynomial.
* @notice Mixes ERC 725/735, foundation, token,
* constructor values that never change (creator, category, encryption keys)
* and provides a box to receive decentralized files and texts.
*/
contract Identity is ClaimHolder {
// Foundation contract.
Foundation foundation;
// Talao token contract.
TalaoToken public token;
// Identity information struct.
struct IdentityInformation {
// Address of this contract creator (factory).
// bytes16 left on SSTORAGE 1 after this.
address creator;
// Identity category.
// 1001 => 1999: Freelancer.
// 2001 => 2999: Freelancer team.
// 3001 => 3999: Corporate marketplace.
// 4001 => 4999: Public marketplace.
// 5001 => 5999: Service provider.
// ..
// 64001 => 64999: ?
// bytes14 left after this on SSTORAGE 1.
uint16 category;
// Asymetric encryption key algorithm.
// We use an integer to store algo with offchain references.
// 1 => RSA 2048
// bytes12 left after this on SSTORAGE 1.
uint16 asymetricEncryptionAlgorithm;
// Symetric encryption key algorithm.
// We use an integer to store algo with offchain references.
// 1 => AES 128
// bytes10 left after this on SSTORAGE 1.
uint16 symetricEncryptionAlgorithm;
// Asymetric encryption public key.
// This one can be used to encrypt content especially for this
// contract owner, which is the only one to have the private key,
// offchain of course.
bytes asymetricEncryptionPublicKey;
// Encrypted symetric encryption key (in Hex).
// When decrypted, this passphrase can regenerate
// the symetric encryption key.
// This key encrypts and decrypts data to be shared with many people.
// Uses 0.5 SSTORAGE for AES 128.
bytes symetricEncryptionEncryptedKey;
// Other encrypted secret we might use.
bytes encryptedSecret;
}
// This contract Identity information.
IdentityInformation public identityInformation;
// Identity box: blacklisted addresses.
mapping(address => bool) public identityboxBlacklisted;
// Identity box: event when someone sent us a text.
event TextReceived (
address indexed sender,
uint indexed category,
bytes text
);
// Identity box: event when someone sent us an decentralized file.
event FileReceived (
address indexed sender,
uint indexed fileType,
uint fileEngine,
bytes fileHash
);
/**
* @dev Constructor.
*/
constructor(
address _foundation,
address _token,
uint16 _category,
uint16 _asymetricEncryptionAlgorithm,
uint16 _symetricEncryptionAlgorithm,
bytes _asymetricEncryptionPublicKey,
bytes _symetricEncryptionEncryptedKey,
bytes _encryptedSecret
)
public
{
}
/**
* @dev Owner of this contract, in the Foundation sense.
* We do not allow this to be used externally,
* since a contract could fake ownership.
* In other contracts, you have to call the Foundation to
* know the real owner of this contract.
*/
function identityOwner() internal view returns (address) {
}
/**
* @dev Check in Foundation if msg.sender is the owner of this contract.
* Same remark.
*/
function isIdentityOwner() internal view returns (bool) {
}
/**
* @dev Modifier version of isIdentityOwner.
*/
modifier onlyIdentityOwner() {
require(<FILL_ME>)
_;
}
/**
* @dev Owner functions require open Vault in token.
*/
function isActiveIdentityOwner() public view returns (bool) {
}
/**
* @dev Modifier version of isActiveOwner.
*/
modifier onlyActiveIdentityOwner() {
}
/**
* @dev Does this contract owner have an open Vault in the token?
*/
function isActiveIdentity() public view returns (bool) {
}
/**
* @dev Does msg.sender have an ERC 725 key with certain purpose,
* and does the contract owner have an open Vault in the token?
*/
function hasIdentityPurpose(uint256 _purpose) public view returns (bool) {
}
/**
* @dev Modifier version of hasKeyForPurpose
*/
modifier onlyIdentityPurpose(uint256 _purpose) {
}
/**
* @dev "Send" a text to this contract.
* Text can be encrypted on this contract asymetricEncryptionPublicKey,
* before submitting a TX here.
*/
function identityboxSendtext(uint _category, bytes _text) external {
}
/**
* @dev "Send" a "file" to this contract.
* File should be encrypted on this contract asymetricEncryptionPublicKey,
* before upload on decentralized file storage,
* before submitting a TX here.
*/
function identityboxSendfile(
uint _fileType, uint _fileEngine, bytes _fileHash
)
external
{
}
/**
* @dev Blacklist an address in this Identity box.
*/
function identityboxBlacklist(address _address)
external
onlyIdentityPurpose(20004)
{
}
/**
* @dev Unblacklist.
*/
function identityboxUnblacklist(address _address)
external
onlyIdentityPurpose(20004)
{
}
}
/**
* @title Interface with clones or inherited contracts.
*/
interface IdentityInterface {
function identityInformation()
external
view
returns (address, uint16, uint16, uint16, bytes, bytes, bytes);
function identityboxSendtext(uint, bytes) external;
}
| isIdentityOwner(),"Access denied" | 16,239 | isIdentityOwner() |
"Access denied" | /**
* @title The Identity is where ERC 725/735 and our custom code meet.
* @author Talao, Polynomial.
* @notice Mixes ERC 725/735, foundation, token,
* constructor values that never change (creator, category, encryption keys)
* and provides a box to receive decentralized files and texts.
*/
contract Identity is ClaimHolder {
// Foundation contract.
Foundation foundation;
// Talao token contract.
TalaoToken public token;
// Identity information struct.
struct IdentityInformation {
// Address of this contract creator (factory).
// bytes16 left on SSTORAGE 1 after this.
address creator;
// Identity category.
// 1001 => 1999: Freelancer.
// 2001 => 2999: Freelancer team.
// 3001 => 3999: Corporate marketplace.
// 4001 => 4999: Public marketplace.
// 5001 => 5999: Service provider.
// ..
// 64001 => 64999: ?
// bytes14 left after this on SSTORAGE 1.
uint16 category;
// Asymetric encryption key algorithm.
// We use an integer to store algo with offchain references.
// 1 => RSA 2048
// bytes12 left after this on SSTORAGE 1.
uint16 asymetricEncryptionAlgorithm;
// Symetric encryption key algorithm.
// We use an integer to store algo with offchain references.
// 1 => AES 128
// bytes10 left after this on SSTORAGE 1.
uint16 symetricEncryptionAlgorithm;
// Asymetric encryption public key.
// This one can be used to encrypt content especially for this
// contract owner, which is the only one to have the private key,
// offchain of course.
bytes asymetricEncryptionPublicKey;
// Encrypted symetric encryption key (in Hex).
// When decrypted, this passphrase can regenerate
// the symetric encryption key.
// This key encrypts and decrypts data to be shared with many people.
// Uses 0.5 SSTORAGE for AES 128.
bytes symetricEncryptionEncryptedKey;
// Other encrypted secret we might use.
bytes encryptedSecret;
}
// This contract Identity information.
IdentityInformation public identityInformation;
// Identity box: blacklisted addresses.
mapping(address => bool) public identityboxBlacklisted;
// Identity box: event when someone sent us a text.
event TextReceived (
address indexed sender,
uint indexed category,
bytes text
);
// Identity box: event when someone sent us an decentralized file.
event FileReceived (
address indexed sender,
uint indexed fileType,
uint fileEngine,
bytes fileHash
);
/**
* @dev Constructor.
*/
constructor(
address _foundation,
address _token,
uint16 _category,
uint16 _asymetricEncryptionAlgorithm,
uint16 _symetricEncryptionAlgorithm,
bytes _asymetricEncryptionPublicKey,
bytes _symetricEncryptionEncryptedKey,
bytes _encryptedSecret
)
public
{
}
/**
* @dev Owner of this contract, in the Foundation sense.
* We do not allow this to be used externally,
* since a contract could fake ownership.
* In other contracts, you have to call the Foundation to
* know the real owner of this contract.
*/
function identityOwner() internal view returns (address) {
}
/**
* @dev Check in Foundation if msg.sender is the owner of this contract.
* Same remark.
*/
function isIdentityOwner() internal view returns (bool) {
}
/**
* @dev Modifier version of isIdentityOwner.
*/
modifier onlyIdentityOwner() {
}
/**
* @dev Owner functions require open Vault in token.
*/
function isActiveIdentityOwner() public view returns (bool) {
}
/**
* @dev Modifier version of isActiveOwner.
*/
modifier onlyActiveIdentityOwner() {
require(<FILL_ME>)
_;
}
/**
* @dev Does this contract owner have an open Vault in the token?
*/
function isActiveIdentity() public view returns (bool) {
}
/**
* @dev Does msg.sender have an ERC 725 key with certain purpose,
* and does the contract owner have an open Vault in the token?
*/
function hasIdentityPurpose(uint256 _purpose) public view returns (bool) {
}
/**
* @dev Modifier version of hasKeyForPurpose
*/
modifier onlyIdentityPurpose(uint256 _purpose) {
}
/**
* @dev "Send" a text to this contract.
* Text can be encrypted on this contract asymetricEncryptionPublicKey,
* before submitting a TX here.
*/
function identityboxSendtext(uint _category, bytes _text) external {
}
/**
* @dev "Send" a "file" to this contract.
* File should be encrypted on this contract asymetricEncryptionPublicKey,
* before upload on decentralized file storage,
* before submitting a TX here.
*/
function identityboxSendfile(
uint _fileType, uint _fileEngine, bytes _fileHash
)
external
{
}
/**
* @dev Blacklist an address in this Identity box.
*/
function identityboxBlacklist(address _address)
external
onlyIdentityPurpose(20004)
{
}
/**
* @dev Unblacklist.
*/
function identityboxUnblacklist(address _address)
external
onlyIdentityPurpose(20004)
{
}
}
/**
* @title Interface with clones or inherited contracts.
*/
interface IdentityInterface {
function identityInformation()
external
view
returns (address, uint16, uint16, uint16, bytes, bytes, bytes);
function identityboxSendtext(uint, bytes) external;
}
| isActiveIdentityOwner(),"Access denied" | 16,239 | isActiveIdentityOwner() |
"Access denied" | /**
* @title The Identity is where ERC 725/735 and our custom code meet.
* @author Talao, Polynomial.
* @notice Mixes ERC 725/735, foundation, token,
* constructor values that never change (creator, category, encryption keys)
* and provides a box to receive decentralized files and texts.
*/
contract Identity is ClaimHolder {
// Foundation contract.
Foundation foundation;
// Talao token contract.
TalaoToken public token;
// Identity information struct.
struct IdentityInformation {
// Address of this contract creator (factory).
// bytes16 left on SSTORAGE 1 after this.
address creator;
// Identity category.
// 1001 => 1999: Freelancer.
// 2001 => 2999: Freelancer team.
// 3001 => 3999: Corporate marketplace.
// 4001 => 4999: Public marketplace.
// 5001 => 5999: Service provider.
// ..
// 64001 => 64999: ?
// bytes14 left after this on SSTORAGE 1.
uint16 category;
// Asymetric encryption key algorithm.
// We use an integer to store algo with offchain references.
// 1 => RSA 2048
// bytes12 left after this on SSTORAGE 1.
uint16 asymetricEncryptionAlgorithm;
// Symetric encryption key algorithm.
// We use an integer to store algo with offchain references.
// 1 => AES 128
// bytes10 left after this on SSTORAGE 1.
uint16 symetricEncryptionAlgorithm;
// Asymetric encryption public key.
// This one can be used to encrypt content especially for this
// contract owner, which is the only one to have the private key,
// offchain of course.
bytes asymetricEncryptionPublicKey;
// Encrypted symetric encryption key (in Hex).
// When decrypted, this passphrase can regenerate
// the symetric encryption key.
// This key encrypts and decrypts data to be shared with many people.
// Uses 0.5 SSTORAGE for AES 128.
bytes symetricEncryptionEncryptedKey;
// Other encrypted secret we might use.
bytes encryptedSecret;
}
// This contract Identity information.
IdentityInformation public identityInformation;
// Identity box: blacklisted addresses.
mapping(address => bool) public identityboxBlacklisted;
// Identity box: event when someone sent us a text.
event TextReceived (
address indexed sender,
uint indexed category,
bytes text
);
// Identity box: event when someone sent us an decentralized file.
event FileReceived (
address indexed sender,
uint indexed fileType,
uint fileEngine,
bytes fileHash
);
/**
* @dev Constructor.
*/
constructor(
address _foundation,
address _token,
uint16 _category,
uint16 _asymetricEncryptionAlgorithm,
uint16 _symetricEncryptionAlgorithm,
bytes _asymetricEncryptionPublicKey,
bytes _symetricEncryptionEncryptedKey,
bytes _encryptedSecret
)
public
{
}
/**
* @dev Owner of this contract, in the Foundation sense.
* We do not allow this to be used externally,
* since a contract could fake ownership.
* In other contracts, you have to call the Foundation to
* know the real owner of this contract.
*/
function identityOwner() internal view returns (address) {
}
/**
* @dev Check in Foundation if msg.sender is the owner of this contract.
* Same remark.
*/
function isIdentityOwner() internal view returns (bool) {
}
/**
* @dev Modifier version of isIdentityOwner.
*/
modifier onlyIdentityOwner() {
}
/**
* @dev Owner functions require open Vault in token.
*/
function isActiveIdentityOwner() public view returns (bool) {
}
/**
* @dev Modifier version of isActiveOwner.
*/
modifier onlyActiveIdentityOwner() {
}
/**
* @dev Does this contract owner have an open Vault in the token?
*/
function isActiveIdentity() public view returns (bool) {
}
/**
* @dev Does msg.sender have an ERC 725 key with certain purpose,
* and does the contract owner have an open Vault in the token?
*/
function hasIdentityPurpose(uint256 _purpose) public view returns (bool) {
}
/**
* @dev Modifier version of hasKeyForPurpose
*/
modifier onlyIdentityPurpose(uint256 _purpose) {
require(<FILL_ME>)
_;
}
/**
* @dev "Send" a text to this contract.
* Text can be encrypted on this contract asymetricEncryptionPublicKey,
* before submitting a TX here.
*/
function identityboxSendtext(uint _category, bytes _text) external {
}
/**
* @dev "Send" a "file" to this contract.
* File should be encrypted on this contract asymetricEncryptionPublicKey,
* before upload on decentralized file storage,
* before submitting a TX here.
*/
function identityboxSendfile(
uint _fileType, uint _fileEngine, bytes _fileHash
)
external
{
}
/**
* @dev Blacklist an address in this Identity box.
*/
function identityboxBlacklist(address _address)
external
onlyIdentityPurpose(20004)
{
}
/**
* @dev Unblacklist.
*/
function identityboxUnblacklist(address _address)
external
onlyIdentityPurpose(20004)
{
}
}
/**
* @title Interface with clones or inherited contracts.
*/
interface IdentityInterface {
function identityInformation()
external
view
returns (address, uint16, uint16, uint16, bytes, bytes, bytes);
function identityboxSendtext(uint, bytes) external;
}
| hasIdentityPurpose(_purpose),"Access denied" | 16,239 | hasIdentityPurpose(_purpose) |
"You are blacklisted" | /**
* @title The Identity is where ERC 725/735 and our custom code meet.
* @author Talao, Polynomial.
* @notice Mixes ERC 725/735, foundation, token,
* constructor values that never change (creator, category, encryption keys)
* and provides a box to receive decentralized files and texts.
*/
contract Identity is ClaimHolder {
// Foundation contract.
Foundation foundation;
// Talao token contract.
TalaoToken public token;
// Identity information struct.
struct IdentityInformation {
// Address of this contract creator (factory).
// bytes16 left on SSTORAGE 1 after this.
address creator;
// Identity category.
// 1001 => 1999: Freelancer.
// 2001 => 2999: Freelancer team.
// 3001 => 3999: Corporate marketplace.
// 4001 => 4999: Public marketplace.
// 5001 => 5999: Service provider.
// ..
// 64001 => 64999: ?
// bytes14 left after this on SSTORAGE 1.
uint16 category;
// Asymetric encryption key algorithm.
// We use an integer to store algo with offchain references.
// 1 => RSA 2048
// bytes12 left after this on SSTORAGE 1.
uint16 asymetricEncryptionAlgorithm;
// Symetric encryption key algorithm.
// We use an integer to store algo with offchain references.
// 1 => AES 128
// bytes10 left after this on SSTORAGE 1.
uint16 symetricEncryptionAlgorithm;
// Asymetric encryption public key.
// This one can be used to encrypt content especially for this
// contract owner, which is the only one to have the private key,
// offchain of course.
bytes asymetricEncryptionPublicKey;
// Encrypted symetric encryption key (in Hex).
// When decrypted, this passphrase can regenerate
// the symetric encryption key.
// This key encrypts and decrypts data to be shared with many people.
// Uses 0.5 SSTORAGE for AES 128.
bytes symetricEncryptionEncryptedKey;
// Other encrypted secret we might use.
bytes encryptedSecret;
}
// This contract Identity information.
IdentityInformation public identityInformation;
// Identity box: blacklisted addresses.
mapping(address => bool) public identityboxBlacklisted;
// Identity box: event when someone sent us a text.
event TextReceived (
address indexed sender,
uint indexed category,
bytes text
);
// Identity box: event when someone sent us an decentralized file.
event FileReceived (
address indexed sender,
uint indexed fileType,
uint fileEngine,
bytes fileHash
);
/**
* @dev Constructor.
*/
constructor(
address _foundation,
address _token,
uint16 _category,
uint16 _asymetricEncryptionAlgorithm,
uint16 _symetricEncryptionAlgorithm,
bytes _asymetricEncryptionPublicKey,
bytes _symetricEncryptionEncryptedKey,
bytes _encryptedSecret
)
public
{
}
/**
* @dev Owner of this contract, in the Foundation sense.
* We do not allow this to be used externally,
* since a contract could fake ownership.
* In other contracts, you have to call the Foundation to
* know the real owner of this contract.
*/
function identityOwner() internal view returns (address) {
}
/**
* @dev Check in Foundation if msg.sender is the owner of this contract.
* Same remark.
*/
function isIdentityOwner() internal view returns (bool) {
}
/**
* @dev Modifier version of isIdentityOwner.
*/
modifier onlyIdentityOwner() {
}
/**
* @dev Owner functions require open Vault in token.
*/
function isActiveIdentityOwner() public view returns (bool) {
}
/**
* @dev Modifier version of isActiveOwner.
*/
modifier onlyActiveIdentityOwner() {
}
/**
* @dev Does this contract owner have an open Vault in the token?
*/
function isActiveIdentity() public view returns (bool) {
}
/**
* @dev Does msg.sender have an ERC 725 key with certain purpose,
* and does the contract owner have an open Vault in the token?
*/
function hasIdentityPurpose(uint256 _purpose) public view returns (bool) {
}
/**
* @dev Modifier version of hasKeyForPurpose
*/
modifier onlyIdentityPurpose(uint256 _purpose) {
}
/**
* @dev "Send" a text to this contract.
* Text can be encrypted on this contract asymetricEncryptionPublicKey,
* before submitting a TX here.
*/
function identityboxSendtext(uint _category, bytes _text) external {
require(<FILL_ME>)
emit TextReceived(msg.sender, _category, _text);
}
/**
* @dev "Send" a "file" to this contract.
* File should be encrypted on this contract asymetricEncryptionPublicKey,
* before upload on decentralized file storage,
* before submitting a TX here.
*/
function identityboxSendfile(
uint _fileType, uint _fileEngine, bytes _fileHash
)
external
{
}
/**
* @dev Blacklist an address in this Identity box.
*/
function identityboxBlacklist(address _address)
external
onlyIdentityPurpose(20004)
{
}
/**
* @dev Unblacklist.
*/
function identityboxUnblacklist(address _address)
external
onlyIdentityPurpose(20004)
{
}
}
/**
* @title Interface with clones or inherited contracts.
*/
interface IdentityInterface {
function identityInformation()
external
view
returns (address, uint16, uint16, uint16, bytes, bytes, bytes);
function identityboxSendtext(uint, bytes) external;
}
| !identityboxBlacklisted[msg.sender],"You are blacklisted" | 16,239 | !identityboxBlacklisted[msg.sender] |
"Access denied" | /**
* @title Permissions contract.
* @author Talao, Polynomial.
* @notice See ../identity/KeyHolder.sol as well.
*/
contract Permissions is Partnership {
// Foundation contract.
Foundation foundation;
// Talao token contract.
TalaoToken public token;
/**
* @dev Constructor.
*/
constructor(
address _foundation,
address _token,
uint16 _category,
uint16 _asymetricEncryptionAlgorithm,
uint16 _symetricEncryptionAlgorithm,
bytes _asymetricEncryptionPublicKey,
bytes _symetricEncryptionEncryptedKey,
bytes _encryptedSecret
)
Partnership(
_foundation,
_token,
_category,
_asymetricEncryptionAlgorithm,
_symetricEncryptionAlgorithm,
_asymetricEncryptionPublicKey,
_symetricEncryptionEncryptedKey,
_encryptedSecret
)
public
{
}
/**
* @dev Is msg.sender a "member" of this contract, in the Foundation sense?
*/
function isMember() public view returns (bool) {
}
/**
* @dev Read authorization for inherited contracts "private" data.
*/
function isReader() public view returns (bool) {
}
/**
* @dev Modifier version of isReader.
*/
modifier onlyReader() {
require(<FILL_ME>)
_;
}
}
| isReader(),"Access denied" | 16,242 | isReader() |
null | // 0.4.20+commit.3155dd80.Emscripten.clang
pragma solidity ^0.4.20;
/**
* Ethereum Token callback
*/
interface tokenRecipient {
function receiveApproval( address from, uint256 value, bytes data ) external;
}
/**
* ERC223 callback
*/
interface ContractReceiver {
function tokenFallback( address from, uint value, bytes data ) external;
}
/**
* Ownable Contract
*/
contract Owned {
address public owner;
function owned() public {
}
function changeOwner(address _newOwner) public onlyOwner {
}
modifier onlyOwner {
}
}
/**
* ERC20 token with added ERC223 and Ethereum-Token support
*
* Blend of multiple interfaces:
* - https://theethereum.wiki/w/index.php/ERC20_Token_Standard
* - https://www.ethereum.org/token (uncontrolled, non-standard)
* - https://github.com/Dexaran/ERC23-tokens/blob/Recommended/ERC223_Token.sol
*/
contract Token is Owned {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping( address => uint256 ) balances;
mapping( address => mapping(address => uint256) ) allowances;
/**
* ERC20 Approval Event
*/
event Approval(
address indexed owner,
address indexed spender,
uint value
);
/**
* ERC20-compatible version only, breaks ERC223 compliance but block
* explorers and exchanges expect ERC20. Also, cannot overload events
*/
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
function Token(
uint256 _initialSupply,
string _tokenName,
string _tokenSymbol
)
public
{
}
/**
* ERC20 Balance Of Function
*/
function balanceOf( address owner ) public constant returns (uint) {
}
/**
* ERC20 Approve Function
*/
function approve( address spender, uint256 value ) public returns (bool success) {
}
/**
* Recommended fix for known attack on any ERC20
*/
function safeApprove(
address _spender,
uint256 _currentValue,
uint256 _value
)
public
returns (bool success)
{
}
/**
* ERC20 Allowance Function
*/
function allowance(
address owner,
address spender
)
public constant
returns (uint256 remaining)
{
}
/**
* ERC20 Transfer Function
*/
function transfer(
address to,
uint256 value
)
public
returns (bool success)
{
}
/**
* ERC20 Transfer From Function
*/
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool success)
{
}
/**
* Ethereum Token Approve and Call Function
*/
function approveAndCall(
address spender,
uint256 value,
bytes context
)
public
returns (bool success)
{
}
/**
* ERC223 Transfer and invoke specified callback
*/
function transfer(
address to,
uint value,
bytes data,
string custom_fallback
)
public
returns (bool success)
{
_transfer( msg.sender, to, value, data );
// throws if custom_fallback is not a valid contract call
require(<FILL_ME>)
return true;
}
/**
* ERC223 Transfer to a contract or externally-owned account
*/
function transfer(
address to,
uint value,
bytes data
)
public
returns (bool success)
{
}
/**
* ERC223 Transfer to contract and invoke tokenFallback() method
*/
function transferToContract(
address to,
uint value,
bytes data
)
private
returns (bool success)
{
}
/**
* ERC223 fetch contract size (must be nonzero to be a contract)
*/
function isContract(address _addr)
private
constant
returns (bool)
{
}
/**
* Transfer Functionality
*/
function _transfer(
address from,
address to,
uint value,
bytes data
)
internal
{
}
}
| address(to).call.value(0)(bytes4(keccak256(custom_fallback)),msg.sender,value,data) | 16,263 | address(to).call.value(0)(bytes4(keccak256(custom_fallback)),msg.sender,value,data) |
null | // 0.4.20+commit.3155dd80.Emscripten.clang
pragma solidity ^0.4.20;
/**
* Ethereum Token callback
*/
interface tokenRecipient {
function receiveApproval( address from, uint256 value, bytes data ) external;
}
/**
* ERC223 callback
*/
interface ContractReceiver {
function tokenFallback( address from, uint value, bytes data ) external;
}
/**
* Ownable Contract
*/
contract Owned {
address public owner;
function owned() public {
}
function changeOwner(address _newOwner) public onlyOwner {
}
modifier onlyOwner {
}
}
/**
* ERC20 token with added ERC223 and Ethereum-Token support
*
* Blend of multiple interfaces:
* - https://theethereum.wiki/w/index.php/ERC20_Token_Standard
* - https://www.ethereum.org/token (uncontrolled, non-standard)
* - https://github.com/Dexaran/ERC23-tokens/blob/Recommended/ERC223_Token.sol
*/
contract Token is Owned {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping( address => uint256 ) balances;
mapping( address => mapping(address => uint256) ) allowances;
/**
* ERC20 Approval Event
*/
event Approval(
address indexed owner,
address indexed spender,
uint value
);
/**
* ERC20-compatible version only, breaks ERC223 compliance but block
* explorers and exchanges expect ERC20. Also, cannot overload events
*/
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
function Token(
uint256 _initialSupply,
string _tokenName,
string _tokenSymbol
)
public
{
}
/**
* ERC20 Balance Of Function
*/
function balanceOf( address owner ) public constant returns (uint) {
}
/**
* ERC20 Approve Function
*/
function approve( address spender, uint256 value ) public returns (bool success) {
}
/**
* Recommended fix for known attack on any ERC20
*/
function safeApprove(
address _spender,
uint256 _currentValue,
uint256 _value
)
public
returns (bool success)
{
}
/**
* ERC20 Allowance Function
*/
function allowance(
address owner,
address spender
)
public constant
returns (uint256 remaining)
{
}
/**
* ERC20 Transfer Function
*/
function transfer(
address to,
uint256 value
)
public
returns (bool success)
{
}
/**
* ERC20 Transfer From Function
*/
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool success)
{
}
/**
* Ethereum Token Approve and Call Function
*/
function approveAndCall(
address spender,
uint256 value,
bytes context
)
public
returns (bool success)
{
}
/**
* ERC223 Transfer and invoke specified callback
*/
function transfer(
address to,
uint value,
bytes data,
string custom_fallback
)
public
returns (bool success)
{
}
/**
* ERC223 Transfer to a contract or externally-owned account
*/
function transfer(
address to,
uint value,
bytes data
)
public
returns (bool success)
{
}
/**
* ERC223 Transfer to contract and invoke tokenFallback() method
*/
function transferToContract(
address to,
uint value,
bytes data
)
private
returns (bool success)
{
}
/**
* ERC223 fetch contract size (must be nonzero to be a contract)
*/
function isContract(address _addr)
private
constant
returns (bool)
{
}
/**
* Transfer Functionality
*/
function _transfer(
address from,
address to,
uint value,
bytes data
)
internal
{
require( to != 0x0 );
require(<FILL_ME>)
require( balances[to] + value > balances[to] ); // catch overflow
balances[from] -= value;
balances[to] += value;
bytes memory ignore;
ignore = data; // ignore compiler warning
Transfer( from, to, value ); // ERC20-version, ignore data
}
}
| balances[from]>=value | 16,263 | balances[from]>=value |
null | // 0.4.20+commit.3155dd80.Emscripten.clang
pragma solidity ^0.4.20;
/**
* Ethereum Token callback
*/
interface tokenRecipient {
function receiveApproval( address from, uint256 value, bytes data ) external;
}
/**
* ERC223 callback
*/
interface ContractReceiver {
function tokenFallback( address from, uint value, bytes data ) external;
}
/**
* Ownable Contract
*/
contract Owned {
address public owner;
function owned() public {
}
function changeOwner(address _newOwner) public onlyOwner {
}
modifier onlyOwner {
}
}
/**
* ERC20 token with added ERC223 and Ethereum-Token support
*
* Blend of multiple interfaces:
* - https://theethereum.wiki/w/index.php/ERC20_Token_Standard
* - https://www.ethereum.org/token (uncontrolled, non-standard)
* - https://github.com/Dexaran/ERC23-tokens/blob/Recommended/ERC223_Token.sol
*/
contract Token is Owned {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping( address => uint256 ) balances;
mapping( address => mapping(address => uint256) ) allowances;
/**
* ERC20 Approval Event
*/
event Approval(
address indexed owner,
address indexed spender,
uint value
);
/**
* ERC20-compatible version only, breaks ERC223 compliance but block
* explorers and exchanges expect ERC20. Also, cannot overload events
*/
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
function Token(
uint256 _initialSupply,
string _tokenName,
string _tokenSymbol
)
public
{
}
/**
* ERC20 Balance Of Function
*/
function balanceOf( address owner ) public constant returns (uint) {
}
/**
* ERC20 Approve Function
*/
function approve( address spender, uint256 value ) public returns (bool success) {
}
/**
* Recommended fix for known attack on any ERC20
*/
function safeApprove(
address _spender,
uint256 _currentValue,
uint256 _value
)
public
returns (bool success)
{
}
/**
* ERC20 Allowance Function
*/
function allowance(
address owner,
address spender
)
public constant
returns (uint256 remaining)
{
}
/**
* ERC20 Transfer Function
*/
function transfer(
address to,
uint256 value
)
public
returns (bool success)
{
}
/**
* ERC20 Transfer From Function
*/
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool success)
{
}
/**
* Ethereum Token Approve and Call Function
*/
function approveAndCall(
address spender,
uint256 value,
bytes context
)
public
returns (bool success)
{
}
/**
* ERC223 Transfer and invoke specified callback
*/
function transfer(
address to,
uint value,
bytes data,
string custom_fallback
)
public
returns (bool success)
{
}
/**
* ERC223 Transfer to a contract or externally-owned account
*/
function transfer(
address to,
uint value,
bytes data
)
public
returns (bool success)
{
}
/**
* ERC223 Transfer to contract and invoke tokenFallback() method
*/
function transferToContract(
address to,
uint value,
bytes data
)
private
returns (bool success)
{
}
/**
* ERC223 fetch contract size (must be nonzero to be a contract)
*/
function isContract(address _addr)
private
constant
returns (bool)
{
}
/**
* Transfer Functionality
*/
function _transfer(
address from,
address to,
uint value,
bytes data
)
internal
{
require( to != 0x0 );
require( balances[from] >= value );
require(<FILL_ME>) // catch overflow
balances[from] -= value;
balances[to] += value;
bytes memory ignore;
ignore = data; // ignore compiler warning
Transfer( from, to, value ); // ERC20-version, ignore data
}
}
| balances[to]+value>balances[to] | 16,263 | balances[to]+value>balances[to] |
"Sale end" | pragma solidity ^0.8.0;
contract Pattern is ERC721, Ownable {
using Strings for uint256;
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
Counters.Counter private _burnedTracker;
string public baseTokenURI;
uint256 public constant MAX_ELEMENTS = 1200;
uint256 public constant MINT_PRICE = 8 * 10**16;
//Confident that all will be minted
uint public c_supply=1200;
address
public constant creatorAddress = 0xbC7b2461bfaA2fB47bD8f632d0c797C3BFD93B93;
event CreatePattern(uint256 indexed id);
constructor() public ERC721("Pattern", "Patt") {}
modifier saleIsOpen {
require(<FILL_ME>)
_;
}
function totalSupply() public view returns (uint256) {
}
function _totalSupply() internal view returns (uint256) {
}
function _totalBurned() internal view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function totalMint() public view returns (uint256) {
}
function mint(address _to, uint256 _count) public payable saleIsOpen {
}
function price(uint256 _count) public pure returns (uint256) {
}
function _mintAnElement(address _to) private {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
/**
* @dev Returns an URI for a given token ID
*/
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
/**
* @dev Burns and pays the mint price to the token owner.
* @param _tokenId The token to burn.
*/
function burn(uint256 _tokenId) public {
}
function _widthdraw(address _address, uint256 _amount) private {
}
}
| _totalSupply()<=MAX_ELEMENTS,"Sale end" | 16,271 | _totalSupply()<=MAX_ELEMENTS |
"Max limit" | pragma solidity ^0.8.0;
contract Pattern is ERC721, Ownable {
using Strings for uint256;
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
Counters.Counter private _burnedTracker;
string public baseTokenURI;
uint256 public constant MAX_ELEMENTS = 1200;
uint256 public constant MINT_PRICE = 8 * 10**16;
//Confident that all will be minted
uint public c_supply=1200;
address
public constant creatorAddress = 0xbC7b2461bfaA2fB47bD8f632d0c797C3BFD93B93;
event CreatePattern(uint256 indexed id);
constructor() public ERC721("Pattern", "Patt") {}
modifier saleIsOpen {
}
function totalSupply() public view returns (uint256) {
}
function _totalSupply() internal view returns (uint256) {
}
function _totalBurned() internal view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function totalMint() public view returns (uint256) {
}
function mint(address _to, uint256 _count) public payable saleIsOpen {
uint256 total = _totalSupply();
require(<FILL_ME>)
require(total <= MAX_ELEMENTS, "Sale end");
require(msg.value >= price(_count), "Value below price");
for (uint256 i = 0; i < _count; i++) {
_mintAnElement(_to);
}
}
function price(uint256 _count) public pure returns (uint256) {
}
function _mintAnElement(address _to) private {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
/**
* @dev Returns an URI for a given token ID
*/
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
/**
* @dev Burns and pays the mint price to the token owner.
* @param _tokenId The token to burn.
*/
function burn(uint256 _tokenId) public {
}
function _widthdraw(address _address, uint256 _amount) private {
}
}
| total+_count<=MAX_ELEMENTS,"Max limit" | 16,271 | total+_count<=MAX_ELEMENTS |
null | pragma solidity ^0.5.0;
/**
* @title ERC721Mintable
* @dev ERC721 minting logic.
*/
contract ERC721Mintable is Initializable, ERC721, MinterRole {
function initialize(address sender) public initializer {
require(<FILL_ME>)
MinterRole.initialize(sender);
}
/**
* @dev Function to mint tokens.
* @param to The address that will receive the minted token.
* @param tokenId The token id to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address to, uint256 tokenId) public onlyMinter returns (bool) {
}
/**
* @dev Function to safely mint tokens.
* @param to The address that will receive the minted token.
* @param tokenId The token id to mint.
* @return A boolean that indicates if the operation was successful.
*/
function safeMint(address to, uint256 tokenId) public onlyMinter returns (bool) {
}
/**
* @dev Function to safely mint tokens.
* @param to The address that will receive the minted token.
* @param tokenId The token id to mint.
* @param _data bytes data to send along with a safe transfer check.
* @return A boolean that indicates if the operation was successful.
*/
function safeMint(address to, uint256 tokenId, bytes memory _data) public onlyMinter returns (bool) {
}
uint256[50] private ______gap;
}
| ERC721._hasBeenInitialized() | 16,290 | ERC721._hasBeenInitialized() |
"dev admin only" | pragma solidity 0.8.10;
/***
*@title Vesting Escrow
*@author InsureDAO
* SPDX-License-Identifier: MIT
*@notice Vests `InsureToken` tokens for multiple addresses over multiple vesting periods
*/
//libraries
contract VestingEscrow is ReentrancyGuard {
using SafeERC20
for IERC20;
event Fund(address indexed recipient, uint256 amount);
event Claim(address indexed recipient, uint256 claimed);
event RugPull(address recipient, uint256 rugged);
event ToggleDisable(address recipient, bool disabled);
event CommitOwnership(address admin);
event AcceptOwnership(address admin);
address public token; //address of $INSURE
uint256 public start_time;
uint256 public end_time;
mapping(address => uint256) public initial_locked;
mapping(address => uint256) public total_claimed;
mapping(address => bool) public is_ragged;
uint256 public initial_locked_supply;
uint256 public unallocated_supply;
uint256 public rugged_amount;
bool public can_disable;
mapping(address => uint256) public disabled_at;
address public admin;
address public future_admin;
bool public fund_admins_enabled;
mapping(address => bool) public fund_admins;
/***
*@param _token Address of the ERC20 token being distributed
*@param _start_time Timestamp at which the distribution starts. Should be in
* the future, so that we have enough time to VoteLock everyone
*@param _end_time Time until everything should be vested
*@param _can_disable Whether admin can disable accounts in this deployment.
*@param _fund_admins Temporary admin accounts used only for funding
*/
constructor(
address _token,
uint256 _start_time,
uint256 _end_time,
bool _can_disable,
address[4] memory _fund_admins
) {
}
/***
*@notice Transfer vestable tokens into the contract
*@dev Handled separate from `fund` to reduce transaction count when using funding admins
*@param _amount Number of tokens to transfer
*/
function add_tokens(uint256 _amount) external {
}
/***
*@notice Vest tokens for multiple recipients.
*@param _recipients List of addresses to fund
*@param _amounts Amount of vested tokens for each address
*/
function fund(address[100] memory _recipients, uint256[100] memory _amounts) external nonReentrant {
if (msg.sender != admin) {
require(<FILL_ME>)
require(fund_admins_enabled, "dev fund admins disabled");
}
uint256 _total_amount = 0;
for (uint256 i; i < 100; i++) {
uint256 amount = _amounts[i];
address recipient = _recipients[i];
if (recipient == address(0)) {
break;
}
_total_amount += amount;
initial_locked[recipient] += amount;
emit Fund(recipient, amount);
}
initial_locked_supply += _total_amount;
unallocated_supply -= _total_amount;
}
/***
*@notice Disable further flow of tokens and clawback the unvested part to admin
*/
function rug_pull(address _target) external {
}
/***
*@notice Disable or re-enable a vested address's ability to claim tokens
*@dev When disabled, the address is only unable to claim tokens which are still
* locked at the time of this call. It is not possible to block the claim
* of tokens which have already vested.
*@param _recipient Address to disable or enable
*/
function toggle_disable(address _recipient) external {
}
/***
*@notice Disable the ability to call `toggle_disable`
*/
function disable_can_disable() external {
}
/***
*@notice Disable the funding admin accounts
*/
function disable_fund_admins() external {
}
/***
* @notice Amount of unlocked token amount of _recipient at _time. (include claimed)
*/
function _total_vested_of(address _recipient, uint256 _time) internal view returns(uint256) {
}
function _total_vested() internal view returns(uint256) {
}
/***
*@notice Get the total number of tokens which have vested, that are held
* by this contract
*/
function vestedSupply() external view returns(uint256) {
}
/***
*@notice Get the total number of tokens which are still locked
* (have not yet vested)
*/
function lockedSupply() external view returns(uint256) {
}
/***
*@notice Get the number of tokens which have vested for a given address
*@param _recipient address to check
*/
function vestedOf(address _recipient) external view returns(uint256) {
}
/***
*@notice Get the number of unclaimed, vested tokens for a given address
*@param _recipient address to check
*/
function balanceOf(address _recipient) external view returns(uint256) {
}
/***
*@notice Get the number of locked tokens for a given address
*@param _recipient address to check
*/
function lockedOf(address _recipient) external view returns(uint256) {
}
/***
*@notice Claim tokens which have vested
*@param addr Address to claim tokens for
*/
function claim(address addr) external nonReentrant {
}
/***
*@notice Transfer ownership of GaugeController to `addr`
*@param addr Address to have ownership transferred to
*/
function commit_transfer_ownership(address addr) external returns(bool) {
}
/***
*@notice Accept a transfer of ownership
*@return bool success
*/
function accept_transfer_ownership() external {
}
function min(uint256 a, uint256 b) internal pure returns(uint256) {
}
}
| fund_admins[msg.sender],"dev admin only" | 16,379 | fund_admins[msg.sender] |
null | pragma solidity 0.8.10;
/***
*@title Vesting Escrow
*@author InsureDAO
* SPDX-License-Identifier: MIT
*@notice Vests `InsureToken` tokens for multiple addresses over multiple vesting periods
*/
//libraries
contract VestingEscrow is ReentrancyGuard {
using SafeERC20
for IERC20;
event Fund(address indexed recipient, uint256 amount);
event Claim(address indexed recipient, uint256 claimed);
event RugPull(address recipient, uint256 rugged);
event ToggleDisable(address recipient, bool disabled);
event CommitOwnership(address admin);
event AcceptOwnership(address admin);
address public token; //address of $INSURE
uint256 public start_time;
uint256 public end_time;
mapping(address => uint256) public initial_locked;
mapping(address => uint256) public total_claimed;
mapping(address => bool) public is_ragged;
uint256 public initial_locked_supply;
uint256 public unallocated_supply;
uint256 public rugged_amount;
bool public can_disable;
mapping(address => uint256) public disabled_at;
address public admin;
address public future_admin;
bool public fund_admins_enabled;
mapping(address => bool) public fund_admins;
/***
*@param _token Address of the ERC20 token being distributed
*@param _start_time Timestamp at which the distribution starts. Should be in
* the future, so that we have enough time to VoteLock everyone
*@param _end_time Time until everything should be vested
*@param _can_disable Whether admin can disable accounts in this deployment.
*@param _fund_admins Temporary admin accounts used only for funding
*/
constructor(
address _token,
uint256 _start_time,
uint256 _end_time,
bool _can_disable,
address[4] memory _fund_admins
) {
}
/***
*@notice Transfer vestable tokens into the contract
*@dev Handled separate from `fund` to reduce transaction count when using funding admins
*@param _amount Number of tokens to transfer
*/
function add_tokens(uint256 _amount) external {
}
/***
*@notice Vest tokens for multiple recipients.
*@param _recipients List of addresses to fund
*@param _amounts Amount of vested tokens for each address
*/
function fund(address[100] memory _recipients, uint256[100] memory _amounts) external nonReentrant {
}
/***
*@notice Disable further flow of tokens and clawback the unvested part to admin
*/
function rug_pull(address _target) external {
require(msg.sender == admin, "onlyOwner");
uint256 raggable = initial_locked[_target] - _total_vested_of(_target, block.timestamp); //all unvested token
is_ragged[_target] = true;
disabled_at[_target] = block.timestamp; //never be updated later on.
rugged_amount += raggable;
require(<FILL_ME>)
emit RugPull(admin, raggable);
}
/***
*@notice Disable or re-enable a vested address's ability to claim tokens
*@dev When disabled, the address is only unable to claim tokens which are still
* locked at the time of this call. It is not possible to block the claim
* of tokens which have already vested.
*@param _recipient Address to disable or enable
*/
function toggle_disable(address _recipient) external {
}
/***
*@notice Disable the ability to call `toggle_disable`
*/
function disable_can_disable() external {
}
/***
*@notice Disable the funding admin accounts
*/
function disable_fund_admins() external {
}
/***
* @notice Amount of unlocked token amount of _recipient at _time. (include claimed)
*/
function _total_vested_of(address _recipient, uint256 _time) internal view returns(uint256) {
}
function _total_vested() internal view returns(uint256) {
}
/***
*@notice Get the total number of tokens which have vested, that are held
* by this contract
*/
function vestedSupply() external view returns(uint256) {
}
/***
*@notice Get the total number of tokens which are still locked
* (have not yet vested)
*/
function lockedSupply() external view returns(uint256) {
}
/***
*@notice Get the number of tokens which have vested for a given address
*@param _recipient address to check
*/
function vestedOf(address _recipient) external view returns(uint256) {
}
/***
*@notice Get the number of unclaimed, vested tokens for a given address
*@param _recipient address to check
*/
function balanceOf(address _recipient) external view returns(uint256) {
}
/***
*@notice Get the number of locked tokens for a given address
*@param _recipient address to check
*/
function lockedOf(address _recipient) external view returns(uint256) {
}
/***
*@notice Claim tokens which have vested
*@param addr Address to claim tokens for
*/
function claim(address addr) external nonReentrant {
}
/***
*@notice Transfer ownership of GaugeController to `addr`
*@param addr Address to have ownership transferred to
*/
function commit_transfer_ownership(address addr) external returns(bool) {
}
/***
*@notice Accept a transfer of ownership
*@return bool success
*/
function accept_transfer_ownership() external {
}
function min(uint256 a, uint256 b) internal pure returns(uint256) {
}
}
| IERC20(token).transfer(admin,raggable) | 16,379 | IERC20(token).transfer(admin,raggable) |
"is rugged" | pragma solidity 0.8.10;
/***
*@title Vesting Escrow
*@author InsureDAO
* SPDX-License-Identifier: MIT
*@notice Vests `InsureToken` tokens for multiple addresses over multiple vesting periods
*/
//libraries
contract VestingEscrow is ReentrancyGuard {
using SafeERC20
for IERC20;
event Fund(address indexed recipient, uint256 amount);
event Claim(address indexed recipient, uint256 claimed);
event RugPull(address recipient, uint256 rugged);
event ToggleDisable(address recipient, bool disabled);
event CommitOwnership(address admin);
event AcceptOwnership(address admin);
address public token; //address of $INSURE
uint256 public start_time;
uint256 public end_time;
mapping(address => uint256) public initial_locked;
mapping(address => uint256) public total_claimed;
mapping(address => bool) public is_ragged;
uint256 public initial_locked_supply;
uint256 public unallocated_supply;
uint256 public rugged_amount;
bool public can_disable;
mapping(address => uint256) public disabled_at;
address public admin;
address public future_admin;
bool public fund_admins_enabled;
mapping(address => bool) public fund_admins;
/***
*@param _token Address of the ERC20 token being distributed
*@param _start_time Timestamp at which the distribution starts. Should be in
* the future, so that we have enough time to VoteLock everyone
*@param _end_time Time until everything should be vested
*@param _can_disable Whether admin can disable accounts in this deployment.
*@param _fund_admins Temporary admin accounts used only for funding
*/
constructor(
address _token,
uint256 _start_time,
uint256 _end_time,
bool _can_disable,
address[4] memory _fund_admins
) {
}
/***
*@notice Transfer vestable tokens into the contract
*@dev Handled separate from `fund` to reduce transaction count when using funding admins
*@param _amount Number of tokens to transfer
*/
function add_tokens(uint256 _amount) external {
}
/***
*@notice Vest tokens for multiple recipients.
*@param _recipients List of addresses to fund
*@param _amounts Amount of vested tokens for each address
*/
function fund(address[100] memory _recipients, uint256[100] memory _amounts) external nonReentrant {
}
/***
*@notice Disable further flow of tokens and clawback the unvested part to admin
*/
function rug_pull(address _target) external {
}
/***
*@notice Disable or re-enable a vested address's ability to claim tokens
*@dev When disabled, the address is only unable to claim tokens which are still
* locked at the time of this call. It is not possible to block the claim
* of tokens which have already vested.
*@param _recipient Address to disable or enable
*/
function toggle_disable(address _recipient) external {
require(msg.sender == admin, "onlyOwner");
require(can_disable, "Cannot disable");
require(<FILL_ME>)
bool is_disabled = disabled_at[_recipient] == 0;
if (is_disabled) {
disabled_at[_recipient] = block.timestamp;
} else {
disabled_at[_recipient] = 0;
}
emit ToggleDisable(_recipient, is_disabled);
}
/***
*@notice Disable the ability to call `toggle_disable`
*/
function disable_can_disable() external {
}
/***
*@notice Disable the funding admin accounts
*/
function disable_fund_admins() external {
}
/***
* @notice Amount of unlocked token amount of _recipient at _time. (include claimed)
*/
function _total_vested_of(address _recipient, uint256 _time) internal view returns(uint256) {
}
function _total_vested() internal view returns(uint256) {
}
/***
*@notice Get the total number of tokens which have vested, that are held
* by this contract
*/
function vestedSupply() external view returns(uint256) {
}
/***
*@notice Get the total number of tokens which are still locked
* (have not yet vested)
*/
function lockedSupply() external view returns(uint256) {
}
/***
*@notice Get the number of tokens which have vested for a given address
*@param _recipient address to check
*/
function vestedOf(address _recipient) external view returns(uint256) {
}
/***
*@notice Get the number of unclaimed, vested tokens for a given address
*@param _recipient address to check
*/
function balanceOf(address _recipient) external view returns(uint256) {
}
/***
*@notice Get the number of locked tokens for a given address
*@param _recipient address to check
*/
function lockedOf(address _recipient) external view returns(uint256) {
}
/***
*@notice Claim tokens which have vested
*@param addr Address to claim tokens for
*/
function claim(address addr) external nonReentrant {
}
/***
*@notice Transfer ownership of GaugeController to `addr`
*@param addr Address to have ownership transferred to
*/
function commit_transfer_ownership(address addr) external returns(bool) {
}
/***
*@notice Accept a transfer of ownership
*@return bool success
*/
function accept_transfer_ownership() external {
}
function min(uint256 a, uint256 b) internal pure returns(uint256) {
}
}
| !is_ragged[_recipient],"is rugged" | 16,379 | !is_ragged[_recipient] |
null | pragma solidity 0.8.10;
/***
*@title Vesting Escrow
*@author InsureDAO
* SPDX-License-Identifier: MIT
*@notice Vests `InsureToken` tokens for multiple addresses over multiple vesting periods
*/
//libraries
contract VestingEscrow is ReentrancyGuard {
using SafeERC20
for IERC20;
event Fund(address indexed recipient, uint256 amount);
event Claim(address indexed recipient, uint256 claimed);
event RugPull(address recipient, uint256 rugged);
event ToggleDisable(address recipient, bool disabled);
event CommitOwnership(address admin);
event AcceptOwnership(address admin);
address public token; //address of $INSURE
uint256 public start_time;
uint256 public end_time;
mapping(address => uint256) public initial_locked;
mapping(address => uint256) public total_claimed;
mapping(address => bool) public is_ragged;
uint256 public initial_locked_supply;
uint256 public unallocated_supply;
uint256 public rugged_amount;
bool public can_disable;
mapping(address => uint256) public disabled_at;
address public admin;
address public future_admin;
bool public fund_admins_enabled;
mapping(address => bool) public fund_admins;
/***
*@param _token Address of the ERC20 token being distributed
*@param _start_time Timestamp at which the distribution starts. Should be in
* the future, so that we have enough time to VoteLock everyone
*@param _end_time Time until everything should be vested
*@param _can_disable Whether admin can disable accounts in this deployment.
*@param _fund_admins Temporary admin accounts used only for funding
*/
constructor(
address _token,
uint256 _start_time,
uint256 _end_time,
bool _can_disable,
address[4] memory _fund_admins
) {
}
/***
*@notice Transfer vestable tokens into the contract
*@dev Handled separate from `fund` to reduce transaction count when using funding admins
*@param _amount Number of tokens to transfer
*/
function add_tokens(uint256 _amount) external {
}
/***
*@notice Vest tokens for multiple recipients.
*@param _recipients List of addresses to fund
*@param _amounts Amount of vested tokens for each address
*/
function fund(address[100] memory _recipients, uint256[100] memory _amounts) external nonReentrant {
}
/***
*@notice Disable further flow of tokens and clawback the unvested part to admin
*/
function rug_pull(address _target) external {
}
/***
*@notice Disable or re-enable a vested address's ability to claim tokens
*@dev When disabled, the address is only unable to claim tokens which are still
* locked at the time of this call. It is not possible to block the claim
* of tokens which have already vested.
*@param _recipient Address to disable or enable
*/
function toggle_disable(address _recipient) external {
}
/***
*@notice Disable the ability to call `toggle_disable`
*/
function disable_can_disable() external {
}
/***
*@notice Disable the funding admin accounts
*/
function disable_fund_admins() external {
}
/***
* @notice Amount of unlocked token amount of _recipient at _time. (include claimed)
*/
function _total_vested_of(address _recipient, uint256 _time) internal view returns(uint256) {
}
function _total_vested() internal view returns(uint256) {
}
/***
*@notice Get the total number of tokens which have vested, that are held
* by this contract
*/
function vestedSupply() external view returns(uint256) {
}
/***
*@notice Get the total number of tokens which are still locked
* (have not yet vested)
*/
function lockedSupply() external view returns(uint256) {
}
/***
*@notice Get the number of tokens which have vested for a given address
*@param _recipient address to check
*/
function vestedOf(address _recipient) external view returns(uint256) {
}
/***
*@notice Get the number of unclaimed, vested tokens for a given address
*@param _recipient address to check
*/
function balanceOf(address _recipient) external view returns(uint256) {
}
/***
*@notice Get the number of locked tokens for a given address
*@param _recipient address to check
*/
function lockedOf(address _recipient) external view returns(uint256) {
}
/***
*@notice Claim tokens which have vested
*@param addr Address to claim tokens for
*/
function claim(address addr) external nonReentrant {
uint256 t = disabled_at[addr];
if (t == 0) {
t = block.timestamp;
}
uint256 claimable = _total_vested_of(addr, t) - total_claimed[addr];
total_claimed[addr] += claimable;
require(<FILL_ME>)
emit Claim(addr, claimable);
}
/***
*@notice Transfer ownership of GaugeController to `addr`
*@param addr Address to have ownership transferred to
*/
function commit_transfer_ownership(address addr) external returns(bool) {
}
/***
*@notice Accept a transfer of ownership
*@return bool success
*/
function accept_transfer_ownership() external {
}
function min(uint256 a, uint256 b) internal pure returns(uint256) {
}
}
| IERC20(token).transfer(addr,claimable) | 16,379 | IERC20(token).transfer(addr,claimable) |
"onlyFutureOwner" | pragma solidity 0.8.10;
/***
*@title Vesting Escrow
*@author InsureDAO
* SPDX-License-Identifier: MIT
*@notice Vests `InsureToken` tokens for multiple addresses over multiple vesting periods
*/
//libraries
contract VestingEscrow is ReentrancyGuard {
using SafeERC20
for IERC20;
event Fund(address indexed recipient, uint256 amount);
event Claim(address indexed recipient, uint256 claimed);
event RugPull(address recipient, uint256 rugged);
event ToggleDisable(address recipient, bool disabled);
event CommitOwnership(address admin);
event AcceptOwnership(address admin);
address public token; //address of $INSURE
uint256 public start_time;
uint256 public end_time;
mapping(address => uint256) public initial_locked;
mapping(address => uint256) public total_claimed;
mapping(address => bool) public is_ragged;
uint256 public initial_locked_supply;
uint256 public unallocated_supply;
uint256 public rugged_amount;
bool public can_disable;
mapping(address => uint256) public disabled_at;
address public admin;
address public future_admin;
bool public fund_admins_enabled;
mapping(address => bool) public fund_admins;
/***
*@param _token Address of the ERC20 token being distributed
*@param _start_time Timestamp at which the distribution starts. Should be in
* the future, so that we have enough time to VoteLock everyone
*@param _end_time Time until everything should be vested
*@param _can_disable Whether admin can disable accounts in this deployment.
*@param _fund_admins Temporary admin accounts used only for funding
*/
constructor(
address _token,
uint256 _start_time,
uint256 _end_time,
bool _can_disable,
address[4] memory _fund_admins
) {
}
/***
*@notice Transfer vestable tokens into the contract
*@dev Handled separate from `fund` to reduce transaction count when using funding admins
*@param _amount Number of tokens to transfer
*/
function add_tokens(uint256 _amount) external {
}
/***
*@notice Vest tokens for multiple recipients.
*@param _recipients List of addresses to fund
*@param _amounts Amount of vested tokens for each address
*/
function fund(address[100] memory _recipients, uint256[100] memory _amounts) external nonReentrant {
}
/***
*@notice Disable further flow of tokens and clawback the unvested part to admin
*/
function rug_pull(address _target) external {
}
/***
*@notice Disable or re-enable a vested address's ability to claim tokens
*@dev When disabled, the address is only unable to claim tokens which are still
* locked at the time of this call. It is not possible to block the claim
* of tokens which have already vested.
*@param _recipient Address to disable or enable
*/
function toggle_disable(address _recipient) external {
}
/***
*@notice Disable the ability to call `toggle_disable`
*/
function disable_can_disable() external {
}
/***
*@notice Disable the funding admin accounts
*/
function disable_fund_admins() external {
}
/***
* @notice Amount of unlocked token amount of _recipient at _time. (include claimed)
*/
function _total_vested_of(address _recipient, uint256 _time) internal view returns(uint256) {
}
function _total_vested() internal view returns(uint256) {
}
/***
*@notice Get the total number of tokens which have vested, that are held
* by this contract
*/
function vestedSupply() external view returns(uint256) {
}
/***
*@notice Get the total number of tokens which are still locked
* (have not yet vested)
*/
function lockedSupply() external view returns(uint256) {
}
/***
*@notice Get the number of tokens which have vested for a given address
*@param _recipient address to check
*/
function vestedOf(address _recipient) external view returns(uint256) {
}
/***
*@notice Get the number of unclaimed, vested tokens for a given address
*@param _recipient address to check
*/
function balanceOf(address _recipient) external view returns(uint256) {
}
/***
*@notice Get the number of locked tokens for a given address
*@param _recipient address to check
*/
function lockedOf(address _recipient) external view returns(uint256) {
}
/***
*@notice Claim tokens which have vested
*@param addr Address to claim tokens for
*/
function claim(address addr) external nonReentrant {
}
/***
*@notice Transfer ownership of GaugeController to `addr`
*@param addr Address to have ownership transferred to
*/
function commit_transfer_ownership(address addr) external returns(bool) {
}
/***
*@notice Accept a transfer of ownership
*@return bool success
*/
function accept_transfer_ownership() external {
address _future_admin = future_admin;
require(<FILL_ME>)
admin = _future_admin;
emit AcceptOwnership(_future_admin);
}
function min(uint256 a, uint256 b) internal pure returns(uint256) {
}
}
| address(msg.sender)==_future_admin,"onlyFutureOwner" | 16,379 | address(msg.sender)==_future_admin |
"Sold out !" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
contract MrNonFungible is ERC721A, Ownable {
using Strings for uint256;
string private baseTokenURI;
string private notRevealedUri;
uint256 public cost = 0.1 ether;
uint256 public maxSupply = 9999;
bool public paused = false;
bool public revealed = false;
address payable private devguy = payable(0x5C3229ef0c9A4219D226dE5cA2c14C7FAA175799);
constructor() ERC721A("MrNonFungible", "MrNF") {}
function mint(uint256 _amount) public payable {
require(!paused, "the mint is paused");
require(<FILL_ME>)
require(msg.value >= cost * _amount, "Not enough ether sended");
_safeMint(msg.sender, _amount);
}
function gift(uint256 _amount, address _to) public onlyOwner {
}
function setPause(bool _state) public onlyOwner {
}
function setCost(uint256 newCost) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseUri() internal view virtual returns (string memory) {
}
function reveal() public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function withdraw() external onlyOwner {
}
}
| totalSupply()+_amount<=maxSupply,"Sold out !" | 16,386 | totalSupply()+_amount<=maxSupply |
null | /**
* @title WhitelistedCrowdsale
* @dev Crowdsale with whitelist required for purchases, based on IndividuallyCappedCrowdsale.
*/
contract WhitelistedCrowdsale is Crowdsale, CapperRole {
using SafeMath for uint256;
uint256 private _invCap;
mapping(address => uint256) private _contributions;
mapping(address => uint256) private _whitelist;
/**
* Event for when _account is added or removed from whitelist
* @param _account address added or removed
* @param _phase represents the whitelist status (0:unwhitelisted, 1:whitelisted)
*/
event WhitelistUpdated(
address indexed _account,
uint8 _phase
);
constructor(uint256 invCap) public
{
}
/**
* @dev Checks whether the _account is in the whitelist.
* @param _account Address to be checked
* @return Whether the _account is whitelisted
*/
function isWhitelisted(address _account) public view returns (bool) {
}
/**
* @notice function to whitelist an address which can be called only by the capper address.
*
* @param _account account address to be whitelisted
* @param _phase 0: unwhitelisted, 1: whitelisted
*
* @return bool address is successfully whitelisted/unwhitelisted.
*/
function updateWhitelist(address _account, uint8 _phase) external onlyCapper returns (bool) {
}
/**
* @notice function to whitelist an address which can be called only by the capper address.
*
* @param _accounts list of account addresses to be whitelisted
* @param _phase 0: unwhitelisted, 1: whitelisted
*
* @return bool addresses are successfully whitelisted/unwhitelisted.
*/
function updateWhitelistAddresses(address[] _accounts, uint8 _phase) external onlyCapper {
for (uint256 i = 0; i < _accounts.length; i++) {
require(<FILL_ME>)
_updateWhitelist(_accounts[i], _phase);
}
}
/**
* @notice function to whitelist an address which can be called only by the capper address.
*
* @param _account account address to be whitelisted
* @param _phase 0: unwhitelisted, 1: whitelisted
*/
function _updateWhitelist(
address _account,
uint8 _phase
)
internal
{
}
/**
* @dev add an address to the whitelist
* @param _account address
* @return true if the address was added to the whitelist, false if the address was already in the whitelist
*/
// function addAddressToWhitelist(address _account) public onlyCapper returns (bool) {
// require(_account != address(0));
// _whitelist[_account] = _invCap;
// return isWhitelisted(_account);
// }
/**
* @dev add addresses to the whitelist
* @param _beneficiaries addresses
* @return true if at least one address was added to the whitelist,
* false if all addresses were already in the whitelist
*/
// function addAddressesToWhitelist(address[] _beneficiaries) external onlyCapper {
// for (uint256 i = 0; i < _beneficiaries.length; i++) {
// addAddressToWhitelist(_beneficiaries[i]);
// }
// }
/**
* @dev remove an address from the whitelist
* @param _account address
* @return true if the address was removed from the whitelist, false if the address wasn't already in the whitelist
*/
// function removeAddressFromWhitelist(address _account) public onlyCapper returns (bool) {
// require(_account != address(0));
// _whitelist[_account] = 0;
// return isWhitelisted(_account);
// }
/**
* @dev remove addresses from the whitelist
* @param _beneficiaries addresses
* @return true if at least one address was removed from the whitelist,
* false if all addresses weren't already in the whitelist
*/
// function removeAddressesFromWhitelist(address[] _beneficiaries) external onlyCapper {
// for (uint256 i = 0; i < _beneficiaries.length; i++) {
// removeAddressFromWhitelist(_beneficiaries[i]);
// }
// }
/**
* @dev Returns the amount contributed so far by a specific _account.
* @param _account Address of contributor
* @return _account contribution so far
*/
function getContribution(address _account)
public view returns (uint256)
{
}
/**
* @dev Extend parent behavior requiring purchase to respect the _account's funding cap.
* @param _account Token purchaser
* @param weiAmount Amount of wei contributed
*/
function _preValidatePurchase(
address _account,
uint256 weiAmount
)
internal
{
}
/**
* @dev Extend parent behavior to update _account contributions
* @param _account Token purchaser
* @param weiAmount Amount of wei contributed
*/
function _updatePurchasingState(
address _account,
uint256 weiAmount
)
internal
{
}
}
| _accounts[i]!=address(0) | 16,420 | _accounts[i]!=address(0) |
null | /**
* @title WhitelistedCrowdsale
* @dev Crowdsale with whitelist required for purchases, based on IndividuallyCappedCrowdsale.
*/
contract WhitelistedCrowdsale is Crowdsale, CapperRole {
using SafeMath for uint256;
uint256 private _invCap;
mapping(address => uint256) private _contributions;
mapping(address => uint256) private _whitelist;
/**
* Event for when _account is added or removed from whitelist
* @param _account address added or removed
* @param _phase represents the whitelist status (0:unwhitelisted, 1:whitelisted)
*/
event WhitelistUpdated(
address indexed _account,
uint8 _phase
);
constructor(uint256 invCap) public
{
}
/**
* @dev Checks whether the _account is in the whitelist.
* @param _account Address to be checked
* @return Whether the _account is whitelisted
*/
function isWhitelisted(address _account) public view returns (bool) {
}
/**
* @notice function to whitelist an address which can be called only by the capper address.
*
* @param _account account address to be whitelisted
* @param _phase 0: unwhitelisted, 1: whitelisted
*
* @return bool address is successfully whitelisted/unwhitelisted.
*/
function updateWhitelist(address _account, uint8 _phase) external onlyCapper returns (bool) {
}
/**
* @notice function to whitelist an address which can be called only by the capper address.
*
* @param _accounts list of account addresses to be whitelisted
* @param _phase 0: unwhitelisted, 1: whitelisted
*
* @return bool addresses are successfully whitelisted/unwhitelisted.
*/
function updateWhitelistAddresses(address[] _accounts, uint8 _phase) external onlyCapper {
}
/**
* @notice function to whitelist an address which can be called only by the capper address.
*
* @param _account account address to be whitelisted
* @param _phase 0: unwhitelisted, 1: whitelisted
*/
function _updateWhitelist(
address _account,
uint8 _phase
)
internal
{
}
/**
* @dev add an address to the whitelist
* @param _account address
* @return true if the address was added to the whitelist, false if the address was already in the whitelist
*/
// function addAddressToWhitelist(address _account) public onlyCapper returns (bool) {
// require(_account != address(0));
// _whitelist[_account] = _invCap;
// return isWhitelisted(_account);
// }
/**
* @dev add addresses to the whitelist
* @param _beneficiaries addresses
* @return true if at least one address was added to the whitelist,
* false if all addresses were already in the whitelist
*/
// function addAddressesToWhitelist(address[] _beneficiaries) external onlyCapper {
// for (uint256 i = 0; i < _beneficiaries.length; i++) {
// addAddressToWhitelist(_beneficiaries[i]);
// }
// }
/**
* @dev remove an address from the whitelist
* @param _account address
* @return true if the address was removed from the whitelist, false if the address wasn't already in the whitelist
*/
// function removeAddressFromWhitelist(address _account) public onlyCapper returns (bool) {
// require(_account != address(0));
// _whitelist[_account] = 0;
// return isWhitelisted(_account);
// }
/**
* @dev remove addresses from the whitelist
* @param _beneficiaries addresses
* @return true if at least one address was removed from the whitelist,
* false if all addresses weren't already in the whitelist
*/
// function removeAddressesFromWhitelist(address[] _beneficiaries) external onlyCapper {
// for (uint256 i = 0; i < _beneficiaries.length; i++) {
// removeAddressFromWhitelist(_beneficiaries[i]);
// }
// }
/**
* @dev Returns the amount contributed so far by a specific _account.
* @param _account Address of contributor
* @return _account contribution so far
*/
function getContribution(address _account)
public view returns (uint256)
{
}
/**
* @dev Extend parent behavior requiring purchase to respect the _account's funding cap.
* @param _account Token purchaser
* @param weiAmount Amount of wei contributed
*/
function _preValidatePurchase(
address _account,
uint256 weiAmount
)
internal
{
super._preValidatePurchase(_account, weiAmount);
require(<FILL_ME>)
}
/**
* @dev Extend parent behavior to update _account contributions
* @param _account Token purchaser
* @param weiAmount Amount of wei contributed
*/
function _updatePurchasingState(
address _account,
uint256 weiAmount
)
internal
{
}
}
| _contributions[_account].add(weiAmount)<=_whitelist[_account] | 16,420 | _contributions[_account].add(weiAmount)<=_whitelist[_account] |
"Refund::removeUnused: bad timing for the request" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "./Services/ERC20.sol";
import "./Services/Blacklist.sol";
import "./Services/Service.sol";
contract Refund is Service, BlackList {
uint public startTimestamp;
uint public endTimestamp;
mapping(address => Base) public pTokens;
address[] pTokensList;
struct Base {
address baseToken;
uint course;
}
mapping(address => mapping(address => uint)) public pTokenAmounts;
mapping(address => address) public baseTokens;
address[] baseTokenList;
struct Balance {
uint amount;
uint out;
}
mapping(address => mapping(address => Balance)) public balances;
mapping(address => uint[]) public checkpoints;
mapping(address => uint) public totalAmount;
address public calcPoolPrice;
constructor(
uint startTimestamp_,
uint endTimestamp_,
address controller_,
address pETH_,
address calcPoolPrice_
) Service(controller_, pETH_) {
}
function addRefundPair(address pToken, address baseToken_, uint course_) public onlyOwner returns (bool) {
}
function addTokensAndCheckpoint(address baseToken, uint baseTokenAmount) public onlyOwner returns (bool) {
}
function removeUnused(address token, uint amount) public onlyOwner returns (bool) {
require(<FILL_ME>)
doTransferOut(token, msg.sender, amount);
return true;
}
function refund(address pToken, uint pTokenAmount) public returns (bool) {
}
function calcRefundAmount(address pToken, uint amount) public view returns (uint) {
}
function claimToken(address pToken) public returns (bool) {
}
function calcClaimAmount(address user, address pToken) public view returns (uint) {
}
function getCheckpointsLength(address baseToken_) public view returns (uint) {
}
function getPTokenList() public view returns (address[] memory) {
}
function getPTokenListLength() public view returns (uint) {
}
function getAllTotalAmount() public view returns (uint) {
}
function getUserUsdAmount(address user) public view returns (uint) {
}
function pTokensIsAllowed(address pToken_) public view returns (bool) {
}
function getAvailableLiquidity() public view returns (uint) {
}
function getBlockTimestamp() public view virtual returns (uint) {
}
}
| getBlockTimestamp()>endTimestamp,"Refund::removeUnused: bad timing for the request" | 16,499 | getBlockTimestamp()>endTimestamp |
"Refund::refund: you can convert pTokens before start timestamp only" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "./Services/ERC20.sol";
import "./Services/Blacklist.sol";
import "./Services/Service.sol";
contract Refund is Service, BlackList {
uint public startTimestamp;
uint public endTimestamp;
mapping(address => Base) public pTokens;
address[] pTokensList;
struct Base {
address baseToken;
uint course;
}
mapping(address => mapping(address => uint)) public pTokenAmounts;
mapping(address => address) public baseTokens;
address[] baseTokenList;
struct Balance {
uint amount;
uint out;
}
mapping(address => mapping(address => Balance)) public balances;
mapping(address => uint[]) public checkpoints;
mapping(address => uint) public totalAmount;
address public calcPoolPrice;
constructor(
uint startTimestamp_,
uint endTimestamp_,
address controller_,
address pETH_,
address calcPoolPrice_
) Service(controller_, pETH_) {
}
function addRefundPair(address pToken, address baseToken_, uint course_) public onlyOwner returns (bool) {
}
function addTokensAndCheckpoint(address baseToken, uint baseTokenAmount) public onlyOwner returns (bool) {
}
function removeUnused(address token, uint amount) public onlyOwner returns (bool) {
}
function refund(address pToken, uint pTokenAmount) public returns (bool) {
require(<FILL_ME>)
require(checkBorrowBalance(msg.sender), "Refund::refund: sumBorrow must be less than $1");
require(pTokensIsAllowed(pToken), "Refund::refund: pToken is not allowed");
uint pTokenAmountIn = doTransferIn(msg.sender, pToken, pTokenAmount);
pTokenAmounts[msg.sender][pToken] += pTokenAmountIn;
address baseToken = baseTokens[pToken];
uint baseTokenAmount = calcRefundAmount(pToken, pTokenAmountIn);
balances[msg.sender][baseToken].amount += baseTokenAmount;
totalAmount[baseToken] += baseTokenAmount;
return true;
}
function calcRefundAmount(address pToken, uint amount) public view returns (uint) {
}
function claimToken(address pToken) public returns (bool) {
}
function calcClaimAmount(address user, address pToken) public view returns (uint) {
}
function getCheckpointsLength(address baseToken_) public view returns (uint) {
}
function getPTokenList() public view returns (address[] memory) {
}
function getPTokenListLength() public view returns (uint) {
}
function getAllTotalAmount() public view returns (uint) {
}
function getUserUsdAmount(address user) public view returns (uint) {
}
function pTokensIsAllowed(address pToken_) public view returns (bool) {
}
function getAvailableLiquidity() public view returns (uint) {
}
function getBlockTimestamp() public view virtual returns (uint) {
}
}
| getBlockTimestamp()<startTimestamp,"Refund::refund: you can convert pTokens before start timestamp only" | 16,499 | getBlockTimestamp()<startTimestamp |
"Refund::refund: sumBorrow must be less than $1" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "./Services/ERC20.sol";
import "./Services/Blacklist.sol";
import "./Services/Service.sol";
contract Refund is Service, BlackList {
uint public startTimestamp;
uint public endTimestamp;
mapping(address => Base) public pTokens;
address[] pTokensList;
struct Base {
address baseToken;
uint course;
}
mapping(address => mapping(address => uint)) public pTokenAmounts;
mapping(address => address) public baseTokens;
address[] baseTokenList;
struct Balance {
uint amount;
uint out;
}
mapping(address => mapping(address => Balance)) public balances;
mapping(address => uint[]) public checkpoints;
mapping(address => uint) public totalAmount;
address public calcPoolPrice;
constructor(
uint startTimestamp_,
uint endTimestamp_,
address controller_,
address pETH_,
address calcPoolPrice_
) Service(controller_, pETH_) {
}
function addRefundPair(address pToken, address baseToken_, uint course_) public onlyOwner returns (bool) {
}
function addTokensAndCheckpoint(address baseToken, uint baseTokenAmount) public onlyOwner returns (bool) {
}
function removeUnused(address token, uint amount) public onlyOwner returns (bool) {
}
function refund(address pToken, uint pTokenAmount) public returns (bool) {
require(getBlockTimestamp() < startTimestamp, "Refund::refund: you can convert pTokens before start timestamp only");
require(<FILL_ME>)
require(pTokensIsAllowed(pToken), "Refund::refund: pToken is not allowed");
uint pTokenAmountIn = doTransferIn(msg.sender, pToken, pTokenAmount);
pTokenAmounts[msg.sender][pToken] += pTokenAmountIn;
address baseToken = baseTokens[pToken];
uint baseTokenAmount = calcRefundAmount(pToken, pTokenAmountIn);
balances[msg.sender][baseToken].amount += baseTokenAmount;
totalAmount[baseToken] += baseTokenAmount;
return true;
}
function calcRefundAmount(address pToken, uint amount) public view returns (uint) {
}
function claimToken(address pToken) public returns (bool) {
}
function calcClaimAmount(address user, address pToken) public view returns (uint) {
}
function getCheckpointsLength(address baseToken_) public view returns (uint) {
}
function getPTokenList() public view returns (address[] memory) {
}
function getPTokenListLength() public view returns (uint) {
}
function getAllTotalAmount() public view returns (uint) {
}
function getUserUsdAmount(address user) public view returns (uint) {
}
function pTokensIsAllowed(address pToken_) public view returns (bool) {
}
function getAvailableLiquidity() public view returns (uint) {
}
function getBlockTimestamp() public view virtual returns (uint) {
}
}
| checkBorrowBalance(msg.sender),"Refund::refund: sumBorrow must be less than $1" | 16,499 | checkBorrowBalance(msg.sender) |
Subsets and Splits