comment
stringlengths 1
211
β | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"!approved" | pragma solidity ^0.6.0;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/proxy/Initializable.sol";
import "./interfaces/IController.sol";
import "./interfaces/IStrategy.sol";
import "./interfaces/IConverter.sol";
/// @title Controller
/// @notice The contract is the middleman between vault and strategy, it balances and trigger earn processes
contract Controller is IController, Ownable, Initializable {
using Address for address;
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice Emits when funds are withdrawn fully from related to vault strategy
/// @param _token Token address to be withdrawn
event WithdrawToVaultAll(address _token);
event Earn(address _token, uint256 _amount);
/// @dev token => vault
mapping(address => address) public override vaults;
/// @dev token => strategy
mapping(address => address) public override strategies;
/// @dev from => to => converter address
mapping(address => mapping(address => address)) public override converters;
/// @dev token => strategy => is strategy approved
mapping(address => mapping(address => bool))
public
override approvedStrategies;
/// @notice Strategist is an actor who created the strategies and he is receiving fees from strategies execution
address public strategist;
/// @notice Treasury contract address (used to channel fees to governance and rewards for voting process and investors)
address private _treasury;
/// @dev Prevents other msg.sender than either governance or strategist addresses
modifier onlyOwnerOrStrategist() {
}
/// @notice Default initialize method for solving migration linearization problem
/// @dev Called once only by deployer
/// @param _initialTreasury treasury contract address
/// @param _initialStrategist strategist address
function configure(
address _initialTreasury,
address _initialStrategist,
address _governance
) external onlyOwner initializer {
}
/// @notice Used only to rescue stuck funds from controller to msg.sender
/// @param _token Token to rescue
/// @param _amount Amount tokens to rescue
function inCaseTokensGetStuck(address _token, uint256 _amount)
external
onlyOwner
{
}
/// @notice Used only to rescue stuck or unrelated funds from strategy to vault
/// @param _strategy Strategy address
/// @param _token Unrelated token address
function inCaseStrategyTokenGetStuck(address _strategy, address _token)
external
onlyOwnerOrStrategist
{
}
/// @notice Withdraws funds from strategy to related vault
/// @param _token Token address to withdraw
/// @param _amount Amount tokens
function withdraw(address _token, uint256 _amount) external override {
}
function claim(address _wantToken, address _tokenToClaim)
external
override
{
}
/// @notice forces the strategy to take away the rewards due to it
// this method must call via backend
/// @param _token want token address
function getRewardStrategy(address _token) external override {
}
/// @notice Usual setter with additional checks
/// @param _newTreasury New value
function setTreasury(address _newTreasury) external onlyOwner {
}
/// @notice Usual setter with check if param is new
/// @param _newStrategist New value
function setStrategist(address _newStrategist) external onlyOwner {
}
/// @notice Used to obtain fees receivers address
/// @return Treasury contract address
function rewards() external view override returns (address) {
}
/// @notice Usual setter of vault in mapping with check if new vault is not address(0)
/// @param _token Business logic token of the vault
/// @param _vault Vault address
function setVault(address _token, address _vault)
external
override
onlyOwnerOrStrategist
{
}
/// @notice Usual setter of converter contract, it implements the optimal logic to token conversion
/// @param _input Input token address
/// @param _output Output token address
/// @param _converter Converter contract
function setConverter(
address _input,
address _output,
address _converter
) external onlyOwnerOrStrategist {
}
/// @notice Sets new link between business logic token and strategy, and if strategy is already used, withdraws all funds from it to the vault
/// @param _token Business logic token address
/// @param _strategy Corresponded strategy contract address
function setStrategy(address _token, address _strategy)
external
override
onlyOwnerOrStrategist
{
require(<FILL_ME>)
address _current = strategies[_token];
if (_current != address(0)) {
uint256 amount = IERC20(IStrategy(_current).want()).balanceOf(
address(this)
);
IStrategy(_current).withdraw(amount);
emit WithdrawToVaultAll(_token);
}
strategies[_token] = _strategy;
}
/// @notice Approves strategy to be added to mapping, needs to be done before setting strategy
/// @param _token Business logic token address
/// @param _strategy Strategy contract address
/// @param _status Approved or not (bool)?
function setApprovedStrategy(
address _token,
address _strategy,
bool _status
) external onlyOwner {
}
/// @notice The method converts if needed given token to business logic strategy token,
/// transfers converted tokens to strategy, and executes the business logic
/// @param _token Given token address (wERC20)
/// @param _amount Amount of given token address
function earn(address _token, uint256 _amount) public override {
}
}
| approvedStrategies[_token][_strategy],"!approved" | 19,536 | approvedStrategies[_token][_strategy] |
"!transferConverterToken" | pragma solidity ^0.6.0;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/proxy/Initializable.sol";
import "./interfaces/IController.sol";
import "./interfaces/IStrategy.sol";
import "./interfaces/IConverter.sol";
/// @title Controller
/// @notice The contract is the middleman between vault and strategy, it balances and trigger earn processes
contract Controller is IController, Ownable, Initializable {
using Address for address;
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice Emits when funds are withdrawn fully from related to vault strategy
/// @param _token Token address to be withdrawn
event WithdrawToVaultAll(address _token);
event Earn(address _token, uint256 _amount);
/// @dev token => vault
mapping(address => address) public override vaults;
/// @dev token => strategy
mapping(address => address) public override strategies;
/// @dev from => to => converter address
mapping(address => mapping(address => address)) public override converters;
/// @dev token => strategy => is strategy approved
mapping(address => mapping(address => bool))
public
override approvedStrategies;
/// @notice Strategist is an actor who created the strategies and he is receiving fees from strategies execution
address public strategist;
/// @notice Treasury contract address (used to channel fees to governance and rewards for voting process and investors)
address private _treasury;
/// @dev Prevents other msg.sender than either governance or strategist addresses
modifier onlyOwnerOrStrategist() {
}
/// @notice Default initialize method for solving migration linearization problem
/// @dev Called once only by deployer
/// @param _initialTreasury treasury contract address
/// @param _initialStrategist strategist address
function configure(
address _initialTreasury,
address _initialStrategist,
address _governance
) external onlyOwner initializer {
}
/// @notice Used only to rescue stuck funds from controller to msg.sender
/// @param _token Token to rescue
/// @param _amount Amount tokens to rescue
function inCaseTokensGetStuck(address _token, uint256 _amount)
external
onlyOwner
{
}
/// @notice Used only to rescue stuck or unrelated funds from strategy to vault
/// @param _strategy Strategy address
/// @param _token Unrelated token address
function inCaseStrategyTokenGetStuck(address _strategy, address _token)
external
onlyOwnerOrStrategist
{
}
/// @notice Withdraws funds from strategy to related vault
/// @param _token Token address to withdraw
/// @param _amount Amount tokens
function withdraw(address _token, uint256 _amount) external override {
}
function claim(address _wantToken, address _tokenToClaim)
external
override
{
}
/// @notice forces the strategy to take away the rewards due to it
// this method must call via backend
/// @param _token want token address
function getRewardStrategy(address _token) external override {
}
/// @notice Usual setter with additional checks
/// @param _newTreasury New value
function setTreasury(address _newTreasury) external onlyOwner {
}
/// @notice Usual setter with check if param is new
/// @param _newStrategist New value
function setStrategist(address _newStrategist) external onlyOwner {
}
/// @notice Used to obtain fees receivers address
/// @return Treasury contract address
function rewards() external view override returns (address) {
}
/// @notice Usual setter of vault in mapping with check if new vault is not address(0)
/// @param _token Business logic token of the vault
/// @param _vault Vault address
function setVault(address _token, address _vault)
external
override
onlyOwnerOrStrategist
{
}
/// @notice Usual setter of converter contract, it implements the optimal logic to token conversion
/// @param _input Input token address
/// @param _output Output token address
/// @param _converter Converter contract
function setConverter(
address _input,
address _output,
address _converter
) external onlyOwnerOrStrategist {
}
/// @notice Sets new link between business logic token and strategy, and if strategy is already used, withdraws all funds from it to the vault
/// @param _token Business logic token address
/// @param _strategy Corresponded strategy contract address
function setStrategy(address _token, address _strategy)
external
override
onlyOwnerOrStrategist
{
}
/// @notice Approves strategy to be added to mapping, needs to be done before setting strategy
/// @param _token Business logic token address
/// @param _strategy Strategy contract address
/// @param _status Approved or not (bool)?
function setApprovedStrategy(
address _token,
address _strategy,
bool _status
) external onlyOwner {
}
/// @notice The method converts if needed given token to business logic strategy token,
/// transfers converted tokens to strategy, and executes the business logic
/// @param _token Given token address (wERC20)
/// @param _amount Amount of given token address
function earn(address _token, uint256 _amount) public override {
address _strategy = strategies[_token];
address _want = IStrategy(_strategy).want();
if (_want != _token) {
address converter = converters[_token][_want];
require(converter != address(0), "!converter");
require(<FILL_ME>)
_amount = IConverter(converter).convert(_strategy);
}
require(
IERC20(_want).transfer(_strategy, _amount),
"!transferStrategyWant"
);
IStrategy(_strategy).deposit();
emit Earn(_token, _amount);
}
}
| IERC20(_token).transfer(converter,_amount),"!transferConverterToken" | 19,536 | IERC20(_token).transfer(converter,_amount) |
"!transferStrategyWant" | pragma solidity ^0.6.0;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/proxy/Initializable.sol";
import "./interfaces/IController.sol";
import "./interfaces/IStrategy.sol";
import "./interfaces/IConverter.sol";
/// @title Controller
/// @notice The contract is the middleman between vault and strategy, it balances and trigger earn processes
contract Controller is IController, Ownable, Initializable {
using Address for address;
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice Emits when funds are withdrawn fully from related to vault strategy
/// @param _token Token address to be withdrawn
event WithdrawToVaultAll(address _token);
event Earn(address _token, uint256 _amount);
/// @dev token => vault
mapping(address => address) public override vaults;
/// @dev token => strategy
mapping(address => address) public override strategies;
/// @dev from => to => converter address
mapping(address => mapping(address => address)) public override converters;
/// @dev token => strategy => is strategy approved
mapping(address => mapping(address => bool))
public
override approvedStrategies;
/// @notice Strategist is an actor who created the strategies and he is receiving fees from strategies execution
address public strategist;
/// @notice Treasury contract address (used to channel fees to governance and rewards for voting process and investors)
address private _treasury;
/// @dev Prevents other msg.sender than either governance or strategist addresses
modifier onlyOwnerOrStrategist() {
}
/// @notice Default initialize method for solving migration linearization problem
/// @dev Called once only by deployer
/// @param _initialTreasury treasury contract address
/// @param _initialStrategist strategist address
function configure(
address _initialTreasury,
address _initialStrategist,
address _governance
) external onlyOwner initializer {
}
/// @notice Used only to rescue stuck funds from controller to msg.sender
/// @param _token Token to rescue
/// @param _amount Amount tokens to rescue
function inCaseTokensGetStuck(address _token, uint256 _amount)
external
onlyOwner
{
}
/// @notice Used only to rescue stuck or unrelated funds from strategy to vault
/// @param _strategy Strategy address
/// @param _token Unrelated token address
function inCaseStrategyTokenGetStuck(address _strategy, address _token)
external
onlyOwnerOrStrategist
{
}
/// @notice Withdraws funds from strategy to related vault
/// @param _token Token address to withdraw
/// @param _amount Amount tokens
function withdraw(address _token, uint256 _amount) external override {
}
function claim(address _wantToken, address _tokenToClaim)
external
override
{
}
/// @notice forces the strategy to take away the rewards due to it
// this method must call via backend
/// @param _token want token address
function getRewardStrategy(address _token) external override {
}
/// @notice Usual setter with additional checks
/// @param _newTreasury New value
function setTreasury(address _newTreasury) external onlyOwner {
}
/// @notice Usual setter with check if param is new
/// @param _newStrategist New value
function setStrategist(address _newStrategist) external onlyOwner {
}
/// @notice Used to obtain fees receivers address
/// @return Treasury contract address
function rewards() external view override returns (address) {
}
/// @notice Usual setter of vault in mapping with check if new vault is not address(0)
/// @param _token Business logic token of the vault
/// @param _vault Vault address
function setVault(address _token, address _vault)
external
override
onlyOwnerOrStrategist
{
}
/// @notice Usual setter of converter contract, it implements the optimal logic to token conversion
/// @param _input Input token address
/// @param _output Output token address
/// @param _converter Converter contract
function setConverter(
address _input,
address _output,
address _converter
) external onlyOwnerOrStrategist {
}
/// @notice Sets new link between business logic token and strategy, and if strategy is already used, withdraws all funds from it to the vault
/// @param _token Business logic token address
/// @param _strategy Corresponded strategy contract address
function setStrategy(address _token, address _strategy)
external
override
onlyOwnerOrStrategist
{
}
/// @notice Approves strategy to be added to mapping, needs to be done before setting strategy
/// @param _token Business logic token address
/// @param _strategy Strategy contract address
/// @param _status Approved or not (bool)?
function setApprovedStrategy(
address _token,
address _strategy,
bool _status
) external onlyOwner {
}
/// @notice The method converts if needed given token to business logic strategy token,
/// transfers converted tokens to strategy, and executes the business logic
/// @param _token Given token address (wERC20)
/// @param _amount Amount of given token address
function earn(address _token, uint256 _amount) public override {
address _strategy = strategies[_token];
address _want = IStrategy(_strategy).want();
if (_want != _token) {
address converter = converters[_token][_want];
require(converter != address(0), "!converter");
require(
IERC20(_token).transfer(converter, _amount),
"!transferConverterToken"
);
_amount = IConverter(converter).convert(_strategy);
}
require(<FILL_ME>)
IStrategy(_strategy).deposit();
emit Earn(_token, _amount);
}
}
| IERC20(_want).transfer(_strategy,_amount),"!transferStrategyWant" | 19,536 | IERC20(_want).transfer(_strategy,_amount) |
"DepositContract: deposit value not multiple of gwei" | // βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// ββββββββββββββββββββββββββββββββββββββββββββββββββ«β£β«βββββββββββββββββββββββββββββββββββββββββ
// ββββββββββββββββββββββββββββββββββββββ«βββββββββ£ββββββββββββββββββββββββββββββββββββββββββββββ
// βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
// SPDX-License-Identifier: CC0-1.0
pragma solidity 0.8.4;
// This interface is designed to be compatible with the Vyper version.
/// @notice This is the Ethereum 2.0 deposit contract interface.
/// For more information see the Phase 0 specification under https://github.com/ethereum/eth2.0-specs
interface IDepositContract {
/// @notice A processed deposit event.
event DepositEvent(
bytes pubkey,
bytes withdrawal_credentials,
bytes amount,
bytes signature,
bytes index
);
/// @notice Submit a Phase 0 DepositData object.
/// @param pubkey A BLS12-381 public key.
/// @param withdrawal_credentials Commitment to a public key for withdrawals.
/// @param signature A BLS12-381 signature.
/// @param deposit_data_root The SHA-256 hash of the SSZ-encoded DepositData object.
/// Used as a protection against malformed input.
function deposit(
bytes calldata pubkey,
bytes calldata withdrawal_credentials,
bytes calldata signature,
bytes32 deposit_data_root
) external payable;
/// @notice Query the current deposit root hash.
/// @return The deposit root hash.
function get_deposit_root() external view returns (bytes32);
/// @notice Query the current deposit count.
/// @return The deposit count encoded as a little endian 64-bit number.
function get_deposit_count() external view returns (bytes memory);
}
// Based on official specification in https://eips.ethereum.org/EIPS/eip-165
interface ERC165 {
/// @notice Query if a contract implements an interface
/// @param interfaceId The interface identifier, as specified in ERC-165
/// @dev Interface identification is specified in ERC-165. This function
/// uses less than 30,000 gas.
/// @return `true` if the contract implements `interfaceId` and
/// `interfaceId` is not 0xffffffff, `false` otherwise
function supportsInterface(bytes4 interfaceId) external pure returns (bool);
}
// This is a rewrite of the Vyper Eth2.0 deposit contract in Solidity.
// It tries to stay as close as possible to the original source code.
/// @notice This is the Ethereum 2.0 deposit contract interface.
/// For more information see the Phase 0 specification under https://github.com/ethereum/eth2.0-specs
contract DepositContract is IDepositContract, ERC165 {
uint constant DEPOSIT_CONTRACT_TREE_DEPTH = 32;
// NOTE: this also ensures `deposit_count` will fit into 64-bits
uint constant MAX_DEPOSIT_COUNT = 2**DEPOSIT_CONTRACT_TREE_DEPTH - 1;
bytes32[DEPOSIT_CONTRACT_TREE_DEPTH] branch;
uint256 deposit_count;
bytes32[DEPOSIT_CONTRACT_TREE_DEPTH] zero_hashes;
constructor() {
}
function get_deposit_root() override external view returns (bytes32) {
}
function get_deposit_count() override external view returns (bytes memory) {
}
function deposit(
bytes calldata pubkey,
bytes calldata withdrawal_credentials,
bytes calldata signature,
bytes32 deposit_data_root
) override external payable {
// Extended ABI length checks since dynamic types are used.
require(pubkey.length == 48, "DepositContract: invalid pubkey length");
require(withdrawal_credentials.length == 32, "DepositContract: invalid withdrawal_credentials length");
require(signature.length == 96, "DepositContract: invalid signature length");
// Check deposit amount
require(msg.value >= 1 ether, "DepositContract: deposit value too low");
require(<FILL_ME>)
uint deposit_amount = msg.value / 1 gwei;
require(deposit_amount <= type(uint64).max, "DepositContract: deposit value too high");
// Emit `DepositEvent` log
bytes memory amount = to_little_endian_64(uint64(deposit_amount));
emit DepositEvent(
pubkey,
withdrawal_credentials,
amount,
signature,
to_little_endian_64(uint64(deposit_count))
);
// Compute deposit data root (`DepositData` hash tree root)
bytes32 pubkey_root = sha256(abi.encodePacked(pubkey, bytes16(0)));
bytes32 signature_root = sha256(abi.encodePacked(
sha256(abi.encodePacked(signature[:64])),
sha256(abi.encodePacked(signature[64:], bytes32(0)))
));
bytes32 node = sha256(abi.encodePacked(
sha256(abi.encodePacked(pubkey_root, withdrawal_credentials)),
sha256(abi.encodePacked(amount, bytes24(0), signature_root))
));
// Verify computed and expected deposit data roots match
require(node == deposit_data_root, "DepositContract: reconstructed DepositData does not match supplied deposit_data_root");
// Avoid overflowing the Merkle tree (and prevent edge case in computing `branch`)
require(deposit_count < MAX_DEPOSIT_COUNT, "DepositContract: merkle tree full");
// Add deposit data root to Merkle tree (update a single `branch` node)
deposit_count += 1;
uint size = deposit_count;
for (uint height = 0; height < DEPOSIT_CONTRACT_TREE_DEPTH; height++) {
if ((size & 1) == 1) {
branch[height] = node;
return;
}
node = sha256(abi.encodePacked(branch[height], node));
size /= 2;
}
// As the loop should always end prematurely with the `return` statement,
// this code should be unreachable. We assert `false` just to be safe.
assert(false);
}
function supportsInterface(bytes4 interfaceId) override external pure returns (bool) {
}
function to_little_endian_64(uint64 value) internal pure returns (bytes memory ret) {
}
}
| msg.value%1gwei==0,"DepositContract: deposit value not multiple of gwei" | 19,549 | msg.value%1gwei==0 |
null | pragma solidity ^0.5.13;
interface Callable {
function tokenCallback(
address _from,
uint256 _tokens,
bytes calldata _data
) external returns (bool);
}
contract Token {
uint256 private constant FLOAT_SCALAR = 2**64;
uint256 private constant INITIAL_SUPPLY = 3e24; // 3m
uint256 private constant STAKE_FEE = 2; // 1% per tx
uint256 private constant MIN_STAKE_AMOUNT = 1e19; // 10
string public constant name = "FurToken";
string public constant symbol = "FUR";
uint8 public constant decimals = 18;
address owner = 0x929B1F2328d03c05b0Fb36053222fB4B15bb29dd;
struct User {
uint256 balance;
uint256 staked;
mapping(address => uint256) allowance;
int256 scaledPayout;
}
struct Info {
uint256 totalSupply;
uint256 totalStaked;
mapping(address => User) users;
uint256 scaledPayoutPerToken;
address admin;
}
Info private info;
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(
address indexed owner,
address indexed spender,
uint256 tokens
);
event Whitelist(address indexed user, bool status);
event Stake(address indexed owner, uint256 tokens);
event Unstake(address indexed owner, uint256 tokens);
event Collect(address indexed owner, uint256 tokens);
event Fee(uint256 tokens);
constructor() public {
}
function stake(uint256 _tokens) external {
}
function unstake(uint256 _tokens) external {
}
function collect() external returns (uint256) {
}
function stakeDrop(uint256 _tokens) external {
require(<FILL_ME>)
uint256 _droppedAmount = _tokens;
info.users[msg.sender].balance -= _tokens;
if (info.totalStaked > 0) {
info.scaledPayoutPerToken +=
(_droppedAmount * FLOAT_SCALAR) /
info.totalStaked;
emit Transfer(msg.sender, address(this), _droppedAmount);
emit Fee(_droppedAmount);
} else {
revert();
}
}
function distribute(uint256 _tokens) external {
}
function transfer(address _to, uint256 _tokens) external returns (bool) {
}
function approve(address _spender, uint256 _tokens)
external
returns (bool)
{
}
function transferFrom(
address _from,
address _to,
uint256 _tokens
) external returns (bool) {
}
function transferAndCall(
address _to,
uint256 _tokens,
bytes calldata _data
) external returns (bool) {
}
function bulkTransfer(
address[] calldata _receivers,
uint256[] calldata _amounts
) external {
}
function totalSupply() public view returns (uint256) {
}
function totalStaked() public view returns (uint256) {
}
function balanceOf(address _user) public view returns (uint256) {
}
function stakedOf(address _user) public view returns (uint256) {
}
function dividendsOf(address _user) public view returns (uint256) {
}
function allowance(address _user, address _spender)
public
view
returns (uint256)
{
}
function allInfoFor(address _user)
public
view
returns (
uint256 totalTokenSupply,
uint256 totalTokensStaked,
uint256 userBalance,
uint256 userStaked,
uint256 userDividends
)
{
}
function _transfer(
address _from,
address _to,
uint256 _tokens
) internal returns (uint256) {
}
function _stake(uint256 _amount) internal {
}
function _unstake(uint256 _amount) internal {
}
}
| balanceOf(msg.sender)>=_tokens | 19,573 | balanceOf(msg.sender)>=_tokens |
null | pragma solidity ^0.5.13;
interface Callable {
function tokenCallback(
address _from,
uint256 _tokens,
bytes calldata _data
) external returns (bool);
}
contract Token {
uint256 private constant FLOAT_SCALAR = 2**64;
uint256 private constant INITIAL_SUPPLY = 3e24; // 3m
uint256 private constant STAKE_FEE = 2; // 1% per tx
uint256 private constant MIN_STAKE_AMOUNT = 1e19; // 10
string public constant name = "FurToken";
string public constant symbol = "FUR";
uint8 public constant decimals = 18;
address owner = 0x929B1F2328d03c05b0Fb36053222fB4B15bb29dd;
struct User {
uint256 balance;
uint256 staked;
mapping(address => uint256) allowance;
int256 scaledPayout;
}
struct Info {
uint256 totalSupply;
uint256 totalStaked;
mapping(address => User) users;
uint256 scaledPayoutPerToken;
address admin;
}
Info private info;
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(
address indexed owner,
address indexed spender,
uint256 tokens
);
event Whitelist(address indexed user, bool status);
event Stake(address indexed owner, uint256 tokens);
event Unstake(address indexed owner, uint256 tokens);
event Collect(address indexed owner, uint256 tokens);
event Fee(uint256 tokens);
constructor() public {
}
function stake(uint256 _tokens) external {
}
function unstake(uint256 _tokens) external {
}
function collect() external returns (uint256) {
}
function stakeDrop(uint256 _tokens) external {
}
function distribute(uint256 _tokens) external {
}
function transfer(address _to, uint256 _tokens) external returns (bool) {
}
function approve(address _spender, uint256 _tokens)
external
returns (bool)
{
}
function transferFrom(
address _from,
address _to,
uint256 _tokens
) external returns (bool) {
require(<FILL_ME>)
info.users[_from].allowance[msg.sender] -= _tokens;
_transfer(_from, _to, _tokens);
return true;
}
function transferAndCall(
address _to,
uint256 _tokens,
bytes calldata _data
) external returns (bool) {
}
function bulkTransfer(
address[] calldata _receivers,
uint256[] calldata _amounts
) external {
}
function totalSupply() public view returns (uint256) {
}
function totalStaked() public view returns (uint256) {
}
function balanceOf(address _user) public view returns (uint256) {
}
function stakedOf(address _user) public view returns (uint256) {
}
function dividendsOf(address _user) public view returns (uint256) {
}
function allowance(address _user, address _spender)
public
view
returns (uint256)
{
}
function allInfoFor(address _user)
public
view
returns (
uint256 totalTokenSupply,
uint256 totalTokensStaked,
uint256 userBalance,
uint256 userStaked,
uint256 userDividends
)
{
}
function _transfer(
address _from,
address _to,
uint256 _tokens
) internal returns (uint256) {
}
function _stake(uint256 _amount) internal {
}
function _unstake(uint256 _amount) internal {
}
}
| info.users[_from].allowance[msg.sender]>=_tokens | 19,573 | info.users[_from].allowance[msg.sender]>=_tokens |
null | pragma solidity ^0.5.13;
interface Callable {
function tokenCallback(
address _from,
uint256 _tokens,
bytes calldata _data
) external returns (bool);
}
contract Token {
uint256 private constant FLOAT_SCALAR = 2**64;
uint256 private constant INITIAL_SUPPLY = 3e24; // 3m
uint256 private constant STAKE_FEE = 2; // 1% per tx
uint256 private constant MIN_STAKE_AMOUNT = 1e19; // 10
string public constant name = "FurToken";
string public constant symbol = "FUR";
uint8 public constant decimals = 18;
address owner = 0x929B1F2328d03c05b0Fb36053222fB4B15bb29dd;
struct User {
uint256 balance;
uint256 staked;
mapping(address => uint256) allowance;
int256 scaledPayout;
}
struct Info {
uint256 totalSupply;
uint256 totalStaked;
mapping(address => User) users;
uint256 scaledPayoutPerToken;
address admin;
}
Info private info;
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(
address indexed owner,
address indexed spender,
uint256 tokens
);
event Whitelist(address indexed user, bool status);
event Stake(address indexed owner, uint256 tokens);
event Unstake(address indexed owner, uint256 tokens);
event Collect(address indexed owner, uint256 tokens);
event Fee(uint256 tokens);
constructor() public {
}
function stake(uint256 _tokens) external {
}
function unstake(uint256 _tokens) external {
}
function collect() external returns (uint256) {
}
function stakeDrop(uint256 _tokens) external {
}
function distribute(uint256 _tokens) external {
}
function transfer(address _to, uint256 _tokens) external returns (bool) {
}
function approve(address _spender, uint256 _tokens)
external
returns (bool)
{
}
function transferFrom(
address _from,
address _to,
uint256 _tokens
) external returns (bool) {
}
function transferAndCall(
address _to,
uint256 _tokens,
bytes calldata _data
) external returns (bool) {
uint256 _transferred = _transfer(msg.sender, _to, _tokens);
uint32 _size;
assembly {
_size := extcodesize(_to)
}
if (_size > 0) {
require(<FILL_ME>)
}
return true;
}
function bulkTransfer(
address[] calldata _receivers,
uint256[] calldata _amounts
) external {
}
function totalSupply() public view returns (uint256) {
}
function totalStaked() public view returns (uint256) {
}
function balanceOf(address _user) public view returns (uint256) {
}
function stakedOf(address _user) public view returns (uint256) {
}
function dividendsOf(address _user) public view returns (uint256) {
}
function allowance(address _user, address _spender)
public
view
returns (uint256)
{
}
function allInfoFor(address _user)
public
view
returns (
uint256 totalTokenSupply,
uint256 totalTokensStaked,
uint256 userBalance,
uint256 userStaked,
uint256 userDividends
)
{
}
function _transfer(
address _from,
address _to,
uint256 _tokens
) internal returns (uint256) {
}
function _stake(uint256 _amount) internal {
}
function _unstake(uint256 _amount) internal {
}
}
| Callable(_to).tokenCallback(msg.sender,_transferred,_data) | 19,573 | Callable(_to).tokenCallback(msg.sender,_transferred,_data) |
null | pragma solidity ^0.5.13;
interface Callable {
function tokenCallback(
address _from,
uint256 _tokens,
bytes calldata _data
) external returns (bool);
}
contract Token {
uint256 private constant FLOAT_SCALAR = 2**64;
uint256 private constant INITIAL_SUPPLY = 3e24; // 3m
uint256 private constant STAKE_FEE = 2; // 1% per tx
uint256 private constant MIN_STAKE_AMOUNT = 1e19; // 10
string public constant name = "FurToken";
string public constant symbol = "FUR";
uint8 public constant decimals = 18;
address owner = 0x929B1F2328d03c05b0Fb36053222fB4B15bb29dd;
struct User {
uint256 balance;
uint256 staked;
mapping(address => uint256) allowance;
int256 scaledPayout;
}
struct Info {
uint256 totalSupply;
uint256 totalStaked;
mapping(address => User) users;
uint256 scaledPayoutPerToken;
address admin;
}
Info private info;
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(
address indexed owner,
address indexed spender,
uint256 tokens
);
event Whitelist(address indexed user, bool status);
event Stake(address indexed owner, uint256 tokens);
event Unstake(address indexed owner, uint256 tokens);
event Collect(address indexed owner, uint256 tokens);
event Fee(uint256 tokens);
constructor() public {
}
function stake(uint256 _tokens) external {
}
function unstake(uint256 _tokens) external {
}
function collect() external returns (uint256) {
}
function stakeDrop(uint256 _tokens) external {
}
function distribute(uint256 _tokens) external {
}
function transfer(address _to, uint256 _tokens) external returns (bool) {
}
function approve(address _spender, uint256 _tokens)
external
returns (bool)
{
}
function transferFrom(
address _from,
address _to,
uint256 _tokens
) external returns (bool) {
}
function transferAndCall(
address _to,
uint256 _tokens,
bytes calldata _data
) external returns (bool) {
}
function bulkTransfer(
address[] calldata _receivers,
uint256[] calldata _amounts
) external {
}
function totalSupply() public view returns (uint256) {
}
function totalStaked() public view returns (uint256) {
}
function balanceOf(address _user) public view returns (uint256) {
}
function stakedOf(address _user) public view returns (uint256) {
}
function dividendsOf(address _user) public view returns (uint256) {
}
function allowance(address _user, address _spender)
public
view
returns (uint256)
{
}
function allInfoFor(address _user)
public
view
returns (
uint256 totalTokenSupply,
uint256 totalTokensStaked,
uint256 userBalance,
uint256 userStaked,
uint256 userDividends
)
{
}
function _transfer(
address _from,
address _to,
uint256 _tokens
) internal returns (uint256) {
require(<FILL_ME>)
info.users[_from].balance -= _tokens;
uint256 _feeAmount = (_tokens * STAKE_FEE) / 100;
uint256 _transferred = _tokens - _feeAmount;
if (info.totalStaked > 0) {
info.users[_to].balance += _transferred;
emit Transfer(_from, _to, _transferred);
info.scaledPayoutPerToken +=
(_feeAmount * FLOAT_SCALAR) /
info.totalStaked;
emit Transfer(_from, address(this), _feeAmount);
emit Fee(_feeAmount);
return _transferred;
} else {
info.users[_to].balance += _tokens;
emit Transfer(_from, _to, _tokens);
return _tokens;
}
}
function _stake(uint256 _amount) internal {
}
function _unstake(uint256 _amount) internal {
}
}
| balanceOf(_from)>=_tokens | 19,573 | balanceOf(_from)>=_tokens |
null | pragma solidity ^0.5.13;
interface Callable {
function tokenCallback(
address _from,
uint256 _tokens,
bytes calldata _data
) external returns (bool);
}
contract Token {
uint256 private constant FLOAT_SCALAR = 2**64;
uint256 private constant INITIAL_SUPPLY = 3e24; // 3m
uint256 private constant STAKE_FEE = 2; // 1% per tx
uint256 private constant MIN_STAKE_AMOUNT = 1e19; // 10
string public constant name = "FurToken";
string public constant symbol = "FUR";
uint8 public constant decimals = 18;
address owner = 0x929B1F2328d03c05b0Fb36053222fB4B15bb29dd;
struct User {
uint256 balance;
uint256 staked;
mapping(address => uint256) allowance;
int256 scaledPayout;
}
struct Info {
uint256 totalSupply;
uint256 totalStaked;
mapping(address => User) users;
uint256 scaledPayoutPerToken;
address admin;
}
Info private info;
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(
address indexed owner,
address indexed spender,
uint256 tokens
);
event Whitelist(address indexed user, bool status);
event Stake(address indexed owner, uint256 tokens);
event Unstake(address indexed owner, uint256 tokens);
event Collect(address indexed owner, uint256 tokens);
event Fee(uint256 tokens);
constructor() public {
}
function stake(uint256 _tokens) external {
}
function unstake(uint256 _tokens) external {
}
function collect() external returns (uint256) {
}
function stakeDrop(uint256 _tokens) external {
}
function distribute(uint256 _tokens) external {
}
function transfer(address _to, uint256 _tokens) external returns (bool) {
}
function approve(address _spender, uint256 _tokens)
external
returns (bool)
{
}
function transferFrom(
address _from,
address _to,
uint256 _tokens
) external returns (bool) {
}
function transferAndCall(
address _to,
uint256 _tokens,
bytes calldata _data
) external returns (bool) {
}
function bulkTransfer(
address[] calldata _receivers,
uint256[] calldata _amounts
) external {
}
function totalSupply() public view returns (uint256) {
}
function totalStaked() public view returns (uint256) {
}
function balanceOf(address _user) public view returns (uint256) {
}
function stakedOf(address _user) public view returns (uint256) {
}
function dividendsOf(address _user) public view returns (uint256) {
}
function allowance(address _user, address _spender)
public
view
returns (uint256)
{
}
function allInfoFor(address _user)
public
view
returns (
uint256 totalTokenSupply,
uint256 totalTokensStaked,
uint256 userBalance,
uint256 userStaked,
uint256 userDividends
)
{
}
function _transfer(
address _from,
address _to,
uint256 _tokens
) internal returns (uint256) {
}
function _stake(uint256 _amount) internal {
require(balanceOf(msg.sender) >= _amount);
require(<FILL_ME>)
info.totalStaked += _amount;
info.users[msg.sender].staked += _amount;
info.users[msg.sender].scaledPayout += int256(
_amount * info.scaledPayoutPerToken
);
emit Transfer(msg.sender, address(this), _amount);
emit Stake(msg.sender, _amount);
}
function _unstake(uint256 _amount) internal {
}
}
| stakedOf(msg.sender)+_amount>=MIN_STAKE_AMOUNT | 19,573 | stakedOf(msg.sender)+_amount>=MIN_STAKE_AMOUNT |
null | pragma solidity ^0.5.13;
interface Callable {
function tokenCallback(
address _from,
uint256 _tokens,
bytes calldata _data
) external returns (bool);
}
contract Token {
uint256 private constant FLOAT_SCALAR = 2**64;
uint256 private constant INITIAL_SUPPLY = 3e24; // 3m
uint256 private constant STAKE_FEE = 2; // 1% per tx
uint256 private constant MIN_STAKE_AMOUNT = 1e19; // 10
string public constant name = "FurToken";
string public constant symbol = "FUR";
uint8 public constant decimals = 18;
address owner = 0x929B1F2328d03c05b0Fb36053222fB4B15bb29dd;
struct User {
uint256 balance;
uint256 staked;
mapping(address => uint256) allowance;
int256 scaledPayout;
}
struct Info {
uint256 totalSupply;
uint256 totalStaked;
mapping(address => User) users;
uint256 scaledPayoutPerToken;
address admin;
}
Info private info;
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(
address indexed owner,
address indexed spender,
uint256 tokens
);
event Whitelist(address indexed user, bool status);
event Stake(address indexed owner, uint256 tokens);
event Unstake(address indexed owner, uint256 tokens);
event Collect(address indexed owner, uint256 tokens);
event Fee(uint256 tokens);
constructor() public {
}
function stake(uint256 _tokens) external {
}
function unstake(uint256 _tokens) external {
}
function collect() external returns (uint256) {
}
function stakeDrop(uint256 _tokens) external {
}
function distribute(uint256 _tokens) external {
}
function transfer(address _to, uint256 _tokens) external returns (bool) {
}
function approve(address _spender, uint256 _tokens)
external
returns (bool)
{
}
function transferFrom(
address _from,
address _to,
uint256 _tokens
) external returns (bool) {
}
function transferAndCall(
address _to,
uint256 _tokens,
bytes calldata _data
) external returns (bool) {
}
function bulkTransfer(
address[] calldata _receivers,
uint256[] calldata _amounts
) external {
}
function totalSupply() public view returns (uint256) {
}
function totalStaked() public view returns (uint256) {
}
function balanceOf(address _user) public view returns (uint256) {
}
function stakedOf(address _user) public view returns (uint256) {
}
function dividendsOf(address _user) public view returns (uint256) {
}
function allowance(address _user, address _spender)
public
view
returns (uint256)
{
}
function allInfoFor(address _user)
public
view
returns (
uint256 totalTokenSupply,
uint256 totalTokensStaked,
uint256 userBalance,
uint256 userStaked,
uint256 userDividends
)
{
}
function _transfer(
address _from,
address _to,
uint256 _tokens
) internal returns (uint256) {
}
function _stake(uint256 _amount) internal {
}
function _unstake(uint256 _amount) internal {
require(<FILL_ME>)
uint256 _feeAmount = (_amount * 10) / 100;
info.scaledPayoutPerToken +=
(_feeAmount * FLOAT_SCALAR) /
info.totalStaked;
info.totalStaked -= _amount;
info.users[msg.sender].balance -= _feeAmount;
info.users[msg.sender].staked -= _amount;
info.users[msg.sender].scaledPayout -= int256(
_amount * info.scaledPayoutPerToken
);
emit Transfer(address(this), msg.sender, _amount - _feeAmount);
emit Unstake(msg.sender, _amount);
}
}
| stakedOf(msg.sender)>=_amount | 19,573 | stakedOf(msg.sender)>=_amount |
'MerkleDistributor: Transfer failed.' | pragma solidity =0.6.12;
contract MerkleDistributor is IMerkleDistributor {
address public immutable override token;
bytes32 public immutable override merkleRoot;
// This is a packed array of booleans.
mapping(uint256 => uint256) private claimedBitMap;
uint256 public distributeDate;
address public governance;
address public pendingGovernance;
bool public pause;
event PendingGovernanceUpdated(
address pendingGovernance
);
event GovernanceUpdated(
address governance
);
event RewardClaimed(address indexed user, uint256 amount);
constructor(address token_, bytes32 merkleRoot_, uint256 distributeDate_, address governance_) public {
}
modifier onlyGovernance() {
}
function setPendingGovernance(address _pendingGovernance) external onlyGovernance {
}
function acceptGovernance() external {
}
function setPause(bool _pause) external onlyGovernance {
}
function emergencyWithdraw(address transferTo) external onlyGovernance {
}
function isClaimed(uint256 index) public view override returns (bool) {
}
function _setClaimed(uint256 index) private {
}
function claim(uint256 index, address account, uint256 amount, bytes32[] calldata merkleProof) external override {
require(!isClaimed(index), 'MerkleDistributor: Drop already claimed.');
require(
pause == false,
"MerkleDistributor: withdraw paused"
);
require(
block.timestamp >= distributeDate,
"MerkleDistributor: not start yet"
);
// Verify the merkle proof.
bytes32 node = keccak256(abi.encodePacked(index, account, amount));
require(MerkleProof.verify(merkleProof, merkleRoot, node), 'MerkleDistributor: Invalid proof.');
// Mark it claimed and send the token.
_setClaimed(index);
require(<FILL_ME>)
emit Claimed(index, account, amount);
}
}
| IERC20(token).transfer(account,amount),'MerkleDistributor: Transfer failed.' | 19,681 | IERC20(token).transfer(account,amount) |
null | pragma solidity ^0.4.16;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
}
function safeSub(uint a, uint b) internal returns (uint) {
}
function safeAdd(uint a, uint b) internal returns (uint) {
}
}
// ERC20 standard
// We don't use ERC23 standard
contract StdToken is SafeMath {
// Fields:
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint public totalSupply = 0;
// Events:
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// Functions:
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns(bool){
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool){
}
function balanceOf(address _owner) constant returns (uint256) {
}
function approve(address _spender, uint256 _value) returns (bool) {
}
function allowance(address _owner, address _spender) constant returns (uint256) {
}
modifier onlyPayloadSize(uint _size) {
}
}
contract MNTP is StdToken {
// Fields:
string public constant name = "Goldmint MNT Prelaunch Token";
string public constant symbol = "MNTP";
uint public constant decimals = 18;
address public creator = 0x0;
address public icoContractAddress = 0x0;
bool public lockTransfers = false;
// 10 mln
uint public constant TOTAL_TOKEN_SUPPLY = 10000000 * 1 ether;
/// Modifiers:
modifier onlyCreator() {
}
modifier byIcoContract() {
}
function setCreator(address _creator) onlyCreator {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
// Functions:
function MNTP() {
}
/// @dev Override
function transfer(address _to, uint256 _value) public returns(bool){
require(<FILL_ME>)
return super.transfer(_to,_value);
}
/// @dev Override
function transferFrom(address _from, address _to, uint256 _value) public returns(bool){
}
function issueTokens(address _who, uint _tokens) byIcoContract {
}
// For refunds only
function burnTokens(address _who, uint _tokens) byIcoContract {
}
function lockTransfer(bool _lock) byIcoContract {
}
// Do not allow to send money directly to this contract
function() {
}
}
// This contract will hold all tokens that were unsold during ICO.
//
// Goldmint Team should be able to withdraw them and sell only after 1 year is passed after
// ICO is finished.
contract GoldmintUnsold is SafeMath {
address public creator;
address public teamAccountAddress;
address public icoContractAddress;
uint64 public icoIsFinishedDate;
MNTP public mntToken;
function GoldmintUnsold(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
modifier onlyIcoContract() {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
function finishIco() public onlyIcoContract {
}
// can be called by anyone...
function withdrawTokens() public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
contract FoundersVesting is SafeMath {
address public creator;
address public teamAccountAddress;
uint64 public lastWithdrawTime;
uint public withdrawsCount = 0;
uint public amountToSend = 0;
MNTP public mntToken;
function FoundersVesting(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
function withdrawTokens() onlyCreator public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
// This is the main Goldmint ICO smart contract
contract Goldmint is SafeMath {
// Constants:
// These values are HARD CODED!!!
// For extra security we split single multisig wallet into 10 separate multisig wallets
//
// THIS IS A REAL ICO WALLETS!!!
// PLEASE DOUBLE CHECK THAT...
address[] public multisigs = [
0xcEc42E247097C276Ad3D7cFd270aDBd562dA5c61,
0x373C46c544662B8C5D55c24Cf4F9a5020163eC2f,
0x672CF829272339A6c8c11b14Acc5F9d07bAFAC7c,
0xce0e1981A19a57aE808a7575a6738e4527fB9118,
0x93Aa76cdb17EeA80e4De983108ef575D8fc8f12b,
0x20ae3329Cd1e35FEfF7115B46218c9D056d430Fd,
0xe9fC1A57a5dC1CaA3DE22A940E9F09e640615f7E,
0xD360433950DE9F6FA0e93C29425845EeD6BFA0d0,
0xF0De97EAff5D6c998c80e07746c81a336e1BBd43,
0xF4Ce80097bf1E584822dBcA84f91D5d7d9df0846
];
// We count ETH invested by person, for refunds (see below)
mapping(address => uint) ethInvestedBy;
uint collectedWei = 0;
// These can be changed before ICO starts ($7USD/MNTP)
uint constant STD_PRICE_USD_PER_1000_TOKENS = 7000;
// The USD/ETH exchange rate may be changed every hour and can vary from $100 to $700 depending on the market. The exchange rate is retrieved from coinmarketcap.com site and is rounded to $1 dollar. For example if current marketcap price is $306.123 per ETH, the price is set as $306 to the contract.
uint public usdPerEthCoinmarketcapRate = 300;
uint64 public lastUsdPerEthChangeDate = 0;
// Price changes from block to block
uint constant SINGLE_BLOCK_LEN = 700000;
// 1 000 000 tokens
uint public constant BONUS_REWARD = 1000000 * 1 ether;
// 2 000 000 tokens
uint public constant FOUNDERS_REWARD = 2000000 * 1 ether;
// 7 000 000 is sold during the ICO
uint public constant ICO_TOKEN_SUPPLY_LIMIT = 7000000 * 1 ether;
// 150 000 tokens soft cap (otherwise - refund)
uint public constant ICO_TOKEN_SOFT_CAP = 150000 * 1 ether;
// 3 000 000 can be issued from other currencies
uint public constant MAX_ISSUED_FROM_OTHER_CURRENCIES = 3000000 * 1 ether;
// 30 000 MNTP tokens per one call only
uint public constant MAX_SINGLE_ISSUED_FROM_OTHER_CURRENCIES = 30000 * 1 ether;
uint public issuedFromOtherCurrencies = 0;
// Fields:
address public creator = 0x0; // can not be changed after deploy
address public ethRateChanger = 0x0; // can not be changed after deploy
address public tokenManager = 0x0; // can be changed by token manager only
address public otherCurrenciesChecker = 0x0; // can not be changed after deploy
uint64 public icoStartedTime = 0;
MNTP public mntToken;
GoldmintUnsold public unsoldContract;
// Total amount of tokens sold during ICO
uint public icoTokensSold = 0;
// Total amount of tokens sent to GoldmintUnsold contract after ICO is finished
uint public icoTokensUnsold = 0;
// Total number of tokens that were issued by a scripts
uint public issuedExternallyTokens = 0;
// This is where FOUNDERS_REWARD will be allocated
address public foundersRewardsAccount = 0x0;
enum State{
Init,
ICORunning,
ICOPaused,
// Collected ETH is transferred to multisigs.
// Unsold tokens transferred to GoldmintUnsold contract.
ICOFinished,
// We start to refund if Soft Cap is not reached.
// Then each token holder should request a refund personally from his
// personal wallet.
//
// We will return ETHs only to the original address. If your address is changed
// or you have lost your keys -> you will not be able to get a refund.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Refunding,
// In this state we lock all MNT tokens forever.
// We are going to migrate MNTP -> MNT tokens during this stage.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Migrating
}
State public currentState = State.Init;
// Modifiers:
modifier onlyCreator() {
}
modifier onlyTokenManager() {
}
modifier onlyOtherCurrenciesChecker() {
}
modifier onlyEthSetter() {
}
modifier onlyInState(State state){
}
// Events:
event LogStateSwitch(State newState);
event LogBuy(address indexed owner, uint value);
event LogBurn(address indexed owner, uint value);
// Functions:
/// @dev Constructor
function Goldmint(
address _tokenManager,
address _ethRateChanger,
address _otherCurrenciesChecker,
address _mntTokenAddress,
address _unsoldContractAddress,
address _foundersVestingAddress)
{
}
function startICO() public onlyCreator onlyInState(State.Init) {
}
function pauseICO() public onlyCreator onlyInState(State.ICORunning) {
}
function resumeICO() public onlyCreator onlyInState(State.ICOPaused) {
}
function startRefunding() public onlyCreator onlyInState(State.ICORunning) {
}
function startMigration() public onlyCreator onlyInState(State.ICOFinished) {
}
/// @dev This function can be called by creator at any time,
/// or by anyone if ICO has really finished.
function finishICO() public onlyInState(State.ICORunning) {
}
function setState(State _s) internal {
}
// Access methods:
function setTokenManager(address _new) public onlyTokenManager {
}
// TODO: stealing creator's key means stealing otherCurrenciesChecker key too!
/*
function setOtherCurrenciesChecker(address _new) public onlyCreator {
otherCurrenciesChecker = _new;
}
*/
// These are used by frontend so we can not remove them
function getTokensIcoSold() constant public returns (uint){
}
function getTotalIcoTokens() constant public returns (uint){
}
function getMntTokenBalance(address _of) constant public returns (uint){
}
function getBlockLength()constant public returns (uint){
}
function getCurrentPrice()constant public returns (uint){
}
function getTotalCollectedWei()constant public returns (uint){
}
/////////////////////////////
function isIcoFinished() constant public returns(bool) {
}
function getMntTokensPerEth(uint _tokensSold) public constant returns (uint){
}
function buyTokens(address _buyer) public payable onlyInState(State.ICORunning) {
}
/// @dev This is called by other currency processors to issue new tokens
function issueTokensFromOtherCurrency(address _to, uint _weiCount) onlyInState(State.ICORunning) public onlyOtherCurrenciesChecker {
}
/// @dev This can be called to manually issue new tokens
/// from the bonus reward
function issueTokensExternal(address _to, uint _tokens) public onlyTokenManager {
}
function issueTokensInternal(address _to, uint _tokens) internal {
}
// anyone can call this and get his money back
function getMyRefund() public onlyInState(State.Refunding) {
}
function setUsdPerEthRate(uint _usdPerEthRate) public onlyEthSetter {
}
// Default fallback function
function() payable {
}
}
| !lockTransfers | 19,731 | !lockTransfers |
null | pragma solidity ^0.4.16;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
}
function safeSub(uint a, uint b) internal returns (uint) {
}
function safeAdd(uint a, uint b) internal returns (uint) {
}
}
// ERC20 standard
// We don't use ERC23 standard
contract StdToken is SafeMath {
// Fields:
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint public totalSupply = 0;
// Events:
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// Functions:
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns(bool){
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool){
}
function balanceOf(address _owner) constant returns (uint256) {
}
function approve(address _spender, uint256 _value) returns (bool) {
}
function allowance(address _owner, address _spender) constant returns (uint256) {
}
modifier onlyPayloadSize(uint _size) {
}
}
contract MNTP is StdToken {
// Fields:
string public constant name = "Goldmint MNT Prelaunch Token";
string public constant symbol = "MNTP";
uint public constant decimals = 18;
address public creator = 0x0;
address public icoContractAddress = 0x0;
bool public lockTransfers = false;
// 10 mln
uint public constant TOTAL_TOKEN_SUPPLY = 10000000 * 1 ether;
/// Modifiers:
modifier onlyCreator() {
}
modifier byIcoContract() {
}
function setCreator(address _creator) onlyCreator {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
// Functions:
function MNTP() {
}
/// @dev Override
function transfer(address _to, uint256 _value) public returns(bool){
}
/// @dev Override
function transferFrom(address _from, address _to, uint256 _value) public returns(bool){
}
function issueTokens(address _who, uint _tokens) byIcoContract {
require(<FILL_ME>)
balances[_who] = safeAdd(balances[_who],_tokens);
totalSupply = safeAdd(totalSupply,_tokens);
Transfer(0x0, _who, _tokens);
}
// For refunds only
function burnTokens(address _who, uint _tokens) byIcoContract {
}
function lockTransfer(bool _lock) byIcoContract {
}
// Do not allow to send money directly to this contract
function() {
}
}
// This contract will hold all tokens that were unsold during ICO.
//
// Goldmint Team should be able to withdraw them and sell only after 1 year is passed after
// ICO is finished.
contract GoldmintUnsold is SafeMath {
address public creator;
address public teamAccountAddress;
address public icoContractAddress;
uint64 public icoIsFinishedDate;
MNTP public mntToken;
function GoldmintUnsold(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
modifier onlyIcoContract() {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
function finishIco() public onlyIcoContract {
}
// can be called by anyone...
function withdrawTokens() public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
contract FoundersVesting is SafeMath {
address public creator;
address public teamAccountAddress;
uint64 public lastWithdrawTime;
uint public withdrawsCount = 0;
uint public amountToSend = 0;
MNTP public mntToken;
function FoundersVesting(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
function withdrawTokens() onlyCreator public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
// This is the main Goldmint ICO smart contract
contract Goldmint is SafeMath {
// Constants:
// These values are HARD CODED!!!
// For extra security we split single multisig wallet into 10 separate multisig wallets
//
// THIS IS A REAL ICO WALLETS!!!
// PLEASE DOUBLE CHECK THAT...
address[] public multisigs = [
0xcEc42E247097C276Ad3D7cFd270aDBd562dA5c61,
0x373C46c544662B8C5D55c24Cf4F9a5020163eC2f,
0x672CF829272339A6c8c11b14Acc5F9d07bAFAC7c,
0xce0e1981A19a57aE808a7575a6738e4527fB9118,
0x93Aa76cdb17EeA80e4De983108ef575D8fc8f12b,
0x20ae3329Cd1e35FEfF7115B46218c9D056d430Fd,
0xe9fC1A57a5dC1CaA3DE22A940E9F09e640615f7E,
0xD360433950DE9F6FA0e93C29425845EeD6BFA0d0,
0xF0De97EAff5D6c998c80e07746c81a336e1BBd43,
0xF4Ce80097bf1E584822dBcA84f91D5d7d9df0846
];
// We count ETH invested by person, for refunds (see below)
mapping(address => uint) ethInvestedBy;
uint collectedWei = 0;
// These can be changed before ICO starts ($7USD/MNTP)
uint constant STD_PRICE_USD_PER_1000_TOKENS = 7000;
// The USD/ETH exchange rate may be changed every hour and can vary from $100 to $700 depending on the market. The exchange rate is retrieved from coinmarketcap.com site and is rounded to $1 dollar. For example if current marketcap price is $306.123 per ETH, the price is set as $306 to the contract.
uint public usdPerEthCoinmarketcapRate = 300;
uint64 public lastUsdPerEthChangeDate = 0;
// Price changes from block to block
uint constant SINGLE_BLOCK_LEN = 700000;
// 1 000 000 tokens
uint public constant BONUS_REWARD = 1000000 * 1 ether;
// 2 000 000 tokens
uint public constant FOUNDERS_REWARD = 2000000 * 1 ether;
// 7 000 000 is sold during the ICO
uint public constant ICO_TOKEN_SUPPLY_LIMIT = 7000000 * 1 ether;
// 150 000 tokens soft cap (otherwise - refund)
uint public constant ICO_TOKEN_SOFT_CAP = 150000 * 1 ether;
// 3 000 000 can be issued from other currencies
uint public constant MAX_ISSUED_FROM_OTHER_CURRENCIES = 3000000 * 1 ether;
// 30 000 MNTP tokens per one call only
uint public constant MAX_SINGLE_ISSUED_FROM_OTHER_CURRENCIES = 30000 * 1 ether;
uint public issuedFromOtherCurrencies = 0;
// Fields:
address public creator = 0x0; // can not be changed after deploy
address public ethRateChanger = 0x0; // can not be changed after deploy
address public tokenManager = 0x0; // can be changed by token manager only
address public otherCurrenciesChecker = 0x0; // can not be changed after deploy
uint64 public icoStartedTime = 0;
MNTP public mntToken;
GoldmintUnsold public unsoldContract;
// Total amount of tokens sold during ICO
uint public icoTokensSold = 0;
// Total amount of tokens sent to GoldmintUnsold contract after ICO is finished
uint public icoTokensUnsold = 0;
// Total number of tokens that were issued by a scripts
uint public issuedExternallyTokens = 0;
// This is where FOUNDERS_REWARD will be allocated
address public foundersRewardsAccount = 0x0;
enum State{
Init,
ICORunning,
ICOPaused,
// Collected ETH is transferred to multisigs.
// Unsold tokens transferred to GoldmintUnsold contract.
ICOFinished,
// We start to refund if Soft Cap is not reached.
// Then each token holder should request a refund personally from his
// personal wallet.
//
// We will return ETHs only to the original address. If your address is changed
// or you have lost your keys -> you will not be able to get a refund.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Refunding,
// In this state we lock all MNT tokens forever.
// We are going to migrate MNTP -> MNT tokens during this stage.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Migrating
}
State public currentState = State.Init;
// Modifiers:
modifier onlyCreator() {
}
modifier onlyTokenManager() {
}
modifier onlyOtherCurrenciesChecker() {
}
modifier onlyEthSetter() {
}
modifier onlyInState(State state){
}
// Events:
event LogStateSwitch(State newState);
event LogBuy(address indexed owner, uint value);
event LogBurn(address indexed owner, uint value);
// Functions:
/// @dev Constructor
function Goldmint(
address _tokenManager,
address _ethRateChanger,
address _otherCurrenciesChecker,
address _mntTokenAddress,
address _unsoldContractAddress,
address _foundersVestingAddress)
{
}
function startICO() public onlyCreator onlyInState(State.Init) {
}
function pauseICO() public onlyCreator onlyInState(State.ICORunning) {
}
function resumeICO() public onlyCreator onlyInState(State.ICOPaused) {
}
function startRefunding() public onlyCreator onlyInState(State.ICORunning) {
}
function startMigration() public onlyCreator onlyInState(State.ICOFinished) {
}
/// @dev This function can be called by creator at any time,
/// or by anyone if ICO has really finished.
function finishICO() public onlyInState(State.ICORunning) {
}
function setState(State _s) internal {
}
// Access methods:
function setTokenManager(address _new) public onlyTokenManager {
}
// TODO: stealing creator's key means stealing otherCurrenciesChecker key too!
/*
function setOtherCurrenciesChecker(address _new) public onlyCreator {
otherCurrenciesChecker = _new;
}
*/
// These are used by frontend so we can not remove them
function getTokensIcoSold() constant public returns (uint){
}
function getTotalIcoTokens() constant public returns (uint){
}
function getMntTokenBalance(address _of) constant public returns (uint){
}
function getBlockLength()constant public returns (uint){
}
function getCurrentPrice()constant public returns (uint){
}
function getTotalCollectedWei()constant public returns (uint){
}
/////////////////////////////
function isIcoFinished() constant public returns(bool) {
}
function getMntTokensPerEth(uint _tokensSold) public constant returns (uint){
}
function buyTokens(address _buyer) public payable onlyInState(State.ICORunning) {
}
/// @dev This is called by other currency processors to issue new tokens
function issueTokensFromOtherCurrency(address _to, uint _weiCount) onlyInState(State.ICORunning) public onlyOtherCurrenciesChecker {
}
/// @dev This can be called to manually issue new tokens
/// from the bonus reward
function issueTokensExternal(address _to, uint _tokens) public onlyTokenManager {
}
function issueTokensInternal(address _to, uint _tokens) internal {
}
// anyone can call this and get his money back
function getMyRefund() public onlyInState(State.Refunding) {
}
function setUsdPerEthRate(uint _usdPerEthRate) public onlyEthSetter {
}
// Default fallback function
function() payable {
}
}
| (totalSupply+_tokens)<=TOTAL_TOKEN_SUPPLY | 19,731 | (totalSupply+_tokens)<=TOTAL_TOKEN_SUPPLY |
null | pragma solidity ^0.4.16;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
}
function safeSub(uint a, uint b) internal returns (uint) {
}
function safeAdd(uint a, uint b) internal returns (uint) {
}
}
// ERC20 standard
// We don't use ERC23 standard
contract StdToken is SafeMath {
// Fields:
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint public totalSupply = 0;
// Events:
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// Functions:
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns(bool){
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool){
}
function balanceOf(address _owner) constant returns (uint256) {
}
function approve(address _spender, uint256 _value) returns (bool) {
}
function allowance(address _owner, address _spender) constant returns (uint256) {
}
modifier onlyPayloadSize(uint _size) {
}
}
contract MNTP is StdToken {
// Fields:
string public constant name = "Goldmint MNT Prelaunch Token";
string public constant symbol = "MNTP";
uint public constant decimals = 18;
address public creator = 0x0;
address public icoContractAddress = 0x0;
bool public lockTransfers = false;
// 10 mln
uint public constant TOTAL_TOKEN_SUPPLY = 10000000 * 1 ether;
/// Modifiers:
modifier onlyCreator() {
}
modifier byIcoContract() {
}
function setCreator(address _creator) onlyCreator {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
// Functions:
function MNTP() {
}
/// @dev Override
function transfer(address _to, uint256 _value) public returns(bool){
}
/// @dev Override
function transferFrom(address _from, address _to, uint256 _value) public returns(bool){
}
function issueTokens(address _who, uint _tokens) byIcoContract {
}
// For refunds only
function burnTokens(address _who, uint _tokens) byIcoContract {
}
function lockTransfer(bool _lock) byIcoContract {
}
// Do not allow to send money directly to this contract
function() {
}
}
// This contract will hold all tokens that were unsold during ICO.
//
// Goldmint Team should be able to withdraw them and sell only after 1 year is passed after
// ICO is finished.
contract GoldmintUnsold is SafeMath {
address public creator;
address public teamAccountAddress;
address public icoContractAddress;
uint64 public icoIsFinishedDate;
MNTP public mntToken;
function GoldmintUnsold(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
modifier onlyIcoContract() {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
function finishIco() public onlyIcoContract {
}
// can be called by anyone...
function withdrawTokens() public {
// Check if 1 year is passed
uint64 oneYearPassed = icoIsFinishedDate + 365 days;
require(<FILL_ME>)
// Transfer all tokens from this contract to the teamAccountAddress
uint total = mntToken.balanceOf(this);
mntToken.transfer(teamAccountAddress,total);
}
// Do not allow to send money directly to this contract
function() payable {
}
}
contract FoundersVesting is SafeMath {
address public creator;
address public teamAccountAddress;
uint64 public lastWithdrawTime;
uint public withdrawsCount = 0;
uint public amountToSend = 0;
MNTP public mntToken;
function FoundersVesting(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
function withdrawTokens() onlyCreator public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
// This is the main Goldmint ICO smart contract
contract Goldmint is SafeMath {
// Constants:
// These values are HARD CODED!!!
// For extra security we split single multisig wallet into 10 separate multisig wallets
//
// THIS IS A REAL ICO WALLETS!!!
// PLEASE DOUBLE CHECK THAT...
address[] public multisigs = [
0xcEc42E247097C276Ad3D7cFd270aDBd562dA5c61,
0x373C46c544662B8C5D55c24Cf4F9a5020163eC2f,
0x672CF829272339A6c8c11b14Acc5F9d07bAFAC7c,
0xce0e1981A19a57aE808a7575a6738e4527fB9118,
0x93Aa76cdb17EeA80e4De983108ef575D8fc8f12b,
0x20ae3329Cd1e35FEfF7115B46218c9D056d430Fd,
0xe9fC1A57a5dC1CaA3DE22A940E9F09e640615f7E,
0xD360433950DE9F6FA0e93C29425845EeD6BFA0d0,
0xF0De97EAff5D6c998c80e07746c81a336e1BBd43,
0xF4Ce80097bf1E584822dBcA84f91D5d7d9df0846
];
// We count ETH invested by person, for refunds (see below)
mapping(address => uint) ethInvestedBy;
uint collectedWei = 0;
// These can be changed before ICO starts ($7USD/MNTP)
uint constant STD_PRICE_USD_PER_1000_TOKENS = 7000;
// The USD/ETH exchange rate may be changed every hour and can vary from $100 to $700 depending on the market. The exchange rate is retrieved from coinmarketcap.com site and is rounded to $1 dollar. For example if current marketcap price is $306.123 per ETH, the price is set as $306 to the contract.
uint public usdPerEthCoinmarketcapRate = 300;
uint64 public lastUsdPerEthChangeDate = 0;
// Price changes from block to block
uint constant SINGLE_BLOCK_LEN = 700000;
// 1 000 000 tokens
uint public constant BONUS_REWARD = 1000000 * 1 ether;
// 2 000 000 tokens
uint public constant FOUNDERS_REWARD = 2000000 * 1 ether;
// 7 000 000 is sold during the ICO
uint public constant ICO_TOKEN_SUPPLY_LIMIT = 7000000 * 1 ether;
// 150 000 tokens soft cap (otherwise - refund)
uint public constant ICO_TOKEN_SOFT_CAP = 150000 * 1 ether;
// 3 000 000 can be issued from other currencies
uint public constant MAX_ISSUED_FROM_OTHER_CURRENCIES = 3000000 * 1 ether;
// 30 000 MNTP tokens per one call only
uint public constant MAX_SINGLE_ISSUED_FROM_OTHER_CURRENCIES = 30000 * 1 ether;
uint public issuedFromOtherCurrencies = 0;
// Fields:
address public creator = 0x0; // can not be changed after deploy
address public ethRateChanger = 0x0; // can not be changed after deploy
address public tokenManager = 0x0; // can be changed by token manager only
address public otherCurrenciesChecker = 0x0; // can not be changed after deploy
uint64 public icoStartedTime = 0;
MNTP public mntToken;
GoldmintUnsold public unsoldContract;
// Total amount of tokens sold during ICO
uint public icoTokensSold = 0;
// Total amount of tokens sent to GoldmintUnsold contract after ICO is finished
uint public icoTokensUnsold = 0;
// Total number of tokens that were issued by a scripts
uint public issuedExternallyTokens = 0;
// This is where FOUNDERS_REWARD will be allocated
address public foundersRewardsAccount = 0x0;
enum State{
Init,
ICORunning,
ICOPaused,
// Collected ETH is transferred to multisigs.
// Unsold tokens transferred to GoldmintUnsold contract.
ICOFinished,
// We start to refund if Soft Cap is not reached.
// Then each token holder should request a refund personally from his
// personal wallet.
//
// We will return ETHs only to the original address. If your address is changed
// or you have lost your keys -> you will not be able to get a refund.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Refunding,
// In this state we lock all MNT tokens forever.
// We are going to migrate MNTP -> MNT tokens during this stage.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Migrating
}
State public currentState = State.Init;
// Modifiers:
modifier onlyCreator() {
}
modifier onlyTokenManager() {
}
modifier onlyOtherCurrenciesChecker() {
}
modifier onlyEthSetter() {
}
modifier onlyInState(State state){
}
// Events:
event LogStateSwitch(State newState);
event LogBuy(address indexed owner, uint value);
event LogBurn(address indexed owner, uint value);
// Functions:
/// @dev Constructor
function Goldmint(
address _tokenManager,
address _ethRateChanger,
address _otherCurrenciesChecker,
address _mntTokenAddress,
address _unsoldContractAddress,
address _foundersVestingAddress)
{
}
function startICO() public onlyCreator onlyInState(State.Init) {
}
function pauseICO() public onlyCreator onlyInState(State.ICORunning) {
}
function resumeICO() public onlyCreator onlyInState(State.ICOPaused) {
}
function startRefunding() public onlyCreator onlyInState(State.ICORunning) {
}
function startMigration() public onlyCreator onlyInState(State.ICOFinished) {
}
/// @dev This function can be called by creator at any time,
/// or by anyone if ICO has really finished.
function finishICO() public onlyInState(State.ICORunning) {
}
function setState(State _s) internal {
}
// Access methods:
function setTokenManager(address _new) public onlyTokenManager {
}
// TODO: stealing creator's key means stealing otherCurrenciesChecker key too!
/*
function setOtherCurrenciesChecker(address _new) public onlyCreator {
otherCurrenciesChecker = _new;
}
*/
// These are used by frontend so we can not remove them
function getTokensIcoSold() constant public returns (uint){
}
function getTotalIcoTokens() constant public returns (uint){
}
function getMntTokenBalance(address _of) constant public returns (uint){
}
function getBlockLength()constant public returns (uint){
}
function getCurrentPrice()constant public returns (uint){
}
function getTotalCollectedWei()constant public returns (uint){
}
/////////////////////////////
function isIcoFinished() constant public returns(bool) {
}
function getMntTokensPerEth(uint _tokensSold) public constant returns (uint){
}
function buyTokens(address _buyer) public payable onlyInState(State.ICORunning) {
}
/// @dev This is called by other currency processors to issue new tokens
function issueTokensFromOtherCurrency(address _to, uint _weiCount) onlyInState(State.ICORunning) public onlyOtherCurrenciesChecker {
}
/// @dev This can be called to manually issue new tokens
/// from the bonus reward
function issueTokensExternal(address _to, uint _tokens) public onlyTokenManager {
}
function issueTokensInternal(address _to, uint _tokens) internal {
}
// anyone can call this and get his money back
function getMyRefund() public onlyInState(State.Refunding) {
}
function setUsdPerEthRate(uint _usdPerEthRate) public onlyEthSetter {
}
// Default fallback function
function() payable {
}
}
| uint(now)>=oneYearPassed | 19,731 | uint(now)>=oneYearPassed |
null | pragma solidity ^0.4.16;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
}
function safeSub(uint a, uint b) internal returns (uint) {
}
function safeAdd(uint a, uint b) internal returns (uint) {
}
}
// ERC20 standard
// We don't use ERC23 standard
contract StdToken is SafeMath {
// Fields:
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint public totalSupply = 0;
// Events:
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// Functions:
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns(bool){
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool){
}
function balanceOf(address _owner) constant returns (uint256) {
}
function approve(address _spender, uint256 _value) returns (bool) {
}
function allowance(address _owner, address _spender) constant returns (uint256) {
}
modifier onlyPayloadSize(uint _size) {
}
}
contract MNTP is StdToken {
// Fields:
string public constant name = "Goldmint MNT Prelaunch Token";
string public constant symbol = "MNTP";
uint public constant decimals = 18;
address public creator = 0x0;
address public icoContractAddress = 0x0;
bool public lockTransfers = false;
// 10 mln
uint public constant TOTAL_TOKEN_SUPPLY = 10000000 * 1 ether;
/// Modifiers:
modifier onlyCreator() {
}
modifier byIcoContract() {
}
function setCreator(address _creator) onlyCreator {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
// Functions:
function MNTP() {
}
/// @dev Override
function transfer(address _to, uint256 _value) public returns(bool){
}
/// @dev Override
function transferFrom(address _from, address _to, uint256 _value) public returns(bool){
}
function issueTokens(address _who, uint _tokens) byIcoContract {
}
// For refunds only
function burnTokens(address _who, uint _tokens) byIcoContract {
}
function lockTransfer(bool _lock) byIcoContract {
}
// Do not allow to send money directly to this contract
function() {
}
}
// This contract will hold all tokens that were unsold during ICO.
//
// Goldmint Team should be able to withdraw them and sell only after 1 year is passed after
// ICO is finished.
contract GoldmintUnsold is SafeMath {
address public creator;
address public teamAccountAddress;
address public icoContractAddress;
uint64 public icoIsFinishedDate;
MNTP public mntToken;
function GoldmintUnsold(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
modifier onlyIcoContract() {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
function finishIco() public onlyIcoContract {
}
// can be called by anyone...
function withdrawTokens() public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
contract FoundersVesting is SafeMath {
address public creator;
address public teamAccountAddress;
uint64 public lastWithdrawTime;
uint public withdrawsCount = 0;
uint public amountToSend = 0;
MNTP public mntToken;
function FoundersVesting(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
function withdrawTokens() onlyCreator public {
// 1 - wait for the next month
uint64 oneMonth = lastWithdrawTime + 30 days;
require(<FILL_ME>)
// 2 - calculate amount (only first time)
if(withdrawsCount==0){
amountToSend = mntToken.balanceOf(this) / 10;
}
require(amountToSend!=0);
// 3 - send 1/10th
uint currentBalance = mntToken.balanceOf(this);
if(currentBalance<amountToSend){
amountToSend = currentBalance;
}
mntToken.transfer(teamAccountAddress,amountToSend);
// 4 - update counter
withdrawsCount++;
lastWithdrawTime = uint64(now);
}
// Do not allow to send money directly to this contract
function() payable {
}
}
// This is the main Goldmint ICO smart contract
contract Goldmint is SafeMath {
// Constants:
// These values are HARD CODED!!!
// For extra security we split single multisig wallet into 10 separate multisig wallets
//
// THIS IS A REAL ICO WALLETS!!!
// PLEASE DOUBLE CHECK THAT...
address[] public multisigs = [
0xcEc42E247097C276Ad3D7cFd270aDBd562dA5c61,
0x373C46c544662B8C5D55c24Cf4F9a5020163eC2f,
0x672CF829272339A6c8c11b14Acc5F9d07bAFAC7c,
0xce0e1981A19a57aE808a7575a6738e4527fB9118,
0x93Aa76cdb17EeA80e4De983108ef575D8fc8f12b,
0x20ae3329Cd1e35FEfF7115B46218c9D056d430Fd,
0xe9fC1A57a5dC1CaA3DE22A940E9F09e640615f7E,
0xD360433950DE9F6FA0e93C29425845EeD6BFA0d0,
0xF0De97EAff5D6c998c80e07746c81a336e1BBd43,
0xF4Ce80097bf1E584822dBcA84f91D5d7d9df0846
];
// We count ETH invested by person, for refunds (see below)
mapping(address => uint) ethInvestedBy;
uint collectedWei = 0;
// These can be changed before ICO starts ($7USD/MNTP)
uint constant STD_PRICE_USD_PER_1000_TOKENS = 7000;
// The USD/ETH exchange rate may be changed every hour and can vary from $100 to $700 depending on the market. The exchange rate is retrieved from coinmarketcap.com site and is rounded to $1 dollar. For example if current marketcap price is $306.123 per ETH, the price is set as $306 to the contract.
uint public usdPerEthCoinmarketcapRate = 300;
uint64 public lastUsdPerEthChangeDate = 0;
// Price changes from block to block
uint constant SINGLE_BLOCK_LEN = 700000;
// 1 000 000 tokens
uint public constant BONUS_REWARD = 1000000 * 1 ether;
// 2 000 000 tokens
uint public constant FOUNDERS_REWARD = 2000000 * 1 ether;
// 7 000 000 is sold during the ICO
uint public constant ICO_TOKEN_SUPPLY_LIMIT = 7000000 * 1 ether;
// 150 000 tokens soft cap (otherwise - refund)
uint public constant ICO_TOKEN_SOFT_CAP = 150000 * 1 ether;
// 3 000 000 can be issued from other currencies
uint public constant MAX_ISSUED_FROM_OTHER_CURRENCIES = 3000000 * 1 ether;
// 30 000 MNTP tokens per one call only
uint public constant MAX_SINGLE_ISSUED_FROM_OTHER_CURRENCIES = 30000 * 1 ether;
uint public issuedFromOtherCurrencies = 0;
// Fields:
address public creator = 0x0; // can not be changed after deploy
address public ethRateChanger = 0x0; // can not be changed after deploy
address public tokenManager = 0x0; // can be changed by token manager only
address public otherCurrenciesChecker = 0x0; // can not be changed after deploy
uint64 public icoStartedTime = 0;
MNTP public mntToken;
GoldmintUnsold public unsoldContract;
// Total amount of tokens sold during ICO
uint public icoTokensSold = 0;
// Total amount of tokens sent to GoldmintUnsold contract after ICO is finished
uint public icoTokensUnsold = 0;
// Total number of tokens that were issued by a scripts
uint public issuedExternallyTokens = 0;
// This is where FOUNDERS_REWARD will be allocated
address public foundersRewardsAccount = 0x0;
enum State{
Init,
ICORunning,
ICOPaused,
// Collected ETH is transferred to multisigs.
// Unsold tokens transferred to GoldmintUnsold contract.
ICOFinished,
// We start to refund if Soft Cap is not reached.
// Then each token holder should request a refund personally from his
// personal wallet.
//
// We will return ETHs only to the original address. If your address is changed
// or you have lost your keys -> you will not be able to get a refund.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Refunding,
// In this state we lock all MNT tokens forever.
// We are going to migrate MNTP -> MNT tokens during this stage.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Migrating
}
State public currentState = State.Init;
// Modifiers:
modifier onlyCreator() {
}
modifier onlyTokenManager() {
}
modifier onlyOtherCurrenciesChecker() {
}
modifier onlyEthSetter() {
}
modifier onlyInState(State state){
}
// Events:
event LogStateSwitch(State newState);
event LogBuy(address indexed owner, uint value);
event LogBurn(address indexed owner, uint value);
// Functions:
/// @dev Constructor
function Goldmint(
address _tokenManager,
address _ethRateChanger,
address _otherCurrenciesChecker,
address _mntTokenAddress,
address _unsoldContractAddress,
address _foundersVestingAddress)
{
}
function startICO() public onlyCreator onlyInState(State.Init) {
}
function pauseICO() public onlyCreator onlyInState(State.ICORunning) {
}
function resumeICO() public onlyCreator onlyInState(State.ICOPaused) {
}
function startRefunding() public onlyCreator onlyInState(State.ICORunning) {
}
function startMigration() public onlyCreator onlyInState(State.ICOFinished) {
}
/// @dev This function can be called by creator at any time,
/// or by anyone if ICO has really finished.
function finishICO() public onlyInState(State.ICORunning) {
}
function setState(State _s) internal {
}
// Access methods:
function setTokenManager(address _new) public onlyTokenManager {
}
// TODO: stealing creator's key means stealing otherCurrenciesChecker key too!
/*
function setOtherCurrenciesChecker(address _new) public onlyCreator {
otherCurrenciesChecker = _new;
}
*/
// These are used by frontend so we can not remove them
function getTokensIcoSold() constant public returns (uint){
}
function getTotalIcoTokens() constant public returns (uint){
}
function getMntTokenBalance(address _of) constant public returns (uint){
}
function getBlockLength()constant public returns (uint){
}
function getCurrentPrice()constant public returns (uint){
}
function getTotalCollectedWei()constant public returns (uint){
}
/////////////////////////////
function isIcoFinished() constant public returns(bool) {
}
function getMntTokensPerEth(uint _tokensSold) public constant returns (uint){
}
function buyTokens(address _buyer) public payable onlyInState(State.ICORunning) {
}
/// @dev This is called by other currency processors to issue new tokens
function issueTokensFromOtherCurrency(address _to, uint _weiCount) onlyInState(State.ICORunning) public onlyOtherCurrenciesChecker {
}
/// @dev This can be called to manually issue new tokens
/// from the bonus reward
function issueTokensExternal(address _to, uint _tokens) public onlyTokenManager {
}
function issueTokensInternal(address _to, uint _tokens) internal {
}
// anyone can call this and get his money back
function getMyRefund() public onlyInState(State.Refunding) {
}
function setUsdPerEthRate(uint _usdPerEthRate) public onlyEthSetter {
}
// Default fallback function
function() payable {
}
}
| uint(now)>=oneMonth | 19,731 | uint(now)>=oneMonth |
null | pragma solidity ^0.4.16;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
}
function safeSub(uint a, uint b) internal returns (uint) {
}
function safeAdd(uint a, uint b) internal returns (uint) {
}
}
// ERC20 standard
// We don't use ERC23 standard
contract StdToken is SafeMath {
// Fields:
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint public totalSupply = 0;
// Events:
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// Functions:
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns(bool){
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool){
}
function balanceOf(address _owner) constant returns (uint256) {
}
function approve(address _spender, uint256 _value) returns (bool) {
}
function allowance(address _owner, address _spender) constant returns (uint256) {
}
modifier onlyPayloadSize(uint _size) {
}
}
contract MNTP is StdToken {
// Fields:
string public constant name = "Goldmint MNT Prelaunch Token";
string public constant symbol = "MNTP";
uint public constant decimals = 18;
address public creator = 0x0;
address public icoContractAddress = 0x0;
bool public lockTransfers = false;
// 10 mln
uint public constant TOTAL_TOKEN_SUPPLY = 10000000 * 1 ether;
/// Modifiers:
modifier onlyCreator() {
}
modifier byIcoContract() {
}
function setCreator(address _creator) onlyCreator {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
// Functions:
function MNTP() {
}
/// @dev Override
function transfer(address _to, uint256 _value) public returns(bool){
}
/// @dev Override
function transferFrom(address _from, address _to, uint256 _value) public returns(bool){
}
function issueTokens(address _who, uint _tokens) byIcoContract {
}
// For refunds only
function burnTokens(address _who, uint _tokens) byIcoContract {
}
function lockTransfer(bool _lock) byIcoContract {
}
// Do not allow to send money directly to this contract
function() {
}
}
// This contract will hold all tokens that were unsold during ICO.
//
// Goldmint Team should be able to withdraw them and sell only after 1 year is passed after
// ICO is finished.
contract GoldmintUnsold is SafeMath {
address public creator;
address public teamAccountAddress;
address public icoContractAddress;
uint64 public icoIsFinishedDate;
MNTP public mntToken;
function GoldmintUnsold(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
modifier onlyIcoContract() {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
function finishIco() public onlyIcoContract {
}
// can be called by anyone...
function withdrawTokens() public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
contract FoundersVesting is SafeMath {
address public creator;
address public teamAccountAddress;
uint64 public lastWithdrawTime;
uint public withdrawsCount = 0;
uint public amountToSend = 0;
MNTP public mntToken;
function FoundersVesting(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
function withdrawTokens() onlyCreator public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
// This is the main Goldmint ICO smart contract
contract Goldmint is SafeMath {
// Constants:
// These values are HARD CODED!!!
// For extra security we split single multisig wallet into 10 separate multisig wallets
//
// THIS IS A REAL ICO WALLETS!!!
// PLEASE DOUBLE CHECK THAT...
address[] public multisigs = [
0xcEc42E247097C276Ad3D7cFd270aDBd562dA5c61,
0x373C46c544662B8C5D55c24Cf4F9a5020163eC2f,
0x672CF829272339A6c8c11b14Acc5F9d07bAFAC7c,
0xce0e1981A19a57aE808a7575a6738e4527fB9118,
0x93Aa76cdb17EeA80e4De983108ef575D8fc8f12b,
0x20ae3329Cd1e35FEfF7115B46218c9D056d430Fd,
0xe9fC1A57a5dC1CaA3DE22A940E9F09e640615f7E,
0xD360433950DE9F6FA0e93C29425845EeD6BFA0d0,
0xF0De97EAff5D6c998c80e07746c81a336e1BBd43,
0xF4Ce80097bf1E584822dBcA84f91D5d7d9df0846
];
// We count ETH invested by person, for refunds (see below)
mapping(address => uint) ethInvestedBy;
uint collectedWei = 0;
// These can be changed before ICO starts ($7USD/MNTP)
uint constant STD_PRICE_USD_PER_1000_TOKENS = 7000;
// The USD/ETH exchange rate may be changed every hour and can vary from $100 to $700 depending on the market. The exchange rate is retrieved from coinmarketcap.com site and is rounded to $1 dollar. For example if current marketcap price is $306.123 per ETH, the price is set as $306 to the contract.
uint public usdPerEthCoinmarketcapRate = 300;
uint64 public lastUsdPerEthChangeDate = 0;
// Price changes from block to block
uint constant SINGLE_BLOCK_LEN = 700000;
// 1 000 000 tokens
uint public constant BONUS_REWARD = 1000000 * 1 ether;
// 2 000 000 tokens
uint public constant FOUNDERS_REWARD = 2000000 * 1 ether;
// 7 000 000 is sold during the ICO
uint public constant ICO_TOKEN_SUPPLY_LIMIT = 7000000 * 1 ether;
// 150 000 tokens soft cap (otherwise - refund)
uint public constant ICO_TOKEN_SOFT_CAP = 150000 * 1 ether;
// 3 000 000 can be issued from other currencies
uint public constant MAX_ISSUED_FROM_OTHER_CURRENCIES = 3000000 * 1 ether;
// 30 000 MNTP tokens per one call only
uint public constant MAX_SINGLE_ISSUED_FROM_OTHER_CURRENCIES = 30000 * 1 ether;
uint public issuedFromOtherCurrencies = 0;
// Fields:
address public creator = 0x0; // can not be changed after deploy
address public ethRateChanger = 0x0; // can not be changed after deploy
address public tokenManager = 0x0; // can be changed by token manager only
address public otherCurrenciesChecker = 0x0; // can not be changed after deploy
uint64 public icoStartedTime = 0;
MNTP public mntToken;
GoldmintUnsold public unsoldContract;
// Total amount of tokens sold during ICO
uint public icoTokensSold = 0;
// Total amount of tokens sent to GoldmintUnsold contract after ICO is finished
uint public icoTokensUnsold = 0;
// Total number of tokens that were issued by a scripts
uint public issuedExternallyTokens = 0;
// This is where FOUNDERS_REWARD will be allocated
address public foundersRewardsAccount = 0x0;
enum State{
Init,
ICORunning,
ICOPaused,
// Collected ETH is transferred to multisigs.
// Unsold tokens transferred to GoldmintUnsold contract.
ICOFinished,
// We start to refund if Soft Cap is not reached.
// Then each token holder should request a refund personally from his
// personal wallet.
//
// We will return ETHs only to the original address. If your address is changed
// or you have lost your keys -> you will not be able to get a refund.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Refunding,
// In this state we lock all MNT tokens forever.
// We are going to migrate MNTP -> MNT tokens during this stage.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Migrating
}
State public currentState = State.Init;
// Modifiers:
modifier onlyCreator() {
}
modifier onlyTokenManager() {
}
modifier onlyOtherCurrenciesChecker() {
}
modifier onlyEthSetter() {
}
modifier onlyInState(State state){
}
// Events:
event LogStateSwitch(State newState);
event LogBuy(address indexed owner, uint value);
event LogBurn(address indexed owner, uint value);
// Functions:
/// @dev Constructor
function Goldmint(
address _tokenManager,
address _ethRateChanger,
address _otherCurrenciesChecker,
address _mntTokenAddress,
address _unsoldContractAddress,
address _foundersVestingAddress)
{
}
function startICO() public onlyCreator onlyInState(State.Init) {
}
function pauseICO() public onlyCreator onlyInState(State.ICORunning) {
}
function resumeICO() public onlyCreator onlyInState(State.ICOPaused) {
}
function startRefunding() public onlyCreator onlyInState(State.ICORunning) {
}
function startMigration() public onlyCreator onlyInState(State.ICOFinished) {
}
/// @dev This function can be called by creator at any time,
/// or by anyone if ICO has really finished.
function finishICO() public onlyInState(State.ICORunning) {
}
function setState(State _s) internal {
}
// Access methods:
function setTokenManager(address _new) public onlyTokenManager {
}
// TODO: stealing creator's key means stealing otherCurrenciesChecker key too!
/*
function setOtherCurrenciesChecker(address _new) public onlyCreator {
otherCurrenciesChecker = _new;
}
*/
// These are used by frontend so we can not remove them
function getTokensIcoSold() constant public returns (uint){
}
function getTotalIcoTokens() constant public returns (uint){
}
function getMntTokenBalance(address _of) constant public returns (uint){
}
function getBlockLength()constant public returns (uint){
}
function getCurrentPrice()constant public returns (uint){
}
function getTotalCollectedWei()constant public returns (uint){
}
/////////////////////////////
function isIcoFinished() constant public returns(bool) {
}
function getMntTokensPerEth(uint _tokensSold) public constant returns (uint){
}
function buyTokens(address _buyer) public payable onlyInState(State.ICORunning) {
}
/// @dev This is called by other currency processors to issue new tokens
function issueTokensFromOtherCurrency(address _to, uint _weiCount) onlyInState(State.ICORunning) public onlyOtherCurrenciesChecker {
require(_weiCount!=0);
uint newTokens = (_weiCount * getMntTokensPerEth(icoTokensSold)) / 1 ether;
require(newTokens<=MAX_SINGLE_ISSUED_FROM_OTHER_CURRENCIES);
require(<FILL_ME>)
issueTokensInternal(_to,newTokens);
issuedFromOtherCurrencies = issuedFromOtherCurrencies + newTokens;
}
/// @dev This can be called to manually issue new tokens
/// from the bonus reward
function issueTokensExternal(address _to, uint _tokens) public onlyTokenManager {
}
function issueTokensInternal(address _to, uint _tokens) internal {
}
// anyone can call this and get his money back
function getMyRefund() public onlyInState(State.Refunding) {
}
function setUsdPerEthRate(uint _usdPerEthRate) public onlyEthSetter {
}
// Default fallback function
function() payable {
}
}
| (issuedFromOtherCurrencies+newTokens)<=MAX_ISSUED_FROM_OTHER_CURRENCIES | 19,731 | (issuedFromOtherCurrencies+newTokens)<=MAX_ISSUED_FROM_OTHER_CURRENCIES |
null | pragma solidity ^0.4.16;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
}
function safeSub(uint a, uint b) internal returns (uint) {
}
function safeAdd(uint a, uint b) internal returns (uint) {
}
}
// ERC20 standard
// We don't use ERC23 standard
contract StdToken is SafeMath {
// Fields:
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint public totalSupply = 0;
// Events:
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// Functions:
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns(bool){
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool){
}
function balanceOf(address _owner) constant returns (uint256) {
}
function approve(address _spender, uint256 _value) returns (bool) {
}
function allowance(address _owner, address _spender) constant returns (uint256) {
}
modifier onlyPayloadSize(uint _size) {
}
}
contract MNTP is StdToken {
// Fields:
string public constant name = "Goldmint MNT Prelaunch Token";
string public constant symbol = "MNTP";
uint public constant decimals = 18;
address public creator = 0x0;
address public icoContractAddress = 0x0;
bool public lockTransfers = false;
// 10 mln
uint public constant TOTAL_TOKEN_SUPPLY = 10000000 * 1 ether;
/// Modifiers:
modifier onlyCreator() {
}
modifier byIcoContract() {
}
function setCreator(address _creator) onlyCreator {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
// Functions:
function MNTP() {
}
/// @dev Override
function transfer(address _to, uint256 _value) public returns(bool){
}
/// @dev Override
function transferFrom(address _from, address _to, uint256 _value) public returns(bool){
}
function issueTokens(address _who, uint _tokens) byIcoContract {
}
// For refunds only
function burnTokens(address _who, uint _tokens) byIcoContract {
}
function lockTransfer(bool _lock) byIcoContract {
}
// Do not allow to send money directly to this contract
function() {
}
}
// This contract will hold all tokens that were unsold during ICO.
//
// Goldmint Team should be able to withdraw them and sell only after 1 year is passed after
// ICO is finished.
contract GoldmintUnsold is SafeMath {
address public creator;
address public teamAccountAddress;
address public icoContractAddress;
uint64 public icoIsFinishedDate;
MNTP public mntToken;
function GoldmintUnsold(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
modifier onlyIcoContract() {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
function finishIco() public onlyIcoContract {
}
// can be called by anyone...
function withdrawTokens() public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
contract FoundersVesting is SafeMath {
address public creator;
address public teamAccountAddress;
uint64 public lastWithdrawTime;
uint public withdrawsCount = 0;
uint public amountToSend = 0;
MNTP public mntToken;
function FoundersVesting(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
function withdrawTokens() onlyCreator public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
// This is the main Goldmint ICO smart contract
contract Goldmint is SafeMath {
// Constants:
// These values are HARD CODED!!!
// For extra security we split single multisig wallet into 10 separate multisig wallets
//
// THIS IS A REAL ICO WALLETS!!!
// PLEASE DOUBLE CHECK THAT...
address[] public multisigs = [
0xcEc42E247097C276Ad3D7cFd270aDBd562dA5c61,
0x373C46c544662B8C5D55c24Cf4F9a5020163eC2f,
0x672CF829272339A6c8c11b14Acc5F9d07bAFAC7c,
0xce0e1981A19a57aE808a7575a6738e4527fB9118,
0x93Aa76cdb17EeA80e4De983108ef575D8fc8f12b,
0x20ae3329Cd1e35FEfF7115B46218c9D056d430Fd,
0xe9fC1A57a5dC1CaA3DE22A940E9F09e640615f7E,
0xD360433950DE9F6FA0e93C29425845EeD6BFA0d0,
0xF0De97EAff5D6c998c80e07746c81a336e1BBd43,
0xF4Ce80097bf1E584822dBcA84f91D5d7d9df0846
];
// We count ETH invested by person, for refunds (see below)
mapping(address => uint) ethInvestedBy;
uint collectedWei = 0;
// These can be changed before ICO starts ($7USD/MNTP)
uint constant STD_PRICE_USD_PER_1000_TOKENS = 7000;
// The USD/ETH exchange rate may be changed every hour and can vary from $100 to $700 depending on the market. The exchange rate is retrieved from coinmarketcap.com site and is rounded to $1 dollar. For example if current marketcap price is $306.123 per ETH, the price is set as $306 to the contract.
uint public usdPerEthCoinmarketcapRate = 300;
uint64 public lastUsdPerEthChangeDate = 0;
// Price changes from block to block
uint constant SINGLE_BLOCK_LEN = 700000;
// 1 000 000 tokens
uint public constant BONUS_REWARD = 1000000 * 1 ether;
// 2 000 000 tokens
uint public constant FOUNDERS_REWARD = 2000000 * 1 ether;
// 7 000 000 is sold during the ICO
uint public constant ICO_TOKEN_SUPPLY_LIMIT = 7000000 * 1 ether;
// 150 000 tokens soft cap (otherwise - refund)
uint public constant ICO_TOKEN_SOFT_CAP = 150000 * 1 ether;
// 3 000 000 can be issued from other currencies
uint public constant MAX_ISSUED_FROM_OTHER_CURRENCIES = 3000000 * 1 ether;
// 30 000 MNTP tokens per one call only
uint public constant MAX_SINGLE_ISSUED_FROM_OTHER_CURRENCIES = 30000 * 1 ether;
uint public issuedFromOtherCurrencies = 0;
// Fields:
address public creator = 0x0; // can not be changed after deploy
address public ethRateChanger = 0x0; // can not be changed after deploy
address public tokenManager = 0x0; // can be changed by token manager only
address public otherCurrenciesChecker = 0x0; // can not be changed after deploy
uint64 public icoStartedTime = 0;
MNTP public mntToken;
GoldmintUnsold public unsoldContract;
// Total amount of tokens sold during ICO
uint public icoTokensSold = 0;
// Total amount of tokens sent to GoldmintUnsold contract after ICO is finished
uint public icoTokensUnsold = 0;
// Total number of tokens that were issued by a scripts
uint public issuedExternallyTokens = 0;
// This is where FOUNDERS_REWARD will be allocated
address public foundersRewardsAccount = 0x0;
enum State{
Init,
ICORunning,
ICOPaused,
// Collected ETH is transferred to multisigs.
// Unsold tokens transferred to GoldmintUnsold contract.
ICOFinished,
// We start to refund if Soft Cap is not reached.
// Then each token holder should request a refund personally from his
// personal wallet.
//
// We will return ETHs only to the original address. If your address is changed
// or you have lost your keys -> you will not be able to get a refund.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Refunding,
// In this state we lock all MNT tokens forever.
// We are going to migrate MNTP -> MNT tokens during this stage.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Migrating
}
State public currentState = State.Init;
// Modifiers:
modifier onlyCreator() {
}
modifier onlyTokenManager() {
}
modifier onlyOtherCurrenciesChecker() {
}
modifier onlyEthSetter() {
}
modifier onlyInState(State state){
}
// Events:
event LogStateSwitch(State newState);
event LogBuy(address indexed owner, uint value);
event LogBurn(address indexed owner, uint value);
// Functions:
/// @dev Constructor
function Goldmint(
address _tokenManager,
address _ethRateChanger,
address _otherCurrenciesChecker,
address _mntTokenAddress,
address _unsoldContractAddress,
address _foundersVestingAddress)
{
}
function startICO() public onlyCreator onlyInState(State.Init) {
}
function pauseICO() public onlyCreator onlyInState(State.ICORunning) {
}
function resumeICO() public onlyCreator onlyInState(State.ICOPaused) {
}
function startRefunding() public onlyCreator onlyInState(State.ICORunning) {
}
function startMigration() public onlyCreator onlyInState(State.ICOFinished) {
}
/// @dev This function can be called by creator at any time,
/// or by anyone if ICO has really finished.
function finishICO() public onlyInState(State.ICORunning) {
}
function setState(State _s) internal {
}
// Access methods:
function setTokenManager(address _new) public onlyTokenManager {
}
// TODO: stealing creator's key means stealing otherCurrenciesChecker key too!
/*
function setOtherCurrenciesChecker(address _new) public onlyCreator {
otherCurrenciesChecker = _new;
}
*/
// These are used by frontend so we can not remove them
function getTokensIcoSold() constant public returns (uint){
}
function getTotalIcoTokens() constant public returns (uint){
}
function getMntTokenBalance(address _of) constant public returns (uint){
}
function getBlockLength()constant public returns (uint){
}
function getCurrentPrice()constant public returns (uint){
}
function getTotalCollectedWei()constant public returns (uint){
}
/////////////////////////////
function isIcoFinished() constant public returns(bool) {
}
function getMntTokensPerEth(uint _tokensSold) public constant returns (uint){
}
function buyTokens(address _buyer) public payable onlyInState(State.ICORunning) {
}
/// @dev This is called by other currency processors to issue new tokens
function issueTokensFromOtherCurrency(address _to, uint _weiCount) onlyInState(State.ICORunning) public onlyOtherCurrenciesChecker {
}
/// @dev This can be called to manually issue new tokens
/// from the bonus reward
function issueTokensExternal(address _to, uint _tokens) public onlyTokenManager {
// in 2 states
require(<FILL_ME>)
// can not issue more than BONUS_REWARD
require((issuedExternallyTokens + _tokens)<=BONUS_REWARD);
mntToken.issueTokens(_to,_tokens);
issuedExternallyTokens = issuedExternallyTokens + _tokens;
}
function issueTokensInternal(address _to, uint _tokens) internal {
}
// anyone can call this and get his money back
function getMyRefund() public onlyInState(State.Refunding) {
}
function setUsdPerEthRate(uint _usdPerEthRate) public onlyEthSetter {
}
// Default fallback function
function() payable {
}
}
| (State.ICOFinished==currentState)||(State.ICORunning==currentState) | 19,731 | (State.ICOFinished==currentState)||(State.ICORunning==currentState) |
null | pragma solidity ^0.4.16;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
}
function safeSub(uint a, uint b) internal returns (uint) {
}
function safeAdd(uint a, uint b) internal returns (uint) {
}
}
// ERC20 standard
// We don't use ERC23 standard
contract StdToken is SafeMath {
// Fields:
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint public totalSupply = 0;
// Events:
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// Functions:
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns(bool){
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool){
}
function balanceOf(address _owner) constant returns (uint256) {
}
function approve(address _spender, uint256 _value) returns (bool) {
}
function allowance(address _owner, address _spender) constant returns (uint256) {
}
modifier onlyPayloadSize(uint _size) {
}
}
contract MNTP is StdToken {
// Fields:
string public constant name = "Goldmint MNT Prelaunch Token";
string public constant symbol = "MNTP";
uint public constant decimals = 18;
address public creator = 0x0;
address public icoContractAddress = 0x0;
bool public lockTransfers = false;
// 10 mln
uint public constant TOTAL_TOKEN_SUPPLY = 10000000 * 1 ether;
/// Modifiers:
modifier onlyCreator() {
}
modifier byIcoContract() {
}
function setCreator(address _creator) onlyCreator {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
// Functions:
function MNTP() {
}
/// @dev Override
function transfer(address _to, uint256 _value) public returns(bool){
}
/// @dev Override
function transferFrom(address _from, address _to, uint256 _value) public returns(bool){
}
function issueTokens(address _who, uint _tokens) byIcoContract {
}
// For refunds only
function burnTokens(address _who, uint _tokens) byIcoContract {
}
function lockTransfer(bool _lock) byIcoContract {
}
// Do not allow to send money directly to this contract
function() {
}
}
// This contract will hold all tokens that were unsold during ICO.
//
// Goldmint Team should be able to withdraw them and sell only after 1 year is passed after
// ICO is finished.
contract GoldmintUnsold is SafeMath {
address public creator;
address public teamAccountAddress;
address public icoContractAddress;
uint64 public icoIsFinishedDate;
MNTP public mntToken;
function GoldmintUnsold(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
modifier onlyIcoContract() {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
function finishIco() public onlyIcoContract {
}
// can be called by anyone...
function withdrawTokens() public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
contract FoundersVesting is SafeMath {
address public creator;
address public teamAccountAddress;
uint64 public lastWithdrawTime;
uint public withdrawsCount = 0;
uint public amountToSend = 0;
MNTP public mntToken;
function FoundersVesting(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
function withdrawTokens() onlyCreator public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
// This is the main Goldmint ICO smart contract
contract Goldmint is SafeMath {
// Constants:
// These values are HARD CODED!!!
// For extra security we split single multisig wallet into 10 separate multisig wallets
//
// THIS IS A REAL ICO WALLETS!!!
// PLEASE DOUBLE CHECK THAT...
address[] public multisigs = [
0xcEc42E247097C276Ad3D7cFd270aDBd562dA5c61,
0x373C46c544662B8C5D55c24Cf4F9a5020163eC2f,
0x672CF829272339A6c8c11b14Acc5F9d07bAFAC7c,
0xce0e1981A19a57aE808a7575a6738e4527fB9118,
0x93Aa76cdb17EeA80e4De983108ef575D8fc8f12b,
0x20ae3329Cd1e35FEfF7115B46218c9D056d430Fd,
0xe9fC1A57a5dC1CaA3DE22A940E9F09e640615f7E,
0xD360433950DE9F6FA0e93C29425845EeD6BFA0d0,
0xF0De97EAff5D6c998c80e07746c81a336e1BBd43,
0xF4Ce80097bf1E584822dBcA84f91D5d7d9df0846
];
// We count ETH invested by person, for refunds (see below)
mapping(address => uint) ethInvestedBy;
uint collectedWei = 0;
// These can be changed before ICO starts ($7USD/MNTP)
uint constant STD_PRICE_USD_PER_1000_TOKENS = 7000;
// The USD/ETH exchange rate may be changed every hour and can vary from $100 to $700 depending on the market. The exchange rate is retrieved from coinmarketcap.com site and is rounded to $1 dollar. For example if current marketcap price is $306.123 per ETH, the price is set as $306 to the contract.
uint public usdPerEthCoinmarketcapRate = 300;
uint64 public lastUsdPerEthChangeDate = 0;
// Price changes from block to block
uint constant SINGLE_BLOCK_LEN = 700000;
// 1 000 000 tokens
uint public constant BONUS_REWARD = 1000000 * 1 ether;
// 2 000 000 tokens
uint public constant FOUNDERS_REWARD = 2000000 * 1 ether;
// 7 000 000 is sold during the ICO
uint public constant ICO_TOKEN_SUPPLY_LIMIT = 7000000 * 1 ether;
// 150 000 tokens soft cap (otherwise - refund)
uint public constant ICO_TOKEN_SOFT_CAP = 150000 * 1 ether;
// 3 000 000 can be issued from other currencies
uint public constant MAX_ISSUED_FROM_OTHER_CURRENCIES = 3000000 * 1 ether;
// 30 000 MNTP tokens per one call only
uint public constant MAX_SINGLE_ISSUED_FROM_OTHER_CURRENCIES = 30000 * 1 ether;
uint public issuedFromOtherCurrencies = 0;
// Fields:
address public creator = 0x0; // can not be changed after deploy
address public ethRateChanger = 0x0; // can not be changed after deploy
address public tokenManager = 0x0; // can be changed by token manager only
address public otherCurrenciesChecker = 0x0; // can not be changed after deploy
uint64 public icoStartedTime = 0;
MNTP public mntToken;
GoldmintUnsold public unsoldContract;
// Total amount of tokens sold during ICO
uint public icoTokensSold = 0;
// Total amount of tokens sent to GoldmintUnsold contract after ICO is finished
uint public icoTokensUnsold = 0;
// Total number of tokens that were issued by a scripts
uint public issuedExternallyTokens = 0;
// This is where FOUNDERS_REWARD will be allocated
address public foundersRewardsAccount = 0x0;
enum State{
Init,
ICORunning,
ICOPaused,
// Collected ETH is transferred to multisigs.
// Unsold tokens transferred to GoldmintUnsold contract.
ICOFinished,
// We start to refund if Soft Cap is not reached.
// Then each token holder should request a refund personally from his
// personal wallet.
//
// We will return ETHs only to the original address. If your address is changed
// or you have lost your keys -> you will not be able to get a refund.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Refunding,
// In this state we lock all MNT tokens forever.
// We are going to migrate MNTP -> MNT tokens during this stage.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Migrating
}
State public currentState = State.Init;
// Modifiers:
modifier onlyCreator() {
}
modifier onlyTokenManager() {
}
modifier onlyOtherCurrenciesChecker() {
}
modifier onlyEthSetter() {
}
modifier onlyInState(State state){
}
// Events:
event LogStateSwitch(State newState);
event LogBuy(address indexed owner, uint value);
event LogBurn(address indexed owner, uint value);
// Functions:
/// @dev Constructor
function Goldmint(
address _tokenManager,
address _ethRateChanger,
address _otherCurrenciesChecker,
address _mntTokenAddress,
address _unsoldContractAddress,
address _foundersVestingAddress)
{
}
function startICO() public onlyCreator onlyInState(State.Init) {
}
function pauseICO() public onlyCreator onlyInState(State.ICORunning) {
}
function resumeICO() public onlyCreator onlyInState(State.ICOPaused) {
}
function startRefunding() public onlyCreator onlyInState(State.ICORunning) {
}
function startMigration() public onlyCreator onlyInState(State.ICOFinished) {
}
/// @dev This function can be called by creator at any time,
/// or by anyone if ICO has really finished.
function finishICO() public onlyInState(State.ICORunning) {
}
function setState(State _s) internal {
}
// Access methods:
function setTokenManager(address _new) public onlyTokenManager {
}
// TODO: stealing creator's key means stealing otherCurrenciesChecker key too!
/*
function setOtherCurrenciesChecker(address _new) public onlyCreator {
otherCurrenciesChecker = _new;
}
*/
// These are used by frontend so we can not remove them
function getTokensIcoSold() constant public returns (uint){
}
function getTotalIcoTokens() constant public returns (uint){
}
function getMntTokenBalance(address _of) constant public returns (uint){
}
function getBlockLength()constant public returns (uint){
}
function getCurrentPrice()constant public returns (uint){
}
function getTotalCollectedWei()constant public returns (uint){
}
/////////////////////////////
function isIcoFinished() constant public returns(bool) {
}
function getMntTokensPerEth(uint _tokensSold) public constant returns (uint){
}
function buyTokens(address _buyer) public payable onlyInState(State.ICORunning) {
}
/// @dev This is called by other currency processors to issue new tokens
function issueTokensFromOtherCurrency(address _to, uint _weiCount) onlyInState(State.ICORunning) public onlyOtherCurrenciesChecker {
}
/// @dev This can be called to manually issue new tokens
/// from the bonus reward
function issueTokensExternal(address _to, uint _tokens) public onlyTokenManager {
// in 2 states
require((State.ICOFinished==currentState) || (State.ICORunning==currentState));
// can not issue more than BONUS_REWARD
require(<FILL_ME>)
mntToken.issueTokens(_to,_tokens);
issuedExternallyTokens = issuedExternallyTokens + _tokens;
}
function issueTokensInternal(address _to, uint _tokens) internal {
}
// anyone can call this and get his money back
function getMyRefund() public onlyInState(State.Refunding) {
}
function setUsdPerEthRate(uint _usdPerEthRate) public onlyEthSetter {
}
// Default fallback function
function() payable {
}
}
| (issuedExternallyTokens+_tokens)<=BONUS_REWARD | 19,731 | (issuedExternallyTokens+_tokens)<=BONUS_REWARD |
null | pragma solidity ^0.4.16;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
}
function safeSub(uint a, uint b) internal returns (uint) {
}
function safeAdd(uint a, uint b) internal returns (uint) {
}
}
// ERC20 standard
// We don't use ERC23 standard
contract StdToken is SafeMath {
// Fields:
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint public totalSupply = 0;
// Events:
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// Functions:
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns(bool){
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool){
}
function balanceOf(address _owner) constant returns (uint256) {
}
function approve(address _spender, uint256 _value) returns (bool) {
}
function allowance(address _owner, address _spender) constant returns (uint256) {
}
modifier onlyPayloadSize(uint _size) {
}
}
contract MNTP is StdToken {
// Fields:
string public constant name = "Goldmint MNT Prelaunch Token";
string public constant symbol = "MNTP";
uint public constant decimals = 18;
address public creator = 0x0;
address public icoContractAddress = 0x0;
bool public lockTransfers = false;
// 10 mln
uint public constant TOTAL_TOKEN_SUPPLY = 10000000 * 1 ether;
/// Modifiers:
modifier onlyCreator() {
}
modifier byIcoContract() {
}
function setCreator(address _creator) onlyCreator {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
// Functions:
function MNTP() {
}
/// @dev Override
function transfer(address _to, uint256 _value) public returns(bool){
}
/// @dev Override
function transferFrom(address _from, address _to, uint256 _value) public returns(bool){
}
function issueTokens(address _who, uint _tokens) byIcoContract {
}
// For refunds only
function burnTokens(address _who, uint _tokens) byIcoContract {
}
function lockTransfer(bool _lock) byIcoContract {
}
// Do not allow to send money directly to this contract
function() {
}
}
// This contract will hold all tokens that were unsold during ICO.
//
// Goldmint Team should be able to withdraw them and sell only after 1 year is passed after
// ICO is finished.
contract GoldmintUnsold is SafeMath {
address public creator;
address public teamAccountAddress;
address public icoContractAddress;
uint64 public icoIsFinishedDate;
MNTP public mntToken;
function GoldmintUnsold(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
modifier onlyIcoContract() {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
function finishIco() public onlyIcoContract {
}
// can be called by anyone...
function withdrawTokens() public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
contract FoundersVesting is SafeMath {
address public creator;
address public teamAccountAddress;
uint64 public lastWithdrawTime;
uint public withdrawsCount = 0;
uint public amountToSend = 0;
MNTP public mntToken;
function FoundersVesting(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
function withdrawTokens() onlyCreator public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
// This is the main Goldmint ICO smart contract
contract Goldmint is SafeMath {
// Constants:
// These values are HARD CODED!!!
// For extra security we split single multisig wallet into 10 separate multisig wallets
//
// THIS IS A REAL ICO WALLETS!!!
// PLEASE DOUBLE CHECK THAT...
address[] public multisigs = [
0xcEc42E247097C276Ad3D7cFd270aDBd562dA5c61,
0x373C46c544662B8C5D55c24Cf4F9a5020163eC2f,
0x672CF829272339A6c8c11b14Acc5F9d07bAFAC7c,
0xce0e1981A19a57aE808a7575a6738e4527fB9118,
0x93Aa76cdb17EeA80e4De983108ef575D8fc8f12b,
0x20ae3329Cd1e35FEfF7115B46218c9D056d430Fd,
0xe9fC1A57a5dC1CaA3DE22A940E9F09e640615f7E,
0xD360433950DE9F6FA0e93C29425845EeD6BFA0d0,
0xF0De97EAff5D6c998c80e07746c81a336e1BBd43,
0xF4Ce80097bf1E584822dBcA84f91D5d7d9df0846
];
// We count ETH invested by person, for refunds (see below)
mapping(address => uint) ethInvestedBy;
uint collectedWei = 0;
// These can be changed before ICO starts ($7USD/MNTP)
uint constant STD_PRICE_USD_PER_1000_TOKENS = 7000;
// The USD/ETH exchange rate may be changed every hour and can vary from $100 to $700 depending on the market. The exchange rate is retrieved from coinmarketcap.com site and is rounded to $1 dollar. For example if current marketcap price is $306.123 per ETH, the price is set as $306 to the contract.
uint public usdPerEthCoinmarketcapRate = 300;
uint64 public lastUsdPerEthChangeDate = 0;
// Price changes from block to block
uint constant SINGLE_BLOCK_LEN = 700000;
// 1 000 000 tokens
uint public constant BONUS_REWARD = 1000000 * 1 ether;
// 2 000 000 tokens
uint public constant FOUNDERS_REWARD = 2000000 * 1 ether;
// 7 000 000 is sold during the ICO
uint public constant ICO_TOKEN_SUPPLY_LIMIT = 7000000 * 1 ether;
// 150 000 tokens soft cap (otherwise - refund)
uint public constant ICO_TOKEN_SOFT_CAP = 150000 * 1 ether;
// 3 000 000 can be issued from other currencies
uint public constant MAX_ISSUED_FROM_OTHER_CURRENCIES = 3000000 * 1 ether;
// 30 000 MNTP tokens per one call only
uint public constant MAX_SINGLE_ISSUED_FROM_OTHER_CURRENCIES = 30000 * 1 ether;
uint public issuedFromOtherCurrencies = 0;
// Fields:
address public creator = 0x0; // can not be changed after deploy
address public ethRateChanger = 0x0; // can not be changed after deploy
address public tokenManager = 0x0; // can be changed by token manager only
address public otherCurrenciesChecker = 0x0; // can not be changed after deploy
uint64 public icoStartedTime = 0;
MNTP public mntToken;
GoldmintUnsold public unsoldContract;
// Total amount of tokens sold during ICO
uint public icoTokensSold = 0;
// Total amount of tokens sent to GoldmintUnsold contract after ICO is finished
uint public icoTokensUnsold = 0;
// Total number of tokens that were issued by a scripts
uint public issuedExternallyTokens = 0;
// This is where FOUNDERS_REWARD will be allocated
address public foundersRewardsAccount = 0x0;
enum State{
Init,
ICORunning,
ICOPaused,
// Collected ETH is transferred to multisigs.
// Unsold tokens transferred to GoldmintUnsold contract.
ICOFinished,
// We start to refund if Soft Cap is not reached.
// Then each token holder should request a refund personally from his
// personal wallet.
//
// We will return ETHs only to the original address. If your address is changed
// or you have lost your keys -> you will not be able to get a refund.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Refunding,
// In this state we lock all MNT tokens forever.
// We are going to migrate MNTP -> MNT tokens during this stage.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Migrating
}
State public currentState = State.Init;
// Modifiers:
modifier onlyCreator() {
}
modifier onlyTokenManager() {
}
modifier onlyOtherCurrenciesChecker() {
}
modifier onlyEthSetter() {
}
modifier onlyInState(State state){
}
// Events:
event LogStateSwitch(State newState);
event LogBuy(address indexed owner, uint value);
event LogBurn(address indexed owner, uint value);
// Functions:
/// @dev Constructor
function Goldmint(
address _tokenManager,
address _ethRateChanger,
address _otherCurrenciesChecker,
address _mntTokenAddress,
address _unsoldContractAddress,
address _foundersVestingAddress)
{
}
function startICO() public onlyCreator onlyInState(State.Init) {
}
function pauseICO() public onlyCreator onlyInState(State.ICORunning) {
}
function resumeICO() public onlyCreator onlyInState(State.ICOPaused) {
}
function startRefunding() public onlyCreator onlyInState(State.ICORunning) {
}
function startMigration() public onlyCreator onlyInState(State.ICOFinished) {
}
/// @dev This function can be called by creator at any time,
/// or by anyone if ICO has really finished.
function finishICO() public onlyInState(State.ICORunning) {
}
function setState(State _s) internal {
}
// Access methods:
function setTokenManager(address _new) public onlyTokenManager {
}
// TODO: stealing creator's key means stealing otherCurrenciesChecker key too!
/*
function setOtherCurrenciesChecker(address _new) public onlyCreator {
otherCurrenciesChecker = _new;
}
*/
// These are used by frontend so we can not remove them
function getTokensIcoSold() constant public returns (uint){
}
function getTotalIcoTokens() constant public returns (uint){
}
function getMntTokenBalance(address _of) constant public returns (uint){
}
function getBlockLength()constant public returns (uint){
}
function getCurrentPrice()constant public returns (uint){
}
function getTotalCollectedWei()constant public returns (uint){
}
/////////////////////////////
function isIcoFinished() constant public returns(bool) {
}
function getMntTokensPerEth(uint _tokensSold) public constant returns (uint){
}
function buyTokens(address _buyer) public payable onlyInState(State.ICORunning) {
}
/// @dev This is called by other currency processors to issue new tokens
function issueTokensFromOtherCurrency(address _to, uint _weiCount) onlyInState(State.ICORunning) public onlyOtherCurrenciesChecker {
}
/// @dev This can be called to manually issue new tokens
/// from the bonus reward
function issueTokensExternal(address _to, uint _tokens) public onlyTokenManager {
}
function issueTokensInternal(address _to, uint _tokens) internal {
require(<FILL_ME>)
mntToken.issueTokens(_to,_tokens);
icoTokensSold+=_tokens;
LogBuy(_to,_tokens);
}
// anyone can call this and get his money back
function getMyRefund() public onlyInState(State.Refunding) {
}
function setUsdPerEthRate(uint _usdPerEthRate) public onlyEthSetter {
}
// Default fallback function
function() payable {
}
}
| (icoTokensSold+_tokens)<=ICO_TOKEN_SUPPLY_LIMIT | 19,731 | (icoTokensSold+_tokens)<=ICO_TOKEN_SUPPLY_LIMIT |
null | pragma solidity ^0.4.16;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
}
function safeSub(uint a, uint b) internal returns (uint) {
}
function safeAdd(uint a, uint b) internal returns (uint) {
}
}
// ERC20 standard
// We don't use ERC23 standard
contract StdToken is SafeMath {
// Fields:
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint public totalSupply = 0;
// Events:
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// Functions:
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns(bool){
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool){
}
function balanceOf(address _owner) constant returns (uint256) {
}
function approve(address _spender, uint256 _value) returns (bool) {
}
function allowance(address _owner, address _spender) constant returns (uint256) {
}
modifier onlyPayloadSize(uint _size) {
}
}
contract MNTP is StdToken {
// Fields:
string public constant name = "Goldmint MNT Prelaunch Token";
string public constant symbol = "MNTP";
uint public constant decimals = 18;
address public creator = 0x0;
address public icoContractAddress = 0x0;
bool public lockTransfers = false;
// 10 mln
uint public constant TOTAL_TOKEN_SUPPLY = 10000000 * 1 ether;
/// Modifiers:
modifier onlyCreator() {
}
modifier byIcoContract() {
}
function setCreator(address _creator) onlyCreator {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
// Functions:
function MNTP() {
}
/// @dev Override
function transfer(address _to, uint256 _value) public returns(bool){
}
/// @dev Override
function transferFrom(address _from, address _to, uint256 _value) public returns(bool){
}
function issueTokens(address _who, uint _tokens) byIcoContract {
}
// For refunds only
function burnTokens(address _who, uint _tokens) byIcoContract {
}
function lockTransfer(bool _lock) byIcoContract {
}
// Do not allow to send money directly to this contract
function() {
}
}
// This contract will hold all tokens that were unsold during ICO.
//
// Goldmint Team should be able to withdraw them and sell only after 1 year is passed after
// ICO is finished.
contract GoldmintUnsold is SafeMath {
address public creator;
address public teamAccountAddress;
address public icoContractAddress;
uint64 public icoIsFinishedDate;
MNTP public mntToken;
function GoldmintUnsold(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
modifier onlyIcoContract() {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
function finishIco() public onlyIcoContract {
}
// can be called by anyone...
function withdrawTokens() public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
contract FoundersVesting is SafeMath {
address public creator;
address public teamAccountAddress;
uint64 public lastWithdrawTime;
uint public withdrawsCount = 0;
uint public amountToSend = 0;
MNTP public mntToken;
function FoundersVesting(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
function withdrawTokens() onlyCreator public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
// This is the main Goldmint ICO smart contract
contract Goldmint is SafeMath {
// Constants:
// These values are HARD CODED!!!
// For extra security we split single multisig wallet into 10 separate multisig wallets
//
// THIS IS A REAL ICO WALLETS!!!
// PLEASE DOUBLE CHECK THAT...
address[] public multisigs = [
0xcEc42E247097C276Ad3D7cFd270aDBd562dA5c61,
0x373C46c544662B8C5D55c24Cf4F9a5020163eC2f,
0x672CF829272339A6c8c11b14Acc5F9d07bAFAC7c,
0xce0e1981A19a57aE808a7575a6738e4527fB9118,
0x93Aa76cdb17EeA80e4De983108ef575D8fc8f12b,
0x20ae3329Cd1e35FEfF7115B46218c9D056d430Fd,
0xe9fC1A57a5dC1CaA3DE22A940E9F09e640615f7E,
0xD360433950DE9F6FA0e93C29425845EeD6BFA0d0,
0xF0De97EAff5D6c998c80e07746c81a336e1BBd43,
0xF4Ce80097bf1E584822dBcA84f91D5d7d9df0846
];
// We count ETH invested by person, for refunds (see below)
mapping(address => uint) ethInvestedBy;
uint collectedWei = 0;
// These can be changed before ICO starts ($7USD/MNTP)
uint constant STD_PRICE_USD_PER_1000_TOKENS = 7000;
// The USD/ETH exchange rate may be changed every hour and can vary from $100 to $700 depending on the market. The exchange rate is retrieved from coinmarketcap.com site and is rounded to $1 dollar. For example if current marketcap price is $306.123 per ETH, the price is set as $306 to the contract.
uint public usdPerEthCoinmarketcapRate = 300;
uint64 public lastUsdPerEthChangeDate = 0;
// Price changes from block to block
uint constant SINGLE_BLOCK_LEN = 700000;
// 1 000 000 tokens
uint public constant BONUS_REWARD = 1000000 * 1 ether;
// 2 000 000 tokens
uint public constant FOUNDERS_REWARD = 2000000 * 1 ether;
// 7 000 000 is sold during the ICO
uint public constant ICO_TOKEN_SUPPLY_LIMIT = 7000000 * 1 ether;
// 150 000 tokens soft cap (otherwise - refund)
uint public constant ICO_TOKEN_SOFT_CAP = 150000 * 1 ether;
// 3 000 000 can be issued from other currencies
uint public constant MAX_ISSUED_FROM_OTHER_CURRENCIES = 3000000 * 1 ether;
// 30 000 MNTP tokens per one call only
uint public constant MAX_SINGLE_ISSUED_FROM_OTHER_CURRENCIES = 30000 * 1 ether;
uint public issuedFromOtherCurrencies = 0;
// Fields:
address public creator = 0x0; // can not be changed after deploy
address public ethRateChanger = 0x0; // can not be changed after deploy
address public tokenManager = 0x0; // can be changed by token manager only
address public otherCurrenciesChecker = 0x0; // can not be changed after deploy
uint64 public icoStartedTime = 0;
MNTP public mntToken;
GoldmintUnsold public unsoldContract;
// Total amount of tokens sold during ICO
uint public icoTokensSold = 0;
// Total amount of tokens sent to GoldmintUnsold contract after ICO is finished
uint public icoTokensUnsold = 0;
// Total number of tokens that were issued by a scripts
uint public issuedExternallyTokens = 0;
// This is where FOUNDERS_REWARD will be allocated
address public foundersRewardsAccount = 0x0;
enum State{
Init,
ICORunning,
ICOPaused,
// Collected ETH is transferred to multisigs.
// Unsold tokens transferred to GoldmintUnsold contract.
ICOFinished,
// We start to refund if Soft Cap is not reached.
// Then each token holder should request a refund personally from his
// personal wallet.
//
// We will return ETHs only to the original address. If your address is changed
// or you have lost your keys -> you will not be able to get a refund.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Refunding,
// In this state we lock all MNT tokens forever.
// We are going to migrate MNTP -> MNT tokens during this stage.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Migrating
}
State public currentState = State.Init;
// Modifiers:
modifier onlyCreator() {
}
modifier onlyTokenManager() {
}
modifier onlyOtherCurrenciesChecker() {
}
modifier onlyEthSetter() {
}
modifier onlyInState(State state){
}
// Events:
event LogStateSwitch(State newState);
event LogBuy(address indexed owner, uint value);
event LogBurn(address indexed owner, uint value);
// Functions:
/// @dev Constructor
function Goldmint(
address _tokenManager,
address _ethRateChanger,
address _otherCurrenciesChecker,
address _mntTokenAddress,
address _unsoldContractAddress,
address _foundersVestingAddress)
{
}
function startICO() public onlyCreator onlyInState(State.Init) {
}
function pauseICO() public onlyCreator onlyInState(State.ICORunning) {
}
function resumeICO() public onlyCreator onlyInState(State.ICOPaused) {
}
function startRefunding() public onlyCreator onlyInState(State.ICORunning) {
}
function startMigration() public onlyCreator onlyInState(State.ICOFinished) {
}
/// @dev This function can be called by creator at any time,
/// or by anyone if ICO has really finished.
function finishICO() public onlyInState(State.ICORunning) {
}
function setState(State _s) internal {
}
// Access methods:
function setTokenManager(address _new) public onlyTokenManager {
}
// TODO: stealing creator's key means stealing otherCurrenciesChecker key too!
/*
function setOtherCurrenciesChecker(address _new) public onlyCreator {
otherCurrenciesChecker = _new;
}
*/
// These are used by frontend so we can not remove them
function getTokensIcoSold() constant public returns (uint){
}
function getTotalIcoTokens() constant public returns (uint){
}
function getMntTokenBalance(address _of) constant public returns (uint){
}
function getBlockLength()constant public returns (uint){
}
function getCurrentPrice()constant public returns (uint){
}
function getTotalCollectedWei()constant public returns (uint){
}
/////////////////////////////
function isIcoFinished() constant public returns(bool) {
}
function getMntTokensPerEth(uint _tokensSold) public constant returns (uint){
}
function buyTokens(address _buyer) public payable onlyInState(State.ICORunning) {
}
/// @dev This is called by other currency processors to issue new tokens
function issueTokensFromOtherCurrency(address _to, uint _weiCount) onlyInState(State.ICORunning) public onlyOtherCurrenciesChecker {
}
/// @dev This can be called to manually issue new tokens
/// from the bonus reward
function issueTokensExternal(address _to, uint _tokens) public onlyTokenManager {
}
function issueTokensInternal(address _to, uint _tokens) internal {
}
// anyone can call this and get his money back
function getMyRefund() public onlyInState(State.Refunding) {
}
function setUsdPerEthRate(uint _usdPerEthRate) public onlyEthSetter {
// 1 - check
require(<FILL_ME>)
uint64 hoursPassed = lastUsdPerEthChangeDate + 1 hours;
require(uint(now) >= hoursPassed);
// 2 - update
usdPerEthCoinmarketcapRate = _usdPerEthRate;
lastUsdPerEthChangeDate = uint64(now);
}
// Default fallback function
function() payable {
}
}
| (_usdPerEthRate>=100)&&(_usdPerEthRate<=700) | 19,731 | (_usdPerEthRate>=100)&&(_usdPerEthRate<=700) |
null | pragma solidity ^0.4.16;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
}
function safeSub(uint a, uint b) internal returns (uint) {
}
function safeAdd(uint a, uint b) internal returns (uint) {
}
}
// ERC20 standard
// We don't use ERC23 standard
contract StdToken is SafeMath {
// Fields:
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint public totalSupply = 0;
// Events:
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// Functions:
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns(bool){
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool){
}
function balanceOf(address _owner) constant returns (uint256) {
}
function approve(address _spender, uint256 _value) returns (bool) {
}
function allowance(address _owner, address _spender) constant returns (uint256) {
}
modifier onlyPayloadSize(uint _size) {
}
}
contract MNTP is StdToken {
// Fields:
string public constant name = "Goldmint MNT Prelaunch Token";
string public constant symbol = "MNTP";
uint public constant decimals = 18;
address public creator = 0x0;
address public icoContractAddress = 0x0;
bool public lockTransfers = false;
// 10 mln
uint public constant TOTAL_TOKEN_SUPPLY = 10000000 * 1 ether;
/// Modifiers:
modifier onlyCreator() {
}
modifier byIcoContract() {
}
function setCreator(address _creator) onlyCreator {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
// Functions:
function MNTP() {
}
/// @dev Override
function transfer(address _to, uint256 _value) public returns(bool){
}
/// @dev Override
function transferFrom(address _from, address _to, uint256 _value) public returns(bool){
}
function issueTokens(address _who, uint _tokens) byIcoContract {
}
// For refunds only
function burnTokens(address _who, uint _tokens) byIcoContract {
}
function lockTransfer(bool _lock) byIcoContract {
}
// Do not allow to send money directly to this contract
function() {
}
}
// This contract will hold all tokens that were unsold during ICO.
//
// Goldmint Team should be able to withdraw them and sell only after 1 year is passed after
// ICO is finished.
contract GoldmintUnsold is SafeMath {
address public creator;
address public teamAccountAddress;
address public icoContractAddress;
uint64 public icoIsFinishedDate;
MNTP public mntToken;
function GoldmintUnsold(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
modifier onlyIcoContract() {
}
// Setters/Getters
function setIcoContractAddress(address _icoContractAddress) onlyCreator {
}
function finishIco() public onlyIcoContract {
}
// can be called by anyone...
function withdrawTokens() public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
contract FoundersVesting is SafeMath {
address public creator;
address public teamAccountAddress;
uint64 public lastWithdrawTime;
uint public withdrawsCount = 0;
uint public amountToSend = 0;
MNTP public mntToken;
function FoundersVesting(address _teamAccountAddress,address _mntTokenAddress){
}
modifier onlyCreator() {
}
function withdrawTokens() onlyCreator public {
}
// Do not allow to send money directly to this contract
function() payable {
}
}
// This is the main Goldmint ICO smart contract
contract Goldmint is SafeMath {
// Constants:
// These values are HARD CODED!!!
// For extra security we split single multisig wallet into 10 separate multisig wallets
//
// THIS IS A REAL ICO WALLETS!!!
// PLEASE DOUBLE CHECK THAT...
address[] public multisigs = [
0xcEc42E247097C276Ad3D7cFd270aDBd562dA5c61,
0x373C46c544662B8C5D55c24Cf4F9a5020163eC2f,
0x672CF829272339A6c8c11b14Acc5F9d07bAFAC7c,
0xce0e1981A19a57aE808a7575a6738e4527fB9118,
0x93Aa76cdb17EeA80e4De983108ef575D8fc8f12b,
0x20ae3329Cd1e35FEfF7115B46218c9D056d430Fd,
0xe9fC1A57a5dC1CaA3DE22A940E9F09e640615f7E,
0xD360433950DE9F6FA0e93C29425845EeD6BFA0d0,
0xF0De97EAff5D6c998c80e07746c81a336e1BBd43,
0xF4Ce80097bf1E584822dBcA84f91D5d7d9df0846
];
// We count ETH invested by person, for refunds (see below)
mapping(address => uint) ethInvestedBy;
uint collectedWei = 0;
// These can be changed before ICO starts ($7USD/MNTP)
uint constant STD_PRICE_USD_PER_1000_TOKENS = 7000;
// The USD/ETH exchange rate may be changed every hour and can vary from $100 to $700 depending on the market. The exchange rate is retrieved from coinmarketcap.com site and is rounded to $1 dollar. For example if current marketcap price is $306.123 per ETH, the price is set as $306 to the contract.
uint public usdPerEthCoinmarketcapRate = 300;
uint64 public lastUsdPerEthChangeDate = 0;
// Price changes from block to block
uint constant SINGLE_BLOCK_LEN = 700000;
// 1 000 000 tokens
uint public constant BONUS_REWARD = 1000000 * 1 ether;
// 2 000 000 tokens
uint public constant FOUNDERS_REWARD = 2000000 * 1 ether;
// 7 000 000 is sold during the ICO
uint public constant ICO_TOKEN_SUPPLY_LIMIT = 7000000 * 1 ether;
// 150 000 tokens soft cap (otherwise - refund)
uint public constant ICO_TOKEN_SOFT_CAP = 150000 * 1 ether;
// 3 000 000 can be issued from other currencies
uint public constant MAX_ISSUED_FROM_OTHER_CURRENCIES = 3000000 * 1 ether;
// 30 000 MNTP tokens per one call only
uint public constant MAX_SINGLE_ISSUED_FROM_OTHER_CURRENCIES = 30000 * 1 ether;
uint public issuedFromOtherCurrencies = 0;
// Fields:
address public creator = 0x0; // can not be changed after deploy
address public ethRateChanger = 0x0; // can not be changed after deploy
address public tokenManager = 0x0; // can be changed by token manager only
address public otherCurrenciesChecker = 0x0; // can not be changed after deploy
uint64 public icoStartedTime = 0;
MNTP public mntToken;
GoldmintUnsold public unsoldContract;
// Total amount of tokens sold during ICO
uint public icoTokensSold = 0;
// Total amount of tokens sent to GoldmintUnsold contract after ICO is finished
uint public icoTokensUnsold = 0;
// Total number of tokens that were issued by a scripts
uint public issuedExternallyTokens = 0;
// This is where FOUNDERS_REWARD will be allocated
address public foundersRewardsAccount = 0x0;
enum State{
Init,
ICORunning,
ICOPaused,
// Collected ETH is transferred to multisigs.
// Unsold tokens transferred to GoldmintUnsold contract.
ICOFinished,
// We start to refund if Soft Cap is not reached.
// Then each token holder should request a refund personally from his
// personal wallet.
//
// We will return ETHs only to the original address. If your address is changed
// or you have lost your keys -> you will not be able to get a refund.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Refunding,
// In this state we lock all MNT tokens forever.
// We are going to migrate MNTP -> MNT tokens during this stage.
//
// There is no any possibility to transfer tokens
// There is no any possibility to move back
Migrating
}
State public currentState = State.Init;
// Modifiers:
modifier onlyCreator() {
}
modifier onlyTokenManager() {
}
modifier onlyOtherCurrenciesChecker() {
}
modifier onlyEthSetter() {
}
modifier onlyInState(State state){
}
// Events:
event LogStateSwitch(State newState);
event LogBuy(address indexed owner, uint value);
event LogBurn(address indexed owner, uint value);
// Functions:
/// @dev Constructor
function Goldmint(
address _tokenManager,
address _ethRateChanger,
address _otherCurrenciesChecker,
address _mntTokenAddress,
address _unsoldContractAddress,
address _foundersVestingAddress)
{
}
function startICO() public onlyCreator onlyInState(State.Init) {
}
function pauseICO() public onlyCreator onlyInState(State.ICORunning) {
}
function resumeICO() public onlyCreator onlyInState(State.ICOPaused) {
}
function startRefunding() public onlyCreator onlyInState(State.ICORunning) {
}
function startMigration() public onlyCreator onlyInState(State.ICOFinished) {
}
/// @dev This function can be called by creator at any time,
/// or by anyone if ICO has really finished.
function finishICO() public onlyInState(State.ICORunning) {
}
function setState(State _s) internal {
}
// Access methods:
function setTokenManager(address _new) public onlyTokenManager {
}
// TODO: stealing creator's key means stealing otherCurrenciesChecker key too!
/*
function setOtherCurrenciesChecker(address _new) public onlyCreator {
otherCurrenciesChecker = _new;
}
*/
// These are used by frontend so we can not remove them
function getTokensIcoSold() constant public returns (uint){
}
function getTotalIcoTokens() constant public returns (uint){
}
function getMntTokenBalance(address _of) constant public returns (uint){
}
function getBlockLength()constant public returns (uint){
}
function getCurrentPrice()constant public returns (uint){
}
function getTotalCollectedWei()constant public returns (uint){
}
/////////////////////////////
function isIcoFinished() constant public returns(bool) {
}
function getMntTokensPerEth(uint _tokensSold) public constant returns (uint){
}
function buyTokens(address _buyer) public payable onlyInState(State.ICORunning) {
}
/// @dev This is called by other currency processors to issue new tokens
function issueTokensFromOtherCurrency(address _to, uint _weiCount) onlyInState(State.ICORunning) public onlyOtherCurrenciesChecker {
}
/// @dev This can be called to manually issue new tokens
/// from the bonus reward
function issueTokensExternal(address _to, uint _tokens) public onlyTokenManager {
}
function issueTokensInternal(address _to, uint _tokens) internal {
}
// anyone can call this and get his money back
function getMyRefund() public onlyInState(State.Refunding) {
}
function setUsdPerEthRate(uint _usdPerEthRate) public onlyEthSetter {
// 1 - check
require((_usdPerEthRate>=100) && (_usdPerEthRate<=700));
uint64 hoursPassed = lastUsdPerEthChangeDate + 1 hours;
require(<FILL_ME>)
// 2 - update
usdPerEthCoinmarketcapRate = _usdPerEthRate;
lastUsdPerEthChangeDate = uint64(now);
}
// Default fallback function
function() payable {
}
}
| uint(now)>=hoursPassed | 19,731 | uint(now)>=hoursPassed |
"HIVE:ADD TO WAITING ROOM:ONLY BEES CONTRACT" | // SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ICryptoBees.sol";
import "./IHoney.sol";
import "./IHive.sol";
import "./IAttack.sol";
contract Hive is IHive, Ownable, IERC721Receiver, Pausable {
using Strings for uint256;
using Strings for uint48;
using Strings for uint32;
using Strings for uint16;
using Strings for uint8;
event AddedToHive(address indexed owner, uint256 indexed hiveId, uint256 tokenId, uint256 timestamp);
event AddedToWaitingRoom(address indexed owner, uint256 indexed tokenId, uint256 timestamp);
event RemovedFromWaitingRoom(address indexed owner, uint256 indexed tokenId, uint256 timestamp);
event TokenClaimed(address indexed owner, uint256 indexed tokenId, uint256 earned);
event HiveRestarted(uint256 indexed hiveId);
event HiveFull(address indexed owner, uint256 hiveId, uint256 tokenId, uint256 timestamp);
// contract references
ICryptoBees beesContract;
IAttack attackContract;
// maps tokenId to hives
mapping(uint256 => BeeHive) public hives;
mapping(uint256 => Bee) public waitingRoom;
// bee must have stay 1 day in the hive
uint256 public constant MINIMUM_TO_EXIT = 1 days;
// number of Bees staked
uint256 public totalBeesStaked;
// hive to stake in
uint256 public availableHive;
// extra hives above minted / 100
uint256 public extraHives = 2;
// emergency rescue to allow unstaking without any checks but without $HONEY
bool public rescueEnabled = false;
constructor() {}
function setContracts(address _BEES, address _ATTACK) external onlyOwner {
}
/** STAKING */
/**
* calculates how much $honey a bee got so far
* it's progressive based on the hive age
* it's precalculated off chain to save gas
*/
// how much a hive creates honey each day of it's life
uint16[] accDaily = [400, 480, 576, 690, 830, 1000, 1200];
uint16[] accCombined = [400, 880, 1456, 2146, 2976, 3976, 5176];
function calculateAccumulation(uint256 start, uint256 end) internal view returns (uint256 owed) {
}
function calculateBeeOwed(uint256 hiveId, uint256 tokenId) public view returns (uint256 owed) {
}
/**
* stakes an unknown Token type
* @param account the address of the staker
* @param tokenId the ID of the Token to add
*/
function addToWaitingRoom(address account, uint256 tokenId) external whenNotPaused {
require(<FILL_ME>)
waitingRoom[tokenId] = Bee({owner: account, tokenId: uint16(tokenId), index: 0, since: uint48(block.timestamp)});
emit AddedToWaitingRoom(account, tokenId, block.timestamp);
}
/**
* either unstakes or adds to hive
* @param tokenId the ID of the token
*/
function removeFromWaitingRoom(uint256 tokenId, uint256 hiveId) external whenNotPaused {
}
/**
* adds Bees to the Hive
* @param account the address of the staker
* @param tokenIds the IDs of the Bees
* @param hiveIds the IDs of the Hives
*/
function addManyToHive(
address account,
uint16[] calldata tokenIds,
uint16[] calldata hiveIds
) external whenNotPaused {
}
/**
* adds a single Bee to a specific Hive
* @param account the address of the staker
* @param tokenId the ID of the Bee to add
* @param hiveId the ID of the Hive
*/
function _addBeeToHive(
address account,
uint256 tokenId,
uint256 hiveId
) internal {
}
/** CLAIMING / UNSTAKING */
/**
* change hive or unstake and realize $HONEY earnings
* it requires it has 1 day worth of $HONEY unclaimed
* @param tokenIds the IDs of the tokens to claim earnings from
* @param hiveIds the IDs of the Hives for each Bee
* @param newHiveIds the IDs of new Hives (or to unstake if it's -1)
*/
function claimManyFromHive(
uint16[] calldata tokenIds,
uint16[] calldata hiveIds,
uint16[] calldata newHiveIds
) external whenNotPaused {
}
/**
* change hive or unstake and realize $HONEY earnings
* @param tokenId the ID of the Bee to claim earnings from
* @param hiveId the ID of the Hive where the Bee is
* @param newHiveId the ID of the Hive where the Bee want to go (-1 for unstake)
* @return owed - the amount of $HONEY earned
*/
function _claimBeeFromHive(
uint256 tokenId,
uint256 hiveId,
uint256 newHiveId
) internal returns (uint256 owed) {
}
// GETTERS / SETTERS
function getLastStolenHoneyTimestamp(uint256 hiveId) external view returns (uint256 lastStolenHoneyTimestamp) {
}
function getHiveProtectionBears(uint256 hiveId) external view returns (uint256 hiveProtectionBears) {
}
function isHiveProtectedFromKeepers(uint256 hiveId) external view returns (bool) {
}
function getHiveOccupancy(uint256 hiveId) external view returns (uint256 occupancy) {
}
function getBeeSinceTimestamp(uint256 hiveId, uint256 tokenId) external view returns (uint256 since) {
}
function getBeeTokenId(uint256 hiveId, uint256 index) external view returns (uint256 tokenId) {
}
function setBeeSince(
uint256 hiveId,
uint256 tokenId,
uint48 since
) external {
}
function incSuccessfulAttacks(uint256 hiveId) external {
}
function incTotalAttacks(uint256 hiveId) external {
}
function setBearAttackData(
uint256 hiveId,
uint32 timestamp,
uint32 protection
) external {
}
function setKeeperAttackData(
uint256 hiveId,
uint32 timestamp,
uint32 collected,
uint32 collectedPerBee
) external {
}
function resetHive(uint256 hiveId) external {
}
/** ADMIN */
function setRescueEnabled(bool _enabled) external onlyOwner {
}
function setExtraHives(uint256 _extra) external onlyOwner {
}
function setPaused(bool _paused) external onlyOwner {
}
function setAvailableHive(uint256 _hiveId) external onlyOwner {
}
/** READ ONLY */
function getInfoOnBee(uint256 tokenId, uint256 hiveId) public view returns (Bee memory) {
}
function getHiveAge(uint256 hiveId) external view returns (uint32) {
}
function getHiveSuccessfulAttacks(uint256 hiveId) external view returns (uint8) {
}
function getWaitingRoomOwner(uint256 tokenId) external view returns (address) {
}
function getInfoOnHive(uint256 hiveId) public view returns (string memory) {
}
function getInfoOnHives(uint256 _start, uint256 _to) public view returns (string memory) {
}
function onERC721Received(
address,
address from,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| _msgSender()==address(beesContract),"HIVE:ADD TO WAITING ROOM:ONLY BEES CONTRACT" | 19,752 | _msgSender()==address(beesContract) |
"CANNOT REMOVE UNREVEALED TOKEN" | // SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ICryptoBees.sol";
import "./IHoney.sol";
import "./IHive.sol";
import "./IAttack.sol";
contract Hive is IHive, Ownable, IERC721Receiver, Pausable {
using Strings for uint256;
using Strings for uint48;
using Strings for uint32;
using Strings for uint16;
using Strings for uint8;
event AddedToHive(address indexed owner, uint256 indexed hiveId, uint256 tokenId, uint256 timestamp);
event AddedToWaitingRoom(address indexed owner, uint256 indexed tokenId, uint256 timestamp);
event RemovedFromWaitingRoom(address indexed owner, uint256 indexed tokenId, uint256 timestamp);
event TokenClaimed(address indexed owner, uint256 indexed tokenId, uint256 earned);
event HiveRestarted(uint256 indexed hiveId);
event HiveFull(address indexed owner, uint256 hiveId, uint256 tokenId, uint256 timestamp);
// contract references
ICryptoBees beesContract;
IAttack attackContract;
// maps tokenId to hives
mapping(uint256 => BeeHive) public hives;
mapping(uint256 => Bee) public waitingRoom;
// bee must have stay 1 day in the hive
uint256 public constant MINIMUM_TO_EXIT = 1 days;
// number of Bees staked
uint256 public totalBeesStaked;
// hive to stake in
uint256 public availableHive;
// extra hives above minted / 100
uint256 public extraHives = 2;
// emergency rescue to allow unstaking without any checks but without $HONEY
bool public rescueEnabled = false;
constructor() {}
function setContracts(address _BEES, address _ATTACK) external onlyOwner {
}
/** STAKING */
/**
* calculates how much $honey a bee got so far
* it's progressive based on the hive age
* it's precalculated off chain to save gas
*/
// how much a hive creates honey each day of it's life
uint16[] accDaily = [400, 480, 576, 690, 830, 1000, 1200];
uint16[] accCombined = [400, 880, 1456, 2146, 2976, 3976, 5176];
function calculateAccumulation(uint256 start, uint256 end) internal view returns (uint256 owed) {
}
function calculateBeeOwed(uint256 hiveId, uint256 tokenId) public view returns (uint256 owed) {
}
/**
* stakes an unknown Token type
* @param account the address of the staker
* @param tokenId the ID of the Token to add
*/
function addToWaitingRoom(address account, uint256 tokenId) external whenNotPaused {
}
/**
* either unstakes or adds to hive
* @param tokenId the ID of the token
*/
function removeFromWaitingRoom(uint256 tokenId, uint256 hiveId) external whenNotPaused {
Bee memory token = waitingRoom[tokenId];
if (token.tokenId > 0 && beesContract.getTokenData(token.tokenId)._type == 1) {
if (availableHive != 0 && hiveId == 0 && hives[availableHive].beesArray.length < 100) hiveId = availableHive;
if (hiveId == 0) {
uint256 totalHives = ((beesContract.getMinted() / 100) + extraHives);
for (uint256 i = 1; i <= totalHives; i++) {
if (hives[i].beesArray.length < 100) {
hiveId = i;
availableHive = i;
break;
}
}
}
_addBeeToHive(token.owner, tokenId, hiveId);
delete waitingRoom[tokenId];
} else if (token.tokenId > 0 && beesContract.getTokenData(token.tokenId)._type > 1) {
beesContract.performSafeTransferFrom(address(this), _msgSender(), tokenId); // send the bear/beekeeper back
delete waitingRoom[tokenId];
emit TokenClaimed(_msgSender(), tokenId, 0);
} else if (token.tokenId > 0) {
require(<FILL_ME>)
beesContract.performSafeTransferFrom(address(this), _msgSender(), tokenId); // send the bear/beekeeper back
delete waitingRoom[tokenId];
emit TokenClaimed(_msgSender(), tokenId, 0);
}
}
/**
* adds Bees to the Hive
* @param account the address of the staker
* @param tokenIds the IDs of the Bees
* @param hiveIds the IDs of the Hives
*/
function addManyToHive(
address account,
uint16[] calldata tokenIds,
uint16[] calldata hiveIds
) external whenNotPaused {
}
/**
* adds a single Bee to a specific Hive
* @param account the address of the staker
* @param tokenId the ID of the Bee to add
* @param hiveId the ID of the Hive
*/
function _addBeeToHive(
address account,
uint256 tokenId,
uint256 hiveId
) internal {
}
/** CLAIMING / UNSTAKING */
/**
* change hive or unstake and realize $HONEY earnings
* it requires it has 1 day worth of $HONEY unclaimed
* @param tokenIds the IDs of the tokens to claim earnings from
* @param hiveIds the IDs of the Hives for each Bee
* @param newHiveIds the IDs of new Hives (or to unstake if it's -1)
*/
function claimManyFromHive(
uint16[] calldata tokenIds,
uint16[] calldata hiveIds,
uint16[] calldata newHiveIds
) external whenNotPaused {
}
/**
* change hive or unstake and realize $HONEY earnings
* @param tokenId the ID of the Bee to claim earnings from
* @param hiveId the ID of the Hive where the Bee is
* @param newHiveId the ID of the Hive where the Bee want to go (-1 for unstake)
* @return owed - the amount of $HONEY earned
*/
function _claimBeeFromHive(
uint256 tokenId,
uint256 hiveId,
uint256 newHiveId
) internal returns (uint256 owed) {
}
// GETTERS / SETTERS
function getLastStolenHoneyTimestamp(uint256 hiveId) external view returns (uint256 lastStolenHoneyTimestamp) {
}
function getHiveProtectionBears(uint256 hiveId) external view returns (uint256 hiveProtectionBears) {
}
function isHiveProtectedFromKeepers(uint256 hiveId) external view returns (bool) {
}
function getHiveOccupancy(uint256 hiveId) external view returns (uint256 occupancy) {
}
function getBeeSinceTimestamp(uint256 hiveId, uint256 tokenId) external view returns (uint256 since) {
}
function getBeeTokenId(uint256 hiveId, uint256 index) external view returns (uint256 tokenId) {
}
function setBeeSince(
uint256 hiveId,
uint256 tokenId,
uint48 since
) external {
}
function incSuccessfulAttacks(uint256 hiveId) external {
}
function incTotalAttacks(uint256 hiveId) external {
}
function setBearAttackData(
uint256 hiveId,
uint32 timestamp,
uint32 protection
) external {
}
function setKeeperAttackData(
uint256 hiveId,
uint32 timestamp,
uint32 collected,
uint32 collectedPerBee
) external {
}
function resetHive(uint256 hiveId) external {
}
/** ADMIN */
function setRescueEnabled(bool _enabled) external onlyOwner {
}
function setExtraHives(uint256 _extra) external onlyOwner {
}
function setPaused(bool _paused) external onlyOwner {
}
function setAvailableHive(uint256 _hiveId) external onlyOwner {
}
/** READ ONLY */
function getInfoOnBee(uint256 tokenId, uint256 hiveId) public view returns (Bee memory) {
}
function getHiveAge(uint256 hiveId) external view returns (uint32) {
}
function getHiveSuccessfulAttacks(uint256 hiveId) external view returns (uint8) {
}
function getWaitingRoomOwner(uint256 tokenId) external view returns (address) {
}
function getInfoOnHive(uint256 hiveId) public view returns (string memory) {
}
function getInfoOnHives(uint256 _start, uint256 _to) public view returns (string memory) {
}
function onERC721Received(
address,
address from,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| _msgSender()==owner()||token.owner==_msgSender(),"CANNOT REMOVE UNREVEALED TOKEN" | 19,752 | _msgSender()==owner()||token.owner==_msgSender() |
"TOKEN MUST BE A BEE" | // SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ICryptoBees.sol";
import "./IHoney.sol";
import "./IHive.sol";
import "./IAttack.sol";
contract Hive is IHive, Ownable, IERC721Receiver, Pausable {
using Strings for uint256;
using Strings for uint48;
using Strings for uint32;
using Strings for uint16;
using Strings for uint8;
event AddedToHive(address indexed owner, uint256 indexed hiveId, uint256 tokenId, uint256 timestamp);
event AddedToWaitingRoom(address indexed owner, uint256 indexed tokenId, uint256 timestamp);
event RemovedFromWaitingRoom(address indexed owner, uint256 indexed tokenId, uint256 timestamp);
event TokenClaimed(address indexed owner, uint256 indexed tokenId, uint256 earned);
event HiveRestarted(uint256 indexed hiveId);
event HiveFull(address indexed owner, uint256 hiveId, uint256 tokenId, uint256 timestamp);
// contract references
ICryptoBees beesContract;
IAttack attackContract;
// maps tokenId to hives
mapping(uint256 => BeeHive) public hives;
mapping(uint256 => Bee) public waitingRoom;
// bee must have stay 1 day in the hive
uint256 public constant MINIMUM_TO_EXIT = 1 days;
// number of Bees staked
uint256 public totalBeesStaked;
// hive to stake in
uint256 public availableHive;
// extra hives above minted / 100
uint256 public extraHives = 2;
// emergency rescue to allow unstaking without any checks but without $HONEY
bool public rescueEnabled = false;
constructor() {}
function setContracts(address _BEES, address _ATTACK) external onlyOwner {
}
/** STAKING */
/**
* calculates how much $honey a bee got so far
* it's progressive based on the hive age
* it's precalculated off chain to save gas
*/
// how much a hive creates honey each day of it's life
uint16[] accDaily = [400, 480, 576, 690, 830, 1000, 1200];
uint16[] accCombined = [400, 880, 1456, 2146, 2976, 3976, 5176];
function calculateAccumulation(uint256 start, uint256 end) internal view returns (uint256 owed) {
}
function calculateBeeOwed(uint256 hiveId, uint256 tokenId) public view returns (uint256 owed) {
}
/**
* stakes an unknown Token type
* @param account the address of the staker
* @param tokenId the ID of the Token to add
*/
function addToWaitingRoom(address account, uint256 tokenId) external whenNotPaused {
}
/**
* either unstakes or adds to hive
* @param tokenId the ID of the token
*/
function removeFromWaitingRoom(uint256 tokenId, uint256 hiveId) external whenNotPaused {
}
/**
* adds Bees to the Hive
* @param account the address of the staker
* @param tokenIds the IDs of the Bees
* @param hiveIds the IDs of the Hives
*/
function addManyToHive(
address account,
uint16[] calldata tokenIds,
uint16[] calldata hiveIds
) external whenNotPaused {
require(account == _msgSender() || _msgSender() == address(beesContract), "DONT GIVE YOUR TOKENS AWAY");
require(tokenIds.length == hiveIds.length, "THE ARGUMENTS LENGTHS DO NOT MATCH");
uint256 totalHives = ((beesContract.getMinted() / 100) + extraHives);
for (uint256 i = 0; i < tokenIds.length; i++) {
require(<FILL_ME>)
require(totalHives >= hiveIds[i], "HIVE NOT AVAILABLE");
// dont do this step if its a mint + stake
if (_msgSender() != address(beesContract)) {
require(beesContract.getOwnerOf(tokenIds[i]) == _msgSender(), "AINT YO TOKEN");
beesContract.performTransferFrom(_msgSender(), address(this), tokenIds[i]);
}
_addBeeToHive(account, tokenIds[i], hiveIds[i]);
}
}
/**
* adds a single Bee to a specific Hive
* @param account the address of the staker
* @param tokenId the ID of the Bee to add
* @param hiveId the ID of the Hive
*/
function _addBeeToHive(
address account,
uint256 tokenId,
uint256 hiveId
) internal {
}
/** CLAIMING / UNSTAKING */
/**
* change hive or unstake and realize $HONEY earnings
* it requires it has 1 day worth of $HONEY unclaimed
* @param tokenIds the IDs of the tokens to claim earnings from
* @param hiveIds the IDs of the Hives for each Bee
* @param newHiveIds the IDs of new Hives (or to unstake if it's -1)
*/
function claimManyFromHive(
uint16[] calldata tokenIds,
uint16[] calldata hiveIds,
uint16[] calldata newHiveIds
) external whenNotPaused {
}
/**
* change hive or unstake and realize $HONEY earnings
* @param tokenId the ID of the Bee to claim earnings from
* @param hiveId the ID of the Hive where the Bee is
* @param newHiveId the ID of the Hive where the Bee want to go (-1 for unstake)
* @return owed - the amount of $HONEY earned
*/
function _claimBeeFromHive(
uint256 tokenId,
uint256 hiveId,
uint256 newHiveId
) internal returns (uint256 owed) {
}
// GETTERS / SETTERS
function getLastStolenHoneyTimestamp(uint256 hiveId) external view returns (uint256 lastStolenHoneyTimestamp) {
}
function getHiveProtectionBears(uint256 hiveId) external view returns (uint256 hiveProtectionBears) {
}
function isHiveProtectedFromKeepers(uint256 hiveId) external view returns (bool) {
}
function getHiveOccupancy(uint256 hiveId) external view returns (uint256 occupancy) {
}
function getBeeSinceTimestamp(uint256 hiveId, uint256 tokenId) external view returns (uint256 since) {
}
function getBeeTokenId(uint256 hiveId, uint256 index) external view returns (uint256 tokenId) {
}
function setBeeSince(
uint256 hiveId,
uint256 tokenId,
uint48 since
) external {
}
function incSuccessfulAttacks(uint256 hiveId) external {
}
function incTotalAttacks(uint256 hiveId) external {
}
function setBearAttackData(
uint256 hiveId,
uint32 timestamp,
uint32 protection
) external {
}
function setKeeperAttackData(
uint256 hiveId,
uint32 timestamp,
uint32 collected,
uint32 collectedPerBee
) external {
}
function resetHive(uint256 hiveId) external {
}
/** ADMIN */
function setRescueEnabled(bool _enabled) external onlyOwner {
}
function setExtraHives(uint256 _extra) external onlyOwner {
}
function setPaused(bool _paused) external onlyOwner {
}
function setAvailableHive(uint256 _hiveId) external onlyOwner {
}
/** READ ONLY */
function getInfoOnBee(uint256 tokenId, uint256 hiveId) public view returns (Bee memory) {
}
function getHiveAge(uint256 hiveId) external view returns (uint32) {
}
function getHiveSuccessfulAttacks(uint256 hiveId) external view returns (uint8) {
}
function getWaitingRoomOwner(uint256 tokenId) external view returns (address) {
}
function getInfoOnHive(uint256 hiveId) public view returns (string memory) {
}
function getInfoOnHives(uint256 _start, uint256 _to) public view returns (string memory) {
}
function onERC721Received(
address,
address from,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| beesContract.getTokenData(tokenIds[i])._type==1,"TOKEN MUST BE A BEE" | 19,752 | beesContract.getTokenData(tokenIds[i])._type==1 |
"AINT YO TOKEN" | // SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ICryptoBees.sol";
import "./IHoney.sol";
import "./IHive.sol";
import "./IAttack.sol";
contract Hive is IHive, Ownable, IERC721Receiver, Pausable {
using Strings for uint256;
using Strings for uint48;
using Strings for uint32;
using Strings for uint16;
using Strings for uint8;
event AddedToHive(address indexed owner, uint256 indexed hiveId, uint256 tokenId, uint256 timestamp);
event AddedToWaitingRoom(address indexed owner, uint256 indexed tokenId, uint256 timestamp);
event RemovedFromWaitingRoom(address indexed owner, uint256 indexed tokenId, uint256 timestamp);
event TokenClaimed(address indexed owner, uint256 indexed tokenId, uint256 earned);
event HiveRestarted(uint256 indexed hiveId);
event HiveFull(address indexed owner, uint256 hiveId, uint256 tokenId, uint256 timestamp);
// contract references
ICryptoBees beesContract;
IAttack attackContract;
// maps tokenId to hives
mapping(uint256 => BeeHive) public hives;
mapping(uint256 => Bee) public waitingRoom;
// bee must have stay 1 day in the hive
uint256 public constant MINIMUM_TO_EXIT = 1 days;
// number of Bees staked
uint256 public totalBeesStaked;
// hive to stake in
uint256 public availableHive;
// extra hives above minted / 100
uint256 public extraHives = 2;
// emergency rescue to allow unstaking without any checks but without $HONEY
bool public rescueEnabled = false;
constructor() {}
function setContracts(address _BEES, address _ATTACK) external onlyOwner {
}
/** STAKING */
/**
* calculates how much $honey a bee got so far
* it's progressive based on the hive age
* it's precalculated off chain to save gas
*/
// how much a hive creates honey each day of it's life
uint16[] accDaily = [400, 480, 576, 690, 830, 1000, 1200];
uint16[] accCombined = [400, 880, 1456, 2146, 2976, 3976, 5176];
function calculateAccumulation(uint256 start, uint256 end) internal view returns (uint256 owed) {
}
function calculateBeeOwed(uint256 hiveId, uint256 tokenId) public view returns (uint256 owed) {
}
/**
* stakes an unknown Token type
* @param account the address of the staker
* @param tokenId the ID of the Token to add
*/
function addToWaitingRoom(address account, uint256 tokenId) external whenNotPaused {
}
/**
* either unstakes or adds to hive
* @param tokenId the ID of the token
*/
function removeFromWaitingRoom(uint256 tokenId, uint256 hiveId) external whenNotPaused {
}
/**
* adds Bees to the Hive
* @param account the address of the staker
* @param tokenIds the IDs of the Bees
* @param hiveIds the IDs of the Hives
*/
function addManyToHive(
address account,
uint16[] calldata tokenIds,
uint16[] calldata hiveIds
) external whenNotPaused {
require(account == _msgSender() || _msgSender() == address(beesContract), "DONT GIVE YOUR TOKENS AWAY");
require(tokenIds.length == hiveIds.length, "THE ARGUMENTS LENGTHS DO NOT MATCH");
uint256 totalHives = ((beesContract.getMinted() / 100) + extraHives);
for (uint256 i = 0; i < tokenIds.length; i++) {
require(beesContract.getTokenData(tokenIds[i])._type == 1, "TOKEN MUST BE A BEE");
require(totalHives >= hiveIds[i], "HIVE NOT AVAILABLE");
// dont do this step if its a mint + stake
if (_msgSender() != address(beesContract)) {
require(<FILL_ME>)
beesContract.performTransferFrom(_msgSender(), address(this), tokenIds[i]);
}
_addBeeToHive(account, tokenIds[i], hiveIds[i]);
}
}
/**
* adds a single Bee to a specific Hive
* @param account the address of the staker
* @param tokenId the ID of the Bee to add
* @param hiveId the ID of the Hive
*/
function _addBeeToHive(
address account,
uint256 tokenId,
uint256 hiveId
) internal {
}
/** CLAIMING / UNSTAKING */
/**
* change hive or unstake and realize $HONEY earnings
* it requires it has 1 day worth of $HONEY unclaimed
* @param tokenIds the IDs of the tokens to claim earnings from
* @param hiveIds the IDs of the Hives for each Bee
* @param newHiveIds the IDs of new Hives (or to unstake if it's -1)
*/
function claimManyFromHive(
uint16[] calldata tokenIds,
uint16[] calldata hiveIds,
uint16[] calldata newHiveIds
) external whenNotPaused {
}
/**
* change hive or unstake and realize $HONEY earnings
* @param tokenId the ID of the Bee to claim earnings from
* @param hiveId the ID of the Hive where the Bee is
* @param newHiveId the ID of the Hive where the Bee want to go (-1 for unstake)
* @return owed - the amount of $HONEY earned
*/
function _claimBeeFromHive(
uint256 tokenId,
uint256 hiveId,
uint256 newHiveId
) internal returns (uint256 owed) {
}
// GETTERS / SETTERS
function getLastStolenHoneyTimestamp(uint256 hiveId) external view returns (uint256 lastStolenHoneyTimestamp) {
}
function getHiveProtectionBears(uint256 hiveId) external view returns (uint256 hiveProtectionBears) {
}
function isHiveProtectedFromKeepers(uint256 hiveId) external view returns (bool) {
}
function getHiveOccupancy(uint256 hiveId) external view returns (uint256 occupancy) {
}
function getBeeSinceTimestamp(uint256 hiveId, uint256 tokenId) external view returns (uint256 since) {
}
function getBeeTokenId(uint256 hiveId, uint256 index) external view returns (uint256 tokenId) {
}
function setBeeSince(
uint256 hiveId,
uint256 tokenId,
uint48 since
) external {
}
function incSuccessfulAttacks(uint256 hiveId) external {
}
function incTotalAttacks(uint256 hiveId) external {
}
function setBearAttackData(
uint256 hiveId,
uint32 timestamp,
uint32 protection
) external {
}
function setKeeperAttackData(
uint256 hiveId,
uint32 timestamp,
uint32 collected,
uint32 collectedPerBee
) external {
}
function resetHive(uint256 hiveId) external {
}
/** ADMIN */
function setRescueEnabled(bool _enabled) external onlyOwner {
}
function setExtraHives(uint256 _extra) external onlyOwner {
}
function setPaused(bool _paused) external onlyOwner {
}
function setAvailableHive(uint256 _hiveId) external onlyOwner {
}
/** READ ONLY */
function getInfoOnBee(uint256 tokenId, uint256 hiveId) public view returns (Bee memory) {
}
function getHiveAge(uint256 hiveId) external view returns (uint32) {
}
function getHiveSuccessfulAttacks(uint256 hiveId) external view returns (uint8) {
}
function getWaitingRoomOwner(uint256 tokenId) external view returns (address) {
}
function getInfoOnHive(uint256 hiveId) public view returns (string memory) {
}
function getInfoOnHives(uint256 _start, uint256 _to) public view returns (string memory) {
}
function onERC721Received(
address,
address from,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| beesContract.getOwnerOf(tokenIds[i])==_msgSender(),"AINT YO TOKEN" | 19,752 | beesContract.getOwnerOf(tokenIds[i])==_msgSender() |
"YOU NEED MORE HONEY TO GET OUT OF THE HIVE" | // SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ICryptoBees.sol";
import "./IHoney.sol";
import "./IHive.sol";
import "./IAttack.sol";
contract Hive is IHive, Ownable, IERC721Receiver, Pausable {
using Strings for uint256;
using Strings for uint48;
using Strings for uint32;
using Strings for uint16;
using Strings for uint8;
event AddedToHive(address indexed owner, uint256 indexed hiveId, uint256 tokenId, uint256 timestamp);
event AddedToWaitingRoom(address indexed owner, uint256 indexed tokenId, uint256 timestamp);
event RemovedFromWaitingRoom(address indexed owner, uint256 indexed tokenId, uint256 timestamp);
event TokenClaimed(address indexed owner, uint256 indexed tokenId, uint256 earned);
event HiveRestarted(uint256 indexed hiveId);
event HiveFull(address indexed owner, uint256 hiveId, uint256 tokenId, uint256 timestamp);
// contract references
ICryptoBees beesContract;
IAttack attackContract;
// maps tokenId to hives
mapping(uint256 => BeeHive) public hives;
mapping(uint256 => Bee) public waitingRoom;
// bee must have stay 1 day in the hive
uint256 public constant MINIMUM_TO_EXIT = 1 days;
// number of Bees staked
uint256 public totalBeesStaked;
// hive to stake in
uint256 public availableHive;
// extra hives above minted / 100
uint256 public extraHives = 2;
// emergency rescue to allow unstaking without any checks but without $HONEY
bool public rescueEnabled = false;
constructor() {}
function setContracts(address _BEES, address _ATTACK) external onlyOwner {
}
/** STAKING */
/**
* calculates how much $honey a bee got so far
* it's progressive based on the hive age
* it's precalculated off chain to save gas
*/
// how much a hive creates honey each day of it's life
uint16[] accDaily = [400, 480, 576, 690, 830, 1000, 1200];
uint16[] accCombined = [400, 880, 1456, 2146, 2976, 3976, 5176];
function calculateAccumulation(uint256 start, uint256 end) internal view returns (uint256 owed) {
}
function calculateBeeOwed(uint256 hiveId, uint256 tokenId) public view returns (uint256 owed) {
}
/**
* stakes an unknown Token type
* @param account the address of the staker
* @param tokenId the ID of the Token to add
*/
function addToWaitingRoom(address account, uint256 tokenId) external whenNotPaused {
}
/**
* either unstakes or adds to hive
* @param tokenId the ID of the token
*/
function removeFromWaitingRoom(uint256 tokenId, uint256 hiveId) external whenNotPaused {
}
/**
* adds Bees to the Hive
* @param account the address of the staker
* @param tokenIds the IDs of the Bees
* @param hiveIds the IDs of the Hives
*/
function addManyToHive(
address account,
uint16[] calldata tokenIds,
uint16[] calldata hiveIds
) external whenNotPaused {
}
/**
* adds a single Bee to a specific Hive
* @param account the address of the staker
* @param tokenId the ID of the Bee to add
* @param hiveId the ID of the Hive
*/
function _addBeeToHive(
address account,
uint256 tokenId,
uint256 hiveId
) internal {
}
/** CLAIMING / UNSTAKING */
/**
* change hive or unstake and realize $HONEY earnings
* it requires it has 1 day worth of $HONEY unclaimed
* @param tokenIds the IDs of the tokens to claim earnings from
* @param hiveIds the IDs of the Hives for each Bee
* @param newHiveIds the IDs of new Hives (or to unstake if it's -1)
*/
function claimManyFromHive(
uint16[] calldata tokenIds,
uint16[] calldata hiveIds,
uint16[] calldata newHiveIds
) external whenNotPaused {
}
/**
* change hive or unstake and realize $HONEY earnings
* @param tokenId the ID of the Bee to claim earnings from
* @param hiveId the ID of the Hive where the Bee is
* @param newHiveId the ID of the Hive where the Bee want to go (-1 for unstake)
* @return owed - the amount of $HONEY earned
*/
function _claimBeeFromHive(
uint256 tokenId,
uint256 hiveId,
uint256 newHiveId
) internal returns (uint256 owed) {
Bee memory bee = hives[hiveId].bees[tokenId];
require(bee.owner == _msgSender(), "YOU ARE NOT THE OWNER");
if (!rescueEnabled) {
require(<FILL_ME>)
}
owed = calculateBeeOwed(hiveId, tokenId);
beesContract.increaseTokensPot(bee.owner, owed);
if (newHiveId == 0) {
beesContract.performSafeTransferFrom(address(this), _msgSender(), tokenId); // send the bee back
uint256 index = hives[hiveId].bees[tokenId].index;
if (index != hives[hiveId].beesArray.length - 1) {
uint256 lastIndex = hives[hiveId].beesArray.length - 1;
uint256 lastTokenIndex = hives[hiveId].beesArray[lastIndex];
hives[hiveId].beesArray[index] = uint16(lastTokenIndex);
hives[hiveId].bees[lastTokenIndex].index = uint8(index);
}
hives[hiveId].beesArray.pop();
delete hives[hiveId].bees[tokenId];
totalBeesStaked -= 1;
emit TokenClaimed(_msgSender(), tokenId, owed);
} else if (hives[newHiveId].beesArray.length < 100) {
uint256 index = hives[hiveId].bees[tokenId].index;
if (index != hives[hiveId].beesArray.length - 1) {
uint256 lastIndex = hives[hiveId].beesArray.length - 1;
uint256 lastTokenIndex = hives[hiveId].beesArray[lastIndex];
hives[hiveId].beesArray[index] = uint16(lastTokenIndex);
hives[hiveId].bees[lastTokenIndex].index = uint8(index);
}
hives[hiveId].beesArray.pop();
delete hives[hiveId].bees[tokenId];
uint256 newIndex = hives[newHiveId].beesArray.length;
hives[newHiveId].bees[tokenId] = Bee({owner: _msgSender(), tokenId: uint16(tokenId), index: uint8(newIndex), since: uint48(block.timestamp)}); // reset stake
if (hives[newHiveId].startedTimestamp == 0) hives[newHiveId].startedTimestamp = uint32(block.timestamp);
hives[newHiveId].beesArray.push(uint16(tokenId));
if (newIndex < 90 && availableHive != newHiveId) {
availableHive = newHiveId;
}
emit AddedToHive(_msgSender(), newHiveId, tokenId, block.timestamp);
} else {
emit HiveFull(_msgSender(), newHiveId, tokenId, block.timestamp);
}
}
// GETTERS / SETTERS
function getLastStolenHoneyTimestamp(uint256 hiveId) external view returns (uint256 lastStolenHoneyTimestamp) {
}
function getHiveProtectionBears(uint256 hiveId) external view returns (uint256 hiveProtectionBears) {
}
function isHiveProtectedFromKeepers(uint256 hiveId) external view returns (bool) {
}
function getHiveOccupancy(uint256 hiveId) external view returns (uint256 occupancy) {
}
function getBeeSinceTimestamp(uint256 hiveId, uint256 tokenId) external view returns (uint256 since) {
}
function getBeeTokenId(uint256 hiveId, uint256 index) external view returns (uint256 tokenId) {
}
function setBeeSince(
uint256 hiveId,
uint256 tokenId,
uint48 since
) external {
}
function incSuccessfulAttacks(uint256 hiveId) external {
}
function incTotalAttacks(uint256 hiveId) external {
}
function setBearAttackData(
uint256 hiveId,
uint32 timestamp,
uint32 protection
) external {
}
function setKeeperAttackData(
uint256 hiveId,
uint32 timestamp,
uint32 collected,
uint32 collectedPerBee
) external {
}
function resetHive(uint256 hiveId) external {
}
/** ADMIN */
function setRescueEnabled(bool _enabled) external onlyOwner {
}
function setExtraHives(uint256 _extra) external onlyOwner {
}
function setPaused(bool _paused) external onlyOwner {
}
function setAvailableHive(uint256 _hiveId) external onlyOwner {
}
/** READ ONLY */
function getInfoOnBee(uint256 tokenId, uint256 hiveId) public view returns (Bee memory) {
}
function getHiveAge(uint256 hiveId) external view returns (uint32) {
}
function getHiveSuccessfulAttacks(uint256 hiveId) external view returns (uint8) {
}
function getWaitingRoomOwner(uint256 tokenId) external view returns (address) {
}
function getInfoOnHive(uint256 hiveId) public view returns (string memory) {
}
function getInfoOnHives(uint256 _start, uint256 _to) public view returns (string memory) {
}
function onERC721Received(
address,
address from,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| block.timestamp-bee.since>MINIMUM_TO_EXIT,"YOU NEED MORE HONEY TO GET OUT OF THE HIVE" | 19,752 | block.timestamp-bee.since>MINIMUM_TO_EXIT |
"ONLY ATTACK CONTRACT CAN CALL THIS" | // SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ICryptoBees.sol";
import "./IHoney.sol";
import "./IHive.sol";
import "./IAttack.sol";
contract Hive is IHive, Ownable, IERC721Receiver, Pausable {
using Strings for uint256;
using Strings for uint48;
using Strings for uint32;
using Strings for uint16;
using Strings for uint8;
event AddedToHive(address indexed owner, uint256 indexed hiveId, uint256 tokenId, uint256 timestamp);
event AddedToWaitingRoom(address indexed owner, uint256 indexed tokenId, uint256 timestamp);
event RemovedFromWaitingRoom(address indexed owner, uint256 indexed tokenId, uint256 timestamp);
event TokenClaimed(address indexed owner, uint256 indexed tokenId, uint256 earned);
event HiveRestarted(uint256 indexed hiveId);
event HiveFull(address indexed owner, uint256 hiveId, uint256 tokenId, uint256 timestamp);
// contract references
ICryptoBees beesContract;
IAttack attackContract;
// maps tokenId to hives
mapping(uint256 => BeeHive) public hives;
mapping(uint256 => Bee) public waitingRoom;
// bee must have stay 1 day in the hive
uint256 public constant MINIMUM_TO_EXIT = 1 days;
// number of Bees staked
uint256 public totalBeesStaked;
// hive to stake in
uint256 public availableHive;
// extra hives above minted / 100
uint256 public extraHives = 2;
// emergency rescue to allow unstaking without any checks but without $HONEY
bool public rescueEnabled = false;
constructor() {}
function setContracts(address _BEES, address _ATTACK) external onlyOwner {
}
/** STAKING */
/**
* calculates how much $honey a bee got so far
* it's progressive based on the hive age
* it's precalculated off chain to save gas
*/
// how much a hive creates honey each day of it's life
uint16[] accDaily = [400, 480, 576, 690, 830, 1000, 1200];
uint16[] accCombined = [400, 880, 1456, 2146, 2976, 3976, 5176];
function calculateAccumulation(uint256 start, uint256 end) internal view returns (uint256 owed) {
}
function calculateBeeOwed(uint256 hiveId, uint256 tokenId) public view returns (uint256 owed) {
}
/**
* stakes an unknown Token type
* @param account the address of the staker
* @param tokenId the ID of the Token to add
*/
function addToWaitingRoom(address account, uint256 tokenId) external whenNotPaused {
}
/**
* either unstakes or adds to hive
* @param tokenId the ID of the token
*/
function removeFromWaitingRoom(uint256 tokenId, uint256 hiveId) external whenNotPaused {
}
/**
* adds Bees to the Hive
* @param account the address of the staker
* @param tokenIds the IDs of the Bees
* @param hiveIds the IDs of the Hives
*/
function addManyToHive(
address account,
uint16[] calldata tokenIds,
uint16[] calldata hiveIds
) external whenNotPaused {
}
/**
* adds a single Bee to a specific Hive
* @param account the address of the staker
* @param tokenId the ID of the Bee to add
* @param hiveId the ID of the Hive
*/
function _addBeeToHive(
address account,
uint256 tokenId,
uint256 hiveId
) internal {
}
/** CLAIMING / UNSTAKING */
/**
* change hive or unstake and realize $HONEY earnings
* it requires it has 1 day worth of $HONEY unclaimed
* @param tokenIds the IDs of the tokens to claim earnings from
* @param hiveIds the IDs of the Hives for each Bee
* @param newHiveIds the IDs of new Hives (or to unstake if it's -1)
*/
function claimManyFromHive(
uint16[] calldata tokenIds,
uint16[] calldata hiveIds,
uint16[] calldata newHiveIds
) external whenNotPaused {
}
/**
* change hive or unstake and realize $HONEY earnings
* @param tokenId the ID of the Bee to claim earnings from
* @param hiveId the ID of the Hive where the Bee is
* @param newHiveId the ID of the Hive where the Bee want to go (-1 for unstake)
* @return owed - the amount of $HONEY earned
*/
function _claimBeeFromHive(
uint256 tokenId,
uint256 hiveId,
uint256 newHiveId
) internal returns (uint256 owed) {
}
// GETTERS / SETTERS
function getLastStolenHoneyTimestamp(uint256 hiveId) external view returns (uint256 lastStolenHoneyTimestamp) {
}
function getHiveProtectionBears(uint256 hiveId) external view returns (uint256 hiveProtectionBears) {
}
function isHiveProtectedFromKeepers(uint256 hiveId) external view returns (bool) {
}
function getHiveOccupancy(uint256 hiveId) external view returns (uint256 occupancy) {
}
function getBeeSinceTimestamp(uint256 hiveId, uint256 tokenId) external view returns (uint256 since) {
}
function getBeeTokenId(uint256 hiveId, uint256 index) external view returns (uint256 tokenId) {
}
function setBeeSince(
uint256 hiveId,
uint256 tokenId,
uint48 since
) external {
require(<FILL_ME>)
hives[hiveId].bees[tokenId].since = since;
}
function incSuccessfulAttacks(uint256 hiveId) external {
}
function incTotalAttacks(uint256 hiveId) external {
}
function setBearAttackData(
uint256 hiveId,
uint32 timestamp,
uint32 protection
) external {
}
function setKeeperAttackData(
uint256 hiveId,
uint32 timestamp,
uint32 collected,
uint32 collectedPerBee
) external {
}
function resetHive(uint256 hiveId) external {
}
/** ADMIN */
function setRescueEnabled(bool _enabled) external onlyOwner {
}
function setExtraHives(uint256 _extra) external onlyOwner {
}
function setPaused(bool _paused) external onlyOwner {
}
function setAvailableHive(uint256 _hiveId) external onlyOwner {
}
/** READ ONLY */
function getInfoOnBee(uint256 tokenId, uint256 hiveId) public view returns (Bee memory) {
}
function getHiveAge(uint256 hiveId) external view returns (uint32) {
}
function getHiveSuccessfulAttacks(uint256 hiveId) external view returns (uint8) {
}
function getWaitingRoomOwner(uint256 tokenId) external view returns (address) {
}
function getInfoOnHive(uint256 hiveId) public view returns (string memory) {
}
function getInfoOnHives(uint256 _start, uint256 _to) public view returns (string memory) {
}
function onERC721Received(
address,
address from,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| _msgSender()==address(attackContract),"ONLY ATTACK CONTRACT CAN CALL THIS" | 19,752 | _msgSender()==address(attackContract) |
"ONLY ATTACK CONTRACT CAN CALL THIS" | // SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ICryptoBees.sol";
import "./IHoney.sol";
import "./IHive.sol";
import "./IAttack.sol";
contract Hive is IHive, Ownable, IERC721Receiver, Pausable {
using Strings for uint256;
using Strings for uint48;
using Strings for uint32;
using Strings for uint16;
using Strings for uint8;
event AddedToHive(address indexed owner, uint256 indexed hiveId, uint256 tokenId, uint256 timestamp);
event AddedToWaitingRoom(address indexed owner, uint256 indexed tokenId, uint256 timestamp);
event RemovedFromWaitingRoom(address indexed owner, uint256 indexed tokenId, uint256 timestamp);
event TokenClaimed(address indexed owner, uint256 indexed tokenId, uint256 earned);
event HiveRestarted(uint256 indexed hiveId);
event HiveFull(address indexed owner, uint256 hiveId, uint256 tokenId, uint256 timestamp);
// contract references
ICryptoBees beesContract;
IAttack attackContract;
// maps tokenId to hives
mapping(uint256 => BeeHive) public hives;
mapping(uint256 => Bee) public waitingRoom;
// bee must have stay 1 day in the hive
uint256 public constant MINIMUM_TO_EXIT = 1 days;
// number of Bees staked
uint256 public totalBeesStaked;
// hive to stake in
uint256 public availableHive;
// extra hives above minted / 100
uint256 public extraHives = 2;
// emergency rescue to allow unstaking without any checks but without $HONEY
bool public rescueEnabled = false;
constructor() {}
function setContracts(address _BEES, address _ATTACK) external onlyOwner {
}
/** STAKING */
/**
* calculates how much $honey a bee got so far
* it's progressive based on the hive age
* it's precalculated off chain to save gas
*/
// how much a hive creates honey each day of it's life
uint16[] accDaily = [400, 480, 576, 690, 830, 1000, 1200];
uint16[] accCombined = [400, 880, 1456, 2146, 2976, 3976, 5176];
function calculateAccumulation(uint256 start, uint256 end) internal view returns (uint256 owed) {
}
function calculateBeeOwed(uint256 hiveId, uint256 tokenId) public view returns (uint256 owed) {
}
/**
* stakes an unknown Token type
* @param account the address of the staker
* @param tokenId the ID of the Token to add
*/
function addToWaitingRoom(address account, uint256 tokenId) external whenNotPaused {
}
/**
* either unstakes or adds to hive
* @param tokenId the ID of the token
*/
function removeFromWaitingRoom(uint256 tokenId, uint256 hiveId) external whenNotPaused {
}
/**
* adds Bees to the Hive
* @param account the address of the staker
* @param tokenIds the IDs of the Bees
* @param hiveIds the IDs of the Hives
*/
function addManyToHive(
address account,
uint16[] calldata tokenIds,
uint16[] calldata hiveIds
) external whenNotPaused {
}
/**
* adds a single Bee to a specific Hive
* @param account the address of the staker
* @param tokenId the ID of the Bee to add
* @param hiveId the ID of the Hive
*/
function _addBeeToHive(
address account,
uint256 tokenId,
uint256 hiveId
) internal {
}
/** CLAIMING / UNSTAKING */
/**
* change hive or unstake and realize $HONEY earnings
* it requires it has 1 day worth of $HONEY unclaimed
* @param tokenIds the IDs of the tokens to claim earnings from
* @param hiveIds the IDs of the Hives for each Bee
* @param newHiveIds the IDs of new Hives (or to unstake if it's -1)
*/
function claimManyFromHive(
uint16[] calldata tokenIds,
uint16[] calldata hiveIds,
uint16[] calldata newHiveIds
) external whenNotPaused {
}
/**
* change hive or unstake and realize $HONEY earnings
* @param tokenId the ID of the Bee to claim earnings from
* @param hiveId the ID of the Hive where the Bee is
* @param newHiveId the ID of the Hive where the Bee want to go (-1 for unstake)
* @return owed - the amount of $HONEY earned
*/
function _claimBeeFromHive(
uint256 tokenId,
uint256 hiveId,
uint256 newHiveId
) internal returns (uint256 owed) {
}
// GETTERS / SETTERS
function getLastStolenHoneyTimestamp(uint256 hiveId) external view returns (uint256 lastStolenHoneyTimestamp) {
}
function getHiveProtectionBears(uint256 hiveId) external view returns (uint256 hiveProtectionBears) {
}
function isHiveProtectedFromKeepers(uint256 hiveId) external view returns (bool) {
}
function getHiveOccupancy(uint256 hiveId) external view returns (uint256 occupancy) {
}
function getBeeSinceTimestamp(uint256 hiveId, uint256 tokenId) external view returns (uint256 since) {
}
function getBeeTokenId(uint256 hiveId, uint256 index) external view returns (uint256 tokenId) {
}
function setBeeSince(
uint256 hiveId,
uint256 tokenId,
uint48 since
) external {
}
function incSuccessfulAttacks(uint256 hiveId) external {
}
function incTotalAttacks(uint256 hiveId) external {
}
function setBearAttackData(
uint256 hiveId,
uint32 timestamp,
uint32 protection
) external {
}
function setKeeperAttackData(
uint256 hiveId,
uint32 timestamp,
uint32 collected,
uint32 collectedPerBee
) external {
}
function resetHive(uint256 hiveId) external {
require(<FILL_ME>)
hives[hiveId].startedTimestamp = uint32(block.timestamp);
hives[hiveId].lastCollectedHoneyTimestamp = 0;
hives[hiveId].hiveProtectionBears = 0;
hives[hiveId].lastStolenHoneyTimestamp = 0;
hives[hiveId].collectionAmount = 0;
hives[hiveId].collectionAmountPerBee = 0;
hives[hiveId].successfulAttacks = 0;
hives[hiveId].totalAttacks = 0;
emit HiveRestarted(hiveId);
}
/** ADMIN */
function setRescueEnabled(bool _enabled) external onlyOwner {
}
function setExtraHives(uint256 _extra) external onlyOwner {
}
function setPaused(bool _paused) external onlyOwner {
}
function setAvailableHive(uint256 _hiveId) external onlyOwner {
}
/** READ ONLY */
function getInfoOnBee(uint256 tokenId, uint256 hiveId) public view returns (Bee memory) {
}
function getHiveAge(uint256 hiveId) external view returns (uint32) {
}
function getHiveSuccessfulAttacks(uint256 hiveId) external view returns (uint8) {
}
function getWaitingRoomOwner(uint256 tokenId) external view returns (address) {
}
function getInfoOnHive(uint256 hiveId) public view returns (string memory) {
}
function getInfoOnHives(uint256 _start, uint256 _to) public view returns (string memory) {
}
function onERC721Received(
address,
address from,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
}
| _msgSender()==address(attackContract)||_msgSender()==owner(),"ONLY ATTACK CONTRACT CAN CALL THIS" | 19,752 | _msgSender()==address(attackContract)||_msgSender()==owner() |
"ORDER_TAKEN_OR_CANCELLED" | /*
Copyright 2020 Swap Holdings Ltd.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/**
* @title Swap: The Atomic Swap used on the AirSwap Network
*/
contract Swap is ISwap {
// Domain and version for use in signatures (EIP-712)
bytes constant internal DOMAIN_NAME = "SWAP";
bytes constant internal DOMAIN_VERSION = "2";
// Unique domain identifier for use in signatures (EIP-712)
bytes32 private _domainSeparator;
// Possible nonce statuses
byte constant internal AVAILABLE = 0x00;
byte constant internal UNAVAILABLE = 0x01;
// Mapping of sender address to a delegated sender address and bool
mapping (address => mapping (address => bool)) public senderAuthorizations;
// Mapping of signer address to a delegated signer and bool
mapping (address => mapping (address => bool)) public signerAuthorizations;
// Mapping of signers to nonces with value AVAILABLE (0x00) or UNAVAILABLE (0x01)
mapping (address => mapping (uint256 => byte)) public signerNonceStatus;
// Mapping of signer addresses to an optionally set minimum valid nonce
mapping (address => uint256) public signerMinimumNonce;
// A registry storing a transfer handler for different token kinds
TransferHandlerRegistry public registry;
/**
* @notice Contract Constructor
* @dev Sets domain for signature validation (EIP-712)
* @param swapRegistry TransferHandlerRegistry
*/
constructor(TransferHandlerRegistry swapRegistry) public {
}
/**
* @notice Atomic Token Swap
* @param order Types.Order Order to settle
*/
function swap(
Types.Order calldata order
) external {
// Ensure the order is not expired.
require(order.expiry > block.timestamp,
"ORDER_EXPIRED");
// Ensure the nonce is AVAILABLE (0x00).
require(<FILL_ME>)
// Ensure the order nonce is above the minimum.
require(order.nonce >= signerMinimumNonce[order.signer.wallet],
"NONCE_TOO_LOW");
// Mark the nonce UNAVAILABLE (0x01).
signerNonceStatus[order.signer.wallet][order.nonce] = UNAVAILABLE;
// Validate the sender side of the trade.
address finalSenderWallet;
if (order.sender.wallet == address(0)) {
/**
* Sender is not specified. The msg.sender of the transaction becomes
* the sender of the order.
*/
finalSenderWallet = msg.sender;
} else {
/**
* Sender is specified. If the msg.sender is not the specified sender,
* this determines whether the msg.sender is an authorized sender.
*/
require(isSenderAuthorized(order.sender.wallet, msg.sender),
"SENDER_UNAUTHORIZED");
// The msg.sender is authorized.
finalSenderWallet = order.sender.wallet;
}
// Validate the signer side of the trade.
if (order.signature.v == 0) {
/**
* Signature is not provided. The signer may have authorized the
* msg.sender to swap on its behalf, which does not require a signature.
*/
require(isSignerAuthorized(order.signer.wallet, msg.sender),
"SIGNER_UNAUTHORIZED");
} else {
/**
* The signature is provided. Determine whether the signer is
* authorized and if so validate the signature itself.
*/
require(isSignerAuthorized(order.signer.wallet, order.signature.signatory),
"SIGNER_UNAUTHORIZED");
// Ensure the signature is valid.
require(isValid(order, _domainSeparator),
"SIGNATURE_INVALID");
}
// Transfer token from sender to signer.
transferToken(
finalSenderWallet,
order.signer.wallet,
order.sender.amount,
order.sender.id,
order.sender.token,
order.sender.kind
);
// Transfer token from signer to sender.
transferToken(
order.signer.wallet,
finalSenderWallet,
order.signer.amount,
order.signer.id,
order.signer.token,
order.signer.kind
);
// Transfer token from signer to affiliate if specified.
if (order.affiliate.token != address(0)) {
transferToken(
order.signer.wallet,
order.affiliate.wallet,
order.affiliate.amount,
order.affiliate.id,
order.affiliate.token,
order.affiliate.kind
);
}
emit Swap(
order.nonce,
block.timestamp,
order.signer.wallet,
order.signer.amount,
order.signer.id,
order.signer.token,
finalSenderWallet,
order.sender.amount,
order.sender.id,
order.sender.token,
order.affiliate.wallet,
order.affiliate.amount,
order.affiliate.id,
order.affiliate.token
);
}
/**
* @notice Cancel one or more open orders by nonce
* @dev Cancelled nonces are marked UNAVAILABLE (0x01)
* @dev Emits a Cancel event
* @dev Out of gas may occur in arrays of length > 400
* @param nonces uint256[] List of nonces to cancel
*/
function cancel(
uint256[] calldata nonces
) external {
}
/**
* @notice Cancels all orders below a nonce value
* @dev Emits a CancelUpTo event
* @param minimumNonce uint256 Minimum valid nonce
*/
function cancelUpTo(
uint256 minimumNonce
) external {
}
/**
* @notice Authorize a delegated sender
* @dev Emits an AuthorizeSender event
* @param authorizedSender address Address to authorize
*/
function authorizeSender(
address authorizedSender
) external {
}
/**
* @notice Authorize a delegated signer
* @dev Emits an AuthorizeSigner event
* @param authorizedSigner address Address to authorize
*/
function authorizeSigner(
address authorizedSigner
) external {
}
/**
* @notice Revoke an authorized sender
* @dev Emits a RevokeSender event
* @param authorizedSender address Address to revoke
*/
function revokeSender(
address authorizedSender
) external {
}
/**
* @notice Revoke an authorized signer
* @dev Emits a RevokeSigner event
* @param authorizedSigner address Address to revoke
*/
function revokeSigner(
address authorizedSigner
) external {
}
/**
* @notice Determine whether a sender delegate is authorized
* @param authorizer address Address doing the authorization
* @param delegate address Address being authorized
* @return bool True if a delegate is authorized to send
*/
function isSenderAuthorized(
address authorizer,
address delegate
) internal view returns (bool) {
}
/**
* @notice Determine whether a signer delegate is authorized
* @param authorizer address Address doing the authorization
* @param delegate address Address being authorized
* @return bool True if a delegate is authorized to sign
*/
function isSignerAuthorized(
address authorizer,
address delegate
) internal view returns (bool) {
}
/**
* @notice Validate signature using an EIP-712 typed data hash
* @param order Types.Order Order to validate
* @param domainSeparator bytes32 Domain identifier used in signatures (EIP-712)
* @return bool True if order has a valid signature
*/
function isValid(
Types.Order memory order,
bytes32 domainSeparator
) internal pure returns (bool) {
}
/**
* @notice Perform token transfer for tokens in registry
* @dev Transfer type specified by the bytes4 kind param
* @dev ERC721: uses transferFrom for transfer
* @dev ERC20: Takes into account non-standard ERC-20 tokens.
* @param from address Wallet address to transfer from
* @param to address Wallet address to transfer to
* @param amount uint256 Amount for ERC-20
* @param id token ID for ERC-721
* @param token address Contract address of token
* @param kind bytes4 EIP-165 interface ID of the token
*/
function transferToken(
address from,
address to,
uint256 amount,
uint256 id,
address token,
bytes4 kind
) internal {
}
}
| signerNonceStatus[order.signer.wallet][order.nonce]==AVAILABLE,"ORDER_TAKEN_OR_CANCELLED" | 19,827 | signerNonceStatus[order.signer.wallet][order.nonce]==AVAILABLE |
"SENDER_UNAUTHORIZED" | /*
Copyright 2020 Swap Holdings Ltd.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/**
* @title Swap: The Atomic Swap used on the AirSwap Network
*/
contract Swap is ISwap {
// Domain and version for use in signatures (EIP-712)
bytes constant internal DOMAIN_NAME = "SWAP";
bytes constant internal DOMAIN_VERSION = "2";
// Unique domain identifier for use in signatures (EIP-712)
bytes32 private _domainSeparator;
// Possible nonce statuses
byte constant internal AVAILABLE = 0x00;
byte constant internal UNAVAILABLE = 0x01;
// Mapping of sender address to a delegated sender address and bool
mapping (address => mapping (address => bool)) public senderAuthorizations;
// Mapping of signer address to a delegated signer and bool
mapping (address => mapping (address => bool)) public signerAuthorizations;
// Mapping of signers to nonces with value AVAILABLE (0x00) or UNAVAILABLE (0x01)
mapping (address => mapping (uint256 => byte)) public signerNonceStatus;
// Mapping of signer addresses to an optionally set minimum valid nonce
mapping (address => uint256) public signerMinimumNonce;
// A registry storing a transfer handler for different token kinds
TransferHandlerRegistry public registry;
/**
* @notice Contract Constructor
* @dev Sets domain for signature validation (EIP-712)
* @param swapRegistry TransferHandlerRegistry
*/
constructor(TransferHandlerRegistry swapRegistry) public {
}
/**
* @notice Atomic Token Swap
* @param order Types.Order Order to settle
*/
function swap(
Types.Order calldata order
) external {
// Ensure the order is not expired.
require(order.expiry > block.timestamp,
"ORDER_EXPIRED");
// Ensure the nonce is AVAILABLE (0x00).
require(signerNonceStatus[order.signer.wallet][order.nonce] == AVAILABLE,
"ORDER_TAKEN_OR_CANCELLED");
// Ensure the order nonce is above the minimum.
require(order.nonce >= signerMinimumNonce[order.signer.wallet],
"NONCE_TOO_LOW");
// Mark the nonce UNAVAILABLE (0x01).
signerNonceStatus[order.signer.wallet][order.nonce] = UNAVAILABLE;
// Validate the sender side of the trade.
address finalSenderWallet;
if (order.sender.wallet == address(0)) {
/**
* Sender is not specified. The msg.sender of the transaction becomes
* the sender of the order.
*/
finalSenderWallet = msg.sender;
} else {
/**
* Sender is specified. If the msg.sender is not the specified sender,
* this determines whether the msg.sender is an authorized sender.
*/
require(<FILL_ME>)
// The msg.sender is authorized.
finalSenderWallet = order.sender.wallet;
}
// Validate the signer side of the trade.
if (order.signature.v == 0) {
/**
* Signature is not provided. The signer may have authorized the
* msg.sender to swap on its behalf, which does not require a signature.
*/
require(isSignerAuthorized(order.signer.wallet, msg.sender),
"SIGNER_UNAUTHORIZED");
} else {
/**
* The signature is provided. Determine whether the signer is
* authorized and if so validate the signature itself.
*/
require(isSignerAuthorized(order.signer.wallet, order.signature.signatory),
"SIGNER_UNAUTHORIZED");
// Ensure the signature is valid.
require(isValid(order, _domainSeparator),
"SIGNATURE_INVALID");
}
// Transfer token from sender to signer.
transferToken(
finalSenderWallet,
order.signer.wallet,
order.sender.amount,
order.sender.id,
order.sender.token,
order.sender.kind
);
// Transfer token from signer to sender.
transferToken(
order.signer.wallet,
finalSenderWallet,
order.signer.amount,
order.signer.id,
order.signer.token,
order.signer.kind
);
// Transfer token from signer to affiliate if specified.
if (order.affiliate.token != address(0)) {
transferToken(
order.signer.wallet,
order.affiliate.wallet,
order.affiliate.amount,
order.affiliate.id,
order.affiliate.token,
order.affiliate.kind
);
}
emit Swap(
order.nonce,
block.timestamp,
order.signer.wallet,
order.signer.amount,
order.signer.id,
order.signer.token,
finalSenderWallet,
order.sender.amount,
order.sender.id,
order.sender.token,
order.affiliate.wallet,
order.affiliate.amount,
order.affiliate.id,
order.affiliate.token
);
}
/**
* @notice Cancel one or more open orders by nonce
* @dev Cancelled nonces are marked UNAVAILABLE (0x01)
* @dev Emits a Cancel event
* @dev Out of gas may occur in arrays of length > 400
* @param nonces uint256[] List of nonces to cancel
*/
function cancel(
uint256[] calldata nonces
) external {
}
/**
* @notice Cancels all orders below a nonce value
* @dev Emits a CancelUpTo event
* @param minimumNonce uint256 Minimum valid nonce
*/
function cancelUpTo(
uint256 minimumNonce
) external {
}
/**
* @notice Authorize a delegated sender
* @dev Emits an AuthorizeSender event
* @param authorizedSender address Address to authorize
*/
function authorizeSender(
address authorizedSender
) external {
}
/**
* @notice Authorize a delegated signer
* @dev Emits an AuthorizeSigner event
* @param authorizedSigner address Address to authorize
*/
function authorizeSigner(
address authorizedSigner
) external {
}
/**
* @notice Revoke an authorized sender
* @dev Emits a RevokeSender event
* @param authorizedSender address Address to revoke
*/
function revokeSender(
address authorizedSender
) external {
}
/**
* @notice Revoke an authorized signer
* @dev Emits a RevokeSigner event
* @param authorizedSigner address Address to revoke
*/
function revokeSigner(
address authorizedSigner
) external {
}
/**
* @notice Determine whether a sender delegate is authorized
* @param authorizer address Address doing the authorization
* @param delegate address Address being authorized
* @return bool True if a delegate is authorized to send
*/
function isSenderAuthorized(
address authorizer,
address delegate
) internal view returns (bool) {
}
/**
* @notice Determine whether a signer delegate is authorized
* @param authorizer address Address doing the authorization
* @param delegate address Address being authorized
* @return bool True if a delegate is authorized to sign
*/
function isSignerAuthorized(
address authorizer,
address delegate
) internal view returns (bool) {
}
/**
* @notice Validate signature using an EIP-712 typed data hash
* @param order Types.Order Order to validate
* @param domainSeparator bytes32 Domain identifier used in signatures (EIP-712)
* @return bool True if order has a valid signature
*/
function isValid(
Types.Order memory order,
bytes32 domainSeparator
) internal pure returns (bool) {
}
/**
* @notice Perform token transfer for tokens in registry
* @dev Transfer type specified by the bytes4 kind param
* @dev ERC721: uses transferFrom for transfer
* @dev ERC20: Takes into account non-standard ERC-20 tokens.
* @param from address Wallet address to transfer from
* @param to address Wallet address to transfer to
* @param amount uint256 Amount for ERC-20
* @param id token ID for ERC-721
* @param token address Contract address of token
* @param kind bytes4 EIP-165 interface ID of the token
*/
function transferToken(
address from,
address to,
uint256 amount,
uint256 id,
address token,
bytes4 kind
) internal {
}
}
| isSenderAuthorized(order.sender.wallet,msg.sender),"SENDER_UNAUTHORIZED" | 19,827 | isSenderAuthorized(order.sender.wallet,msg.sender) |
"SIGNER_UNAUTHORIZED" | /*
Copyright 2020 Swap Holdings Ltd.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/**
* @title Swap: The Atomic Swap used on the AirSwap Network
*/
contract Swap is ISwap {
// Domain and version for use in signatures (EIP-712)
bytes constant internal DOMAIN_NAME = "SWAP";
bytes constant internal DOMAIN_VERSION = "2";
// Unique domain identifier for use in signatures (EIP-712)
bytes32 private _domainSeparator;
// Possible nonce statuses
byte constant internal AVAILABLE = 0x00;
byte constant internal UNAVAILABLE = 0x01;
// Mapping of sender address to a delegated sender address and bool
mapping (address => mapping (address => bool)) public senderAuthorizations;
// Mapping of signer address to a delegated signer and bool
mapping (address => mapping (address => bool)) public signerAuthorizations;
// Mapping of signers to nonces with value AVAILABLE (0x00) or UNAVAILABLE (0x01)
mapping (address => mapping (uint256 => byte)) public signerNonceStatus;
// Mapping of signer addresses to an optionally set minimum valid nonce
mapping (address => uint256) public signerMinimumNonce;
// A registry storing a transfer handler for different token kinds
TransferHandlerRegistry public registry;
/**
* @notice Contract Constructor
* @dev Sets domain for signature validation (EIP-712)
* @param swapRegistry TransferHandlerRegistry
*/
constructor(TransferHandlerRegistry swapRegistry) public {
}
/**
* @notice Atomic Token Swap
* @param order Types.Order Order to settle
*/
function swap(
Types.Order calldata order
) external {
// Ensure the order is not expired.
require(order.expiry > block.timestamp,
"ORDER_EXPIRED");
// Ensure the nonce is AVAILABLE (0x00).
require(signerNonceStatus[order.signer.wallet][order.nonce] == AVAILABLE,
"ORDER_TAKEN_OR_CANCELLED");
// Ensure the order nonce is above the minimum.
require(order.nonce >= signerMinimumNonce[order.signer.wallet],
"NONCE_TOO_LOW");
// Mark the nonce UNAVAILABLE (0x01).
signerNonceStatus[order.signer.wallet][order.nonce] = UNAVAILABLE;
// Validate the sender side of the trade.
address finalSenderWallet;
if (order.sender.wallet == address(0)) {
/**
* Sender is not specified. The msg.sender of the transaction becomes
* the sender of the order.
*/
finalSenderWallet = msg.sender;
} else {
/**
* Sender is specified. If the msg.sender is not the specified sender,
* this determines whether the msg.sender is an authorized sender.
*/
require(isSenderAuthorized(order.sender.wallet, msg.sender),
"SENDER_UNAUTHORIZED");
// The msg.sender is authorized.
finalSenderWallet = order.sender.wallet;
}
// Validate the signer side of the trade.
if (order.signature.v == 0) {
/**
* Signature is not provided. The signer may have authorized the
* msg.sender to swap on its behalf, which does not require a signature.
*/
require(<FILL_ME>)
} else {
/**
* The signature is provided. Determine whether the signer is
* authorized and if so validate the signature itself.
*/
require(isSignerAuthorized(order.signer.wallet, order.signature.signatory),
"SIGNER_UNAUTHORIZED");
// Ensure the signature is valid.
require(isValid(order, _domainSeparator),
"SIGNATURE_INVALID");
}
// Transfer token from sender to signer.
transferToken(
finalSenderWallet,
order.signer.wallet,
order.sender.amount,
order.sender.id,
order.sender.token,
order.sender.kind
);
// Transfer token from signer to sender.
transferToken(
order.signer.wallet,
finalSenderWallet,
order.signer.amount,
order.signer.id,
order.signer.token,
order.signer.kind
);
// Transfer token from signer to affiliate if specified.
if (order.affiliate.token != address(0)) {
transferToken(
order.signer.wallet,
order.affiliate.wallet,
order.affiliate.amount,
order.affiliate.id,
order.affiliate.token,
order.affiliate.kind
);
}
emit Swap(
order.nonce,
block.timestamp,
order.signer.wallet,
order.signer.amount,
order.signer.id,
order.signer.token,
finalSenderWallet,
order.sender.amount,
order.sender.id,
order.sender.token,
order.affiliate.wallet,
order.affiliate.amount,
order.affiliate.id,
order.affiliate.token
);
}
/**
* @notice Cancel one or more open orders by nonce
* @dev Cancelled nonces are marked UNAVAILABLE (0x01)
* @dev Emits a Cancel event
* @dev Out of gas may occur in arrays of length > 400
* @param nonces uint256[] List of nonces to cancel
*/
function cancel(
uint256[] calldata nonces
) external {
}
/**
* @notice Cancels all orders below a nonce value
* @dev Emits a CancelUpTo event
* @param minimumNonce uint256 Minimum valid nonce
*/
function cancelUpTo(
uint256 minimumNonce
) external {
}
/**
* @notice Authorize a delegated sender
* @dev Emits an AuthorizeSender event
* @param authorizedSender address Address to authorize
*/
function authorizeSender(
address authorizedSender
) external {
}
/**
* @notice Authorize a delegated signer
* @dev Emits an AuthorizeSigner event
* @param authorizedSigner address Address to authorize
*/
function authorizeSigner(
address authorizedSigner
) external {
}
/**
* @notice Revoke an authorized sender
* @dev Emits a RevokeSender event
* @param authorizedSender address Address to revoke
*/
function revokeSender(
address authorizedSender
) external {
}
/**
* @notice Revoke an authorized signer
* @dev Emits a RevokeSigner event
* @param authorizedSigner address Address to revoke
*/
function revokeSigner(
address authorizedSigner
) external {
}
/**
* @notice Determine whether a sender delegate is authorized
* @param authorizer address Address doing the authorization
* @param delegate address Address being authorized
* @return bool True if a delegate is authorized to send
*/
function isSenderAuthorized(
address authorizer,
address delegate
) internal view returns (bool) {
}
/**
* @notice Determine whether a signer delegate is authorized
* @param authorizer address Address doing the authorization
* @param delegate address Address being authorized
* @return bool True if a delegate is authorized to sign
*/
function isSignerAuthorized(
address authorizer,
address delegate
) internal view returns (bool) {
}
/**
* @notice Validate signature using an EIP-712 typed data hash
* @param order Types.Order Order to validate
* @param domainSeparator bytes32 Domain identifier used in signatures (EIP-712)
* @return bool True if order has a valid signature
*/
function isValid(
Types.Order memory order,
bytes32 domainSeparator
) internal pure returns (bool) {
}
/**
* @notice Perform token transfer for tokens in registry
* @dev Transfer type specified by the bytes4 kind param
* @dev ERC721: uses transferFrom for transfer
* @dev ERC20: Takes into account non-standard ERC-20 tokens.
* @param from address Wallet address to transfer from
* @param to address Wallet address to transfer to
* @param amount uint256 Amount for ERC-20
* @param id token ID for ERC-721
* @param token address Contract address of token
* @param kind bytes4 EIP-165 interface ID of the token
*/
function transferToken(
address from,
address to,
uint256 amount,
uint256 id,
address token,
bytes4 kind
) internal {
}
}
| isSignerAuthorized(order.signer.wallet,msg.sender),"SIGNER_UNAUTHORIZED" | 19,827 | isSignerAuthorized(order.signer.wallet,msg.sender) |
"SIGNER_UNAUTHORIZED" | /*
Copyright 2020 Swap Holdings Ltd.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/**
* @title Swap: The Atomic Swap used on the AirSwap Network
*/
contract Swap is ISwap {
// Domain and version for use in signatures (EIP-712)
bytes constant internal DOMAIN_NAME = "SWAP";
bytes constant internal DOMAIN_VERSION = "2";
// Unique domain identifier for use in signatures (EIP-712)
bytes32 private _domainSeparator;
// Possible nonce statuses
byte constant internal AVAILABLE = 0x00;
byte constant internal UNAVAILABLE = 0x01;
// Mapping of sender address to a delegated sender address and bool
mapping (address => mapping (address => bool)) public senderAuthorizations;
// Mapping of signer address to a delegated signer and bool
mapping (address => mapping (address => bool)) public signerAuthorizations;
// Mapping of signers to nonces with value AVAILABLE (0x00) or UNAVAILABLE (0x01)
mapping (address => mapping (uint256 => byte)) public signerNonceStatus;
// Mapping of signer addresses to an optionally set minimum valid nonce
mapping (address => uint256) public signerMinimumNonce;
// A registry storing a transfer handler for different token kinds
TransferHandlerRegistry public registry;
/**
* @notice Contract Constructor
* @dev Sets domain for signature validation (EIP-712)
* @param swapRegistry TransferHandlerRegistry
*/
constructor(TransferHandlerRegistry swapRegistry) public {
}
/**
* @notice Atomic Token Swap
* @param order Types.Order Order to settle
*/
function swap(
Types.Order calldata order
) external {
// Ensure the order is not expired.
require(order.expiry > block.timestamp,
"ORDER_EXPIRED");
// Ensure the nonce is AVAILABLE (0x00).
require(signerNonceStatus[order.signer.wallet][order.nonce] == AVAILABLE,
"ORDER_TAKEN_OR_CANCELLED");
// Ensure the order nonce is above the minimum.
require(order.nonce >= signerMinimumNonce[order.signer.wallet],
"NONCE_TOO_LOW");
// Mark the nonce UNAVAILABLE (0x01).
signerNonceStatus[order.signer.wallet][order.nonce] = UNAVAILABLE;
// Validate the sender side of the trade.
address finalSenderWallet;
if (order.sender.wallet == address(0)) {
/**
* Sender is not specified. The msg.sender of the transaction becomes
* the sender of the order.
*/
finalSenderWallet = msg.sender;
} else {
/**
* Sender is specified. If the msg.sender is not the specified sender,
* this determines whether the msg.sender is an authorized sender.
*/
require(isSenderAuthorized(order.sender.wallet, msg.sender),
"SENDER_UNAUTHORIZED");
// The msg.sender is authorized.
finalSenderWallet = order.sender.wallet;
}
// Validate the signer side of the trade.
if (order.signature.v == 0) {
/**
* Signature is not provided. The signer may have authorized the
* msg.sender to swap on its behalf, which does not require a signature.
*/
require(isSignerAuthorized(order.signer.wallet, msg.sender),
"SIGNER_UNAUTHORIZED");
} else {
/**
* The signature is provided. Determine whether the signer is
* authorized and if so validate the signature itself.
*/
require(<FILL_ME>)
// Ensure the signature is valid.
require(isValid(order, _domainSeparator),
"SIGNATURE_INVALID");
}
// Transfer token from sender to signer.
transferToken(
finalSenderWallet,
order.signer.wallet,
order.sender.amount,
order.sender.id,
order.sender.token,
order.sender.kind
);
// Transfer token from signer to sender.
transferToken(
order.signer.wallet,
finalSenderWallet,
order.signer.amount,
order.signer.id,
order.signer.token,
order.signer.kind
);
// Transfer token from signer to affiliate if specified.
if (order.affiliate.token != address(0)) {
transferToken(
order.signer.wallet,
order.affiliate.wallet,
order.affiliate.amount,
order.affiliate.id,
order.affiliate.token,
order.affiliate.kind
);
}
emit Swap(
order.nonce,
block.timestamp,
order.signer.wallet,
order.signer.amount,
order.signer.id,
order.signer.token,
finalSenderWallet,
order.sender.amount,
order.sender.id,
order.sender.token,
order.affiliate.wallet,
order.affiliate.amount,
order.affiliate.id,
order.affiliate.token
);
}
/**
* @notice Cancel one or more open orders by nonce
* @dev Cancelled nonces are marked UNAVAILABLE (0x01)
* @dev Emits a Cancel event
* @dev Out of gas may occur in arrays of length > 400
* @param nonces uint256[] List of nonces to cancel
*/
function cancel(
uint256[] calldata nonces
) external {
}
/**
* @notice Cancels all orders below a nonce value
* @dev Emits a CancelUpTo event
* @param minimumNonce uint256 Minimum valid nonce
*/
function cancelUpTo(
uint256 minimumNonce
) external {
}
/**
* @notice Authorize a delegated sender
* @dev Emits an AuthorizeSender event
* @param authorizedSender address Address to authorize
*/
function authorizeSender(
address authorizedSender
) external {
}
/**
* @notice Authorize a delegated signer
* @dev Emits an AuthorizeSigner event
* @param authorizedSigner address Address to authorize
*/
function authorizeSigner(
address authorizedSigner
) external {
}
/**
* @notice Revoke an authorized sender
* @dev Emits a RevokeSender event
* @param authorizedSender address Address to revoke
*/
function revokeSender(
address authorizedSender
) external {
}
/**
* @notice Revoke an authorized signer
* @dev Emits a RevokeSigner event
* @param authorizedSigner address Address to revoke
*/
function revokeSigner(
address authorizedSigner
) external {
}
/**
* @notice Determine whether a sender delegate is authorized
* @param authorizer address Address doing the authorization
* @param delegate address Address being authorized
* @return bool True if a delegate is authorized to send
*/
function isSenderAuthorized(
address authorizer,
address delegate
) internal view returns (bool) {
}
/**
* @notice Determine whether a signer delegate is authorized
* @param authorizer address Address doing the authorization
* @param delegate address Address being authorized
* @return bool True if a delegate is authorized to sign
*/
function isSignerAuthorized(
address authorizer,
address delegate
) internal view returns (bool) {
}
/**
* @notice Validate signature using an EIP-712 typed data hash
* @param order Types.Order Order to validate
* @param domainSeparator bytes32 Domain identifier used in signatures (EIP-712)
* @return bool True if order has a valid signature
*/
function isValid(
Types.Order memory order,
bytes32 domainSeparator
) internal pure returns (bool) {
}
/**
* @notice Perform token transfer for tokens in registry
* @dev Transfer type specified by the bytes4 kind param
* @dev ERC721: uses transferFrom for transfer
* @dev ERC20: Takes into account non-standard ERC-20 tokens.
* @param from address Wallet address to transfer from
* @param to address Wallet address to transfer to
* @param amount uint256 Amount for ERC-20
* @param id token ID for ERC-721
* @param token address Contract address of token
* @param kind bytes4 EIP-165 interface ID of the token
*/
function transferToken(
address from,
address to,
uint256 amount,
uint256 id,
address token,
bytes4 kind
) internal {
}
}
| isSignerAuthorized(order.signer.wallet,order.signature.signatory),"SIGNER_UNAUTHORIZED" | 19,827 | isSignerAuthorized(order.signer.wallet,order.signature.signatory) |
"SIGNATURE_INVALID" | /*
Copyright 2020 Swap Holdings Ltd.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/**
* @title Swap: The Atomic Swap used on the AirSwap Network
*/
contract Swap is ISwap {
// Domain and version for use in signatures (EIP-712)
bytes constant internal DOMAIN_NAME = "SWAP";
bytes constant internal DOMAIN_VERSION = "2";
// Unique domain identifier for use in signatures (EIP-712)
bytes32 private _domainSeparator;
// Possible nonce statuses
byte constant internal AVAILABLE = 0x00;
byte constant internal UNAVAILABLE = 0x01;
// Mapping of sender address to a delegated sender address and bool
mapping (address => mapping (address => bool)) public senderAuthorizations;
// Mapping of signer address to a delegated signer and bool
mapping (address => mapping (address => bool)) public signerAuthorizations;
// Mapping of signers to nonces with value AVAILABLE (0x00) or UNAVAILABLE (0x01)
mapping (address => mapping (uint256 => byte)) public signerNonceStatus;
// Mapping of signer addresses to an optionally set minimum valid nonce
mapping (address => uint256) public signerMinimumNonce;
// A registry storing a transfer handler for different token kinds
TransferHandlerRegistry public registry;
/**
* @notice Contract Constructor
* @dev Sets domain for signature validation (EIP-712)
* @param swapRegistry TransferHandlerRegistry
*/
constructor(TransferHandlerRegistry swapRegistry) public {
}
/**
* @notice Atomic Token Swap
* @param order Types.Order Order to settle
*/
function swap(
Types.Order calldata order
) external {
// Ensure the order is not expired.
require(order.expiry > block.timestamp,
"ORDER_EXPIRED");
// Ensure the nonce is AVAILABLE (0x00).
require(signerNonceStatus[order.signer.wallet][order.nonce] == AVAILABLE,
"ORDER_TAKEN_OR_CANCELLED");
// Ensure the order nonce is above the minimum.
require(order.nonce >= signerMinimumNonce[order.signer.wallet],
"NONCE_TOO_LOW");
// Mark the nonce UNAVAILABLE (0x01).
signerNonceStatus[order.signer.wallet][order.nonce] = UNAVAILABLE;
// Validate the sender side of the trade.
address finalSenderWallet;
if (order.sender.wallet == address(0)) {
/**
* Sender is not specified. The msg.sender of the transaction becomes
* the sender of the order.
*/
finalSenderWallet = msg.sender;
} else {
/**
* Sender is specified. If the msg.sender is not the specified sender,
* this determines whether the msg.sender is an authorized sender.
*/
require(isSenderAuthorized(order.sender.wallet, msg.sender),
"SENDER_UNAUTHORIZED");
// The msg.sender is authorized.
finalSenderWallet = order.sender.wallet;
}
// Validate the signer side of the trade.
if (order.signature.v == 0) {
/**
* Signature is not provided. The signer may have authorized the
* msg.sender to swap on its behalf, which does not require a signature.
*/
require(isSignerAuthorized(order.signer.wallet, msg.sender),
"SIGNER_UNAUTHORIZED");
} else {
/**
* The signature is provided. Determine whether the signer is
* authorized and if so validate the signature itself.
*/
require(isSignerAuthorized(order.signer.wallet, order.signature.signatory),
"SIGNER_UNAUTHORIZED");
// Ensure the signature is valid.
require(<FILL_ME>)
}
// Transfer token from sender to signer.
transferToken(
finalSenderWallet,
order.signer.wallet,
order.sender.amount,
order.sender.id,
order.sender.token,
order.sender.kind
);
// Transfer token from signer to sender.
transferToken(
order.signer.wallet,
finalSenderWallet,
order.signer.amount,
order.signer.id,
order.signer.token,
order.signer.kind
);
// Transfer token from signer to affiliate if specified.
if (order.affiliate.token != address(0)) {
transferToken(
order.signer.wallet,
order.affiliate.wallet,
order.affiliate.amount,
order.affiliate.id,
order.affiliate.token,
order.affiliate.kind
);
}
emit Swap(
order.nonce,
block.timestamp,
order.signer.wallet,
order.signer.amount,
order.signer.id,
order.signer.token,
finalSenderWallet,
order.sender.amount,
order.sender.id,
order.sender.token,
order.affiliate.wallet,
order.affiliate.amount,
order.affiliate.id,
order.affiliate.token
);
}
/**
* @notice Cancel one or more open orders by nonce
* @dev Cancelled nonces are marked UNAVAILABLE (0x01)
* @dev Emits a Cancel event
* @dev Out of gas may occur in arrays of length > 400
* @param nonces uint256[] List of nonces to cancel
*/
function cancel(
uint256[] calldata nonces
) external {
}
/**
* @notice Cancels all orders below a nonce value
* @dev Emits a CancelUpTo event
* @param minimumNonce uint256 Minimum valid nonce
*/
function cancelUpTo(
uint256 minimumNonce
) external {
}
/**
* @notice Authorize a delegated sender
* @dev Emits an AuthorizeSender event
* @param authorizedSender address Address to authorize
*/
function authorizeSender(
address authorizedSender
) external {
}
/**
* @notice Authorize a delegated signer
* @dev Emits an AuthorizeSigner event
* @param authorizedSigner address Address to authorize
*/
function authorizeSigner(
address authorizedSigner
) external {
}
/**
* @notice Revoke an authorized sender
* @dev Emits a RevokeSender event
* @param authorizedSender address Address to revoke
*/
function revokeSender(
address authorizedSender
) external {
}
/**
* @notice Revoke an authorized signer
* @dev Emits a RevokeSigner event
* @param authorizedSigner address Address to revoke
*/
function revokeSigner(
address authorizedSigner
) external {
}
/**
* @notice Determine whether a sender delegate is authorized
* @param authorizer address Address doing the authorization
* @param delegate address Address being authorized
* @return bool True if a delegate is authorized to send
*/
function isSenderAuthorized(
address authorizer,
address delegate
) internal view returns (bool) {
}
/**
* @notice Determine whether a signer delegate is authorized
* @param authorizer address Address doing the authorization
* @param delegate address Address being authorized
* @return bool True if a delegate is authorized to sign
*/
function isSignerAuthorized(
address authorizer,
address delegate
) internal view returns (bool) {
}
/**
* @notice Validate signature using an EIP-712 typed data hash
* @param order Types.Order Order to validate
* @param domainSeparator bytes32 Domain identifier used in signatures (EIP-712)
* @return bool True if order has a valid signature
*/
function isValid(
Types.Order memory order,
bytes32 domainSeparator
) internal pure returns (bool) {
}
/**
* @notice Perform token transfer for tokens in registry
* @dev Transfer type specified by the bytes4 kind param
* @dev ERC721: uses transferFrom for transfer
* @dev ERC20: Takes into account non-standard ERC-20 tokens.
* @param from address Wallet address to transfer from
* @param to address Wallet address to transfer to
* @param amount uint256 Amount for ERC-20
* @param id token ID for ERC-721
* @param token address Contract address of token
* @param kind bytes4 EIP-165 interface ID of the token
*/
function transferToken(
address from,
address to,
uint256 amount,
uint256 id,
address token,
bytes4 kind
) internal {
}
}
| isValid(order,_domainSeparator),"SIGNATURE_INVALID" | 19,827 | isValid(order,_domainSeparator) |
"TOKEN_KIND_UNKNOWN" | /*
Copyright 2020 Swap Holdings Ltd.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/**
* @title Swap: The Atomic Swap used on the AirSwap Network
*/
contract Swap is ISwap {
// Domain and version for use in signatures (EIP-712)
bytes constant internal DOMAIN_NAME = "SWAP";
bytes constant internal DOMAIN_VERSION = "2";
// Unique domain identifier for use in signatures (EIP-712)
bytes32 private _domainSeparator;
// Possible nonce statuses
byte constant internal AVAILABLE = 0x00;
byte constant internal UNAVAILABLE = 0x01;
// Mapping of sender address to a delegated sender address and bool
mapping (address => mapping (address => bool)) public senderAuthorizations;
// Mapping of signer address to a delegated signer and bool
mapping (address => mapping (address => bool)) public signerAuthorizations;
// Mapping of signers to nonces with value AVAILABLE (0x00) or UNAVAILABLE (0x01)
mapping (address => mapping (uint256 => byte)) public signerNonceStatus;
// Mapping of signer addresses to an optionally set minimum valid nonce
mapping (address => uint256) public signerMinimumNonce;
// A registry storing a transfer handler for different token kinds
TransferHandlerRegistry public registry;
/**
* @notice Contract Constructor
* @dev Sets domain for signature validation (EIP-712)
* @param swapRegistry TransferHandlerRegistry
*/
constructor(TransferHandlerRegistry swapRegistry) public {
}
/**
* @notice Atomic Token Swap
* @param order Types.Order Order to settle
*/
function swap(
Types.Order calldata order
) external {
}
/**
* @notice Cancel one or more open orders by nonce
* @dev Cancelled nonces are marked UNAVAILABLE (0x01)
* @dev Emits a Cancel event
* @dev Out of gas may occur in arrays of length > 400
* @param nonces uint256[] List of nonces to cancel
*/
function cancel(
uint256[] calldata nonces
) external {
}
/**
* @notice Cancels all orders below a nonce value
* @dev Emits a CancelUpTo event
* @param minimumNonce uint256 Minimum valid nonce
*/
function cancelUpTo(
uint256 minimumNonce
) external {
}
/**
* @notice Authorize a delegated sender
* @dev Emits an AuthorizeSender event
* @param authorizedSender address Address to authorize
*/
function authorizeSender(
address authorizedSender
) external {
}
/**
* @notice Authorize a delegated signer
* @dev Emits an AuthorizeSigner event
* @param authorizedSigner address Address to authorize
*/
function authorizeSigner(
address authorizedSigner
) external {
}
/**
* @notice Revoke an authorized sender
* @dev Emits a RevokeSender event
* @param authorizedSender address Address to revoke
*/
function revokeSender(
address authorizedSender
) external {
}
/**
* @notice Revoke an authorized signer
* @dev Emits a RevokeSigner event
* @param authorizedSigner address Address to revoke
*/
function revokeSigner(
address authorizedSigner
) external {
}
/**
* @notice Determine whether a sender delegate is authorized
* @param authorizer address Address doing the authorization
* @param delegate address Address being authorized
* @return bool True if a delegate is authorized to send
*/
function isSenderAuthorized(
address authorizer,
address delegate
) internal view returns (bool) {
}
/**
* @notice Determine whether a signer delegate is authorized
* @param authorizer address Address doing the authorization
* @param delegate address Address being authorized
* @return bool True if a delegate is authorized to sign
*/
function isSignerAuthorized(
address authorizer,
address delegate
) internal view returns (bool) {
}
/**
* @notice Validate signature using an EIP-712 typed data hash
* @param order Types.Order Order to validate
* @param domainSeparator bytes32 Domain identifier used in signatures (EIP-712)
* @return bool True if order has a valid signature
*/
function isValid(
Types.Order memory order,
bytes32 domainSeparator
) internal pure returns (bool) {
}
/**
* @notice Perform token transfer for tokens in registry
* @dev Transfer type specified by the bytes4 kind param
* @dev ERC721: uses transferFrom for transfer
* @dev ERC20: Takes into account non-standard ERC-20 tokens.
* @param from address Wallet address to transfer from
* @param to address Wallet address to transfer to
* @param amount uint256 Amount for ERC-20
* @param id token ID for ERC-721
* @param token address Contract address of token
* @param kind bytes4 EIP-165 interface ID of the token
*/
function transferToken(
address from,
address to,
uint256 amount,
uint256 id,
address token,
bytes4 kind
) internal {
// Ensure the transfer is not to self.
require(from != to, "SELF_TRANSFER_INVALID");
ITransferHandler transferHandler = registry.transferHandlers(kind);
require(<FILL_ME>)
// delegatecall required to pass msg.sender as Swap contract to handle the
// token transfer in the calling contract
(bool success, bytes memory data) = address(transferHandler).
delegatecall(abi.encodeWithSelector(
transferHandler.transferTokens.selector,
from,
to,
amount,
id,
token
));
require(success && abi.decode(data, (bool)), "TRANSFER_FAILED");
}
}
| address(transferHandler)!=address(0),"TOKEN_KIND_UNKNOWN" | 19,827 | address(transferHandler)!=address(0) |
"TRANSFER_FAILED" | /*
Copyright 2020 Swap Holdings Ltd.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/**
* @title Swap: The Atomic Swap used on the AirSwap Network
*/
contract Swap is ISwap {
// Domain and version for use in signatures (EIP-712)
bytes constant internal DOMAIN_NAME = "SWAP";
bytes constant internal DOMAIN_VERSION = "2";
// Unique domain identifier for use in signatures (EIP-712)
bytes32 private _domainSeparator;
// Possible nonce statuses
byte constant internal AVAILABLE = 0x00;
byte constant internal UNAVAILABLE = 0x01;
// Mapping of sender address to a delegated sender address and bool
mapping (address => mapping (address => bool)) public senderAuthorizations;
// Mapping of signer address to a delegated signer and bool
mapping (address => mapping (address => bool)) public signerAuthorizations;
// Mapping of signers to nonces with value AVAILABLE (0x00) or UNAVAILABLE (0x01)
mapping (address => mapping (uint256 => byte)) public signerNonceStatus;
// Mapping of signer addresses to an optionally set minimum valid nonce
mapping (address => uint256) public signerMinimumNonce;
// A registry storing a transfer handler for different token kinds
TransferHandlerRegistry public registry;
/**
* @notice Contract Constructor
* @dev Sets domain for signature validation (EIP-712)
* @param swapRegistry TransferHandlerRegistry
*/
constructor(TransferHandlerRegistry swapRegistry) public {
}
/**
* @notice Atomic Token Swap
* @param order Types.Order Order to settle
*/
function swap(
Types.Order calldata order
) external {
}
/**
* @notice Cancel one or more open orders by nonce
* @dev Cancelled nonces are marked UNAVAILABLE (0x01)
* @dev Emits a Cancel event
* @dev Out of gas may occur in arrays of length > 400
* @param nonces uint256[] List of nonces to cancel
*/
function cancel(
uint256[] calldata nonces
) external {
}
/**
* @notice Cancels all orders below a nonce value
* @dev Emits a CancelUpTo event
* @param minimumNonce uint256 Minimum valid nonce
*/
function cancelUpTo(
uint256 minimumNonce
) external {
}
/**
* @notice Authorize a delegated sender
* @dev Emits an AuthorizeSender event
* @param authorizedSender address Address to authorize
*/
function authorizeSender(
address authorizedSender
) external {
}
/**
* @notice Authorize a delegated signer
* @dev Emits an AuthorizeSigner event
* @param authorizedSigner address Address to authorize
*/
function authorizeSigner(
address authorizedSigner
) external {
}
/**
* @notice Revoke an authorized sender
* @dev Emits a RevokeSender event
* @param authorizedSender address Address to revoke
*/
function revokeSender(
address authorizedSender
) external {
}
/**
* @notice Revoke an authorized signer
* @dev Emits a RevokeSigner event
* @param authorizedSigner address Address to revoke
*/
function revokeSigner(
address authorizedSigner
) external {
}
/**
* @notice Determine whether a sender delegate is authorized
* @param authorizer address Address doing the authorization
* @param delegate address Address being authorized
* @return bool True if a delegate is authorized to send
*/
function isSenderAuthorized(
address authorizer,
address delegate
) internal view returns (bool) {
}
/**
* @notice Determine whether a signer delegate is authorized
* @param authorizer address Address doing the authorization
* @param delegate address Address being authorized
* @return bool True if a delegate is authorized to sign
*/
function isSignerAuthorized(
address authorizer,
address delegate
) internal view returns (bool) {
}
/**
* @notice Validate signature using an EIP-712 typed data hash
* @param order Types.Order Order to validate
* @param domainSeparator bytes32 Domain identifier used in signatures (EIP-712)
* @return bool True if order has a valid signature
*/
function isValid(
Types.Order memory order,
bytes32 domainSeparator
) internal pure returns (bool) {
}
/**
* @notice Perform token transfer for tokens in registry
* @dev Transfer type specified by the bytes4 kind param
* @dev ERC721: uses transferFrom for transfer
* @dev ERC20: Takes into account non-standard ERC-20 tokens.
* @param from address Wallet address to transfer from
* @param to address Wallet address to transfer to
* @param amount uint256 Amount for ERC-20
* @param id token ID for ERC-721
* @param token address Contract address of token
* @param kind bytes4 EIP-165 interface ID of the token
*/
function transferToken(
address from,
address to,
uint256 amount,
uint256 id,
address token,
bytes4 kind
) internal {
// Ensure the transfer is not to self.
require(from != to, "SELF_TRANSFER_INVALID");
ITransferHandler transferHandler = registry.transferHandlers(kind);
require(address(transferHandler) != address(0), "TOKEN_KIND_UNKNOWN");
// delegatecall required to pass msg.sender as Swap contract to handle the
// token transfer in the calling contract
(bool success, bytes memory data) = address(transferHandler).
delegatecall(abi.encodeWithSelector(
transferHandler.transferTokens.selector,
from,
to,
amount,
id,
token
));
require(<FILL_ME>)
}
}
| success&&abi.decode(data,(bool)),"TRANSFER_FAILED" | 19,827 | success&&abi.decode(data,(bool)) |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
/*
Copyright 2016, Jordi Baylina
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// This minime token contract adjusted by ArmorFi to remove all functionality of
// inheriting from a parent and only keep functionality related to keeping track of
// balances through different checkpoints.
/// @title MiniMeToken Contract
/// @author Jordi Baylina
/// @dev This token contract's goal is to make it easy for anyone to clone this
/// token using the token distribution at a given block, this will allow DAO's
/// and DApps to upgrade their features in a decentralized manner without
/// affecting the original token
/// @dev It is ERC20 compliant, but still needs to under go further testing.
/// @dev The actual token contract, the default controller is the msg.sender
/// that deploys the contract, so usually this token will be deployed by a
/// token controller contract, which Giveth will call a "Campaign"
contract ArmorToken {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
string public version = '69_420'; //An arbitrary versioning scheme
/// @dev `Checkpoint` is the structure that attaches a block number to a
/// given value, the block number attached is the one that last changed the
/// value
struct Checkpoint {
// `fromBlock` is the block number that the value was generated from
uint128 fromBlock;
// `value` is the amount of tokens at a specific block number
uint128 value;
}
// `creationBlock` is the block number that the Clone Token was created
uint public creationBlock;
// `balances` is the map that tracks the balance of each address, in this
// contract when the balance changes the block number that the change
// occurred is also included in the map
mapping (address => Checkpoint[]) balances;
// `allowed` tracks any extra transfer rights as in all ERC20 tokens
mapping (address => mapping (address => uint256)) allowed;
// Tracks the history of the `totalSupply` of the token
Checkpoint[] totalSupplyHistory;
// Shield that is allowed to mint tokens to peeps.
address public arShield;
// ShieldController--can just withdraw tokens.
address public controller;
////////////////
// Constructor
////////////////
/// @notice Constructor to create a MiniMeToken
/// @param _tokenName Name of the new token
/// @param _tokenSymbol Token Symbol for the new token
constructor(
address _arShield,
string memory _tokenName,
string memory _tokenSymbol
)
{
}
modifier onlyController
{
}
modifier onlyShield
{
}
///////////////////
// ERC20 Methods
///////////////////
/// @notice Send `_amount` tokens to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @return success Whether the transfer was successful or not
function transfer(address _to, uint256 _amount) public returns (bool success) {
}
/// @notice Send `_amount` tokens to `_to` from `_from` on the condition it
/// is approved by `_from`
/// @param _from The address holding the tokens being transferred
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @return success True if the transfer was successful
function transferFrom(address _from, address _to, uint256 _amount
) public returns (bool success) {
}
/// @dev This is the actual transfer function in the token contract, it can
/// only be called by other functions in this contract.
/// @param _from The address holding the tokens being transferred
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
function doTransfer(address _from, address _to, uint _amount
) internal {
if (_amount == 0) {
emit Transfer(_from, _to, _amount); // Follow the spec to louch the event when transfer 0
return;
}
// Do not allow transfer to 0x0 or the token contract itself
require(_to != address(this));
// If the amount being transfered is more than the balance of the
// account the transfer throws
uint256 previousBalanceFrom = balanceOfAt(_from, block.number);
require(previousBalanceFrom >= _amount);
// First update the balance array with the new value for the address
// sending the tokens
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
// Then update the balance array with the new value for the address
// receiving the tokens
uint256 previousBalanceTo = balanceOfAt(_to, block.number);
require(<FILL_ME>) // Check for overflow
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
// An event to make the transfer easy to find on the blockchain
emit Transfer(_from, _to, _amount);
}
/// @param _owner The address that's balance is being requested
/// @return balance The balance of `_owner` at the current block
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/// @notice `msg.sender` approves `_spender` to spend `_amount` tokens on
/// its behalf. This is a modified version of the ERC20 approve function
/// to be a little bit safer
/// @param _spender The address of the account able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return success True if the approval was successful
function approve(address _spender, uint256 _amount) public returns (bool success) {
}
/// @dev This function makes it easy to read the `allowed[]` map
/// @param _owner The address of the account that owns the token
/// @param _spender The address of the account able to transfer the tokens
/// @return remaining Amount of remaining tokens of _owner that _spender is allowed
/// to spend
function allowance(address _owner, address _spender
) public view returns (uint256 remaining) {
}
/// @dev This function makes it easy to get the total number of tokens
/// @return The total number of tokens
function totalSupply() public view returns (uint) {
}
////////////////
// Query balance and totalSupply in History
////////////////
/// @dev Queries the balance of `_owner` at a specific `_blockNumber`
/// @param _owner The address from which the balance will be retrieved
/// @param _blockNumber The block number when the balance is queried
/// @return The balance at `_blockNumber`
function balanceOfAt(address _owner, uint _blockNumber) public view
returns (uint) {
}
/// @notice Total amount of tokens at a specific `_blockNumber`.
/// @param _blockNumber The block number when the totalSupply is queried
/// @return The total amount of tokens at `_blockNumber`
function totalSupplyAt(uint _blockNumber) public view returns(uint) {
}
////////////////
// Generate and destroy tokens
////////////////
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _owner The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function mint(address _owner, uint _amount
) public onlyShield returns (bool) {
}
/// @notice Burns `_amount` tokens from `_owner`
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function burn(uint _amount
) public returns (bool) {
}
////////////////
// Internal helper functions to query and set a value in a snapshot array
////////////////
/// @dev `getValueAt` retrieves the number of tokens at a given block number
/// @param checkpoints The history of values being queried
/// @param _block The block number to retrieve the value at
/// @return The number of tokens being queried
function getValueAt(Checkpoint[] storage checkpoints, uint _block
) view internal returns (uint) {
}
/// @dev `updateValueAtNow` used to update the `balances` map and the
/// `totalSupplyHistory`
/// @param checkpoints The history of data being updated
/// @param _value The new number of tokens
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value
) internal {
}
/// @dev Helper function to return a min betwen the two uints
function min(uint a, uint b) pure internal returns (uint) {
}
//////////
// Safety Methods
//////////
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) public onlyController {
}
////////////////
// Events
////////////////
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _amount
);
}
| previousBalanceTo+_amount>=previousBalanceTo | 19,906 | previousBalanceTo+_amount>=previousBalanceTo |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
/*
Copyright 2016, Jordi Baylina
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// This minime token contract adjusted by ArmorFi to remove all functionality of
// inheriting from a parent and only keep functionality related to keeping track of
// balances through different checkpoints.
/// @title MiniMeToken Contract
/// @author Jordi Baylina
/// @dev This token contract's goal is to make it easy for anyone to clone this
/// token using the token distribution at a given block, this will allow DAO's
/// and DApps to upgrade their features in a decentralized manner without
/// affecting the original token
/// @dev It is ERC20 compliant, but still needs to under go further testing.
/// @dev The actual token contract, the default controller is the msg.sender
/// that deploys the contract, so usually this token will be deployed by a
/// token controller contract, which Giveth will call a "Campaign"
contract ArmorToken {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
string public version = '69_420'; //An arbitrary versioning scheme
/// @dev `Checkpoint` is the structure that attaches a block number to a
/// given value, the block number attached is the one that last changed the
/// value
struct Checkpoint {
// `fromBlock` is the block number that the value was generated from
uint128 fromBlock;
// `value` is the amount of tokens at a specific block number
uint128 value;
}
// `creationBlock` is the block number that the Clone Token was created
uint public creationBlock;
// `balances` is the map that tracks the balance of each address, in this
// contract when the balance changes the block number that the change
// occurred is also included in the map
mapping (address => Checkpoint[]) balances;
// `allowed` tracks any extra transfer rights as in all ERC20 tokens
mapping (address => mapping (address => uint256)) allowed;
// Tracks the history of the `totalSupply` of the token
Checkpoint[] totalSupplyHistory;
// Shield that is allowed to mint tokens to peeps.
address public arShield;
// ShieldController--can just withdraw tokens.
address public controller;
////////////////
// Constructor
////////////////
/// @notice Constructor to create a MiniMeToken
/// @param _tokenName Name of the new token
/// @param _tokenSymbol Token Symbol for the new token
constructor(
address _arShield,
string memory _tokenName,
string memory _tokenSymbol
)
{
}
modifier onlyController
{
}
modifier onlyShield
{
}
///////////////////
// ERC20 Methods
///////////////////
/// @notice Send `_amount` tokens to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @return success Whether the transfer was successful or not
function transfer(address _to, uint256 _amount) public returns (bool success) {
}
/// @notice Send `_amount` tokens to `_to` from `_from` on the condition it
/// is approved by `_from`
/// @param _from The address holding the tokens being transferred
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @return success True if the transfer was successful
function transferFrom(address _from, address _to, uint256 _amount
) public returns (bool success) {
}
/// @dev This is the actual transfer function in the token contract, it can
/// only be called by other functions in this contract.
/// @param _from The address holding the tokens being transferred
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
function doTransfer(address _from, address _to, uint _amount
) internal {
}
/// @param _owner The address that's balance is being requested
/// @return balance The balance of `_owner` at the current block
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/// @notice `msg.sender` approves `_spender` to spend `_amount` tokens on
/// its behalf. This is a modified version of the ERC20 approve function
/// to be a little bit safer
/// @param _spender The address of the account able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return success True if the approval was successful
function approve(address _spender, uint256 _amount) public returns (bool success) {
}
/// @dev This function makes it easy to read the `allowed[]` map
/// @param _owner The address of the account that owns the token
/// @param _spender The address of the account able to transfer the tokens
/// @return remaining Amount of remaining tokens of _owner that _spender is allowed
/// to spend
function allowance(address _owner, address _spender
) public view returns (uint256 remaining) {
}
/// @dev This function makes it easy to get the total number of tokens
/// @return The total number of tokens
function totalSupply() public view returns (uint) {
}
////////////////
// Query balance and totalSupply in History
////////////////
/// @dev Queries the balance of `_owner` at a specific `_blockNumber`
/// @param _owner The address from which the balance will be retrieved
/// @param _blockNumber The block number when the balance is queried
/// @return The balance at `_blockNumber`
function balanceOfAt(address _owner, uint _blockNumber) public view
returns (uint) {
}
/// @notice Total amount of tokens at a specific `_blockNumber`.
/// @param _blockNumber The block number when the totalSupply is queried
/// @return The total amount of tokens at `_blockNumber`
function totalSupplyAt(uint _blockNumber) public view returns(uint) {
}
////////////////
// Generate and destroy tokens
////////////////
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _owner The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function mint(address _owner, uint _amount
) public onlyShield returns (bool) {
uint curTotalSupply = totalSupply();
require(<FILL_ME>) // Check for overflow
uint previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
emit Transfer(address(0), _owner, _amount);
return true;
}
/// @notice Burns `_amount` tokens from `_owner`
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function burn(uint _amount
) public returns (bool) {
}
////////////////
// Internal helper functions to query and set a value in a snapshot array
////////////////
/// @dev `getValueAt` retrieves the number of tokens at a given block number
/// @param checkpoints The history of values being queried
/// @param _block The block number to retrieve the value at
/// @return The number of tokens being queried
function getValueAt(Checkpoint[] storage checkpoints, uint _block
) view internal returns (uint) {
}
/// @dev `updateValueAtNow` used to update the `balances` map and the
/// `totalSupplyHistory`
/// @param checkpoints The history of data being updated
/// @param _value The new number of tokens
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value
) internal {
}
/// @dev Helper function to return a min betwen the two uints
function min(uint a, uint b) pure internal returns (uint) {
}
//////////
// Safety Methods
//////////
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) public onlyController {
}
////////////////
// Events
////////////////
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _amount
);
}
| curTotalSupply+_amount>=curTotalSupply | 19,906 | curTotalSupply+_amount>=curTotalSupply |
"Exceeded individual cap" | pragma solidity ^0.6.0;
// import "@openzeppelin/contracts/crowdsale/Crowdsale.sol";
// import "@openzeppelin/contracts/crowdsale/emission/AllowanceCrowdsale.sol";
// import "@openzeppelin/contracts/crowdsale/validation/CappedCrowdsale.sol";
// import "@openzeppelin/contracts/crowdsale/validation/IndividuallyCappedCrowdsale.sol";
contract TMECrowdsale is Ownable {
using SafeMath for uint256;
uint256 public raised;
mapping (address => uint256) public contributions;
uint256 rate;
uint256 indivCap;
uint256 cap;
address tokenAdd;
address payable tokenLockerAdd;
bool public started;
constructor(
uint256 _rate,
uint256 _indivCap,
uint256 _cap,
address _tokenAdd
)
public
{
}
function setTMELocker(address payable _tokenLocker) external onlyOwner{
}
receive () external payable {
}
function setStarted(bool s) external onlyOwner{
}
function buyTokens() public payable{
require(started, "Presale not started!");
require(tokenLockerAdd != address(0), "tokenLockerAdd not set!");
uint256 amtEth = msg.value;
uint256 amtBought = contributions[msg.sender];
require(<FILL_ME>)
require(raised < cap, "Raise limit has reached");
if (amtEth.add(raised) >= cap){
uint256 amtEthToSpend = cap.sub(raised);
uint256 amtEthToReturn = amtEth.sub(amtEthToSpend);
uint256 amtTokenToReceive = amtEthToSpend.mul(rate);
require(amtTokenToReceive <= amtTokenLeft(), "Ran out of tokens");
contributions[msg.sender] = contributions[msg.sender].add(amtEthToSpend);
raised = raised.add(amtEthToSpend);
IERC20(tokenAdd).transfer(msg.sender, amtTokenToReceive);
msg.sender.transfer(amtEthToReturn);
TMELocker(tokenLockerAdd).receiveFunds{value:amtEthToSpend}();
} else {
uint256 amtTokenToReceive2 = amtEth.mul(rate);
require(amtTokenToReceive2 <= amtTokenLeft(), "Ran out of tokens");
contributions[msg.sender] = contributions[msg.sender].add(amtEth);
raised = raised.add(amtEth);
IERC20(tokenAdd).transfer(msg.sender, amtTokenToReceive2);
TMELocker(tokenLockerAdd).receiveFunds{value: amtEth}();
}
}
function amtTokenLeft() public view returns (uint256) {
}
function claimUnsoldTokens() public onlyOwner {
}
}
| amtBought.add(amtEth)<=indivCap,"Exceeded individual cap" | 19,909 | amtBought.add(amtEth)<=indivCap |
"BloockState::updateState: ONLY_ALLOWED_ROLE" | pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/AccessControl.sol";
contract BloockState is AccessControl {
// bytes32(keccak245(bytes("STATE_MANAGER")));
bytes32 public constant STATE_MANAGER = 0x7c0c08811839d3a8bfad3f26fd05feea7daf5d75bf9d6f3fe140cd8f62b7af38;
// Map containing a relation of the state roots and the timestamp they where published on. 0 if not present.
mapping (bytes32 => uint256) private states;
/**
* @dev Constructor function.
* @param role_manager is the address granted the default_admin role.
* @param state_manager is the address granted the state_manager role.
*/
constructor(address role_manager, address state_manager) {
}
/**
* @dev Appends a new state to the states map with the current timestamp.
* @param state_root the new state_root to append.
*/
function updateState(bytes32 state_root) external {
require(<FILL_ME>)
states[state_root] = block.timestamp;
}
/**
* @dev Checks whether the state_root is present in the state_machine or not.
* @param state_root the state_root to check.
*/
function isStatePresent(bytes32 state_root) public view returns (bool) {
}
/**
* @dev Gets the value of an specific state_root.
* @param state_root the state_root to get.
* @return the timestamp of the anchor.
*/
function getState(bytes32 state_root) public view returns (uint256) {
}
struct InternalStack {
bytes32 hash;
uint32 depth;
}
/**
* @dev Checks the validity of the inclusion proof for a set of contents.
* @param content the hashes of the content to test (keccak).
* @param hashes the minimal set of keys required, aside from the ones in `content` to compute the root key value. They are ordered following a post-order tree traversal.
* @param bitmap Bitmap representing whether an element of `depths` belong `content` set (value 0) or `hashes` set (value 1).
* @param depths Vector containing the depth of each node whose keys belongs to `leaves` or `hashes` set relative to the tree root node. It also follows the post-order traversal order.
* @return the timestamp of the anchor. 0 if not present.
*/
function verifyInclusionProof(bytes32[] calldata content, bytes32[] calldata hashes, bytes calldata bitmap, uint32[] calldata depths) public view returns (uint256) {
}
}
| hasRole(STATE_MANAGER,msg.sender),"BloockState::updateState: ONLY_ALLOWED_ROLE" | 19,937 | hasRole(STATE_MANAGER,msg.sender) |
"!keepers" | pragma solidity ^0.6.2;
abstract contract StrategyCmpdBase is StrategyBase, Exponential {
address public constant comptroller = 0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B;
address public constant lens = 0xd513d22422a3062Bd342Ae374b4b9c20E0a9a074;
address public constant comp = 0xc00e94Cb662C3520282E6f5717214004A7f26888;
address public constant cether = 0x4Ddc2D193948926D02f9B1fE9e1daa0718270ED5;
address public constant usdt = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
// dai/usdc
address public want;
// cdai/cusdc
address public cwant;
// Require a 0.05 buffer between
// market collateral factor and strategy's collateral factor
// when leveraging
uint256 colFactorLeverageBuffer = 50;
uint256 colFactorLeverageBufferMax = 1000;
// Allow a 0.05 buffer
// between market collateral factor and strategy's collateral factor
// until we have to deleverage
// This is so we can hit max leverage and keep accruing interest
uint256 colFactorSyncBuffer = 50;
uint256 colFactorSyncBufferMax = 1000;
// Keeper bots
// Maintain leverage within buffer
mapping(address => bool) keepers;
constructor(
address _btf,
address _want,
address _cwant,
address _governance,
address _strategist,
address _controller,
address _timelock
)
public StrategyBase(_btf, _want, _governance, _strategist, _controller, _timelock)
{
}
// **** Modifiers **** //
modifier onlyKeepers {
require(<FILL_ME>)
_;
}
// **** Views **** //
function getSuppliedView() public view returns (uint256) {
}
function getBorrowedView() public view returns (uint256) {
}
function balanceOfPool() public override view returns (uint256) {
}
// Given an unleveraged supply balance, return the target
// leveraged supply balance which is still within the safety buffer
function getLeveragedSupplyTarget(uint256 supplyBalance)
public
view
returns (uint256)
{
}
function getSafeLeverageColFactor() public view returns (uint256) {
}
function getSafeSyncColFactor() public view returns (uint256) {
}
function getMarketColFactor() public view returns (uint256) {
}
// Max leverage we can go up to, w.r.t safe buffer
function getMaxLeverage() public view returns (uint256) {
}
// **** Pseudo-view functions (use `callStatic` on these) **** //
/* The reason why these exists is because of the nature of the
interest accruing supply + borrow balance. The "view" methods
are technically snapshots and don't represent the real value.
As such there are pseudo view methods where you can retrieve the
results by calling `callStatic`.
*/
function getCompAccrued() public returns (uint256) {
}
function getHarvestable() external returns (uint256) {
}
function getColFactor() public returns (uint256) {
}
function getSuppliedUnleveraged() public returns (uint256) {
}
function getSupplied() public returns (uint256) {
}
function getBorrowed() public returns (uint256) {
}
function getBorrowable() public returns (uint256) {
}
function getCurrentLeverage() public returns (uint256) {
}
// **** Setters **** //
function addKeeper(address _keeper) public {
}
function removeKeeper(address _keeper) public {
}
function setColFactorLeverageBuffer(uint256 _colFactorLeverageBuffer)
public
{
}
function setColFactorSyncBuffer(uint256 _colFactorSyncBuffer) public {
}
// **** State mutations **** //
// Do a `callStatic` on this.
// If it returns true then run it for realz. (i.e. eth_signedTx, not eth_call)
function sync() public returns (bool) {
}
function leverageToMax() public {
}
// Leverages until we're supplying <x> amount
// 1. Redeem <x> DAI
// 2. Repay <x> DAI
function leverageUntil(uint256 _supplyAmount) public onlyKeepers {
}
function deleverageToMin() public {
}
// Deleverages until we're supplying <x> amount
// 1. Redeem <x> DAI
// 2. Repay <x> DAI
function deleverageUntil(uint256 _supplyAmount) public onlyKeepers {
}
function harvest() public override onlyBenevolent {
}
function deposit() public override {
}
function _withdrawSome(uint256 _amount)
internal
override
returns (uint256)
{
}
}
| keepers[msg.sender]||msg.sender==address(this)||msg.sender==strategist||msg.sender==governance,"!keepers" | 19,977 | keepers[msg.sender]||msg.sender==address(this)||msg.sender==strategist||msg.sender==governance |
"!redeem" | pragma solidity ^0.6.2;
abstract contract StrategyCmpdBase is StrategyBase, Exponential {
address public constant comptroller = 0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B;
address public constant lens = 0xd513d22422a3062Bd342Ae374b4b9c20E0a9a074;
address public constant comp = 0xc00e94Cb662C3520282E6f5717214004A7f26888;
address public constant cether = 0x4Ddc2D193948926D02f9B1fE9e1daa0718270ED5;
address public constant usdt = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
// dai/usdc
address public want;
// cdai/cusdc
address public cwant;
// Require a 0.05 buffer between
// market collateral factor and strategy's collateral factor
// when leveraging
uint256 colFactorLeverageBuffer = 50;
uint256 colFactorLeverageBufferMax = 1000;
// Allow a 0.05 buffer
// between market collateral factor and strategy's collateral factor
// until we have to deleverage
// This is so we can hit max leverage and keep accruing interest
uint256 colFactorSyncBuffer = 50;
uint256 colFactorSyncBufferMax = 1000;
// Keeper bots
// Maintain leverage within buffer
mapping(address => bool) keepers;
constructor(
address _btf,
address _want,
address _cwant,
address _governance,
address _strategist,
address _controller,
address _timelock
)
public StrategyBase(_btf, _want, _governance, _strategist, _controller, _timelock)
{
}
// **** Modifiers **** //
modifier onlyKeepers {
}
// **** Views **** //
function getSuppliedView() public view returns (uint256) {
}
function getBorrowedView() public view returns (uint256) {
}
function balanceOfPool() public override view returns (uint256) {
}
// Given an unleveraged supply balance, return the target
// leveraged supply balance which is still within the safety buffer
function getLeveragedSupplyTarget(uint256 supplyBalance)
public
view
returns (uint256)
{
}
function getSafeLeverageColFactor() public view returns (uint256) {
}
function getSafeSyncColFactor() public view returns (uint256) {
}
function getMarketColFactor() public view returns (uint256) {
}
// Max leverage we can go up to, w.r.t safe buffer
function getMaxLeverage() public view returns (uint256) {
}
// **** Pseudo-view functions (use `callStatic` on these) **** //
/* The reason why these exists is because of the nature of the
interest accruing supply + borrow balance. The "view" methods
are technically snapshots and don't represent the real value.
As such there are pseudo view methods where you can retrieve the
results by calling `callStatic`.
*/
function getCompAccrued() public returns (uint256) {
}
function getHarvestable() external returns (uint256) {
}
function getColFactor() public returns (uint256) {
}
function getSuppliedUnleveraged() public returns (uint256) {
}
function getSupplied() public returns (uint256) {
}
function getBorrowed() public returns (uint256) {
}
function getBorrowable() public returns (uint256) {
}
function getCurrentLeverage() public returns (uint256) {
}
// **** Setters **** //
function addKeeper(address _keeper) public {
}
function removeKeeper(address _keeper) public {
}
function setColFactorLeverageBuffer(uint256 _colFactorLeverageBuffer)
public
{
}
function setColFactorSyncBuffer(uint256 _colFactorSyncBuffer) public {
}
// **** State mutations **** //
// Do a `callStatic` on this.
// If it returns true then run it for realz. (i.e. eth_signedTx, not eth_call)
function sync() public returns (bool) {
}
function leverageToMax() public {
}
// Leverages until we're supplying <x> amount
// 1. Redeem <x> DAI
// 2. Repay <x> DAI
function leverageUntil(uint256 _supplyAmount) public onlyKeepers {
}
function deleverageToMin() public {
}
// Deleverages until we're supplying <x> amount
// 1. Redeem <x> DAI
// 2. Repay <x> DAI
function deleverageUntil(uint256 _supplyAmount) public onlyKeepers {
uint256 unleveragedSupply = getSuppliedUnleveraged();
uint256 supplied = getSupplied();
require(
_supplyAmount >= unleveragedSupply && _supplyAmount <= supplied,
"!deleverage"
);
uint256 _redeemAndRepay;
do {
// Since we're only leveraging on 1 asset
// redeemable = borrowable
_redeemAndRepay = getBorrowable();
if (supplied.sub(_redeemAndRepay) < _supplyAmount) {
_redeemAndRepay = supplied.sub(_supplyAmount);
}
require(<FILL_ME>)
IERC20(want).safeApprove(cwant, 0);
IERC20(want).safeApprove(cwant, _redeemAndRepay);
require(ICToken(cwant).repayBorrow(_redeemAndRepay) == 0, "!repay");
supplied = supplied.sub(_redeemAndRepay);
}
while (supplied > _supplyAmount);
}
function harvest() public override onlyBenevolent {
}
function deposit() public override {
}
function _withdrawSome(uint256 _amount)
internal
override
returns (uint256)
{
}
}
| ICToken(cwant).redeemUnderlying(_redeemAndRepay)==0,"!redeem" | 19,977 | ICToken(cwant).redeemUnderlying(_redeemAndRepay)==0 |
"!repay" | pragma solidity ^0.6.2;
abstract contract StrategyCmpdBase is StrategyBase, Exponential {
address public constant comptroller = 0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B;
address public constant lens = 0xd513d22422a3062Bd342Ae374b4b9c20E0a9a074;
address public constant comp = 0xc00e94Cb662C3520282E6f5717214004A7f26888;
address public constant cether = 0x4Ddc2D193948926D02f9B1fE9e1daa0718270ED5;
address public constant usdt = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
// dai/usdc
address public want;
// cdai/cusdc
address public cwant;
// Require a 0.05 buffer between
// market collateral factor and strategy's collateral factor
// when leveraging
uint256 colFactorLeverageBuffer = 50;
uint256 colFactorLeverageBufferMax = 1000;
// Allow a 0.05 buffer
// between market collateral factor and strategy's collateral factor
// until we have to deleverage
// This is so we can hit max leverage and keep accruing interest
uint256 colFactorSyncBuffer = 50;
uint256 colFactorSyncBufferMax = 1000;
// Keeper bots
// Maintain leverage within buffer
mapping(address => bool) keepers;
constructor(
address _btf,
address _want,
address _cwant,
address _governance,
address _strategist,
address _controller,
address _timelock
)
public StrategyBase(_btf, _want, _governance, _strategist, _controller, _timelock)
{
}
// **** Modifiers **** //
modifier onlyKeepers {
}
// **** Views **** //
function getSuppliedView() public view returns (uint256) {
}
function getBorrowedView() public view returns (uint256) {
}
function balanceOfPool() public override view returns (uint256) {
}
// Given an unleveraged supply balance, return the target
// leveraged supply balance which is still within the safety buffer
function getLeveragedSupplyTarget(uint256 supplyBalance)
public
view
returns (uint256)
{
}
function getSafeLeverageColFactor() public view returns (uint256) {
}
function getSafeSyncColFactor() public view returns (uint256) {
}
function getMarketColFactor() public view returns (uint256) {
}
// Max leverage we can go up to, w.r.t safe buffer
function getMaxLeverage() public view returns (uint256) {
}
// **** Pseudo-view functions (use `callStatic` on these) **** //
/* The reason why these exists is because of the nature of the
interest accruing supply + borrow balance. The "view" methods
are technically snapshots and don't represent the real value.
As such there are pseudo view methods where you can retrieve the
results by calling `callStatic`.
*/
function getCompAccrued() public returns (uint256) {
}
function getHarvestable() external returns (uint256) {
}
function getColFactor() public returns (uint256) {
}
function getSuppliedUnleveraged() public returns (uint256) {
}
function getSupplied() public returns (uint256) {
}
function getBorrowed() public returns (uint256) {
}
function getBorrowable() public returns (uint256) {
}
function getCurrentLeverage() public returns (uint256) {
}
// **** Setters **** //
function addKeeper(address _keeper) public {
}
function removeKeeper(address _keeper) public {
}
function setColFactorLeverageBuffer(uint256 _colFactorLeverageBuffer)
public
{
}
function setColFactorSyncBuffer(uint256 _colFactorSyncBuffer) public {
}
// **** State mutations **** //
// Do a `callStatic` on this.
// If it returns true then run it for realz. (i.e. eth_signedTx, not eth_call)
function sync() public returns (bool) {
}
function leverageToMax() public {
}
// Leverages until we're supplying <x> amount
// 1. Redeem <x> DAI
// 2. Repay <x> DAI
function leverageUntil(uint256 _supplyAmount) public onlyKeepers {
}
function deleverageToMin() public {
}
// Deleverages until we're supplying <x> amount
// 1. Redeem <x> DAI
// 2. Repay <x> DAI
function deleverageUntil(uint256 _supplyAmount) public onlyKeepers {
uint256 unleveragedSupply = getSuppliedUnleveraged();
uint256 supplied = getSupplied();
require(
_supplyAmount >= unleveragedSupply && _supplyAmount <= supplied,
"!deleverage"
);
uint256 _redeemAndRepay;
do {
// Since we're only leveraging on 1 asset
// redeemable = borrowable
_redeemAndRepay = getBorrowable();
if (supplied.sub(_redeemAndRepay) < _supplyAmount) {
_redeemAndRepay = supplied.sub(_supplyAmount);
}
require(
ICToken(cwant).redeemUnderlying(_redeemAndRepay) == 0,
"!redeem"
);
IERC20(want).safeApprove(cwant, 0);
IERC20(want).safeApprove(cwant, _redeemAndRepay);
require(<FILL_ME>)
supplied = supplied.sub(_redeemAndRepay);
}
while (supplied > _supplyAmount);
}
function harvest() public override onlyBenevolent {
}
function deposit() public override {
}
function _withdrawSome(uint256 _amount)
internal
override
returns (uint256)
{
}
}
| ICToken(cwant).repayBorrow(_redeemAndRepay)==0,"!repay" | 19,977 | ICToken(cwant).repayBorrow(_redeemAndRepay)==0 |
"!deposit" | pragma solidity ^0.6.2;
abstract contract StrategyCmpdBase is StrategyBase, Exponential {
address public constant comptroller = 0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B;
address public constant lens = 0xd513d22422a3062Bd342Ae374b4b9c20E0a9a074;
address public constant comp = 0xc00e94Cb662C3520282E6f5717214004A7f26888;
address public constant cether = 0x4Ddc2D193948926D02f9B1fE9e1daa0718270ED5;
address public constant usdt = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
// dai/usdc
address public want;
// cdai/cusdc
address public cwant;
// Require a 0.05 buffer between
// market collateral factor and strategy's collateral factor
// when leveraging
uint256 colFactorLeverageBuffer = 50;
uint256 colFactorLeverageBufferMax = 1000;
// Allow a 0.05 buffer
// between market collateral factor and strategy's collateral factor
// until we have to deleverage
// This is so we can hit max leverage and keep accruing interest
uint256 colFactorSyncBuffer = 50;
uint256 colFactorSyncBufferMax = 1000;
// Keeper bots
// Maintain leverage within buffer
mapping(address => bool) keepers;
constructor(
address _btf,
address _want,
address _cwant,
address _governance,
address _strategist,
address _controller,
address _timelock
)
public StrategyBase(_btf, _want, _governance, _strategist, _controller, _timelock)
{
}
// **** Modifiers **** //
modifier onlyKeepers {
}
// **** Views **** //
function getSuppliedView() public view returns (uint256) {
}
function getBorrowedView() public view returns (uint256) {
}
function balanceOfPool() public override view returns (uint256) {
}
// Given an unleveraged supply balance, return the target
// leveraged supply balance which is still within the safety buffer
function getLeveragedSupplyTarget(uint256 supplyBalance)
public
view
returns (uint256)
{
}
function getSafeLeverageColFactor() public view returns (uint256) {
}
function getSafeSyncColFactor() public view returns (uint256) {
}
function getMarketColFactor() public view returns (uint256) {
}
// Max leverage we can go up to, w.r.t safe buffer
function getMaxLeverage() public view returns (uint256) {
}
// **** Pseudo-view functions (use `callStatic` on these) **** //
/* The reason why these exists is because of the nature of the
interest accruing supply + borrow balance. The "view" methods
are technically snapshots and don't represent the real value.
As such there are pseudo view methods where you can retrieve the
results by calling `callStatic`.
*/
function getCompAccrued() public returns (uint256) {
}
function getHarvestable() external returns (uint256) {
}
function getColFactor() public returns (uint256) {
}
function getSuppliedUnleveraged() public returns (uint256) {
}
function getSupplied() public returns (uint256) {
}
function getBorrowed() public returns (uint256) {
}
function getBorrowable() public returns (uint256) {
}
function getCurrentLeverage() public returns (uint256) {
}
// **** Setters **** //
function addKeeper(address _keeper) public {
}
function removeKeeper(address _keeper) public {
}
function setColFactorLeverageBuffer(uint256 _colFactorLeverageBuffer)
public
{
}
function setColFactorSyncBuffer(uint256 _colFactorSyncBuffer) public {
}
// **** State mutations **** //
// Do a `callStatic` on this.
// If it returns true then run it for realz. (i.e. eth_signedTx, not eth_call)
function sync() public returns (bool) {
}
function leverageToMax() public {
}
// Leverages until we're supplying <x> amount
// 1. Redeem <x> DAI
// 2. Repay <x> DAI
function leverageUntil(uint256 _supplyAmount) public onlyKeepers {
}
function deleverageToMin() public {
}
// Deleverages until we're supplying <x> amount
// 1. Redeem <x> DAI
// 2. Repay <x> DAI
function deleverageUntil(uint256 _supplyAmount) public onlyKeepers {
}
function harvest() public override onlyBenevolent {
}
function deposit() public override {
uint256 _want = IERC20(want).balanceOf(address(this));
if (_want > 0) {
IERC20(want).safeApprove(cwant, 0);
IERC20(want).safeApprove(cwant, _want);
require(<FILL_ME>)
}
}
function _withdrawSome(uint256 _amount)
internal
override
returns (uint256)
{
}
}
| ICToken(cwant).mint(_want)==0,"!deposit" | 19,977 | ICToken(cwant).mint(_want)==0 |
"!cash-liquidity" | pragma solidity ^0.6.2;
abstract contract StrategyCmpdBase is StrategyBase, Exponential {
address public constant comptroller = 0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B;
address public constant lens = 0xd513d22422a3062Bd342Ae374b4b9c20E0a9a074;
address public constant comp = 0xc00e94Cb662C3520282E6f5717214004A7f26888;
address public constant cether = 0x4Ddc2D193948926D02f9B1fE9e1daa0718270ED5;
address public constant usdt = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
// dai/usdc
address public want;
// cdai/cusdc
address public cwant;
// Require a 0.05 buffer between
// market collateral factor and strategy's collateral factor
// when leveraging
uint256 colFactorLeverageBuffer = 50;
uint256 colFactorLeverageBufferMax = 1000;
// Allow a 0.05 buffer
// between market collateral factor and strategy's collateral factor
// until we have to deleverage
// This is so we can hit max leverage and keep accruing interest
uint256 colFactorSyncBuffer = 50;
uint256 colFactorSyncBufferMax = 1000;
// Keeper bots
// Maintain leverage within buffer
mapping(address => bool) keepers;
constructor(
address _btf,
address _want,
address _cwant,
address _governance,
address _strategist,
address _controller,
address _timelock
)
public StrategyBase(_btf, _want, _governance, _strategist, _controller, _timelock)
{
}
// **** Modifiers **** //
modifier onlyKeepers {
}
// **** Views **** //
function getSuppliedView() public view returns (uint256) {
}
function getBorrowedView() public view returns (uint256) {
}
function balanceOfPool() public override view returns (uint256) {
}
// Given an unleveraged supply balance, return the target
// leveraged supply balance which is still within the safety buffer
function getLeveragedSupplyTarget(uint256 supplyBalance)
public
view
returns (uint256)
{
}
function getSafeLeverageColFactor() public view returns (uint256) {
}
function getSafeSyncColFactor() public view returns (uint256) {
}
function getMarketColFactor() public view returns (uint256) {
}
// Max leverage we can go up to, w.r.t safe buffer
function getMaxLeverage() public view returns (uint256) {
}
// **** Pseudo-view functions (use `callStatic` on these) **** //
/* The reason why these exists is because of the nature of the
interest accruing supply + borrow balance. The "view" methods
are technically snapshots and don't represent the real value.
As such there are pseudo view methods where you can retrieve the
results by calling `callStatic`.
*/
function getCompAccrued() public returns (uint256) {
}
function getHarvestable() external returns (uint256) {
}
function getColFactor() public returns (uint256) {
}
function getSuppliedUnleveraged() public returns (uint256) {
}
function getSupplied() public returns (uint256) {
}
function getBorrowed() public returns (uint256) {
}
function getBorrowable() public returns (uint256) {
}
function getCurrentLeverage() public returns (uint256) {
}
// **** Setters **** //
function addKeeper(address _keeper) public {
}
function removeKeeper(address _keeper) public {
}
function setColFactorLeverageBuffer(uint256 _colFactorLeverageBuffer)
public
{
}
function setColFactorSyncBuffer(uint256 _colFactorSyncBuffer) public {
}
// **** State mutations **** //
// Do a `callStatic` on this.
// If it returns true then run it for realz. (i.e. eth_signedTx, not eth_call)
function sync() public returns (bool) {
}
function leverageToMax() public {
}
// Leverages until we're supplying <x> amount
// 1. Redeem <x> DAI
// 2. Repay <x> DAI
function leverageUntil(uint256 _supplyAmount) public onlyKeepers {
}
function deleverageToMin() public {
}
// Deleverages until we're supplying <x> amount
// 1. Redeem <x> DAI
// 2. Repay <x> DAI
function deleverageUntil(uint256 _supplyAmount) public onlyKeepers {
}
function harvest() public override onlyBenevolent {
}
function deposit() public override {
}
function _withdrawSome(uint256 _amount)
internal
override
returns (uint256)
{
uint256 _want = balanceOfWant();
if (_want < _amount) {
uint256 _redeem = _amount.sub(_want);
// Make sure market can cover liquidity
require(<FILL_ME>)
// How much borrowed amount do we need to free?
uint256 borrowed = getBorrowed();
uint256 supplied = getSupplied();
uint256 curLeverage = getCurrentLeverage();
uint256 borrowedToBeFree = _redeem.mul(curLeverage).div(1e18);
// If the amount we need to free is > borrowed
// Just free up all the borrowed amount
if (borrowedToBeFree > borrowed) {
this.deleverageToMin();
} else {
// Otherwise just keep freeing up borrowed amounts until
// we hit a safe number to redeem our underlying
this.deleverageUntil(supplied.sub(borrowedToBeFree));
}
// Redeems underlying
require(ICToken(cwant).redeemUnderlying(_redeem) == 0, "!redeem");
}
return _amount;
}
}
| ICToken(cwant).getCash()>=_redeem,"!cash-liquidity" | 19,977 | ICToken(cwant).getCash()>=_redeem |
"!redeem" | pragma solidity ^0.6.2;
abstract contract StrategyCmpdBase is StrategyBase, Exponential {
address public constant comptroller = 0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B;
address public constant lens = 0xd513d22422a3062Bd342Ae374b4b9c20E0a9a074;
address public constant comp = 0xc00e94Cb662C3520282E6f5717214004A7f26888;
address public constant cether = 0x4Ddc2D193948926D02f9B1fE9e1daa0718270ED5;
address public constant usdt = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
// dai/usdc
address public want;
// cdai/cusdc
address public cwant;
// Require a 0.05 buffer between
// market collateral factor and strategy's collateral factor
// when leveraging
uint256 colFactorLeverageBuffer = 50;
uint256 colFactorLeverageBufferMax = 1000;
// Allow a 0.05 buffer
// between market collateral factor and strategy's collateral factor
// until we have to deleverage
// This is so we can hit max leverage and keep accruing interest
uint256 colFactorSyncBuffer = 50;
uint256 colFactorSyncBufferMax = 1000;
// Keeper bots
// Maintain leverage within buffer
mapping(address => bool) keepers;
constructor(
address _btf,
address _want,
address _cwant,
address _governance,
address _strategist,
address _controller,
address _timelock
)
public StrategyBase(_btf, _want, _governance, _strategist, _controller, _timelock)
{
}
// **** Modifiers **** //
modifier onlyKeepers {
}
// **** Views **** //
function getSuppliedView() public view returns (uint256) {
}
function getBorrowedView() public view returns (uint256) {
}
function balanceOfPool() public override view returns (uint256) {
}
// Given an unleveraged supply balance, return the target
// leveraged supply balance which is still within the safety buffer
function getLeveragedSupplyTarget(uint256 supplyBalance)
public
view
returns (uint256)
{
}
function getSafeLeverageColFactor() public view returns (uint256) {
}
function getSafeSyncColFactor() public view returns (uint256) {
}
function getMarketColFactor() public view returns (uint256) {
}
// Max leverage we can go up to, w.r.t safe buffer
function getMaxLeverage() public view returns (uint256) {
}
// **** Pseudo-view functions (use `callStatic` on these) **** //
/* The reason why these exists is because of the nature of the
interest accruing supply + borrow balance. The "view" methods
are technically snapshots and don't represent the real value.
As such there are pseudo view methods where you can retrieve the
results by calling `callStatic`.
*/
function getCompAccrued() public returns (uint256) {
}
function getHarvestable() external returns (uint256) {
}
function getColFactor() public returns (uint256) {
}
function getSuppliedUnleveraged() public returns (uint256) {
}
function getSupplied() public returns (uint256) {
}
function getBorrowed() public returns (uint256) {
}
function getBorrowable() public returns (uint256) {
}
function getCurrentLeverage() public returns (uint256) {
}
// **** Setters **** //
function addKeeper(address _keeper) public {
}
function removeKeeper(address _keeper) public {
}
function setColFactorLeverageBuffer(uint256 _colFactorLeverageBuffer)
public
{
}
function setColFactorSyncBuffer(uint256 _colFactorSyncBuffer) public {
}
// **** State mutations **** //
// Do a `callStatic` on this.
// If it returns true then run it for realz. (i.e. eth_signedTx, not eth_call)
function sync() public returns (bool) {
}
function leverageToMax() public {
}
// Leverages until we're supplying <x> amount
// 1. Redeem <x> DAI
// 2. Repay <x> DAI
function leverageUntil(uint256 _supplyAmount) public onlyKeepers {
}
function deleverageToMin() public {
}
// Deleverages until we're supplying <x> amount
// 1. Redeem <x> DAI
// 2. Repay <x> DAI
function deleverageUntil(uint256 _supplyAmount) public onlyKeepers {
}
function harvest() public override onlyBenevolent {
}
function deposit() public override {
}
function _withdrawSome(uint256 _amount)
internal
override
returns (uint256)
{
uint256 _want = balanceOfWant();
if (_want < _amount) {
uint256 _redeem = _amount.sub(_want);
// Make sure market can cover liquidity
require(ICToken(cwant).getCash() >= _redeem, "!cash-liquidity");
// How much borrowed amount do we need to free?
uint256 borrowed = getBorrowed();
uint256 supplied = getSupplied();
uint256 curLeverage = getCurrentLeverage();
uint256 borrowedToBeFree = _redeem.mul(curLeverage).div(1e18);
// If the amount we need to free is > borrowed
// Just free up all the borrowed amount
if (borrowedToBeFree > borrowed) {
this.deleverageToMin();
} else {
// Otherwise just keep freeing up borrowed amounts until
// we hit a safe number to redeem our underlying
this.deleverageUntil(supplied.sub(borrowedToBeFree));
}
// Redeems underlying
require(<FILL_ME>)
}
return _amount;
}
}
| ICToken(cwant).redeemUnderlying(_redeem)==0,"!redeem" | 19,977 | ICToken(cwant).redeemUnderlying(_redeem)==0 |
null | pragma solidity ^0.4.25;
/**
Triple ROI: https://12hourtrains.github.io/
Earn 4% per 3 hours, triple your ROI every 3 hours you HODL!
3 hours: 4%
6 hours: 12%
9 hours: 36%
12 hours: 108%
...etc...
*/
contract TripleROI {
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) referrer;
uint256 public step = 1000;
uint256 public minimum = 10 finney;
uint256 public maximum = 5 ether;
uint256 public stakingRequirement = 0.3 ether;
address public ownerWallet;
address public owner;
bool public gameStarted;
event Invest(address investor, uint256 amount);
event Withdraw(address investor, uint256 amount);
event Bounty(address hunter, uint256 amount);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Π‘onstructor Sets the original roles of the contract
*/
constructor() public {
}
/**
* @dev Modifiers
*/
modifier onlyOwner() {
}
function startGame() public onlyOwner {
}
/**
* @dev Allows current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
* @param newOwnerWallet The address to transfer ownership to.
*/
function transferOwnership(address newOwner, address newOwnerWallet) public onlyOwner {
}
/**
* @dev Investments
*/
function () public payable {
}
function buy(address _referredBy) public payable {
}
/**
* @dev Evaluate current balance
* @param _address Address of investor
*/
function getBalance(address _address) view public returns (uint256) {
}
/**
* @dev Withdraw dividends from contract
*/
function withdraw() public returns (bool){
require(<FILL_ME>)
uint256 balance = getBalance(msg.sender);
// Reset ROI mulitplier of user
joined[msg.sender] = block.timestamp;
if (address(this).balance > balance){
if (balance > 0){
msg.sender.transfer(balance);
emit Withdraw(msg.sender, balance);
}
return true;
} else {
if (balance > 0) {
msg.sender.transfer(address(this).balance);
emit Withdraw(msg.sender, balance);
}
return true;
}
}
/**
* @dev Bounty reward
*/
function bounty() public {
}
/**
* @dev Gets balance of the sender address.
* @return An uint256 representing the amount owned by the msg.sender.
*/
function checkBalance() public view returns (uint256) {
}
/**
* @dev Gets investments of the specified address.
* @param _investor The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function checkInvestments(address _investor) public view returns (uint256) {
}
/**
* @dev Gets referrer balance of the specified address.
* @param _hunter The address of the referrer
* @return An uint256 representing the referral earnings.
*/
function checkReferral(address _hunter) public view returns (uint256) {
}
}
/**
* @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) {
}
}
| joined[msg.sender]>0 | 20,022 | joined[msg.sender]>0 |
"ERR_ETH_AMOUNT_MISMATCH" | pragma solidity 0.4.26;
/**
* @dev Liquidity Pool v1 Converter
*
* The liquidity pool v1 converter is a specialized version of a converter that manages
* a classic bancor liquidity pool.
*
* Even though classic pools can have many reserves, the most common configuration of
* the pool has 2 reserves with 50%/50% weights.
*/
contract LiquidityPoolV1Converter is LiquidityPoolConverter {
IEtherToken internal etherToken = IEtherToken(0xc0829421C1d260BD3cB3E0F06cfE2D52db2cE315);
/**
* @dev triggered after a conversion with new price data
* deprecated, use `TokenRateUpdate` from version 28 and up
*
* @param _connectorToken reserve token
* @param _tokenSupply smart token supply
* @param _connectorBalance reserve balance
* @param _connectorWeight reserve weight
*/
event PriceDataUpdate(
address indexed _connectorToken,
uint256 _tokenSupply,
uint256 _connectorBalance,
uint32 _connectorWeight
);
/**
* @dev initializes a new LiquidityPoolV1Converter instance
*
* @param _token pool token governed by the converter
* @param _registry address of a contract registry contract
* @param _maxConversionFee maximum conversion fee, represented in ppm
*/
constructor(
ISmartToken _token,
IContractRegistry _registry,
uint32 _maxConversionFee
)
LiquidityPoolConverter(_token, _registry, _maxConversionFee)
public
{
}
/**
* @dev returns the converter type
*
* @return see the converter types in the the main contract doc
*/
function converterType() public pure returns (uint16) {
}
/**
* @dev accepts ownership of the anchor after an ownership transfer
* also activates the converter
* can only be called by the contract owner
* note that prior to version 28, you should use 'acceptTokenOwnership' instead
*/
function acceptAnchorOwnership() public ownerOnly {
}
/**
* @dev returns the expected target amount of converting one reserve to another along with the fee
*
* @param _sourceToken contract address of the source reserve token
* @param _targetToken contract address of the target reserve token
* @param _amount amount of tokens received from the user
*
* @return expected target amount
* @return expected fee
*/
function targetAmountAndFee(IERC20Token _sourceToken, IERC20Token _targetToken, uint256 _amount)
public
view
active
validReserve(_sourceToken)
validReserve(_targetToken)
returns (uint256, uint256)
{
}
/**
* @dev converts a specific amount of source tokens to target tokens
* can only be called by the bancor network contract
*
* @param _sourceToken source ERC20 token
* @param _targetToken target ERC20 token
* @param _amount amount of tokens to convert (in units of the source token)
* @param _trader address of the caller who executed the conversion
* @param _beneficiary wallet to receive the conversion result
*
* @return amount of tokens received (in units of the target token)
*/
function doConvert(IERC20Token _sourceToken, IERC20Token _targetToken, uint256 _amount, address _trader, address _beneficiary)
internal
returns (uint256)
{
}
/**
* @dev increases the pool's liquidity and mints new shares in the pool to the caller
* note that prior to version 28, you should use 'fund' instead
*
* @param _reserveTokens address of each reserve token
* @param _reserveAmounts amount of each reserve token
* @param _minReturn token minimum return-amount
*/
function addLiquidity(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts, uint256 _minReturn)
public
payable
protected
active
{
// verify the user input
verifyLiquidityInput(_reserveTokens, _reserveAmounts, _minReturn);
// if one of the reserves is ETH, then verify that the input amount of ETH is equal to the input value of ETH
for (uint256 i = 0; i < _reserveTokens.length; i++)
if (_reserveTokens[i] == ETH_RESERVE_ADDRESS)
require(<FILL_ME>)
// if the input value of ETH is larger than zero, then verify that one of the reserves is ETH
if (msg.value > 0)
require(reserves[ETH_RESERVE_ADDRESS].isSet, "ERR_NO_ETH_RESERVE");
// get the total supply
uint256 totalSupply = ISmartToken(anchor).totalSupply();
// transfer from the user an equally-worth amount of each one of the reserve tokens
uint256 amount = addLiquidityToPool(_reserveTokens, _reserveAmounts, totalSupply);
// verify that the equivalent amount of tokens is equal to or larger than the user's expectation
require(amount >= _minReturn, "ERR_RETURN_TOO_LOW");
// issue the tokens to the user
ISmartToken(anchor).issue(msg.sender, amount);
}
/**
* @dev decreases the pool's liquidity and burns the caller's shares in the pool
* note that prior to version 28, you should use 'liquidate' instead
*
* @param _amount token amount
* @param _reserveTokens address of each reserve token
* @param _reserveMinReturnAmounts minimum return-amount of each reserve token
*/
function removeLiquidity(uint256 _amount, IERC20Token[] memory _reserveTokens, uint256[] memory _reserveMinReturnAmounts)
public
protected
active
{
}
/**
* @dev increases the pool's liquidity and mints new shares in the pool to the caller
* for example, if the caller increases the supply by 10%,
* then it will cost an amount equal to 10% of each reserve token balance
* note that starting from version 28, you should use 'addLiquidity' instead
*
* @param _amount amount to increase the supply by (in the pool token)
*/
function fund(uint256 _amount) public payable protected {
}
/**
* @dev decreases the pool's liquidity and burns the caller's shares in the pool
* for example, if the holder sells 10% of the supply,
* then they will receive 10% of each reserve token balance in return
* note that starting from version 28, you should use 'removeLiquidity' instead
*
* @param _amount amount to liquidate (in the pool token)
*/
function liquidate(uint256 _amount) public protected {
}
/**
* @dev verifies that a given array of tokens is identical to the converter's array of reserve tokens
* we take this input in order to allow specifying the corresponding reserve amounts in any order
*
* @param _reserveTokens array of reserve tokens
* @param _reserveAmounts array of reserve amounts
* @param _amount token amount
*/
function verifyLiquidityInput(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts, uint256 _amount) private view {
}
/**
* @dev adds liquidity (reserve) to the pool
*
* @param _reserveTokens address of each reserve token
* @param _reserveAmounts amount of each reserve token
* @param _totalSupply token total supply
*/
function addLiquidityToPool(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts, uint256 _totalSupply)
private
returns (uint256)
{
}
/**
* @dev adds liquidity (reserve) to the pool when it's empty
*
* @param _reserveTokens address of each reserve token
* @param _reserveAmounts amount of each reserve token
*/
function addLiquidityToEmptyPool(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts)
private
returns (uint256)
{
}
/**
* @dev adds liquidity (reserve) to the pool when it's not empty
*
* @param _reserveTokens address of each reserve token
* @param _reserveAmounts amount of each reserve token
* @param _totalSupply token total supply
*/
function addLiquidityToNonEmptyPool(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts, uint256 _totalSupply)
private
returns (uint256)
{
}
/**
* @dev removes liquidity (reserve) from the pool
*
* @param _reserveTokens address of each reserve token
* @param _reserveMinReturnAmounts minimum return-amount of each reserve token
* @param _totalSupply token total supply
* @param _amount token amount
*/
function removeLiquidityFromPool(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveMinReturnAmounts, uint256 _totalSupply, uint256 _amount)
private
{
}
function getMinShare(IBancorFormula formula, uint256 _totalSupply, IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts) private view returns (uint256) {
}
/**
* @dev calculates the number of decimal digits in a given value
*
* @param _x value (assumed positive)
* @return the number of decimal digits in the given value
*/
function decimalLength(uint256 _x) public pure returns (uint256) {
}
/**
* @dev calculates the nearest integer to a given quotient
*
* @param _n quotient numerator
* @param _d quotient denominator
* @return the nearest integer to the given quotient
*/
function roundDiv(uint256 _n, uint256 _d) public pure returns (uint256) {
}
/**
* @dev calculates the average number of decimal digits in a given list of values
*
* @param _values list of values (each of which assumed positive)
* @return the average number of decimal digits in the given list of values
*/
function geometricMean(uint256[] memory _values) public pure returns (uint256) {
}
/**
* @dev dispatches rate events for both reserves / pool tokens
* only used to circumvent the `stack too deep` compiler error
*
* @param _sourceToken address of the source reserve token
* @param _targetToken address of the target reserve token
*/
function dispatchRateEvents(IERC20Token _sourceToken, IERC20Token _targetToken) private {
}
/**
* @dev dispatches the `TokenRateUpdate` for the pool token
* only used to circumvent the `stack too deep` compiler error
*
* @param _poolTokenSupply total pool token supply
* @param _reserveToken address of the reserve token
* @param _reserveBalance reserve balance
* @param _reserveWeight reserve weight
*/
function dispatchPoolTokenRateEvent(uint256 _poolTokenSupply, IERC20Token _reserveToken, uint256 _reserveBalance, uint32 _reserveWeight) private {
}
}
| _reserveAmounts[i]==msg.value,"ERR_ETH_AMOUNT_MISMATCH" | 20,039 | _reserveAmounts[i]==msg.value |
"ERR_NO_ETH_RESERVE" | pragma solidity 0.4.26;
/**
* @dev Liquidity Pool v1 Converter
*
* The liquidity pool v1 converter is a specialized version of a converter that manages
* a classic bancor liquidity pool.
*
* Even though classic pools can have many reserves, the most common configuration of
* the pool has 2 reserves with 50%/50% weights.
*/
contract LiquidityPoolV1Converter is LiquidityPoolConverter {
IEtherToken internal etherToken = IEtherToken(0xc0829421C1d260BD3cB3E0F06cfE2D52db2cE315);
/**
* @dev triggered after a conversion with new price data
* deprecated, use `TokenRateUpdate` from version 28 and up
*
* @param _connectorToken reserve token
* @param _tokenSupply smart token supply
* @param _connectorBalance reserve balance
* @param _connectorWeight reserve weight
*/
event PriceDataUpdate(
address indexed _connectorToken,
uint256 _tokenSupply,
uint256 _connectorBalance,
uint32 _connectorWeight
);
/**
* @dev initializes a new LiquidityPoolV1Converter instance
*
* @param _token pool token governed by the converter
* @param _registry address of a contract registry contract
* @param _maxConversionFee maximum conversion fee, represented in ppm
*/
constructor(
ISmartToken _token,
IContractRegistry _registry,
uint32 _maxConversionFee
)
LiquidityPoolConverter(_token, _registry, _maxConversionFee)
public
{
}
/**
* @dev returns the converter type
*
* @return see the converter types in the the main contract doc
*/
function converterType() public pure returns (uint16) {
}
/**
* @dev accepts ownership of the anchor after an ownership transfer
* also activates the converter
* can only be called by the contract owner
* note that prior to version 28, you should use 'acceptTokenOwnership' instead
*/
function acceptAnchorOwnership() public ownerOnly {
}
/**
* @dev returns the expected target amount of converting one reserve to another along with the fee
*
* @param _sourceToken contract address of the source reserve token
* @param _targetToken contract address of the target reserve token
* @param _amount amount of tokens received from the user
*
* @return expected target amount
* @return expected fee
*/
function targetAmountAndFee(IERC20Token _sourceToken, IERC20Token _targetToken, uint256 _amount)
public
view
active
validReserve(_sourceToken)
validReserve(_targetToken)
returns (uint256, uint256)
{
}
/**
* @dev converts a specific amount of source tokens to target tokens
* can only be called by the bancor network contract
*
* @param _sourceToken source ERC20 token
* @param _targetToken target ERC20 token
* @param _amount amount of tokens to convert (in units of the source token)
* @param _trader address of the caller who executed the conversion
* @param _beneficiary wallet to receive the conversion result
*
* @return amount of tokens received (in units of the target token)
*/
function doConvert(IERC20Token _sourceToken, IERC20Token _targetToken, uint256 _amount, address _trader, address _beneficiary)
internal
returns (uint256)
{
}
/**
* @dev increases the pool's liquidity and mints new shares in the pool to the caller
* note that prior to version 28, you should use 'fund' instead
*
* @param _reserveTokens address of each reserve token
* @param _reserveAmounts amount of each reserve token
* @param _minReturn token minimum return-amount
*/
function addLiquidity(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts, uint256 _minReturn)
public
payable
protected
active
{
// verify the user input
verifyLiquidityInput(_reserveTokens, _reserveAmounts, _minReturn);
// if one of the reserves is ETH, then verify that the input amount of ETH is equal to the input value of ETH
for (uint256 i = 0; i < _reserveTokens.length; i++)
if (_reserveTokens[i] == ETH_RESERVE_ADDRESS)
require(_reserveAmounts[i] == msg.value, "ERR_ETH_AMOUNT_MISMATCH");
// if the input value of ETH is larger than zero, then verify that one of the reserves is ETH
if (msg.value > 0)
require(<FILL_ME>)
// get the total supply
uint256 totalSupply = ISmartToken(anchor).totalSupply();
// transfer from the user an equally-worth amount of each one of the reserve tokens
uint256 amount = addLiquidityToPool(_reserveTokens, _reserveAmounts, totalSupply);
// verify that the equivalent amount of tokens is equal to or larger than the user's expectation
require(amount >= _minReturn, "ERR_RETURN_TOO_LOW");
// issue the tokens to the user
ISmartToken(anchor).issue(msg.sender, amount);
}
/**
* @dev decreases the pool's liquidity and burns the caller's shares in the pool
* note that prior to version 28, you should use 'liquidate' instead
*
* @param _amount token amount
* @param _reserveTokens address of each reserve token
* @param _reserveMinReturnAmounts minimum return-amount of each reserve token
*/
function removeLiquidity(uint256 _amount, IERC20Token[] memory _reserveTokens, uint256[] memory _reserveMinReturnAmounts)
public
protected
active
{
}
/**
* @dev increases the pool's liquidity and mints new shares in the pool to the caller
* for example, if the caller increases the supply by 10%,
* then it will cost an amount equal to 10% of each reserve token balance
* note that starting from version 28, you should use 'addLiquidity' instead
*
* @param _amount amount to increase the supply by (in the pool token)
*/
function fund(uint256 _amount) public payable protected {
}
/**
* @dev decreases the pool's liquidity and burns the caller's shares in the pool
* for example, if the holder sells 10% of the supply,
* then they will receive 10% of each reserve token balance in return
* note that starting from version 28, you should use 'removeLiquidity' instead
*
* @param _amount amount to liquidate (in the pool token)
*/
function liquidate(uint256 _amount) public protected {
}
/**
* @dev verifies that a given array of tokens is identical to the converter's array of reserve tokens
* we take this input in order to allow specifying the corresponding reserve amounts in any order
*
* @param _reserveTokens array of reserve tokens
* @param _reserveAmounts array of reserve amounts
* @param _amount token amount
*/
function verifyLiquidityInput(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts, uint256 _amount) private view {
}
/**
* @dev adds liquidity (reserve) to the pool
*
* @param _reserveTokens address of each reserve token
* @param _reserveAmounts amount of each reserve token
* @param _totalSupply token total supply
*/
function addLiquidityToPool(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts, uint256 _totalSupply)
private
returns (uint256)
{
}
/**
* @dev adds liquidity (reserve) to the pool when it's empty
*
* @param _reserveTokens address of each reserve token
* @param _reserveAmounts amount of each reserve token
*/
function addLiquidityToEmptyPool(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts)
private
returns (uint256)
{
}
/**
* @dev adds liquidity (reserve) to the pool when it's not empty
*
* @param _reserveTokens address of each reserve token
* @param _reserveAmounts amount of each reserve token
* @param _totalSupply token total supply
*/
function addLiquidityToNonEmptyPool(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts, uint256 _totalSupply)
private
returns (uint256)
{
}
/**
* @dev removes liquidity (reserve) from the pool
*
* @param _reserveTokens address of each reserve token
* @param _reserveMinReturnAmounts minimum return-amount of each reserve token
* @param _totalSupply token total supply
* @param _amount token amount
*/
function removeLiquidityFromPool(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveMinReturnAmounts, uint256 _totalSupply, uint256 _amount)
private
{
}
function getMinShare(IBancorFormula formula, uint256 _totalSupply, IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts) private view returns (uint256) {
}
/**
* @dev calculates the number of decimal digits in a given value
*
* @param _x value (assumed positive)
* @return the number of decimal digits in the given value
*/
function decimalLength(uint256 _x) public pure returns (uint256) {
}
/**
* @dev calculates the nearest integer to a given quotient
*
* @param _n quotient numerator
* @param _d quotient denominator
* @return the nearest integer to the given quotient
*/
function roundDiv(uint256 _n, uint256 _d) public pure returns (uint256) {
}
/**
* @dev calculates the average number of decimal digits in a given list of values
*
* @param _values list of values (each of which assumed positive)
* @return the average number of decimal digits in the given list of values
*/
function geometricMean(uint256[] memory _values) public pure returns (uint256) {
}
/**
* @dev dispatches rate events for both reserves / pool tokens
* only used to circumvent the `stack too deep` compiler error
*
* @param _sourceToken address of the source reserve token
* @param _targetToken address of the target reserve token
*/
function dispatchRateEvents(IERC20Token _sourceToken, IERC20Token _targetToken) private {
}
/**
* @dev dispatches the `TokenRateUpdate` for the pool token
* only used to circumvent the `stack too deep` compiler error
*
* @param _poolTokenSupply total pool token supply
* @param _reserveToken address of the reserve token
* @param _reserveBalance reserve balance
* @param _reserveWeight reserve weight
*/
function dispatchPoolTokenRateEvent(uint256 _poolTokenSupply, IERC20Token _reserveToken, uint256 _reserveBalance, uint32 _reserveWeight) private {
}
}
| reserves[ETH_RESERVE_ADDRESS].isSet,"ERR_NO_ETH_RESERVE" | 20,039 | reserves[ETH_RESERVE_ADDRESS].isSet |
"ERR_INVALID_RESERVE" | pragma solidity 0.4.26;
/**
* @dev Liquidity Pool v1 Converter
*
* The liquidity pool v1 converter is a specialized version of a converter that manages
* a classic bancor liquidity pool.
*
* Even though classic pools can have many reserves, the most common configuration of
* the pool has 2 reserves with 50%/50% weights.
*/
contract LiquidityPoolV1Converter is LiquidityPoolConverter {
IEtherToken internal etherToken = IEtherToken(0xc0829421C1d260BD3cB3E0F06cfE2D52db2cE315);
/**
* @dev triggered after a conversion with new price data
* deprecated, use `TokenRateUpdate` from version 28 and up
*
* @param _connectorToken reserve token
* @param _tokenSupply smart token supply
* @param _connectorBalance reserve balance
* @param _connectorWeight reserve weight
*/
event PriceDataUpdate(
address indexed _connectorToken,
uint256 _tokenSupply,
uint256 _connectorBalance,
uint32 _connectorWeight
);
/**
* @dev initializes a new LiquidityPoolV1Converter instance
*
* @param _token pool token governed by the converter
* @param _registry address of a contract registry contract
* @param _maxConversionFee maximum conversion fee, represented in ppm
*/
constructor(
ISmartToken _token,
IContractRegistry _registry,
uint32 _maxConversionFee
)
LiquidityPoolConverter(_token, _registry, _maxConversionFee)
public
{
}
/**
* @dev returns the converter type
*
* @return see the converter types in the the main contract doc
*/
function converterType() public pure returns (uint16) {
}
/**
* @dev accepts ownership of the anchor after an ownership transfer
* also activates the converter
* can only be called by the contract owner
* note that prior to version 28, you should use 'acceptTokenOwnership' instead
*/
function acceptAnchorOwnership() public ownerOnly {
}
/**
* @dev returns the expected target amount of converting one reserve to another along with the fee
*
* @param _sourceToken contract address of the source reserve token
* @param _targetToken contract address of the target reserve token
* @param _amount amount of tokens received from the user
*
* @return expected target amount
* @return expected fee
*/
function targetAmountAndFee(IERC20Token _sourceToken, IERC20Token _targetToken, uint256 _amount)
public
view
active
validReserve(_sourceToken)
validReserve(_targetToken)
returns (uint256, uint256)
{
}
/**
* @dev converts a specific amount of source tokens to target tokens
* can only be called by the bancor network contract
*
* @param _sourceToken source ERC20 token
* @param _targetToken target ERC20 token
* @param _amount amount of tokens to convert (in units of the source token)
* @param _trader address of the caller who executed the conversion
* @param _beneficiary wallet to receive the conversion result
*
* @return amount of tokens received (in units of the target token)
*/
function doConvert(IERC20Token _sourceToken, IERC20Token _targetToken, uint256 _amount, address _trader, address _beneficiary)
internal
returns (uint256)
{
}
/**
* @dev increases the pool's liquidity and mints new shares in the pool to the caller
* note that prior to version 28, you should use 'fund' instead
*
* @param _reserveTokens address of each reserve token
* @param _reserveAmounts amount of each reserve token
* @param _minReturn token minimum return-amount
*/
function addLiquidity(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts, uint256 _minReturn)
public
payable
protected
active
{
}
/**
* @dev decreases the pool's liquidity and burns the caller's shares in the pool
* note that prior to version 28, you should use 'liquidate' instead
*
* @param _amount token amount
* @param _reserveTokens address of each reserve token
* @param _reserveMinReturnAmounts minimum return-amount of each reserve token
*/
function removeLiquidity(uint256 _amount, IERC20Token[] memory _reserveTokens, uint256[] memory _reserveMinReturnAmounts)
public
protected
active
{
}
/**
* @dev increases the pool's liquidity and mints new shares in the pool to the caller
* for example, if the caller increases the supply by 10%,
* then it will cost an amount equal to 10% of each reserve token balance
* note that starting from version 28, you should use 'addLiquidity' instead
*
* @param _amount amount to increase the supply by (in the pool token)
*/
function fund(uint256 _amount) public payable protected {
}
/**
* @dev decreases the pool's liquidity and burns the caller's shares in the pool
* for example, if the holder sells 10% of the supply,
* then they will receive 10% of each reserve token balance in return
* note that starting from version 28, you should use 'removeLiquidity' instead
*
* @param _amount amount to liquidate (in the pool token)
*/
function liquidate(uint256 _amount) public protected {
}
/**
* @dev verifies that a given array of tokens is identical to the converter's array of reserve tokens
* we take this input in order to allow specifying the corresponding reserve amounts in any order
*
* @param _reserveTokens array of reserve tokens
* @param _reserveAmounts array of reserve amounts
* @param _amount token amount
*/
function verifyLiquidityInput(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts, uint256 _amount) private view {
uint256 i;
uint256 j;
uint256 length = reserveTokens.length;
require(length == _reserveTokens.length, "ERR_INVALID_RESERVE");
require(length == _reserveAmounts.length, "ERR_INVALID_AMOUNT");
for (i = 0; i < length; i++) {
// verify that every input reserve token is included in the reserve tokens
require(<FILL_ME>)
for (j = 0; j < length; j++) {
if (reserveTokens[i] == _reserveTokens[j])
break;
}
// verify that every reserve token is included in the input reserve tokens
require(j < length, "ERR_INVALID_RESERVE");
// verify that every input reserve token amount is larger than zero
require(_reserveAmounts[i] > 0, "ERR_INVALID_AMOUNT");
}
// verify that the input token amount is larger than zero
require(_amount > 0, "ERR_ZERO_AMOUNT");
}
/**
* @dev adds liquidity (reserve) to the pool
*
* @param _reserveTokens address of each reserve token
* @param _reserveAmounts amount of each reserve token
* @param _totalSupply token total supply
*/
function addLiquidityToPool(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts, uint256 _totalSupply)
private
returns (uint256)
{
}
/**
* @dev adds liquidity (reserve) to the pool when it's empty
*
* @param _reserveTokens address of each reserve token
* @param _reserveAmounts amount of each reserve token
*/
function addLiquidityToEmptyPool(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts)
private
returns (uint256)
{
}
/**
* @dev adds liquidity (reserve) to the pool when it's not empty
*
* @param _reserveTokens address of each reserve token
* @param _reserveAmounts amount of each reserve token
* @param _totalSupply token total supply
*/
function addLiquidityToNonEmptyPool(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts, uint256 _totalSupply)
private
returns (uint256)
{
}
/**
* @dev removes liquidity (reserve) from the pool
*
* @param _reserveTokens address of each reserve token
* @param _reserveMinReturnAmounts minimum return-amount of each reserve token
* @param _totalSupply token total supply
* @param _amount token amount
*/
function removeLiquidityFromPool(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveMinReturnAmounts, uint256 _totalSupply, uint256 _amount)
private
{
}
function getMinShare(IBancorFormula formula, uint256 _totalSupply, IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts) private view returns (uint256) {
}
/**
* @dev calculates the number of decimal digits in a given value
*
* @param _x value (assumed positive)
* @return the number of decimal digits in the given value
*/
function decimalLength(uint256 _x) public pure returns (uint256) {
}
/**
* @dev calculates the nearest integer to a given quotient
*
* @param _n quotient numerator
* @param _d quotient denominator
* @return the nearest integer to the given quotient
*/
function roundDiv(uint256 _n, uint256 _d) public pure returns (uint256) {
}
/**
* @dev calculates the average number of decimal digits in a given list of values
*
* @param _values list of values (each of which assumed positive)
* @return the average number of decimal digits in the given list of values
*/
function geometricMean(uint256[] memory _values) public pure returns (uint256) {
}
/**
* @dev dispatches rate events for both reserves / pool tokens
* only used to circumvent the `stack too deep` compiler error
*
* @param _sourceToken address of the source reserve token
* @param _targetToken address of the target reserve token
*/
function dispatchRateEvents(IERC20Token _sourceToken, IERC20Token _targetToken) private {
}
/**
* @dev dispatches the `TokenRateUpdate` for the pool token
* only used to circumvent the `stack too deep` compiler error
*
* @param _poolTokenSupply total pool token supply
* @param _reserveToken address of the reserve token
* @param _reserveBalance reserve balance
* @param _reserveWeight reserve weight
*/
function dispatchPoolTokenRateEvent(uint256 _poolTokenSupply, IERC20Token _reserveToken, uint256 _reserveBalance, uint32 _reserveWeight) private {
}
}
| reserves[_reserveTokens[i]].isSet,"ERR_INVALID_RESERVE" | 20,039 | reserves[_reserveTokens[i]].isSet |
"ERR_INVALID_AMOUNT" | pragma solidity 0.4.26;
/**
* @dev Liquidity Pool v1 Converter
*
* The liquidity pool v1 converter is a specialized version of a converter that manages
* a classic bancor liquidity pool.
*
* Even though classic pools can have many reserves, the most common configuration of
* the pool has 2 reserves with 50%/50% weights.
*/
contract LiquidityPoolV1Converter is LiquidityPoolConverter {
IEtherToken internal etherToken = IEtherToken(0xc0829421C1d260BD3cB3E0F06cfE2D52db2cE315);
/**
* @dev triggered after a conversion with new price data
* deprecated, use `TokenRateUpdate` from version 28 and up
*
* @param _connectorToken reserve token
* @param _tokenSupply smart token supply
* @param _connectorBalance reserve balance
* @param _connectorWeight reserve weight
*/
event PriceDataUpdate(
address indexed _connectorToken,
uint256 _tokenSupply,
uint256 _connectorBalance,
uint32 _connectorWeight
);
/**
* @dev initializes a new LiquidityPoolV1Converter instance
*
* @param _token pool token governed by the converter
* @param _registry address of a contract registry contract
* @param _maxConversionFee maximum conversion fee, represented in ppm
*/
constructor(
ISmartToken _token,
IContractRegistry _registry,
uint32 _maxConversionFee
)
LiquidityPoolConverter(_token, _registry, _maxConversionFee)
public
{
}
/**
* @dev returns the converter type
*
* @return see the converter types in the the main contract doc
*/
function converterType() public pure returns (uint16) {
}
/**
* @dev accepts ownership of the anchor after an ownership transfer
* also activates the converter
* can only be called by the contract owner
* note that prior to version 28, you should use 'acceptTokenOwnership' instead
*/
function acceptAnchorOwnership() public ownerOnly {
}
/**
* @dev returns the expected target amount of converting one reserve to another along with the fee
*
* @param _sourceToken contract address of the source reserve token
* @param _targetToken contract address of the target reserve token
* @param _amount amount of tokens received from the user
*
* @return expected target amount
* @return expected fee
*/
function targetAmountAndFee(IERC20Token _sourceToken, IERC20Token _targetToken, uint256 _amount)
public
view
active
validReserve(_sourceToken)
validReserve(_targetToken)
returns (uint256, uint256)
{
}
/**
* @dev converts a specific amount of source tokens to target tokens
* can only be called by the bancor network contract
*
* @param _sourceToken source ERC20 token
* @param _targetToken target ERC20 token
* @param _amount amount of tokens to convert (in units of the source token)
* @param _trader address of the caller who executed the conversion
* @param _beneficiary wallet to receive the conversion result
*
* @return amount of tokens received (in units of the target token)
*/
function doConvert(IERC20Token _sourceToken, IERC20Token _targetToken, uint256 _amount, address _trader, address _beneficiary)
internal
returns (uint256)
{
}
/**
* @dev increases the pool's liquidity and mints new shares in the pool to the caller
* note that prior to version 28, you should use 'fund' instead
*
* @param _reserveTokens address of each reserve token
* @param _reserveAmounts amount of each reserve token
* @param _minReturn token minimum return-amount
*/
function addLiquidity(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts, uint256 _minReturn)
public
payable
protected
active
{
}
/**
* @dev decreases the pool's liquidity and burns the caller's shares in the pool
* note that prior to version 28, you should use 'liquidate' instead
*
* @param _amount token amount
* @param _reserveTokens address of each reserve token
* @param _reserveMinReturnAmounts minimum return-amount of each reserve token
*/
function removeLiquidity(uint256 _amount, IERC20Token[] memory _reserveTokens, uint256[] memory _reserveMinReturnAmounts)
public
protected
active
{
}
/**
* @dev increases the pool's liquidity and mints new shares in the pool to the caller
* for example, if the caller increases the supply by 10%,
* then it will cost an amount equal to 10% of each reserve token balance
* note that starting from version 28, you should use 'addLiquidity' instead
*
* @param _amount amount to increase the supply by (in the pool token)
*/
function fund(uint256 _amount) public payable protected {
}
/**
* @dev decreases the pool's liquidity and burns the caller's shares in the pool
* for example, if the holder sells 10% of the supply,
* then they will receive 10% of each reserve token balance in return
* note that starting from version 28, you should use 'removeLiquidity' instead
*
* @param _amount amount to liquidate (in the pool token)
*/
function liquidate(uint256 _amount) public protected {
}
/**
* @dev verifies that a given array of tokens is identical to the converter's array of reserve tokens
* we take this input in order to allow specifying the corresponding reserve amounts in any order
*
* @param _reserveTokens array of reserve tokens
* @param _reserveAmounts array of reserve amounts
* @param _amount token amount
*/
function verifyLiquidityInput(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts, uint256 _amount) private view {
uint256 i;
uint256 j;
uint256 length = reserveTokens.length;
require(length == _reserveTokens.length, "ERR_INVALID_RESERVE");
require(length == _reserveAmounts.length, "ERR_INVALID_AMOUNT");
for (i = 0; i < length; i++) {
// verify that every input reserve token is included in the reserve tokens
require(reserves[_reserveTokens[i]].isSet, "ERR_INVALID_RESERVE");
for (j = 0; j < length; j++) {
if (reserveTokens[i] == _reserveTokens[j])
break;
}
// verify that every reserve token is included in the input reserve tokens
require(j < length, "ERR_INVALID_RESERVE");
// verify that every input reserve token amount is larger than zero
require(<FILL_ME>)
}
// verify that the input token amount is larger than zero
require(_amount > 0, "ERR_ZERO_AMOUNT");
}
/**
* @dev adds liquidity (reserve) to the pool
*
* @param _reserveTokens address of each reserve token
* @param _reserveAmounts amount of each reserve token
* @param _totalSupply token total supply
*/
function addLiquidityToPool(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts, uint256 _totalSupply)
private
returns (uint256)
{
}
/**
* @dev adds liquidity (reserve) to the pool when it's empty
*
* @param _reserveTokens address of each reserve token
* @param _reserveAmounts amount of each reserve token
*/
function addLiquidityToEmptyPool(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts)
private
returns (uint256)
{
}
/**
* @dev adds liquidity (reserve) to the pool when it's not empty
*
* @param _reserveTokens address of each reserve token
* @param _reserveAmounts amount of each reserve token
* @param _totalSupply token total supply
*/
function addLiquidityToNonEmptyPool(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts, uint256 _totalSupply)
private
returns (uint256)
{
}
/**
* @dev removes liquidity (reserve) from the pool
*
* @param _reserveTokens address of each reserve token
* @param _reserveMinReturnAmounts minimum return-amount of each reserve token
* @param _totalSupply token total supply
* @param _amount token amount
*/
function removeLiquidityFromPool(IERC20Token[] memory _reserveTokens, uint256[] memory _reserveMinReturnAmounts, uint256 _totalSupply, uint256 _amount)
private
{
}
function getMinShare(IBancorFormula formula, uint256 _totalSupply, IERC20Token[] memory _reserveTokens, uint256[] memory _reserveAmounts) private view returns (uint256) {
}
/**
* @dev calculates the number of decimal digits in a given value
*
* @param _x value (assumed positive)
* @return the number of decimal digits in the given value
*/
function decimalLength(uint256 _x) public pure returns (uint256) {
}
/**
* @dev calculates the nearest integer to a given quotient
*
* @param _n quotient numerator
* @param _d quotient denominator
* @return the nearest integer to the given quotient
*/
function roundDiv(uint256 _n, uint256 _d) public pure returns (uint256) {
}
/**
* @dev calculates the average number of decimal digits in a given list of values
*
* @param _values list of values (each of which assumed positive)
* @return the average number of decimal digits in the given list of values
*/
function geometricMean(uint256[] memory _values) public pure returns (uint256) {
}
/**
* @dev dispatches rate events for both reserves / pool tokens
* only used to circumvent the `stack too deep` compiler error
*
* @param _sourceToken address of the source reserve token
* @param _targetToken address of the target reserve token
*/
function dispatchRateEvents(IERC20Token _sourceToken, IERC20Token _targetToken) private {
}
/**
* @dev dispatches the `TokenRateUpdate` for the pool token
* only used to circumvent the `stack too deep` compiler error
*
* @param _poolTokenSupply total pool token supply
* @param _reserveToken address of the reserve token
* @param _reserveBalance reserve balance
* @param _reserveWeight reserve weight
*/
function dispatchPoolTokenRateEvent(uint256 _poolTokenSupply, IERC20Token _reserveToken, uint256 _reserveBalance, uint32 _reserveWeight) private {
}
}
| _reserveAmounts[i]>0,"ERR_INVALID_AMOUNT" | 20,039 | _reserveAmounts[i]>0 |
null | /**
*Submitted for verification at Etherscan.io on 2019-09-30
*/
pragma solidity ^0.5.11;
library SafeMathMod {// Partial SafeMath Library
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(<FILL_ME>)
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns(uint c) {
}
function div(uint a, uint b) internal pure returns(uint c) {
}
}
contract ERC20Interface {
function totalSupply() public view returns(uint);
function balanceOf(address tokenOwner) public view returns(uint balance);
function allowance(address tokenOwner, address spender) public view returns(uint remaining);
function transfer(address to, uint tokens) public returns(bool success);
function approve(address spender, uint tokens) public returns(bool success);
function transferFrom(address from, address to, uint tokens) public returns(bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
// blacklist
contract UserLock is Owned {
mapping(address => bool) blacklist;
event LockUser(address indexed who);
event UnlockUser(address indexed who);
modifier permissionCheck {
}
function lockUser(address who) public onlyOwner {
}
function unlockUser(address who) public onlyOwner {
}
}
contract Tokenlock is Owned {
uint8 isLocked = 0;
event Freezed();
event UnFreezed();
modifier validLock {
}
function freeze() public onlyOwner {
}
function unfreeze() public onlyOwner {
}
}
contract IHB is ERC20Interface, Tokenlock, UserLock{//is inherently ERC20
using SafeMathMod for uint256;
/**
* @constant name The name of the token
* @constant symbol The symbol used to display the currency
* @constant decimals The number of decimals used to dispay a balance
* @constant totalSupply The total number of tokens times 10^ of the number of decimals
* @constant MAX_UINT256 Magic number for unlimited allowance
* @storage balanceOf Holds the balances of all token holders
* @storage allowed Holds the allowable balance to be transferable by another address.
*/
string constant public name = "IHB";
string constant public symbol = "IHB";
uint8 constant public decimals = 6;
uint256 _totalSupply = 9e13; // 9000W
uint256 constant private MAX_UINT256 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event TransferFrom(address indexed _spender, address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
constructor() public {
}
function totalSupply() public view returns(uint) {
}
function balanceOf(address tokenOwner) public view returns(uint balance) {
}
/**
* @notice send `_value` token to `_to` from `msg.sender`
*
* @param _to The address of the recipient
* @param _value The amount of token to be transferred
* @return Whether the transfer was successful or not
*/
function transfer(address _to, uint256 _value) public validLock permissionCheck returns (bool success) {
}
/**
* @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value The amount of token to be transferred
* @return Whether the transfer was successful or not
*/
function transferFrom(address _from, address _to, uint256 _value) public validLock permissionCheck returns (bool success) {
}
/**
* @notice `msg.sender` approves `_spender` to spend `_value` tokens
*
* @param _spender The address of the account able to transfer the tokens
* @param _value The amount of tokens to be approved for transfer
* @return Whether the approval was successful or not
*/
function approve(address _spender, uint256 _value) public validLock permissionCheck returns (bool success) {
}
/**
* @param _owner The address of the account owning tokens
* @param _spender The address of the account able to transfer the tokens
* @return Amount of remaining tokens allowed to spent
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
// trust pay
function approveAndCall(address spender, uint tokens, bytes memory data) public validLock permissionCheck returns(bool success) {
}
function mintToken(address target, uint256 mintedAmount) public onlyOwner {
}
function () external payable {
}
function isNotContract(address _addr) private view returns (bool) {
}
}
| (c=a-b)<a | 20,108 | (c=a-b)<a |
null | /**
*Submitted for verification at Etherscan.io on 2019-09-30
*/
pragma solidity ^0.5.11;
library SafeMathMod {// Partial SafeMath Library
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(<FILL_ME>)
}
function mul(uint256 a, uint256 b) internal pure returns(uint c) {
}
function div(uint a, uint b) internal pure returns(uint c) {
}
}
contract ERC20Interface {
function totalSupply() public view returns(uint);
function balanceOf(address tokenOwner) public view returns(uint balance);
function allowance(address tokenOwner, address spender) public view returns(uint remaining);
function transfer(address to, uint tokens) public returns(bool success);
function approve(address spender, uint tokens) public returns(bool success);
function transferFrom(address from, address to, uint tokens) public returns(bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
// blacklist
contract UserLock is Owned {
mapping(address => bool) blacklist;
event LockUser(address indexed who);
event UnlockUser(address indexed who);
modifier permissionCheck {
}
function lockUser(address who) public onlyOwner {
}
function unlockUser(address who) public onlyOwner {
}
}
contract Tokenlock is Owned {
uint8 isLocked = 0;
event Freezed();
event UnFreezed();
modifier validLock {
}
function freeze() public onlyOwner {
}
function unfreeze() public onlyOwner {
}
}
contract IHB is ERC20Interface, Tokenlock, UserLock{//is inherently ERC20
using SafeMathMod for uint256;
/**
* @constant name The name of the token
* @constant symbol The symbol used to display the currency
* @constant decimals The number of decimals used to dispay a balance
* @constant totalSupply The total number of tokens times 10^ of the number of decimals
* @constant MAX_UINT256 Magic number for unlimited allowance
* @storage balanceOf Holds the balances of all token holders
* @storage allowed Holds the allowable balance to be transferable by another address.
*/
string constant public name = "IHB";
string constant public symbol = "IHB";
uint8 constant public decimals = 6;
uint256 _totalSupply = 9e13; // 9000W
uint256 constant private MAX_UINT256 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event TransferFrom(address indexed _spender, address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
constructor() public {
}
function totalSupply() public view returns(uint) {
}
function balanceOf(address tokenOwner) public view returns(uint balance) {
}
/**
* @notice send `_value` token to `_to` from `msg.sender`
*
* @param _to The address of the recipient
* @param _value The amount of token to be transferred
* @return Whether the transfer was successful or not
*/
function transfer(address _to, uint256 _value) public validLock permissionCheck returns (bool success) {
}
/**
* @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value The amount of token to be transferred
* @return Whether the transfer was successful or not
*/
function transferFrom(address _from, address _to, uint256 _value) public validLock permissionCheck returns (bool success) {
}
/**
* @notice `msg.sender` approves `_spender` to spend `_value` tokens
*
* @param _spender The address of the account able to transfer the tokens
* @param _value The amount of tokens to be approved for transfer
* @return Whether the approval was successful or not
*/
function approve(address _spender, uint256 _value) public validLock permissionCheck returns (bool success) {
}
/**
* @param _owner The address of the account owning tokens
* @param _spender The address of the account able to transfer the tokens
* @return Amount of remaining tokens allowed to spent
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
// trust pay
function approveAndCall(address spender, uint tokens, bytes memory data) public validLock permissionCheck returns(bool success) {
}
function mintToken(address target, uint256 mintedAmount) public onlyOwner {
}
function () external payable {
}
function isNotContract(address _addr) private view returns (bool) {
}
}
| (c=a+b)>a | 20,108 | (c=a+b)>a |
null | /**
*Submitted for verification at Etherscan.io on 2019-09-30
*/
pragma solidity ^0.5.11;
library SafeMathMod {// Partial SafeMath Library
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns(uint c) {
}
function div(uint a, uint b) internal pure returns(uint c) {
}
}
contract ERC20Interface {
function totalSupply() public view returns(uint);
function balanceOf(address tokenOwner) public view returns(uint balance);
function allowance(address tokenOwner, address spender) public view returns(uint remaining);
function transfer(address to, uint tokens) public returns(bool success);
function approve(address spender, uint tokens) public returns(bool success);
function transferFrom(address from, address to, uint tokens) public returns(bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
// blacklist
contract UserLock is Owned {
mapping(address => bool) blacklist;
event LockUser(address indexed who);
event UnlockUser(address indexed who);
modifier permissionCheck {
require(<FILL_ME>)
_;
}
function lockUser(address who) public onlyOwner {
}
function unlockUser(address who) public onlyOwner {
}
}
contract Tokenlock is Owned {
uint8 isLocked = 0;
event Freezed();
event UnFreezed();
modifier validLock {
}
function freeze() public onlyOwner {
}
function unfreeze() public onlyOwner {
}
}
contract IHB is ERC20Interface, Tokenlock, UserLock{//is inherently ERC20
using SafeMathMod for uint256;
/**
* @constant name The name of the token
* @constant symbol The symbol used to display the currency
* @constant decimals The number of decimals used to dispay a balance
* @constant totalSupply The total number of tokens times 10^ of the number of decimals
* @constant MAX_UINT256 Magic number for unlimited allowance
* @storage balanceOf Holds the balances of all token holders
* @storage allowed Holds the allowable balance to be transferable by another address.
*/
string constant public name = "IHB";
string constant public symbol = "IHB";
uint8 constant public decimals = 6;
uint256 _totalSupply = 9e13; // 9000W
uint256 constant private MAX_UINT256 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event TransferFrom(address indexed _spender, address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
constructor() public {
}
function totalSupply() public view returns(uint) {
}
function balanceOf(address tokenOwner) public view returns(uint balance) {
}
/**
* @notice send `_value` token to `_to` from `msg.sender`
*
* @param _to The address of the recipient
* @param _value The amount of token to be transferred
* @return Whether the transfer was successful or not
*/
function transfer(address _to, uint256 _value) public validLock permissionCheck returns (bool success) {
}
/**
* @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value The amount of token to be transferred
* @return Whether the transfer was successful or not
*/
function transferFrom(address _from, address _to, uint256 _value) public validLock permissionCheck returns (bool success) {
}
/**
* @notice `msg.sender` approves `_spender` to spend `_value` tokens
*
* @param _spender The address of the account able to transfer the tokens
* @param _value The amount of tokens to be approved for transfer
* @return Whether the approval was successful or not
*/
function approve(address _spender, uint256 _value) public validLock permissionCheck returns (bool success) {
}
/**
* @param _owner The address of the account owning tokens
* @param _spender The address of the account able to transfer the tokens
* @return Amount of remaining tokens allowed to spent
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
// trust pay
function approveAndCall(address spender, uint tokens, bytes memory data) public validLock permissionCheck returns(bool success) {
}
function mintToken(address target, uint256 mintedAmount) public onlyOwner {
}
function () external payable {
}
function isNotContract(address _addr) private view returns (bool) {
}
}
| !blacklist[msg.sender] | 20,108 | !blacklist[msg.sender] |
null | /**
*Submitted for verification at Etherscan.io on 2019-09-30
*/
pragma solidity ^0.5.11;
library SafeMathMod {// Partial SafeMath Library
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns(uint c) {
}
function div(uint a, uint b) internal pure returns(uint c) {
}
}
contract ERC20Interface {
function totalSupply() public view returns(uint);
function balanceOf(address tokenOwner) public view returns(uint balance);
function allowance(address tokenOwner, address spender) public view returns(uint remaining);
function transfer(address to, uint tokens) public returns(bool success);
function approve(address spender, uint tokens) public returns(bool success);
function transferFrom(address from, address to, uint tokens) public returns(bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;
}
contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
// blacklist
contract UserLock is Owned {
mapping(address => bool) blacklist;
event LockUser(address indexed who);
event UnlockUser(address indexed who);
modifier permissionCheck {
}
function lockUser(address who) public onlyOwner {
}
function unlockUser(address who) public onlyOwner {
}
}
contract Tokenlock is Owned {
uint8 isLocked = 0;
event Freezed();
event UnFreezed();
modifier validLock {
}
function freeze() public onlyOwner {
}
function unfreeze() public onlyOwner {
}
}
contract IHB is ERC20Interface, Tokenlock, UserLock{//is inherently ERC20
using SafeMathMod for uint256;
/**
* @constant name The name of the token
* @constant symbol The symbol used to display the currency
* @constant decimals The number of decimals used to dispay a balance
* @constant totalSupply The total number of tokens times 10^ of the number of decimals
* @constant MAX_UINT256 Magic number for unlimited allowance
* @storage balanceOf Holds the balances of all token holders
* @storage allowed Holds the allowable balance to be transferable by another address.
*/
string constant public name = "IHB";
string constant public symbol = "IHB";
uint8 constant public decimals = 6;
uint256 _totalSupply = 9e13; // 9000W
uint256 constant private MAX_UINT256 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event TransferFrom(address indexed _spender, address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
constructor() public {
}
function totalSupply() public view returns(uint) {
}
function balanceOf(address tokenOwner) public view returns(uint balance) {
}
/**
* @notice send `_value` token to `_to` from `msg.sender`
*
* @param _to The address of the recipient
* @param _value The amount of token to be transferred
* @return Whether the transfer was successful or not
*/
function transfer(address _to, uint256 _value) public validLock permissionCheck returns (bool success) {
/* Ensures that tokens are not sent to address "0x0" */
require(_to != address(0));
/* Prevents sending tokens directly to contracts. */
require(<FILL_ME>)
/* SafeMathMOd.sub will throw if there is not enough balance and if the transfer value is 0. */
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
* @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value The amount of token to be transferred
* @return Whether the transfer was successful or not
*/
function transferFrom(address _from, address _to, uint256 _value) public validLock permissionCheck returns (bool success) {
}
/**
* @notice `msg.sender` approves `_spender` to spend `_value` tokens
*
* @param _spender The address of the account able to transfer the tokens
* @param _value The amount of tokens to be approved for transfer
* @return Whether the approval was successful or not
*/
function approve(address _spender, uint256 _value) public validLock permissionCheck returns (bool success) {
}
/**
* @param _owner The address of the account owning tokens
* @param _spender The address of the account able to transfer the tokens
* @return Amount of remaining tokens allowed to spent
*/
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
}
// trust pay
function approveAndCall(address spender, uint tokens, bytes memory data) public validLock permissionCheck returns(bool success) {
}
function mintToken(address target, uint256 mintedAmount) public onlyOwner {
}
function () external payable {
}
function isNotContract(address _addr) private view returns (bool) {
}
}
| isNotContract(_to) | 20,108 | isNotContract(_to) |
"already inited" | contract Initializable {
bool inited = false;
modifier initializer() {
require(<FILL_ME>)
_;
inited = true;
}
}
| !inited,"already inited" | 20,117 | !inited |
"Migrator error: no contract code at new implementation address" | /**
* @title CvcMigrator
* @dev This is a system contract which provides transactional upgrade functionality.
* It allows the ability to add 'upgrade transactions' for multiple proxy contracts and execute all of them in single transaction.
*/
contract CvcMigrator is Ownable {
/**
* @dev The ProxyCreated event is emitted when new instance of CvcProxy contract is deployed.
* @param proxyAddress New proxy contract instance address.
*/
event ProxyCreated(address indexed proxyAddress);
struct Migration {
address proxy;
address implementation;
bytes data;
}
/// List of registered upgrades.
Migration[] public migrations;
/**
* @dev Store migration record for the next migration
* @param _proxy Proxy address
* @param _implementation Implementation address
* @param _data Pass-through to proxy's updateToAndCall
*/
function addUpgrade(address _proxy, address _implementation, bytes _data) external onlyOwner {
require(<FILL_ME>)
require(CvcProxy(_proxy).implementation() != _implementation, "Migrator error: proxy contract already uses specified implementation");
migrations.push(Migration(_proxy, _implementation, _data));
}
/**
* @dev Applies stored upgrades to proxies. Flushes the list of migration records
*/
function migrate() external onlyOwner {
}
/**
* @dev Flushes the migration list without applying them. Can be used in case wrong migration added to the list.
*/
function reset() external onlyOwner {
}
/**
* @dev Transfers ownership from the migrator to a new address
* @param _target Proxy address
* @param _newOwner New proxy owner address
*/
function changeProxyAdmin(address _target, address _newOwner) external onlyOwner {
}
/**
* @dev Proxy factory
* @return CvcProxy
*/
function createProxy() external onlyOwner returns (CvcProxy) {
}
/**
* @dev Returns migration record by index. Will become obsolete as soon as migrations() will be usable via web3.js
* @param _index 0-based index
* @return address Proxy address
* @return address Implementation address
* @return bytes Pass-through to proxy's updateToAndCall
*/
function getMigration(uint256 _index) external view returns (address, address, bytes) {
}
/**
* @dev Returns current stored migration count
* @return uint256 Count
*/
function getMigrationCount() external view returns (uint256) {
}
}
| AddressUtils.isContract(_implementation),"Migrator error: no contract code at new implementation address" | 20,143 | AddressUtils.isContract(_implementation) |
"Migrator error: proxy contract already uses specified implementation" | /**
* @title CvcMigrator
* @dev This is a system contract which provides transactional upgrade functionality.
* It allows the ability to add 'upgrade transactions' for multiple proxy contracts and execute all of them in single transaction.
*/
contract CvcMigrator is Ownable {
/**
* @dev The ProxyCreated event is emitted when new instance of CvcProxy contract is deployed.
* @param proxyAddress New proxy contract instance address.
*/
event ProxyCreated(address indexed proxyAddress);
struct Migration {
address proxy;
address implementation;
bytes data;
}
/// List of registered upgrades.
Migration[] public migrations;
/**
* @dev Store migration record for the next migration
* @param _proxy Proxy address
* @param _implementation Implementation address
* @param _data Pass-through to proxy's updateToAndCall
*/
function addUpgrade(address _proxy, address _implementation, bytes _data) external onlyOwner {
require(AddressUtils.isContract(_implementation), "Migrator error: no contract code at new implementation address");
require(<FILL_ME>)
migrations.push(Migration(_proxy, _implementation, _data));
}
/**
* @dev Applies stored upgrades to proxies. Flushes the list of migration records
*/
function migrate() external onlyOwner {
}
/**
* @dev Flushes the migration list without applying them. Can be used in case wrong migration added to the list.
*/
function reset() external onlyOwner {
}
/**
* @dev Transfers ownership from the migrator to a new address
* @param _target Proxy address
* @param _newOwner New proxy owner address
*/
function changeProxyAdmin(address _target, address _newOwner) external onlyOwner {
}
/**
* @dev Proxy factory
* @return CvcProxy
*/
function createProxy() external onlyOwner returns (CvcProxy) {
}
/**
* @dev Returns migration record by index. Will become obsolete as soon as migrations() will be usable via web3.js
* @param _index 0-based index
* @return address Proxy address
* @return address Implementation address
* @return bytes Pass-through to proxy's updateToAndCall
*/
function getMigration(uint256 _index) external view returns (address, address, bytes) {
}
/**
* @dev Returns current stored migration count
* @return uint256 Count
*/
function getMigrationCount() external view returns (uint256) {
}
}
| CvcProxy(_proxy).implementation()!=_implementation,"Migrator error: proxy contract already uses specified implementation" | 20,143 | CvcProxy(_proxy).implementation()!=_implementation |
null | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract StakingContract is Pausable {
using SafeMath for uint256;
mapping(uint256 => ProductAPR) public products; /* Available Products */
uint256[] public productIds; /* Available Product Ids*/
mapping(address => uint256[]) public mySubscriptions; /* Address Based Subcriptions */
uint256 incrementId = 0;
uint256 lockedTokens = 0;
uint256 constant private year = 365 days;
ERC20 public erc20;
struct SubscriptionAPR {
uint256 _id;
uint256 productId;
uint256 startDate;
uint256 endDate;
uint256 amount;
address subscriberAddress;
uint256 APR; /* APR for this product */
bool finalized;
}
struct ProductAPR {
uint256 createdAt;
uint256 startDate;
uint256 endDate;
uint256 totalMaxAmount;
uint256 individualMinimumAmount;
uint256 APR; /* APR for this product */
uint256 currentAmount;
bool lockedUntilFinalization; /* Product can only be withdrawn when finalized */
address[] subscribers;
uint256[] subscriptionIds;
mapping(uint256 => SubscriptionAPR) subscriptions; /* Distribution object */
}
constructor(address _tokenAddress) public {
}
function random() private view returns (uint) {
}
/* Current Held Tokens */
function heldTokens() public view returns (uint256) {
}
/* Locked Tokens for the APR */
function futureLockedTokens() public view returns (uint256) {
}
/* Available Tokens to he APRed by future subscribers */
function availableTokens() public view returns (uint256) {
}
function subscribeProduct(uint256 _product_id, uint256 _amount) external whenNotPaused {
/* Confirm Amount is positive */
require(_amount > 0);
/* Confirm product still exists */
require(block.timestamp < products[_product_id].endDate);
/* Confirm Max Amount was not hit already */
require(<FILL_ME>)
/* Confirm Amount is bigger than minimum Amount */
require(_amount >= products[_product_id].individualMinimumAmount);
uint256 futureAPRAmount = getAPRAmount(products[_product_id].APR, block.timestamp, products[_product_id].endDate, _amount);
/* Confirm the current funds can assure the user the APR is valid */
require(availableTokens() >= futureAPRAmount);
/* Confirm the user has funds for the transfer */
require(erc20.transferFrom(msg.sender, address(this), _amount));
/* Add to LockedTokens */
lockedTokens = lockedTokens.add(_amount.add(futureAPRAmount));
uint256 subscription_id = random().add(incrementId);
incrementId = incrementId + 1;
/* Create SubscriptionAPR Object */
SubscriptionAPR memory subscriptionAPR = SubscriptionAPR(subscription_id, _product_id, block.timestamp, products[_product_id].endDate, _amount,
msg.sender, products[_product_id].APR, false);
/* Create new subscription */
mySubscriptions[msg.sender].push(subscription_id);
products[_product_id].subscriptionIds.push(subscription_id);
products[_product_id].subscriptions[subscription_id] = subscriptionAPR;
products[_product_id].currentAmount = products[_product_id].currentAmount + _amount;
products[_product_id].subscribers.push(msg.sender);
}
function createProduct(uint256 _startDate, uint256 _endDate, uint256 _totalMaxAmount, uint256 _individualMinimumAmount, uint256 _APR, bool _lockedUntilFinalization) external whenNotPaused onlyOwner {
}
function getAPRAmount(uint256 _APR, uint256 _startDate, uint256 _endDate, uint256 _amount) public pure returns(uint256) {
}
function getProductIds() public view returns(uint256[] memory) {
}
function getMySubscriptions(address _address) public view returns(uint256[] memory) {
}
function withdrawSubscription(uint256 _product_id, uint256 _subscription_id) external whenNotPaused {
}
function getSubscription(uint256 _subscription_id, uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, address, uint256, bool){
}
function getProduct(uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, bool, address[] memory, uint256[] memory){
}
function safeGuardAllTokens(address _address) external onlyOwner whenPaused {
}
function changeTokenAddress(address _tokenAddress) external onlyOwner whenPaused {
}
}
| products[_product_id].totalMaxAmount>(products[_product_id].currentAmount+_amount) | 20,186 | products[_product_id].totalMaxAmount>(products[_product_id].currentAmount+_amount) |
null | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract StakingContract is Pausable {
using SafeMath for uint256;
mapping(uint256 => ProductAPR) public products; /* Available Products */
uint256[] public productIds; /* Available Product Ids*/
mapping(address => uint256[]) public mySubscriptions; /* Address Based Subcriptions */
uint256 incrementId = 0;
uint256 lockedTokens = 0;
uint256 constant private year = 365 days;
ERC20 public erc20;
struct SubscriptionAPR {
uint256 _id;
uint256 productId;
uint256 startDate;
uint256 endDate;
uint256 amount;
address subscriberAddress;
uint256 APR; /* APR for this product */
bool finalized;
}
struct ProductAPR {
uint256 createdAt;
uint256 startDate;
uint256 endDate;
uint256 totalMaxAmount;
uint256 individualMinimumAmount;
uint256 APR; /* APR for this product */
uint256 currentAmount;
bool lockedUntilFinalization; /* Product can only be withdrawn when finalized */
address[] subscribers;
uint256[] subscriptionIds;
mapping(uint256 => SubscriptionAPR) subscriptions; /* Distribution object */
}
constructor(address _tokenAddress) public {
}
function random() private view returns (uint) {
}
/* Current Held Tokens */
function heldTokens() public view returns (uint256) {
}
/* Locked Tokens for the APR */
function futureLockedTokens() public view returns (uint256) {
}
/* Available Tokens to he APRed by future subscribers */
function availableTokens() public view returns (uint256) {
}
function subscribeProduct(uint256 _product_id, uint256 _amount) external whenNotPaused {
/* Confirm Amount is positive */
require(_amount > 0);
/* Confirm product still exists */
require(block.timestamp < products[_product_id].endDate);
/* Confirm Max Amount was not hit already */
require(products[_product_id].totalMaxAmount > (products[_product_id].currentAmount + _amount));
/* Confirm Amount is bigger than minimum Amount */
require(_amount >= products[_product_id].individualMinimumAmount);
uint256 futureAPRAmount = getAPRAmount(products[_product_id].APR, block.timestamp, products[_product_id].endDate, _amount);
/* Confirm the current funds can assure the user the APR is valid */
require(<FILL_ME>)
/* Confirm the user has funds for the transfer */
require(erc20.transferFrom(msg.sender, address(this), _amount));
/* Add to LockedTokens */
lockedTokens = lockedTokens.add(_amount.add(futureAPRAmount));
uint256 subscription_id = random().add(incrementId);
incrementId = incrementId + 1;
/* Create SubscriptionAPR Object */
SubscriptionAPR memory subscriptionAPR = SubscriptionAPR(subscription_id, _product_id, block.timestamp, products[_product_id].endDate, _amount,
msg.sender, products[_product_id].APR, false);
/* Create new subscription */
mySubscriptions[msg.sender].push(subscription_id);
products[_product_id].subscriptionIds.push(subscription_id);
products[_product_id].subscriptions[subscription_id] = subscriptionAPR;
products[_product_id].currentAmount = products[_product_id].currentAmount + _amount;
products[_product_id].subscribers.push(msg.sender);
}
function createProduct(uint256 _startDate, uint256 _endDate, uint256 _totalMaxAmount, uint256 _individualMinimumAmount, uint256 _APR, bool _lockedUntilFinalization) external whenNotPaused onlyOwner {
}
function getAPRAmount(uint256 _APR, uint256 _startDate, uint256 _endDate, uint256 _amount) public pure returns(uint256) {
}
function getProductIds() public view returns(uint256[] memory) {
}
function getMySubscriptions(address _address) public view returns(uint256[] memory) {
}
function withdrawSubscription(uint256 _product_id, uint256 _subscription_id) external whenNotPaused {
}
function getSubscription(uint256 _subscription_id, uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, address, uint256, bool){
}
function getProduct(uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, bool, address[] memory, uint256[] memory){
}
function safeGuardAllTokens(address _address) external onlyOwner whenPaused {
}
function changeTokenAddress(address _tokenAddress) external onlyOwner whenPaused {
}
}
| availableTokens()>=futureAPRAmount | 20,186 | availableTokens()>=futureAPRAmount |
null | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract StakingContract is Pausable {
using SafeMath for uint256;
mapping(uint256 => ProductAPR) public products; /* Available Products */
uint256[] public productIds; /* Available Product Ids*/
mapping(address => uint256[]) public mySubscriptions; /* Address Based Subcriptions */
uint256 incrementId = 0;
uint256 lockedTokens = 0;
uint256 constant private year = 365 days;
ERC20 public erc20;
struct SubscriptionAPR {
uint256 _id;
uint256 productId;
uint256 startDate;
uint256 endDate;
uint256 amount;
address subscriberAddress;
uint256 APR; /* APR for this product */
bool finalized;
}
struct ProductAPR {
uint256 createdAt;
uint256 startDate;
uint256 endDate;
uint256 totalMaxAmount;
uint256 individualMinimumAmount;
uint256 APR; /* APR for this product */
uint256 currentAmount;
bool lockedUntilFinalization; /* Product can only be withdrawn when finalized */
address[] subscribers;
uint256[] subscriptionIds;
mapping(uint256 => SubscriptionAPR) subscriptions; /* Distribution object */
}
constructor(address _tokenAddress) public {
}
function random() private view returns (uint) {
}
/* Current Held Tokens */
function heldTokens() public view returns (uint256) {
}
/* Locked Tokens for the APR */
function futureLockedTokens() public view returns (uint256) {
}
/* Available Tokens to he APRed by future subscribers */
function availableTokens() public view returns (uint256) {
}
function subscribeProduct(uint256 _product_id, uint256 _amount) external whenNotPaused {
/* Confirm Amount is positive */
require(_amount > 0);
/* Confirm product still exists */
require(block.timestamp < products[_product_id].endDate);
/* Confirm Max Amount was not hit already */
require(products[_product_id].totalMaxAmount > (products[_product_id].currentAmount + _amount));
/* Confirm Amount is bigger than minimum Amount */
require(_amount >= products[_product_id].individualMinimumAmount);
uint256 futureAPRAmount = getAPRAmount(products[_product_id].APR, block.timestamp, products[_product_id].endDate, _amount);
/* Confirm the current funds can assure the user the APR is valid */
require(availableTokens() >= futureAPRAmount);
/* Confirm the user has funds for the transfer */
require(<FILL_ME>)
/* Add to LockedTokens */
lockedTokens = lockedTokens.add(_amount.add(futureAPRAmount));
uint256 subscription_id = random().add(incrementId);
incrementId = incrementId + 1;
/* Create SubscriptionAPR Object */
SubscriptionAPR memory subscriptionAPR = SubscriptionAPR(subscription_id, _product_id, block.timestamp, products[_product_id].endDate, _amount,
msg.sender, products[_product_id].APR, false);
/* Create new subscription */
mySubscriptions[msg.sender].push(subscription_id);
products[_product_id].subscriptionIds.push(subscription_id);
products[_product_id].subscriptions[subscription_id] = subscriptionAPR;
products[_product_id].currentAmount = products[_product_id].currentAmount + _amount;
products[_product_id].subscribers.push(msg.sender);
}
function createProduct(uint256 _startDate, uint256 _endDate, uint256 _totalMaxAmount, uint256 _individualMinimumAmount, uint256 _APR, bool _lockedUntilFinalization) external whenNotPaused onlyOwner {
}
function getAPRAmount(uint256 _APR, uint256 _startDate, uint256 _endDate, uint256 _amount) public pure returns(uint256) {
}
function getProductIds() public view returns(uint256[] memory) {
}
function getMySubscriptions(address _address) public view returns(uint256[] memory) {
}
function withdrawSubscription(uint256 _product_id, uint256 _subscription_id) external whenNotPaused {
}
function getSubscription(uint256 _subscription_id, uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, address, uint256, bool){
}
function getProduct(uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, bool, address[] memory, uint256[] memory){
}
function safeGuardAllTokens(address _address) external onlyOwner whenPaused {
}
function changeTokenAddress(address _tokenAddress) external onlyOwner whenPaused {
}
}
| erc20.transferFrom(msg.sender,address(this),_amount) | 20,186 | erc20.transferFrom(msg.sender,address(this),_amount) |
null | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract StakingContract is Pausable {
using SafeMath for uint256;
mapping(uint256 => ProductAPR) public products; /* Available Products */
uint256[] public productIds; /* Available Product Ids*/
mapping(address => uint256[]) public mySubscriptions; /* Address Based Subcriptions */
uint256 incrementId = 0;
uint256 lockedTokens = 0;
uint256 constant private year = 365 days;
ERC20 public erc20;
struct SubscriptionAPR {
uint256 _id;
uint256 productId;
uint256 startDate;
uint256 endDate;
uint256 amount;
address subscriberAddress;
uint256 APR; /* APR for this product */
bool finalized;
}
struct ProductAPR {
uint256 createdAt;
uint256 startDate;
uint256 endDate;
uint256 totalMaxAmount;
uint256 individualMinimumAmount;
uint256 APR; /* APR for this product */
uint256 currentAmount;
bool lockedUntilFinalization; /* Product can only be withdrawn when finalized */
address[] subscribers;
uint256[] subscriptionIds;
mapping(uint256 => SubscriptionAPR) subscriptions; /* Distribution object */
}
constructor(address _tokenAddress) public {
}
function random() private view returns (uint) {
}
/* Current Held Tokens */
function heldTokens() public view returns (uint256) {
}
/* Locked Tokens for the APR */
function futureLockedTokens() public view returns (uint256) {
}
/* Available Tokens to he APRed by future subscribers */
function availableTokens() public view returns (uint256) {
}
function subscribeProduct(uint256 _product_id, uint256 _amount) external whenNotPaused {
}
function createProduct(uint256 _startDate, uint256 _endDate, uint256 _totalMaxAmount, uint256 _individualMinimumAmount, uint256 _APR, bool _lockedUntilFinalization) external whenNotPaused onlyOwner {
}
function getAPRAmount(uint256 _APR, uint256 _startDate, uint256 _endDate, uint256 _amount) public pure returns(uint256) {
}
function getProductIds() public view returns(uint256[] memory) {
}
function getMySubscriptions(address _address) public view returns(uint256[] memory) {
}
function withdrawSubscription(uint256 _product_id, uint256 _subscription_id) external whenNotPaused {
/* Confirm Product exists */
require(<FILL_ME>)
/* Confirm Subscription exists */
require(products[_product_id].subscriptions[_subscription_id].endDate != 0);
/* Confirm Subscription is not finalized */
require(products[_product_id].subscriptions[_subscription_id].finalized == false);
/* Confirm Subscriptor is the sender */
require(products[_product_id].subscriptions[_subscription_id].subscriberAddress == msg.sender);
SubscriptionAPR memory subscription = products[_product_id].subscriptions[_subscription_id];
/* Confirm start date has already passed */
require(block.timestamp > subscription.startDate);
/* Confirm end date for APR */
uint256 finishDate = block.timestamp;
/* Verify if date has passed the end date */
if(block.timestamp >= subscription.endDate){
finishDate = subscription.endDate;
}else{
/* Confirm the Product can be withdrawn at any time */
require(products[_product_id].lockedUntilFinalization == false);
}
/* Update Subscription */
products[_product_id].subscriptions[_subscription_id].finalized = true;
uint256 APRedAmount = getAPRAmount(subscription.APR, subscription.startDate, finishDate, subscription.amount);
require(APRedAmount > 0);
uint256 totalAmount = subscription.amount.add(APRedAmount);
/* Transfer funds to the subscriber address */
require(erc20.transfer(subscription.subscriberAddress, totalAmount));
/* Sub to LockedTokens */
lockedTokens = lockedTokens.sub(totalAmount);
}
function getSubscription(uint256 _subscription_id, uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, address, uint256, bool){
}
function getProduct(uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, bool, address[] memory, uint256[] memory){
}
function safeGuardAllTokens(address _address) external onlyOwner whenPaused {
}
function changeTokenAddress(address _tokenAddress) external onlyOwner whenPaused {
}
}
| products[_product_id].endDate!=0 | 20,186 | products[_product_id].endDate!=0 |
null | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract StakingContract is Pausable {
using SafeMath for uint256;
mapping(uint256 => ProductAPR) public products; /* Available Products */
uint256[] public productIds; /* Available Product Ids*/
mapping(address => uint256[]) public mySubscriptions; /* Address Based Subcriptions */
uint256 incrementId = 0;
uint256 lockedTokens = 0;
uint256 constant private year = 365 days;
ERC20 public erc20;
struct SubscriptionAPR {
uint256 _id;
uint256 productId;
uint256 startDate;
uint256 endDate;
uint256 amount;
address subscriberAddress;
uint256 APR; /* APR for this product */
bool finalized;
}
struct ProductAPR {
uint256 createdAt;
uint256 startDate;
uint256 endDate;
uint256 totalMaxAmount;
uint256 individualMinimumAmount;
uint256 APR; /* APR for this product */
uint256 currentAmount;
bool lockedUntilFinalization; /* Product can only be withdrawn when finalized */
address[] subscribers;
uint256[] subscriptionIds;
mapping(uint256 => SubscriptionAPR) subscriptions; /* Distribution object */
}
constructor(address _tokenAddress) public {
}
function random() private view returns (uint) {
}
/* Current Held Tokens */
function heldTokens() public view returns (uint256) {
}
/* Locked Tokens for the APR */
function futureLockedTokens() public view returns (uint256) {
}
/* Available Tokens to he APRed by future subscribers */
function availableTokens() public view returns (uint256) {
}
function subscribeProduct(uint256 _product_id, uint256 _amount) external whenNotPaused {
}
function createProduct(uint256 _startDate, uint256 _endDate, uint256 _totalMaxAmount, uint256 _individualMinimumAmount, uint256 _APR, bool _lockedUntilFinalization) external whenNotPaused onlyOwner {
}
function getAPRAmount(uint256 _APR, uint256 _startDate, uint256 _endDate, uint256 _amount) public pure returns(uint256) {
}
function getProductIds() public view returns(uint256[] memory) {
}
function getMySubscriptions(address _address) public view returns(uint256[] memory) {
}
function withdrawSubscription(uint256 _product_id, uint256 _subscription_id) external whenNotPaused {
/* Confirm Product exists */
require(products[_product_id].endDate != 0);
/* Confirm Subscription exists */
require(<FILL_ME>)
/* Confirm Subscription is not finalized */
require(products[_product_id].subscriptions[_subscription_id].finalized == false);
/* Confirm Subscriptor is the sender */
require(products[_product_id].subscriptions[_subscription_id].subscriberAddress == msg.sender);
SubscriptionAPR memory subscription = products[_product_id].subscriptions[_subscription_id];
/* Confirm start date has already passed */
require(block.timestamp > subscription.startDate);
/* Confirm end date for APR */
uint256 finishDate = block.timestamp;
/* Verify if date has passed the end date */
if(block.timestamp >= subscription.endDate){
finishDate = subscription.endDate;
}else{
/* Confirm the Product can be withdrawn at any time */
require(products[_product_id].lockedUntilFinalization == false);
}
/* Update Subscription */
products[_product_id].subscriptions[_subscription_id].finalized = true;
uint256 APRedAmount = getAPRAmount(subscription.APR, subscription.startDate, finishDate, subscription.amount);
require(APRedAmount > 0);
uint256 totalAmount = subscription.amount.add(APRedAmount);
/* Transfer funds to the subscriber address */
require(erc20.transfer(subscription.subscriberAddress, totalAmount));
/* Sub to LockedTokens */
lockedTokens = lockedTokens.sub(totalAmount);
}
function getSubscription(uint256 _subscription_id, uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, address, uint256, bool){
}
function getProduct(uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, bool, address[] memory, uint256[] memory){
}
function safeGuardAllTokens(address _address) external onlyOwner whenPaused {
}
function changeTokenAddress(address _tokenAddress) external onlyOwner whenPaused {
}
}
| products[_product_id].subscriptions[_subscription_id].endDate!=0 | 20,186 | products[_product_id].subscriptions[_subscription_id].endDate!=0 |
null | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract StakingContract is Pausable {
using SafeMath for uint256;
mapping(uint256 => ProductAPR) public products; /* Available Products */
uint256[] public productIds; /* Available Product Ids*/
mapping(address => uint256[]) public mySubscriptions; /* Address Based Subcriptions */
uint256 incrementId = 0;
uint256 lockedTokens = 0;
uint256 constant private year = 365 days;
ERC20 public erc20;
struct SubscriptionAPR {
uint256 _id;
uint256 productId;
uint256 startDate;
uint256 endDate;
uint256 amount;
address subscriberAddress;
uint256 APR; /* APR for this product */
bool finalized;
}
struct ProductAPR {
uint256 createdAt;
uint256 startDate;
uint256 endDate;
uint256 totalMaxAmount;
uint256 individualMinimumAmount;
uint256 APR; /* APR for this product */
uint256 currentAmount;
bool lockedUntilFinalization; /* Product can only be withdrawn when finalized */
address[] subscribers;
uint256[] subscriptionIds;
mapping(uint256 => SubscriptionAPR) subscriptions; /* Distribution object */
}
constructor(address _tokenAddress) public {
}
function random() private view returns (uint) {
}
/* Current Held Tokens */
function heldTokens() public view returns (uint256) {
}
/* Locked Tokens for the APR */
function futureLockedTokens() public view returns (uint256) {
}
/* Available Tokens to he APRed by future subscribers */
function availableTokens() public view returns (uint256) {
}
function subscribeProduct(uint256 _product_id, uint256 _amount) external whenNotPaused {
}
function createProduct(uint256 _startDate, uint256 _endDate, uint256 _totalMaxAmount, uint256 _individualMinimumAmount, uint256 _APR, bool _lockedUntilFinalization) external whenNotPaused onlyOwner {
}
function getAPRAmount(uint256 _APR, uint256 _startDate, uint256 _endDate, uint256 _amount) public pure returns(uint256) {
}
function getProductIds() public view returns(uint256[] memory) {
}
function getMySubscriptions(address _address) public view returns(uint256[] memory) {
}
function withdrawSubscription(uint256 _product_id, uint256 _subscription_id) external whenNotPaused {
/* Confirm Product exists */
require(products[_product_id].endDate != 0);
/* Confirm Subscription exists */
require(products[_product_id].subscriptions[_subscription_id].endDate != 0);
/* Confirm Subscription is not finalized */
require(<FILL_ME>)
/* Confirm Subscriptor is the sender */
require(products[_product_id].subscriptions[_subscription_id].subscriberAddress == msg.sender);
SubscriptionAPR memory subscription = products[_product_id].subscriptions[_subscription_id];
/* Confirm start date has already passed */
require(block.timestamp > subscription.startDate);
/* Confirm end date for APR */
uint256 finishDate = block.timestamp;
/* Verify if date has passed the end date */
if(block.timestamp >= subscription.endDate){
finishDate = subscription.endDate;
}else{
/* Confirm the Product can be withdrawn at any time */
require(products[_product_id].lockedUntilFinalization == false);
}
/* Update Subscription */
products[_product_id].subscriptions[_subscription_id].finalized = true;
uint256 APRedAmount = getAPRAmount(subscription.APR, subscription.startDate, finishDate, subscription.amount);
require(APRedAmount > 0);
uint256 totalAmount = subscription.amount.add(APRedAmount);
/* Transfer funds to the subscriber address */
require(erc20.transfer(subscription.subscriberAddress, totalAmount));
/* Sub to LockedTokens */
lockedTokens = lockedTokens.sub(totalAmount);
}
function getSubscription(uint256 _subscription_id, uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, address, uint256, bool){
}
function getProduct(uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, bool, address[] memory, uint256[] memory){
}
function safeGuardAllTokens(address _address) external onlyOwner whenPaused {
}
function changeTokenAddress(address _tokenAddress) external onlyOwner whenPaused {
}
}
| products[_product_id].subscriptions[_subscription_id].finalized==false | 20,186 | products[_product_id].subscriptions[_subscription_id].finalized==false |
null | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract StakingContract is Pausable {
using SafeMath for uint256;
mapping(uint256 => ProductAPR) public products; /* Available Products */
uint256[] public productIds; /* Available Product Ids*/
mapping(address => uint256[]) public mySubscriptions; /* Address Based Subcriptions */
uint256 incrementId = 0;
uint256 lockedTokens = 0;
uint256 constant private year = 365 days;
ERC20 public erc20;
struct SubscriptionAPR {
uint256 _id;
uint256 productId;
uint256 startDate;
uint256 endDate;
uint256 amount;
address subscriberAddress;
uint256 APR; /* APR for this product */
bool finalized;
}
struct ProductAPR {
uint256 createdAt;
uint256 startDate;
uint256 endDate;
uint256 totalMaxAmount;
uint256 individualMinimumAmount;
uint256 APR; /* APR for this product */
uint256 currentAmount;
bool lockedUntilFinalization; /* Product can only be withdrawn when finalized */
address[] subscribers;
uint256[] subscriptionIds;
mapping(uint256 => SubscriptionAPR) subscriptions; /* Distribution object */
}
constructor(address _tokenAddress) public {
}
function random() private view returns (uint) {
}
/* Current Held Tokens */
function heldTokens() public view returns (uint256) {
}
/* Locked Tokens for the APR */
function futureLockedTokens() public view returns (uint256) {
}
/* Available Tokens to he APRed by future subscribers */
function availableTokens() public view returns (uint256) {
}
function subscribeProduct(uint256 _product_id, uint256 _amount) external whenNotPaused {
}
function createProduct(uint256 _startDate, uint256 _endDate, uint256 _totalMaxAmount, uint256 _individualMinimumAmount, uint256 _APR, bool _lockedUntilFinalization) external whenNotPaused onlyOwner {
}
function getAPRAmount(uint256 _APR, uint256 _startDate, uint256 _endDate, uint256 _amount) public pure returns(uint256) {
}
function getProductIds() public view returns(uint256[] memory) {
}
function getMySubscriptions(address _address) public view returns(uint256[] memory) {
}
function withdrawSubscription(uint256 _product_id, uint256 _subscription_id) external whenNotPaused {
/* Confirm Product exists */
require(products[_product_id].endDate != 0);
/* Confirm Subscription exists */
require(products[_product_id].subscriptions[_subscription_id].endDate != 0);
/* Confirm Subscription is not finalized */
require(products[_product_id].subscriptions[_subscription_id].finalized == false);
/* Confirm Subscriptor is the sender */
require(<FILL_ME>)
SubscriptionAPR memory subscription = products[_product_id].subscriptions[_subscription_id];
/* Confirm start date has already passed */
require(block.timestamp > subscription.startDate);
/* Confirm end date for APR */
uint256 finishDate = block.timestamp;
/* Verify if date has passed the end date */
if(block.timestamp >= subscription.endDate){
finishDate = subscription.endDate;
}else{
/* Confirm the Product can be withdrawn at any time */
require(products[_product_id].lockedUntilFinalization == false);
}
/* Update Subscription */
products[_product_id].subscriptions[_subscription_id].finalized = true;
uint256 APRedAmount = getAPRAmount(subscription.APR, subscription.startDate, finishDate, subscription.amount);
require(APRedAmount > 0);
uint256 totalAmount = subscription.amount.add(APRedAmount);
/* Transfer funds to the subscriber address */
require(erc20.transfer(subscription.subscriberAddress, totalAmount));
/* Sub to LockedTokens */
lockedTokens = lockedTokens.sub(totalAmount);
}
function getSubscription(uint256 _subscription_id, uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, address, uint256, bool){
}
function getProduct(uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, bool, address[] memory, uint256[] memory){
}
function safeGuardAllTokens(address _address) external onlyOwner whenPaused {
}
function changeTokenAddress(address _tokenAddress) external onlyOwner whenPaused {
}
}
| products[_product_id].subscriptions[_subscription_id].subscriberAddress==msg.sender | 20,186 | products[_product_id].subscriptions[_subscription_id].subscriberAddress==msg.sender |
null | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract StakingContract is Pausable {
using SafeMath for uint256;
mapping(uint256 => ProductAPR) public products; /* Available Products */
uint256[] public productIds; /* Available Product Ids*/
mapping(address => uint256[]) public mySubscriptions; /* Address Based Subcriptions */
uint256 incrementId = 0;
uint256 lockedTokens = 0;
uint256 constant private year = 365 days;
ERC20 public erc20;
struct SubscriptionAPR {
uint256 _id;
uint256 productId;
uint256 startDate;
uint256 endDate;
uint256 amount;
address subscriberAddress;
uint256 APR; /* APR for this product */
bool finalized;
}
struct ProductAPR {
uint256 createdAt;
uint256 startDate;
uint256 endDate;
uint256 totalMaxAmount;
uint256 individualMinimumAmount;
uint256 APR; /* APR for this product */
uint256 currentAmount;
bool lockedUntilFinalization; /* Product can only be withdrawn when finalized */
address[] subscribers;
uint256[] subscriptionIds;
mapping(uint256 => SubscriptionAPR) subscriptions; /* Distribution object */
}
constructor(address _tokenAddress) public {
}
function random() private view returns (uint) {
}
/* Current Held Tokens */
function heldTokens() public view returns (uint256) {
}
/* Locked Tokens for the APR */
function futureLockedTokens() public view returns (uint256) {
}
/* Available Tokens to he APRed by future subscribers */
function availableTokens() public view returns (uint256) {
}
function subscribeProduct(uint256 _product_id, uint256 _amount) external whenNotPaused {
}
function createProduct(uint256 _startDate, uint256 _endDate, uint256 _totalMaxAmount, uint256 _individualMinimumAmount, uint256 _APR, bool _lockedUntilFinalization) external whenNotPaused onlyOwner {
}
function getAPRAmount(uint256 _APR, uint256 _startDate, uint256 _endDate, uint256 _amount) public pure returns(uint256) {
}
function getProductIds() public view returns(uint256[] memory) {
}
function getMySubscriptions(address _address) public view returns(uint256[] memory) {
}
function withdrawSubscription(uint256 _product_id, uint256 _subscription_id) external whenNotPaused {
/* Confirm Product exists */
require(products[_product_id].endDate != 0);
/* Confirm Subscription exists */
require(products[_product_id].subscriptions[_subscription_id].endDate != 0);
/* Confirm Subscription is not finalized */
require(products[_product_id].subscriptions[_subscription_id].finalized == false);
/* Confirm Subscriptor is the sender */
require(products[_product_id].subscriptions[_subscription_id].subscriberAddress == msg.sender);
SubscriptionAPR memory subscription = products[_product_id].subscriptions[_subscription_id];
/* Confirm start date has already passed */
require(block.timestamp > subscription.startDate);
/* Confirm end date for APR */
uint256 finishDate = block.timestamp;
/* Verify if date has passed the end date */
if(block.timestamp >= subscription.endDate){
finishDate = subscription.endDate;
}else{
/* Confirm the Product can be withdrawn at any time */
require(<FILL_ME>)
}
/* Update Subscription */
products[_product_id].subscriptions[_subscription_id].finalized = true;
uint256 APRedAmount = getAPRAmount(subscription.APR, subscription.startDate, finishDate, subscription.amount);
require(APRedAmount > 0);
uint256 totalAmount = subscription.amount.add(APRedAmount);
/* Transfer funds to the subscriber address */
require(erc20.transfer(subscription.subscriberAddress, totalAmount));
/* Sub to LockedTokens */
lockedTokens = lockedTokens.sub(totalAmount);
}
function getSubscription(uint256 _subscription_id, uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, address, uint256, bool){
}
function getProduct(uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, bool, address[] memory, uint256[] memory){
}
function safeGuardAllTokens(address _address) external onlyOwner whenPaused {
}
function changeTokenAddress(address _tokenAddress) external onlyOwner whenPaused {
}
}
| products[_product_id].lockedUntilFinalization==false | 20,186 | products[_product_id].lockedUntilFinalization==false |
null | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract StakingContract is Pausable {
using SafeMath for uint256;
mapping(uint256 => ProductAPR) public products; /* Available Products */
uint256[] public productIds; /* Available Product Ids*/
mapping(address => uint256[]) public mySubscriptions; /* Address Based Subcriptions */
uint256 incrementId = 0;
uint256 lockedTokens = 0;
uint256 constant private year = 365 days;
ERC20 public erc20;
struct SubscriptionAPR {
uint256 _id;
uint256 productId;
uint256 startDate;
uint256 endDate;
uint256 amount;
address subscriberAddress;
uint256 APR; /* APR for this product */
bool finalized;
}
struct ProductAPR {
uint256 createdAt;
uint256 startDate;
uint256 endDate;
uint256 totalMaxAmount;
uint256 individualMinimumAmount;
uint256 APR; /* APR for this product */
uint256 currentAmount;
bool lockedUntilFinalization; /* Product can only be withdrawn when finalized */
address[] subscribers;
uint256[] subscriptionIds;
mapping(uint256 => SubscriptionAPR) subscriptions; /* Distribution object */
}
constructor(address _tokenAddress) public {
}
function random() private view returns (uint) {
}
/* Current Held Tokens */
function heldTokens() public view returns (uint256) {
}
/* Locked Tokens for the APR */
function futureLockedTokens() public view returns (uint256) {
}
/* Available Tokens to he APRed by future subscribers */
function availableTokens() public view returns (uint256) {
}
function subscribeProduct(uint256 _product_id, uint256 _amount) external whenNotPaused {
}
function createProduct(uint256 _startDate, uint256 _endDate, uint256 _totalMaxAmount, uint256 _individualMinimumAmount, uint256 _APR, bool _lockedUntilFinalization) external whenNotPaused onlyOwner {
}
function getAPRAmount(uint256 _APR, uint256 _startDate, uint256 _endDate, uint256 _amount) public pure returns(uint256) {
}
function getProductIds() public view returns(uint256[] memory) {
}
function getMySubscriptions(address _address) public view returns(uint256[] memory) {
}
function withdrawSubscription(uint256 _product_id, uint256 _subscription_id) external whenNotPaused {
/* Confirm Product exists */
require(products[_product_id].endDate != 0);
/* Confirm Subscription exists */
require(products[_product_id].subscriptions[_subscription_id].endDate != 0);
/* Confirm Subscription is not finalized */
require(products[_product_id].subscriptions[_subscription_id].finalized == false);
/* Confirm Subscriptor is the sender */
require(products[_product_id].subscriptions[_subscription_id].subscriberAddress == msg.sender);
SubscriptionAPR memory subscription = products[_product_id].subscriptions[_subscription_id];
/* Confirm start date has already passed */
require(block.timestamp > subscription.startDate);
/* Confirm end date for APR */
uint256 finishDate = block.timestamp;
/* Verify if date has passed the end date */
if(block.timestamp >= subscription.endDate){
finishDate = subscription.endDate;
}else{
/* Confirm the Product can be withdrawn at any time */
require(products[_product_id].lockedUntilFinalization == false);
}
/* Update Subscription */
products[_product_id].subscriptions[_subscription_id].finalized = true;
uint256 APRedAmount = getAPRAmount(subscription.APR, subscription.startDate, finishDate, subscription.amount);
require(APRedAmount > 0);
uint256 totalAmount = subscription.amount.add(APRedAmount);
/* Transfer funds to the subscriber address */
require(<FILL_ME>)
/* Sub to LockedTokens */
lockedTokens = lockedTokens.sub(totalAmount);
}
function getSubscription(uint256 _subscription_id, uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, address, uint256, bool){
}
function getProduct(uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, bool, address[] memory, uint256[] memory){
}
function safeGuardAllTokens(address _address) external onlyOwner whenPaused {
}
function changeTokenAddress(address _tokenAddress) external onlyOwner whenPaused {
}
}
| erc20.transfer(subscription.subscriberAddress,totalAmount) | 20,186 | erc20.transfer(subscription.subscriberAddress,totalAmount) |
null | /**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract StakingContract is Pausable {
using SafeMath for uint256;
mapping(uint256 => ProductAPR) public products; /* Available Products */
uint256[] public productIds; /* Available Product Ids*/
mapping(address => uint256[]) public mySubscriptions; /* Address Based Subcriptions */
uint256 incrementId = 0;
uint256 lockedTokens = 0;
uint256 constant private year = 365 days;
ERC20 public erc20;
struct SubscriptionAPR {
uint256 _id;
uint256 productId;
uint256 startDate;
uint256 endDate;
uint256 amount;
address subscriberAddress;
uint256 APR; /* APR for this product */
bool finalized;
}
struct ProductAPR {
uint256 createdAt;
uint256 startDate;
uint256 endDate;
uint256 totalMaxAmount;
uint256 individualMinimumAmount;
uint256 APR; /* APR for this product */
uint256 currentAmount;
bool lockedUntilFinalization; /* Product can only be withdrawn when finalized */
address[] subscribers;
uint256[] subscriptionIds;
mapping(uint256 => SubscriptionAPR) subscriptions; /* Distribution object */
}
constructor(address _tokenAddress) public {
}
function random() private view returns (uint) {
}
/* Current Held Tokens */
function heldTokens() public view returns (uint256) {
}
/* Locked Tokens for the APR */
function futureLockedTokens() public view returns (uint256) {
}
/* Available Tokens to he APRed by future subscribers */
function availableTokens() public view returns (uint256) {
}
function subscribeProduct(uint256 _product_id, uint256 _amount) external whenNotPaused {
}
function createProduct(uint256 _startDate, uint256 _endDate, uint256 _totalMaxAmount, uint256 _individualMinimumAmount, uint256 _APR, bool _lockedUntilFinalization) external whenNotPaused onlyOwner {
}
function getAPRAmount(uint256 _APR, uint256 _startDate, uint256 _endDate, uint256 _amount) public pure returns(uint256) {
}
function getProductIds() public view returns(uint256[] memory) {
}
function getMySubscriptions(address _address) public view returns(uint256[] memory) {
}
function withdrawSubscription(uint256 _product_id, uint256 _subscription_id) external whenNotPaused {
}
function getSubscription(uint256 _subscription_id, uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, address, uint256, bool){
}
function getProduct(uint256 _product_id) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, bool, address[] memory, uint256[] memory){
}
function safeGuardAllTokens(address _address) external onlyOwner whenPaused { /* In case of needed urgency for the sake of contract bug */
require(<FILL_ME>)
}
function changeTokenAddress(address _tokenAddress) external onlyOwner whenPaused {
}
}
| erc20.transfer(_address,erc20.balanceOf(address(this))) | 20,186 | erc20.transfer(_address,erc20.balanceOf(address(this))) |
null | pragma solidity 0.4.15;
/// @title provides subject to role checking logic
contract IAccessPolicy {
////////////////////////
// Public functions
////////////////////////
/// @notice We don't make this function constant to allow for state-updating access controls such as rate limiting.
/// @dev checks if subject belongs to requested role for particular object
/// @param subject address to be checked against role, typically msg.sender
/// @param role identifier of required role
/// @param object contract instance context for role checking, typically contract requesting the check
/// @param verb additional data, in current AccessControll implementation msg.sig
/// @return if subject belongs to a role
function allowed(
address subject,
bytes32 role,
address object,
bytes4 verb
)
public
returns (bool);
}
/// @title enables access control in implementing contract
/// @dev see AccessControlled for implementation
contract IAccessControlled {
////////////////////////
// Events
////////////////////////
/// @dev must log on access policy change
event LogAccessPolicyChanged(
address controller,
IAccessPolicy oldPolicy,
IAccessPolicy newPolicy
);
////////////////////////
// Public functions
////////////////////////
/// @dev allows to change access control mechanism for this contract
/// this method must be itself access controlled, see AccessControlled implementation and notice below
/// @notice it is a huge issue for Solidity that modifiers are not part of function signature
/// then interfaces could be used for example to control access semantics
/// @param newPolicy new access policy to controll this contract
/// @param newAccessController address of ROLE_ACCESS_CONTROLLER of new policy that can set access to this contract
function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController)
public;
function accessPolicy()
public
constant
returns (IAccessPolicy);
}
contract StandardRoles {
////////////////////////
// Constants
////////////////////////
// @notice Soldity somehow doesn't evaluate this compile time
// @dev role which has rights to change permissions and set new policy in contract, keccak256("AccessController")
bytes32 internal constant ROLE_ACCESS_CONTROLLER = 0xac42f8beb17975ed062dcb80c63e6d203ef1c2c335ced149dc5664cc671cb7da;
}
/// @title Granular code execution permissions
/// @notice Intended to replace existing Ownable pattern with more granular permissions set to execute smart contract functions
/// for each function where 'only' modifier is applied, IAccessPolicy implementation is called to evaluate if msg.sender belongs to required role for contract being called.
/// Access evaluation specific belong to IAccessPolicy implementation, see RoleBasedAccessPolicy for details.
/// @dev Should be inherited by a contract requiring such permissions controll. IAccessPolicy must be provided in constructor. Access policy may be replaced to a different one
/// by msg.sender with ROLE_ACCESS_CONTROLLER role
contract AccessControlled is IAccessControlled, StandardRoles {
////////////////////////
// Mutable state
////////////////////////
IAccessPolicy private _accessPolicy;
////////////////////////
// Modifiers
////////////////////////
/// @dev limits function execution only to senders assigned to required 'role'
modifier only(bytes32 role) {
require(<FILL_ME>)
_;
}
////////////////////////
// Constructor
////////////////////////
function AccessControlled(IAccessPolicy policy) internal {
}
////////////////////////
// Public functions
////////////////////////
//
// Implements IAccessControlled
//
function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController)
public
only(ROLE_ACCESS_CONTROLLER)
{
}
function accessPolicy()
public
constant
returns (IAccessPolicy)
{
}
}
contract AccessRoles {
////////////////////////
// Constants
////////////////////////
// NOTE: All roles are set to the keccak256 hash of the
// CamelCased role name, i.e.
// ROLE_LOCKED_ACCOUNT_ADMIN = keccak256("LockedAccountAdmin")
// may setup LockedAccount, change disbursal mechanism and set migration
bytes32 internal constant ROLE_LOCKED_ACCOUNT_ADMIN = 0x4675da546d2d92c5b86c4f726a9e61010dce91cccc2491ce6019e78b09d2572e;
// may setup whitelists and abort whitelisting contract with curve rollback
bytes32 internal constant ROLE_WHITELIST_ADMIN = 0xaef456e7c864418e1d2a40d996ca4febf3a7e317fe3af5a7ea4dda59033bbe5c;
// May issue (generate) Neumarks
bytes32 internal constant ROLE_NEUMARK_ISSUER = 0x921c3afa1f1fff707a785f953a1e197bd28c9c50e300424e015953cbf120c06c;
// May burn Neumarks it owns
bytes32 internal constant ROLE_NEUMARK_BURNER = 0x19ce331285f41739cd3362a3ec176edffe014311c0f8075834fdd19d6718e69f;
// May create new snapshots on Neumark
bytes32 internal constant ROLE_SNAPSHOT_CREATOR = 0x08c1785afc57f933523bc52583a72ce9e19b2241354e04dd86f41f887e3d8174;
// May enable/disable transfers on Neumark
bytes32 internal constant ROLE_TRANSFER_ADMIN = 0xb6527e944caca3d151b1f94e49ac5e223142694860743e66164720e034ec9b19;
// may reclaim tokens/ether from contracts supporting IReclaimable interface
bytes32 internal constant ROLE_RECLAIMER = 0x0542bbd0c672578966dcc525b30aa16723bb042675554ac5b0362f86b6e97dc5;
// represents legally platform operator in case of forks and contracts with legal agreement attached. keccak256("PlatformOperatorRepresentative")
bytes32 internal constant ROLE_PLATFORM_OPERATOR_REPRESENTATIVE = 0xb2b321377653f655206f71514ff9f150d0822d062a5abcf220d549e1da7999f0;
// allows to deposit EUR-T and allow addresses to send and receive EUR-T. keccak256("EurtDepositManager")
bytes32 internal constant ROLE_EURT_DEPOSIT_MANAGER = 0x7c8ecdcba80ce87848d16ad77ef57cc196c208fc95c5638e4a48c681a34d4fe7;
}
contract IBasicToken {
////////////////////////
// Events
////////////////////////
event Transfer(
address indexed from,
address indexed to,
uint256 amount);
////////////////////////
// Public functions
////////////////////////
/// @dev This function makes it easy to get the total number of tokens
/// @return The total number of tokens
function totalSupply()
public
constant
returns (uint256);
/// @param owner The address that's balance is being requested
/// @return The balance of `owner` at the current block
function balanceOf(address owner)
public
constant
returns (uint256 balance);
/// @notice Send `amount` tokens to `to` from `msg.sender`
/// @param to The address of the recipient
/// @param amount The amount of tokens to be transferred
/// @return Whether the transfer was successful or not
function transfer(address to, uint256 amount)
public
returns (bool success);
}
/// @title allows deriving contract to recover any token or ether that it has balance of
/// @notice note that this opens your contracts to claims from various people saying they lost tokens and they want them back
/// be ready to handle such claims
/// @dev use with care!
/// 1. ROLE_RECLAIMER is allowed to claim tokens, it's not returning tokens to original owner
/// 2. in derived contract that holds any token by design you must override `reclaim` and block such possibility.
/// see LockedAccount as an example
contract Reclaimable is AccessControlled, AccessRoles {
////////////////////////
// Constants
////////////////////////
IBasicToken constant internal RECLAIM_ETHER = IBasicToken(0x0);
////////////////////////
// Public functions
////////////////////////
function reclaim(IBasicToken token)
public
only(ROLE_RECLAIMER)
{
}
}
contract IEthereumForkArbiter {
////////////////////////
// Events
////////////////////////
event LogForkAnnounced(
string name,
string url,
uint256 blockNumber
);
event LogForkSigned(
uint256 blockNumber,
bytes32 blockHash
);
////////////////////////
// Public functions
////////////////////////
function nextForkName()
public
constant
returns (string);
function nextForkUrl()
public
constant
returns (string);
function nextForkBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockHash()
public
constant
returns (bytes32);
function lastSignedTimestamp()
public
constant
returns (uint256);
}
contract EthereumForkArbiter is
IEthereumForkArbiter,
AccessControlled,
AccessRoles,
Reclaimable
{
////////////////////////
// Mutable state
////////////////////////
string private _nextForkName;
string private _nextForkUrl;
uint256 private _nextForkBlockNumber;
uint256 private _lastSignedBlockNumber;
bytes32 private _lastSignedBlockHash;
uint256 private _lastSignedTimestamp;
////////////////////////
// Constructor
////////////////////////
function EthereumForkArbiter(IAccessPolicy accessPolicy)
AccessControlled(accessPolicy)
Reclaimable()
public
{
}
////////////////////////
// Public functions
////////////////////////
/// @notice Announce that a particular future Ethereum fork will the one taken by the contract. The contract on the other branch should be considered invalid. Once the fork has happened, it will additionally be confirmed by signing a block on the fork. Notice that forks may happen unannounced.
function announceFork(
string name,
string url,
uint256 blockNumber
)
public
only(ROLE_PLATFORM_OPERATOR_REPRESENTATIVE)
{
}
/// @notice Declare that the current fork (as identified by a blockhash) is the valid fork. The valid fork is always the one with the most recent signature.
function signFork(uint256 number, bytes32 hash)
public
only(ROLE_PLATFORM_OPERATOR_REPRESENTATIVE)
{
}
function nextForkName()
public
constant
returns (string)
{
}
function nextForkUrl()
public
constant
returns (string)
{
}
function nextForkBlockNumber()
public
constant
returns (uint256)
{
}
function lastSignedBlockNumber()
public
constant
returns (uint256)
{
}
function lastSignedBlockHash()
public
constant
returns (bytes32)
{
}
function lastSignedTimestamp()
public
constant
returns (uint256)
{
}
}
| _accessPolicy.allowed(msg.sender,role,this,msg.sig) | 20,255 | _accessPolicy.allowed(msg.sender,role,this,msg.sig) |
null | pragma solidity 0.4.15;
/// @title provides subject to role checking logic
contract IAccessPolicy {
////////////////////////
// Public functions
////////////////////////
/// @notice We don't make this function constant to allow for state-updating access controls such as rate limiting.
/// @dev checks if subject belongs to requested role for particular object
/// @param subject address to be checked against role, typically msg.sender
/// @param role identifier of required role
/// @param object contract instance context for role checking, typically contract requesting the check
/// @param verb additional data, in current AccessControll implementation msg.sig
/// @return if subject belongs to a role
function allowed(
address subject,
bytes32 role,
address object,
bytes4 verb
)
public
returns (bool);
}
/// @title enables access control in implementing contract
/// @dev see AccessControlled for implementation
contract IAccessControlled {
////////////////////////
// Events
////////////////////////
/// @dev must log on access policy change
event LogAccessPolicyChanged(
address controller,
IAccessPolicy oldPolicy,
IAccessPolicy newPolicy
);
////////////////////////
// Public functions
////////////////////////
/// @dev allows to change access control mechanism for this contract
/// this method must be itself access controlled, see AccessControlled implementation and notice below
/// @notice it is a huge issue for Solidity that modifiers are not part of function signature
/// then interfaces could be used for example to control access semantics
/// @param newPolicy new access policy to controll this contract
/// @param newAccessController address of ROLE_ACCESS_CONTROLLER of new policy that can set access to this contract
function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController)
public;
function accessPolicy()
public
constant
returns (IAccessPolicy);
}
contract StandardRoles {
////////////////////////
// Constants
////////////////////////
// @notice Soldity somehow doesn't evaluate this compile time
// @dev role which has rights to change permissions and set new policy in contract, keccak256("AccessController")
bytes32 internal constant ROLE_ACCESS_CONTROLLER = 0xac42f8beb17975ed062dcb80c63e6d203ef1c2c335ced149dc5664cc671cb7da;
}
/// @title Granular code execution permissions
/// @notice Intended to replace existing Ownable pattern with more granular permissions set to execute smart contract functions
/// for each function where 'only' modifier is applied, IAccessPolicy implementation is called to evaluate if msg.sender belongs to required role for contract being called.
/// Access evaluation specific belong to IAccessPolicy implementation, see RoleBasedAccessPolicy for details.
/// @dev Should be inherited by a contract requiring such permissions controll. IAccessPolicy must be provided in constructor. Access policy may be replaced to a different one
/// by msg.sender with ROLE_ACCESS_CONTROLLER role
contract AccessControlled is IAccessControlled, StandardRoles {
////////////////////////
// Mutable state
////////////////////////
IAccessPolicy private _accessPolicy;
////////////////////////
// Modifiers
////////////////////////
/// @dev limits function execution only to senders assigned to required 'role'
modifier only(bytes32 role) {
}
////////////////////////
// Constructor
////////////////////////
function AccessControlled(IAccessPolicy policy) internal {
require(<FILL_ME>)
_accessPolicy = policy;
}
////////////////////////
// Public functions
////////////////////////
//
// Implements IAccessControlled
//
function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController)
public
only(ROLE_ACCESS_CONTROLLER)
{
}
function accessPolicy()
public
constant
returns (IAccessPolicy)
{
}
}
contract AccessRoles {
////////////////////////
// Constants
////////////////////////
// NOTE: All roles are set to the keccak256 hash of the
// CamelCased role name, i.e.
// ROLE_LOCKED_ACCOUNT_ADMIN = keccak256("LockedAccountAdmin")
// may setup LockedAccount, change disbursal mechanism and set migration
bytes32 internal constant ROLE_LOCKED_ACCOUNT_ADMIN = 0x4675da546d2d92c5b86c4f726a9e61010dce91cccc2491ce6019e78b09d2572e;
// may setup whitelists and abort whitelisting contract with curve rollback
bytes32 internal constant ROLE_WHITELIST_ADMIN = 0xaef456e7c864418e1d2a40d996ca4febf3a7e317fe3af5a7ea4dda59033bbe5c;
// May issue (generate) Neumarks
bytes32 internal constant ROLE_NEUMARK_ISSUER = 0x921c3afa1f1fff707a785f953a1e197bd28c9c50e300424e015953cbf120c06c;
// May burn Neumarks it owns
bytes32 internal constant ROLE_NEUMARK_BURNER = 0x19ce331285f41739cd3362a3ec176edffe014311c0f8075834fdd19d6718e69f;
// May create new snapshots on Neumark
bytes32 internal constant ROLE_SNAPSHOT_CREATOR = 0x08c1785afc57f933523bc52583a72ce9e19b2241354e04dd86f41f887e3d8174;
// May enable/disable transfers on Neumark
bytes32 internal constant ROLE_TRANSFER_ADMIN = 0xb6527e944caca3d151b1f94e49ac5e223142694860743e66164720e034ec9b19;
// may reclaim tokens/ether from contracts supporting IReclaimable interface
bytes32 internal constant ROLE_RECLAIMER = 0x0542bbd0c672578966dcc525b30aa16723bb042675554ac5b0362f86b6e97dc5;
// represents legally platform operator in case of forks and contracts with legal agreement attached. keccak256("PlatformOperatorRepresentative")
bytes32 internal constant ROLE_PLATFORM_OPERATOR_REPRESENTATIVE = 0xb2b321377653f655206f71514ff9f150d0822d062a5abcf220d549e1da7999f0;
// allows to deposit EUR-T and allow addresses to send and receive EUR-T. keccak256("EurtDepositManager")
bytes32 internal constant ROLE_EURT_DEPOSIT_MANAGER = 0x7c8ecdcba80ce87848d16ad77ef57cc196c208fc95c5638e4a48c681a34d4fe7;
}
contract IBasicToken {
////////////////////////
// Events
////////////////////////
event Transfer(
address indexed from,
address indexed to,
uint256 amount);
////////////////////////
// Public functions
////////////////////////
/// @dev This function makes it easy to get the total number of tokens
/// @return The total number of tokens
function totalSupply()
public
constant
returns (uint256);
/// @param owner The address that's balance is being requested
/// @return The balance of `owner` at the current block
function balanceOf(address owner)
public
constant
returns (uint256 balance);
/// @notice Send `amount` tokens to `to` from `msg.sender`
/// @param to The address of the recipient
/// @param amount The amount of tokens to be transferred
/// @return Whether the transfer was successful or not
function transfer(address to, uint256 amount)
public
returns (bool success);
}
/// @title allows deriving contract to recover any token or ether that it has balance of
/// @notice note that this opens your contracts to claims from various people saying they lost tokens and they want them back
/// be ready to handle such claims
/// @dev use with care!
/// 1. ROLE_RECLAIMER is allowed to claim tokens, it's not returning tokens to original owner
/// 2. in derived contract that holds any token by design you must override `reclaim` and block such possibility.
/// see LockedAccount as an example
contract Reclaimable is AccessControlled, AccessRoles {
////////////////////////
// Constants
////////////////////////
IBasicToken constant internal RECLAIM_ETHER = IBasicToken(0x0);
////////////////////////
// Public functions
////////////////////////
function reclaim(IBasicToken token)
public
only(ROLE_RECLAIMER)
{
}
}
contract IEthereumForkArbiter {
////////////////////////
// Events
////////////////////////
event LogForkAnnounced(
string name,
string url,
uint256 blockNumber
);
event LogForkSigned(
uint256 blockNumber,
bytes32 blockHash
);
////////////////////////
// Public functions
////////////////////////
function nextForkName()
public
constant
returns (string);
function nextForkUrl()
public
constant
returns (string);
function nextForkBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockHash()
public
constant
returns (bytes32);
function lastSignedTimestamp()
public
constant
returns (uint256);
}
contract EthereumForkArbiter is
IEthereumForkArbiter,
AccessControlled,
AccessRoles,
Reclaimable
{
////////////////////////
// Mutable state
////////////////////////
string private _nextForkName;
string private _nextForkUrl;
uint256 private _nextForkBlockNumber;
uint256 private _lastSignedBlockNumber;
bytes32 private _lastSignedBlockHash;
uint256 private _lastSignedTimestamp;
////////////////////////
// Constructor
////////////////////////
function EthereumForkArbiter(IAccessPolicy accessPolicy)
AccessControlled(accessPolicy)
Reclaimable()
public
{
}
////////////////////////
// Public functions
////////////////////////
/// @notice Announce that a particular future Ethereum fork will the one taken by the contract. The contract on the other branch should be considered invalid. Once the fork has happened, it will additionally be confirmed by signing a block on the fork. Notice that forks may happen unannounced.
function announceFork(
string name,
string url,
uint256 blockNumber
)
public
only(ROLE_PLATFORM_OPERATOR_REPRESENTATIVE)
{
}
/// @notice Declare that the current fork (as identified by a blockhash) is the valid fork. The valid fork is always the one with the most recent signature.
function signFork(uint256 number, bytes32 hash)
public
only(ROLE_PLATFORM_OPERATOR_REPRESENTATIVE)
{
}
function nextForkName()
public
constant
returns (string)
{
}
function nextForkUrl()
public
constant
returns (string)
{
}
function nextForkBlockNumber()
public
constant
returns (uint256)
{
}
function lastSignedBlockNumber()
public
constant
returns (uint256)
{
}
function lastSignedBlockHash()
public
constant
returns (bytes32)
{
}
function lastSignedTimestamp()
public
constant
returns (uint256)
{
}
}
| address(policy)!=0x0 | 20,255 | address(policy)!=0x0 |
null | pragma solidity 0.4.15;
/// @title provides subject to role checking logic
contract IAccessPolicy {
////////////////////////
// Public functions
////////////////////////
/// @notice We don't make this function constant to allow for state-updating access controls such as rate limiting.
/// @dev checks if subject belongs to requested role for particular object
/// @param subject address to be checked against role, typically msg.sender
/// @param role identifier of required role
/// @param object contract instance context for role checking, typically contract requesting the check
/// @param verb additional data, in current AccessControll implementation msg.sig
/// @return if subject belongs to a role
function allowed(
address subject,
bytes32 role,
address object,
bytes4 verb
)
public
returns (bool);
}
/// @title enables access control in implementing contract
/// @dev see AccessControlled for implementation
contract IAccessControlled {
////////////////////////
// Events
////////////////////////
/// @dev must log on access policy change
event LogAccessPolicyChanged(
address controller,
IAccessPolicy oldPolicy,
IAccessPolicy newPolicy
);
////////////////////////
// Public functions
////////////////////////
/// @dev allows to change access control mechanism for this contract
/// this method must be itself access controlled, see AccessControlled implementation and notice below
/// @notice it is a huge issue for Solidity that modifiers are not part of function signature
/// then interfaces could be used for example to control access semantics
/// @param newPolicy new access policy to controll this contract
/// @param newAccessController address of ROLE_ACCESS_CONTROLLER of new policy that can set access to this contract
function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController)
public;
function accessPolicy()
public
constant
returns (IAccessPolicy);
}
contract StandardRoles {
////////////////////////
// Constants
////////////////////////
// @notice Soldity somehow doesn't evaluate this compile time
// @dev role which has rights to change permissions and set new policy in contract, keccak256("AccessController")
bytes32 internal constant ROLE_ACCESS_CONTROLLER = 0xac42f8beb17975ed062dcb80c63e6d203ef1c2c335ced149dc5664cc671cb7da;
}
/// @title Granular code execution permissions
/// @notice Intended to replace existing Ownable pattern with more granular permissions set to execute smart contract functions
/// for each function where 'only' modifier is applied, IAccessPolicy implementation is called to evaluate if msg.sender belongs to required role for contract being called.
/// Access evaluation specific belong to IAccessPolicy implementation, see RoleBasedAccessPolicy for details.
/// @dev Should be inherited by a contract requiring such permissions controll. IAccessPolicy must be provided in constructor. Access policy may be replaced to a different one
/// by msg.sender with ROLE_ACCESS_CONTROLLER role
contract AccessControlled is IAccessControlled, StandardRoles {
////////////////////////
// Mutable state
////////////////////////
IAccessPolicy private _accessPolicy;
////////////////////////
// Modifiers
////////////////////////
/// @dev limits function execution only to senders assigned to required 'role'
modifier only(bytes32 role) {
}
////////////////////////
// Constructor
////////////////////////
function AccessControlled(IAccessPolicy policy) internal {
}
////////////////////////
// Public functions
////////////////////////
//
// Implements IAccessControlled
//
function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController)
public
only(ROLE_ACCESS_CONTROLLER)
{
// ROLE_ACCESS_CONTROLLER must be present
// under the new policy. This provides some
// protection against locking yourself out.
require(<FILL_ME>)
// We can now safely set the new policy without foot shooting.
IAccessPolicy oldPolicy = _accessPolicy;
_accessPolicy = newPolicy;
// Log event
LogAccessPolicyChanged(msg.sender, oldPolicy, newPolicy);
}
function accessPolicy()
public
constant
returns (IAccessPolicy)
{
}
}
contract AccessRoles {
////////////////////////
// Constants
////////////////////////
// NOTE: All roles are set to the keccak256 hash of the
// CamelCased role name, i.e.
// ROLE_LOCKED_ACCOUNT_ADMIN = keccak256("LockedAccountAdmin")
// may setup LockedAccount, change disbursal mechanism and set migration
bytes32 internal constant ROLE_LOCKED_ACCOUNT_ADMIN = 0x4675da546d2d92c5b86c4f726a9e61010dce91cccc2491ce6019e78b09d2572e;
// may setup whitelists and abort whitelisting contract with curve rollback
bytes32 internal constant ROLE_WHITELIST_ADMIN = 0xaef456e7c864418e1d2a40d996ca4febf3a7e317fe3af5a7ea4dda59033bbe5c;
// May issue (generate) Neumarks
bytes32 internal constant ROLE_NEUMARK_ISSUER = 0x921c3afa1f1fff707a785f953a1e197bd28c9c50e300424e015953cbf120c06c;
// May burn Neumarks it owns
bytes32 internal constant ROLE_NEUMARK_BURNER = 0x19ce331285f41739cd3362a3ec176edffe014311c0f8075834fdd19d6718e69f;
// May create new snapshots on Neumark
bytes32 internal constant ROLE_SNAPSHOT_CREATOR = 0x08c1785afc57f933523bc52583a72ce9e19b2241354e04dd86f41f887e3d8174;
// May enable/disable transfers on Neumark
bytes32 internal constant ROLE_TRANSFER_ADMIN = 0xb6527e944caca3d151b1f94e49ac5e223142694860743e66164720e034ec9b19;
// may reclaim tokens/ether from contracts supporting IReclaimable interface
bytes32 internal constant ROLE_RECLAIMER = 0x0542bbd0c672578966dcc525b30aa16723bb042675554ac5b0362f86b6e97dc5;
// represents legally platform operator in case of forks and contracts with legal agreement attached. keccak256("PlatformOperatorRepresentative")
bytes32 internal constant ROLE_PLATFORM_OPERATOR_REPRESENTATIVE = 0xb2b321377653f655206f71514ff9f150d0822d062a5abcf220d549e1da7999f0;
// allows to deposit EUR-T and allow addresses to send and receive EUR-T. keccak256("EurtDepositManager")
bytes32 internal constant ROLE_EURT_DEPOSIT_MANAGER = 0x7c8ecdcba80ce87848d16ad77ef57cc196c208fc95c5638e4a48c681a34d4fe7;
}
contract IBasicToken {
////////////////////////
// Events
////////////////////////
event Transfer(
address indexed from,
address indexed to,
uint256 amount);
////////////////////////
// Public functions
////////////////////////
/// @dev This function makes it easy to get the total number of tokens
/// @return The total number of tokens
function totalSupply()
public
constant
returns (uint256);
/// @param owner The address that's balance is being requested
/// @return The balance of `owner` at the current block
function balanceOf(address owner)
public
constant
returns (uint256 balance);
/// @notice Send `amount` tokens to `to` from `msg.sender`
/// @param to The address of the recipient
/// @param amount The amount of tokens to be transferred
/// @return Whether the transfer was successful or not
function transfer(address to, uint256 amount)
public
returns (bool success);
}
/// @title allows deriving contract to recover any token or ether that it has balance of
/// @notice note that this opens your contracts to claims from various people saying they lost tokens and they want them back
/// be ready to handle such claims
/// @dev use with care!
/// 1. ROLE_RECLAIMER is allowed to claim tokens, it's not returning tokens to original owner
/// 2. in derived contract that holds any token by design you must override `reclaim` and block such possibility.
/// see LockedAccount as an example
contract Reclaimable is AccessControlled, AccessRoles {
////////////////////////
// Constants
////////////////////////
IBasicToken constant internal RECLAIM_ETHER = IBasicToken(0x0);
////////////////////////
// Public functions
////////////////////////
function reclaim(IBasicToken token)
public
only(ROLE_RECLAIMER)
{
}
}
contract IEthereumForkArbiter {
////////////////////////
// Events
////////////////////////
event LogForkAnnounced(
string name,
string url,
uint256 blockNumber
);
event LogForkSigned(
uint256 blockNumber,
bytes32 blockHash
);
////////////////////////
// Public functions
////////////////////////
function nextForkName()
public
constant
returns (string);
function nextForkUrl()
public
constant
returns (string);
function nextForkBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockHash()
public
constant
returns (bytes32);
function lastSignedTimestamp()
public
constant
returns (uint256);
}
contract EthereumForkArbiter is
IEthereumForkArbiter,
AccessControlled,
AccessRoles,
Reclaimable
{
////////////////////////
// Mutable state
////////////////////////
string private _nextForkName;
string private _nextForkUrl;
uint256 private _nextForkBlockNumber;
uint256 private _lastSignedBlockNumber;
bytes32 private _lastSignedBlockHash;
uint256 private _lastSignedTimestamp;
////////////////////////
// Constructor
////////////////////////
function EthereumForkArbiter(IAccessPolicy accessPolicy)
AccessControlled(accessPolicy)
Reclaimable()
public
{
}
////////////////////////
// Public functions
////////////////////////
/// @notice Announce that a particular future Ethereum fork will the one taken by the contract. The contract on the other branch should be considered invalid. Once the fork has happened, it will additionally be confirmed by signing a block on the fork. Notice that forks may happen unannounced.
function announceFork(
string name,
string url,
uint256 blockNumber
)
public
only(ROLE_PLATFORM_OPERATOR_REPRESENTATIVE)
{
}
/// @notice Declare that the current fork (as identified by a blockhash) is the valid fork. The valid fork is always the one with the most recent signature.
function signFork(uint256 number, bytes32 hash)
public
only(ROLE_PLATFORM_OPERATOR_REPRESENTATIVE)
{
}
function nextForkName()
public
constant
returns (string)
{
}
function nextForkUrl()
public
constant
returns (string)
{
}
function nextForkBlockNumber()
public
constant
returns (uint256)
{
}
function lastSignedBlockNumber()
public
constant
returns (uint256)
{
}
function lastSignedBlockHash()
public
constant
returns (bytes32)
{
}
function lastSignedTimestamp()
public
constant
returns (uint256)
{
}
}
| newPolicy.allowed(newAccessController,ROLE_ACCESS_CONTROLLER,this,msg.sig) | 20,255 | newPolicy.allowed(newAccessController,ROLE_ACCESS_CONTROLLER,this,msg.sig) |
null | pragma solidity 0.4.15;
/// @title provides subject to role checking logic
contract IAccessPolicy {
////////////////////////
// Public functions
////////////////////////
/// @notice We don't make this function constant to allow for state-updating access controls such as rate limiting.
/// @dev checks if subject belongs to requested role for particular object
/// @param subject address to be checked against role, typically msg.sender
/// @param role identifier of required role
/// @param object contract instance context for role checking, typically contract requesting the check
/// @param verb additional data, in current AccessControll implementation msg.sig
/// @return if subject belongs to a role
function allowed(
address subject,
bytes32 role,
address object,
bytes4 verb
)
public
returns (bool);
}
/// @title enables access control in implementing contract
/// @dev see AccessControlled for implementation
contract IAccessControlled {
////////////////////////
// Events
////////////////////////
/// @dev must log on access policy change
event LogAccessPolicyChanged(
address controller,
IAccessPolicy oldPolicy,
IAccessPolicy newPolicy
);
////////////////////////
// Public functions
////////////////////////
/// @dev allows to change access control mechanism for this contract
/// this method must be itself access controlled, see AccessControlled implementation and notice below
/// @notice it is a huge issue for Solidity that modifiers are not part of function signature
/// then interfaces could be used for example to control access semantics
/// @param newPolicy new access policy to controll this contract
/// @param newAccessController address of ROLE_ACCESS_CONTROLLER of new policy that can set access to this contract
function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController)
public;
function accessPolicy()
public
constant
returns (IAccessPolicy);
}
contract StandardRoles {
////////////////////////
// Constants
////////////////////////
// @notice Soldity somehow doesn't evaluate this compile time
// @dev role which has rights to change permissions and set new policy in contract, keccak256("AccessController")
bytes32 internal constant ROLE_ACCESS_CONTROLLER = 0xac42f8beb17975ed062dcb80c63e6d203ef1c2c335ced149dc5664cc671cb7da;
}
/// @title Granular code execution permissions
/// @notice Intended to replace existing Ownable pattern with more granular permissions set to execute smart contract functions
/// for each function where 'only' modifier is applied, IAccessPolicy implementation is called to evaluate if msg.sender belongs to required role for contract being called.
/// Access evaluation specific belong to IAccessPolicy implementation, see RoleBasedAccessPolicy for details.
/// @dev Should be inherited by a contract requiring such permissions controll. IAccessPolicy must be provided in constructor. Access policy may be replaced to a different one
/// by msg.sender with ROLE_ACCESS_CONTROLLER role
contract AccessControlled is IAccessControlled, StandardRoles {
////////////////////////
// Mutable state
////////////////////////
IAccessPolicy private _accessPolicy;
////////////////////////
// Modifiers
////////////////////////
/// @dev limits function execution only to senders assigned to required 'role'
modifier only(bytes32 role) {
}
////////////////////////
// Constructor
////////////////////////
function AccessControlled(IAccessPolicy policy) internal {
}
////////////////////////
// Public functions
////////////////////////
//
// Implements IAccessControlled
//
function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController)
public
only(ROLE_ACCESS_CONTROLLER)
{
}
function accessPolicy()
public
constant
returns (IAccessPolicy)
{
}
}
contract AccessRoles {
////////////////////////
// Constants
////////////////////////
// NOTE: All roles are set to the keccak256 hash of the
// CamelCased role name, i.e.
// ROLE_LOCKED_ACCOUNT_ADMIN = keccak256("LockedAccountAdmin")
// may setup LockedAccount, change disbursal mechanism and set migration
bytes32 internal constant ROLE_LOCKED_ACCOUNT_ADMIN = 0x4675da546d2d92c5b86c4f726a9e61010dce91cccc2491ce6019e78b09d2572e;
// may setup whitelists and abort whitelisting contract with curve rollback
bytes32 internal constant ROLE_WHITELIST_ADMIN = 0xaef456e7c864418e1d2a40d996ca4febf3a7e317fe3af5a7ea4dda59033bbe5c;
// May issue (generate) Neumarks
bytes32 internal constant ROLE_NEUMARK_ISSUER = 0x921c3afa1f1fff707a785f953a1e197bd28c9c50e300424e015953cbf120c06c;
// May burn Neumarks it owns
bytes32 internal constant ROLE_NEUMARK_BURNER = 0x19ce331285f41739cd3362a3ec176edffe014311c0f8075834fdd19d6718e69f;
// May create new snapshots on Neumark
bytes32 internal constant ROLE_SNAPSHOT_CREATOR = 0x08c1785afc57f933523bc52583a72ce9e19b2241354e04dd86f41f887e3d8174;
// May enable/disable transfers on Neumark
bytes32 internal constant ROLE_TRANSFER_ADMIN = 0xb6527e944caca3d151b1f94e49ac5e223142694860743e66164720e034ec9b19;
// may reclaim tokens/ether from contracts supporting IReclaimable interface
bytes32 internal constant ROLE_RECLAIMER = 0x0542bbd0c672578966dcc525b30aa16723bb042675554ac5b0362f86b6e97dc5;
// represents legally platform operator in case of forks and contracts with legal agreement attached. keccak256("PlatformOperatorRepresentative")
bytes32 internal constant ROLE_PLATFORM_OPERATOR_REPRESENTATIVE = 0xb2b321377653f655206f71514ff9f150d0822d062a5abcf220d549e1da7999f0;
// allows to deposit EUR-T and allow addresses to send and receive EUR-T. keccak256("EurtDepositManager")
bytes32 internal constant ROLE_EURT_DEPOSIT_MANAGER = 0x7c8ecdcba80ce87848d16ad77ef57cc196c208fc95c5638e4a48c681a34d4fe7;
}
contract IBasicToken {
////////////////////////
// Events
////////////////////////
event Transfer(
address indexed from,
address indexed to,
uint256 amount);
////////////////////////
// Public functions
////////////////////////
/// @dev This function makes it easy to get the total number of tokens
/// @return The total number of tokens
function totalSupply()
public
constant
returns (uint256);
/// @param owner The address that's balance is being requested
/// @return The balance of `owner` at the current block
function balanceOf(address owner)
public
constant
returns (uint256 balance);
/// @notice Send `amount` tokens to `to` from `msg.sender`
/// @param to The address of the recipient
/// @param amount The amount of tokens to be transferred
/// @return Whether the transfer was successful or not
function transfer(address to, uint256 amount)
public
returns (bool success);
}
/// @title allows deriving contract to recover any token or ether that it has balance of
/// @notice note that this opens your contracts to claims from various people saying they lost tokens and they want them back
/// be ready to handle such claims
/// @dev use with care!
/// 1. ROLE_RECLAIMER is allowed to claim tokens, it's not returning tokens to original owner
/// 2. in derived contract that holds any token by design you must override `reclaim` and block such possibility.
/// see LockedAccount as an example
contract Reclaimable is AccessControlled, AccessRoles {
////////////////////////
// Constants
////////////////////////
IBasicToken constant internal RECLAIM_ETHER = IBasicToken(0x0);
////////////////////////
// Public functions
////////////////////////
function reclaim(IBasicToken token)
public
only(ROLE_RECLAIMER)
{
address reclaimer = msg.sender;
if(token == RECLAIM_ETHER) {
reclaimer.transfer(this.balance);
} else {
uint256 balance = token.balanceOf(this);
require(<FILL_ME>)
}
}
}
contract IEthereumForkArbiter {
////////////////////////
// Events
////////////////////////
event LogForkAnnounced(
string name,
string url,
uint256 blockNumber
);
event LogForkSigned(
uint256 blockNumber,
bytes32 blockHash
);
////////////////////////
// Public functions
////////////////////////
function nextForkName()
public
constant
returns (string);
function nextForkUrl()
public
constant
returns (string);
function nextForkBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockHash()
public
constant
returns (bytes32);
function lastSignedTimestamp()
public
constant
returns (uint256);
}
contract EthereumForkArbiter is
IEthereumForkArbiter,
AccessControlled,
AccessRoles,
Reclaimable
{
////////////////////////
// Mutable state
////////////////////////
string private _nextForkName;
string private _nextForkUrl;
uint256 private _nextForkBlockNumber;
uint256 private _lastSignedBlockNumber;
bytes32 private _lastSignedBlockHash;
uint256 private _lastSignedTimestamp;
////////////////////////
// Constructor
////////////////////////
function EthereumForkArbiter(IAccessPolicy accessPolicy)
AccessControlled(accessPolicy)
Reclaimable()
public
{
}
////////////////////////
// Public functions
////////////////////////
/// @notice Announce that a particular future Ethereum fork will the one taken by the contract. The contract on the other branch should be considered invalid. Once the fork has happened, it will additionally be confirmed by signing a block on the fork. Notice that forks may happen unannounced.
function announceFork(
string name,
string url,
uint256 blockNumber
)
public
only(ROLE_PLATFORM_OPERATOR_REPRESENTATIVE)
{
}
/// @notice Declare that the current fork (as identified by a blockhash) is the valid fork. The valid fork is always the one with the most recent signature.
function signFork(uint256 number, bytes32 hash)
public
only(ROLE_PLATFORM_OPERATOR_REPRESENTATIVE)
{
}
function nextForkName()
public
constant
returns (string)
{
}
function nextForkUrl()
public
constant
returns (string)
{
}
function nextForkBlockNumber()
public
constant
returns (uint256)
{
}
function lastSignedBlockNumber()
public
constant
returns (uint256)
{
}
function lastSignedBlockHash()
public
constant
returns (bytes32)
{
}
function lastSignedTimestamp()
public
constant
returns (uint256)
{
}
}
| token.transfer(reclaimer,balance) | 20,255 | token.transfer(reclaimer,balance) |
null | pragma solidity 0.4.15;
/// @title provides subject to role checking logic
contract IAccessPolicy {
////////////////////////
// Public functions
////////////////////////
/// @notice We don't make this function constant to allow for state-updating access controls such as rate limiting.
/// @dev checks if subject belongs to requested role for particular object
/// @param subject address to be checked against role, typically msg.sender
/// @param role identifier of required role
/// @param object contract instance context for role checking, typically contract requesting the check
/// @param verb additional data, in current AccessControll implementation msg.sig
/// @return if subject belongs to a role
function allowed(
address subject,
bytes32 role,
address object,
bytes4 verb
)
public
returns (bool);
}
/// @title enables access control in implementing contract
/// @dev see AccessControlled for implementation
contract IAccessControlled {
////////////////////////
// Events
////////////////////////
/// @dev must log on access policy change
event LogAccessPolicyChanged(
address controller,
IAccessPolicy oldPolicy,
IAccessPolicy newPolicy
);
////////////////////////
// Public functions
////////////////////////
/// @dev allows to change access control mechanism for this contract
/// this method must be itself access controlled, see AccessControlled implementation and notice below
/// @notice it is a huge issue for Solidity that modifiers are not part of function signature
/// then interfaces could be used for example to control access semantics
/// @param newPolicy new access policy to controll this contract
/// @param newAccessController address of ROLE_ACCESS_CONTROLLER of new policy that can set access to this contract
function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController)
public;
function accessPolicy()
public
constant
returns (IAccessPolicy);
}
contract StandardRoles {
////////////////////////
// Constants
////////////////////////
// @notice Soldity somehow doesn't evaluate this compile time
// @dev role which has rights to change permissions and set new policy in contract, keccak256("AccessController")
bytes32 internal constant ROLE_ACCESS_CONTROLLER = 0xac42f8beb17975ed062dcb80c63e6d203ef1c2c335ced149dc5664cc671cb7da;
}
/// @title Granular code execution permissions
/// @notice Intended to replace existing Ownable pattern with more granular permissions set to execute smart contract functions
/// for each function where 'only' modifier is applied, IAccessPolicy implementation is called to evaluate if msg.sender belongs to required role for contract being called.
/// Access evaluation specific belong to IAccessPolicy implementation, see RoleBasedAccessPolicy for details.
/// @dev Should be inherited by a contract requiring such permissions controll. IAccessPolicy must be provided in constructor. Access policy may be replaced to a different one
/// by msg.sender with ROLE_ACCESS_CONTROLLER role
contract AccessControlled is IAccessControlled, StandardRoles {
////////////////////////
// Mutable state
////////////////////////
IAccessPolicy private _accessPolicy;
////////////////////////
// Modifiers
////////////////////////
/// @dev limits function execution only to senders assigned to required 'role'
modifier only(bytes32 role) {
}
////////////////////////
// Constructor
////////////////////////
function AccessControlled(IAccessPolicy policy) internal {
}
////////////////////////
// Public functions
////////////////////////
//
// Implements IAccessControlled
//
function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController)
public
only(ROLE_ACCESS_CONTROLLER)
{
}
function accessPolicy()
public
constant
returns (IAccessPolicy)
{
}
}
contract AccessRoles {
////////////////////////
// Constants
////////////////////////
// NOTE: All roles are set to the keccak256 hash of the
// CamelCased role name, i.e.
// ROLE_LOCKED_ACCOUNT_ADMIN = keccak256("LockedAccountAdmin")
// may setup LockedAccount, change disbursal mechanism and set migration
bytes32 internal constant ROLE_LOCKED_ACCOUNT_ADMIN = 0x4675da546d2d92c5b86c4f726a9e61010dce91cccc2491ce6019e78b09d2572e;
// may setup whitelists and abort whitelisting contract with curve rollback
bytes32 internal constant ROLE_WHITELIST_ADMIN = 0xaef456e7c864418e1d2a40d996ca4febf3a7e317fe3af5a7ea4dda59033bbe5c;
// May issue (generate) Neumarks
bytes32 internal constant ROLE_NEUMARK_ISSUER = 0x921c3afa1f1fff707a785f953a1e197bd28c9c50e300424e015953cbf120c06c;
// May burn Neumarks it owns
bytes32 internal constant ROLE_NEUMARK_BURNER = 0x19ce331285f41739cd3362a3ec176edffe014311c0f8075834fdd19d6718e69f;
// May create new snapshots on Neumark
bytes32 internal constant ROLE_SNAPSHOT_CREATOR = 0x08c1785afc57f933523bc52583a72ce9e19b2241354e04dd86f41f887e3d8174;
// May enable/disable transfers on Neumark
bytes32 internal constant ROLE_TRANSFER_ADMIN = 0xb6527e944caca3d151b1f94e49ac5e223142694860743e66164720e034ec9b19;
// may reclaim tokens/ether from contracts supporting IReclaimable interface
bytes32 internal constant ROLE_RECLAIMER = 0x0542bbd0c672578966dcc525b30aa16723bb042675554ac5b0362f86b6e97dc5;
// represents legally platform operator in case of forks and contracts with legal agreement attached. keccak256("PlatformOperatorRepresentative")
bytes32 internal constant ROLE_PLATFORM_OPERATOR_REPRESENTATIVE = 0xb2b321377653f655206f71514ff9f150d0822d062a5abcf220d549e1da7999f0;
// allows to deposit EUR-T and allow addresses to send and receive EUR-T. keccak256("EurtDepositManager")
bytes32 internal constant ROLE_EURT_DEPOSIT_MANAGER = 0x7c8ecdcba80ce87848d16ad77ef57cc196c208fc95c5638e4a48c681a34d4fe7;
}
contract IBasicToken {
////////////////////////
// Events
////////////////////////
event Transfer(
address indexed from,
address indexed to,
uint256 amount);
////////////////////////
// Public functions
////////////////////////
/// @dev This function makes it easy to get the total number of tokens
/// @return The total number of tokens
function totalSupply()
public
constant
returns (uint256);
/// @param owner The address that's balance is being requested
/// @return The balance of `owner` at the current block
function balanceOf(address owner)
public
constant
returns (uint256 balance);
/// @notice Send `amount` tokens to `to` from `msg.sender`
/// @param to The address of the recipient
/// @param amount The amount of tokens to be transferred
/// @return Whether the transfer was successful or not
function transfer(address to, uint256 amount)
public
returns (bool success);
}
/// @title allows deriving contract to recover any token or ether that it has balance of
/// @notice note that this opens your contracts to claims from various people saying they lost tokens and they want them back
/// be ready to handle such claims
/// @dev use with care!
/// 1. ROLE_RECLAIMER is allowed to claim tokens, it's not returning tokens to original owner
/// 2. in derived contract that holds any token by design you must override `reclaim` and block such possibility.
/// see LockedAccount as an example
contract Reclaimable is AccessControlled, AccessRoles {
////////////////////////
// Constants
////////////////////////
IBasicToken constant internal RECLAIM_ETHER = IBasicToken(0x0);
////////////////////////
// Public functions
////////////////////////
function reclaim(IBasicToken token)
public
only(ROLE_RECLAIMER)
{
}
}
contract IEthereumForkArbiter {
////////////////////////
// Events
////////////////////////
event LogForkAnnounced(
string name,
string url,
uint256 blockNumber
);
event LogForkSigned(
uint256 blockNumber,
bytes32 blockHash
);
////////////////////////
// Public functions
////////////////////////
function nextForkName()
public
constant
returns (string);
function nextForkUrl()
public
constant
returns (string);
function nextForkBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockHash()
public
constant
returns (bytes32);
function lastSignedTimestamp()
public
constant
returns (uint256);
}
contract EthereumForkArbiter is
IEthereumForkArbiter,
AccessControlled,
AccessRoles,
Reclaimable
{
////////////////////////
// Mutable state
////////////////////////
string private _nextForkName;
string private _nextForkUrl;
uint256 private _nextForkBlockNumber;
uint256 private _lastSignedBlockNumber;
bytes32 private _lastSignedBlockHash;
uint256 private _lastSignedTimestamp;
////////////////////////
// Constructor
////////////////////////
function EthereumForkArbiter(IAccessPolicy accessPolicy)
AccessControlled(accessPolicy)
Reclaimable()
public
{
}
////////////////////////
// Public functions
////////////////////////
/// @notice Announce that a particular future Ethereum fork will the one taken by the contract. The contract on the other branch should be considered invalid. Once the fork has happened, it will additionally be confirmed by signing a block on the fork. Notice that forks may happen unannounced.
function announceFork(
string name,
string url,
uint256 blockNumber
)
public
only(ROLE_PLATFORM_OPERATOR_REPRESENTATIVE)
{
}
/// @notice Declare that the current fork (as identified by a blockhash) is the valid fork. The valid fork is always the one with the most recent signature.
function signFork(uint256 number, bytes32 hash)
public
only(ROLE_PLATFORM_OPERATOR_REPRESENTATIVE)
{
require(<FILL_ME>)
// Reset announcement
delete _nextForkName;
delete _nextForkUrl;
delete _nextForkBlockNumber;
// Store signature
_lastSignedBlockNumber = number;
_lastSignedBlockHash = hash;
_lastSignedTimestamp = block.timestamp;
// Log
LogForkSigned(_lastSignedBlockNumber, _lastSignedBlockHash);
}
function nextForkName()
public
constant
returns (string)
{
}
function nextForkUrl()
public
constant
returns (string)
{
}
function nextForkBlockNumber()
public
constant
returns (uint256)
{
}
function lastSignedBlockNumber()
public
constant
returns (uint256)
{
}
function lastSignedBlockHash()
public
constant
returns (bytes32)
{
}
function lastSignedTimestamp()
public
constant
returns (uint256)
{
}
}
| block.blockhash(number)==hash | 20,255 | block.blockhash(number)==hash |
"LiquidityMiningManager.onlyGov: permission denied" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./interfaces/IBasePool.sol";
import "./base/TokenSaver.sol";
contract LiquidityMiningManager is TokenSaver {
using SafeERC20 for IERC20;
bytes32 public constant GOV_ROLE = keccak256("GOV_ROLE");
bytes32 public constant REWARD_DISTRIBUTOR_ROLE = keccak256("REWARD_DISTRIBUTOR_ROLE");
uint256 public MAX_POOL_COUNT = 10;
IERC20 immutable public reward;
address immutable public rewardSource;
uint256 public rewardPerSecond; //total reward amount per second
uint256 public lastDistribution; //when rewards were last pushed
uint256 public totalWeight;
mapping(address => bool) public poolAdded;
Pool[] public pools;
struct Pool {
IBasePool poolContract;
uint256 weight;
}
modifier onlyGov {
require(<FILL_ME>)
_;
}
modifier onlyRewardDistributor {
}
event PoolAdded(address indexed pool, uint256 weight);
event PoolRemoved(uint256 indexed poolId, address indexed pool);
event WeightAdjusted(uint256 indexed poolId, address indexed pool, uint256 newWeight);
event RewardsPerSecondSet(uint256 rewardsPerSecond);
event RewardsDistributed(address _from, uint256 indexed _amount);
constructor(address _reward, address _rewardSource) {
}
function addPool(address _poolContract, uint256 _weight) external onlyGov {
}
function removePool(uint256 _poolId) external onlyGov {
}
function adjustWeight(uint256 _poolId, uint256 _newWeight) external onlyGov {
}
function setRewardPerSecond(uint256 _rewardPerSecond) external onlyGov {
}
function distributeRewards() public onlyRewardDistributor {
}
function getPools() external view returns(Pool[] memory result) {
}
}
| hasRole(GOV_ROLE,_msgSender()),"LiquidityMiningManager.onlyGov: permission denied" | 20,258 | hasRole(GOV_ROLE,_msgSender()) |
"LiquidityMiningManager.onlyRewardDistributor: permission denied" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./interfaces/IBasePool.sol";
import "./base/TokenSaver.sol";
contract LiquidityMiningManager is TokenSaver {
using SafeERC20 for IERC20;
bytes32 public constant GOV_ROLE = keccak256("GOV_ROLE");
bytes32 public constant REWARD_DISTRIBUTOR_ROLE = keccak256("REWARD_DISTRIBUTOR_ROLE");
uint256 public MAX_POOL_COUNT = 10;
IERC20 immutable public reward;
address immutable public rewardSource;
uint256 public rewardPerSecond; //total reward amount per second
uint256 public lastDistribution; //when rewards were last pushed
uint256 public totalWeight;
mapping(address => bool) public poolAdded;
Pool[] public pools;
struct Pool {
IBasePool poolContract;
uint256 weight;
}
modifier onlyGov {
}
modifier onlyRewardDistributor {
require(<FILL_ME>)
_;
}
event PoolAdded(address indexed pool, uint256 weight);
event PoolRemoved(uint256 indexed poolId, address indexed pool);
event WeightAdjusted(uint256 indexed poolId, address indexed pool, uint256 newWeight);
event RewardsPerSecondSet(uint256 rewardsPerSecond);
event RewardsDistributed(address _from, uint256 indexed _amount);
constructor(address _reward, address _rewardSource) {
}
function addPool(address _poolContract, uint256 _weight) external onlyGov {
}
function removePool(uint256 _poolId) external onlyGov {
}
function adjustWeight(uint256 _poolId, uint256 _newWeight) external onlyGov {
}
function setRewardPerSecond(uint256 _rewardPerSecond) external onlyGov {
}
function distributeRewards() public onlyRewardDistributor {
}
function getPools() external view returns(Pool[] memory result) {
}
}
| hasRole(REWARD_DISTRIBUTOR_ROLE,_msgSender()),"LiquidityMiningManager.onlyRewardDistributor: permission denied" | 20,258 | hasRole(REWARD_DISTRIBUTOR_ROLE,_msgSender()) |
"LiquidityMiningManager.addPool: Pool already added" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./interfaces/IBasePool.sol";
import "./base/TokenSaver.sol";
contract LiquidityMiningManager is TokenSaver {
using SafeERC20 for IERC20;
bytes32 public constant GOV_ROLE = keccak256("GOV_ROLE");
bytes32 public constant REWARD_DISTRIBUTOR_ROLE = keccak256("REWARD_DISTRIBUTOR_ROLE");
uint256 public MAX_POOL_COUNT = 10;
IERC20 immutable public reward;
address immutable public rewardSource;
uint256 public rewardPerSecond; //total reward amount per second
uint256 public lastDistribution; //when rewards were last pushed
uint256 public totalWeight;
mapping(address => bool) public poolAdded;
Pool[] public pools;
struct Pool {
IBasePool poolContract;
uint256 weight;
}
modifier onlyGov {
}
modifier onlyRewardDistributor {
}
event PoolAdded(address indexed pool, uint256 weight);
event PoolRemoved(uint256 indexed poolId, address indexed pool);
event WeightAdjusted(uint256 indexed poolId, address indexed pool, uint256 newWeight);
event RewardsPerSecondSet(uint256 rewardsPerSecond);
event RewardsDistributed(address _from, uint256 indexed _amount);
constructor(address _reward, address _rewardSource) {
}
function addPool(address _poolContract, uint256 _weight) external onlyGov {
distributeRewards();
require(_poolContract != address(0), "LiquidityMiningManager.addPool: pool contract must be set");
require(<FILL_ME>)
require(pools.length < MAX_POOL_COUNT, "LiquidityMiningManager.addPool: Max amount of pools reached");
// add pool
pools.push(Pool({
poolContract: IBasePool(_poolContract),
weight: _weight
}));
poolAdded[_poolContract] = true;
// increase totalWeight
totalWeight += _weight;
// Approve max token amount
reward.safeApprove(_poolContract, type(uint256).max);
emit PoolAdded(_poolContract, _weight);
}
function removePool(uint256 _poolId) external onlyGov {
}
function adjustWeight(uint256 _poolId, uint256 _newWeight) external onlyGov {
}
function setRewardPerSecond(uint256 _rewardPerSecond) external onlyGov {
}
function distributeRewards() public onlyRewardDistributor {
}
function getPools() external view returns(Pool[] memory result) {
}
}
| !poolAdded[_poolContract],"LiquidityMiningManager.addPool: Pool already added" | 20,258 | !poolAdded[_poolContract] |
"already mint out" | /**
* 10000 Stellar Leopards.
**/
contract StellarLeopards is ERC721A, Ownable, ReentrancyGuard {
string private _baseTokenURI;
constructor() ERC721A("StellarLeopards", "LEO", 50, 10000) {}
function mintBatch(address to, uint256 quantity) external onlyOwner {
require(<FILL_ME>)
require(quantity % maxBatchSize == 0, "can only mint a multiple of the maxBatchSize");
uint256 numChunks = quantity / maxBatchSize;
for (uint256 i = 0; i < numChunks; i++) {
_safeMint(to, maxBatchSize);
}
}
function mint(address to, uint256 quantity) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external onlyOwner {
}
}
| totalSupply()+quantity<=collectionSize,"already mint out" | 20,270 | totalSupply()+quantity<=collectionSize |
"can only mint a multiple of the maxBatchSize" | /**
* 10000 Stellar Leopards.
**/
contract StellarLeopards is ERC721A, Ownable, ReentrancyGuard {
string private _baseTokenURI;
constructor() ERC721A("StellarLeopards", "LEO", 50, 10000) {}
function mintBatch(address to, uint256 quantity) external onlyOwner {
require(totalSupply() + quantity <= collectionSize, "already mint out");
require(<FILL_ME>)
uint256 numChunks = quantity / maxBatchSize;
for (uint256 i = 0; i < numChunks; i++) {
_safeMint(to, maxBatchSize);
}
}
function mint(address to, uint256 quantity) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdrawMoney() external onlyOwner {
}
}
| quantity%maxBatchSize==0,"can only mint a multiple of the maxBatchSize" | 20,270 | quantity%maxBatchSize==0 |
"No more Bad Wolves" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
. .
...',;;;,.. .:lodllodx0d. .;llc:;,..
.codxxOKkoollokO: .lOxo:. .:KMK, .lXOccllllc,.
.,,'..o0; .oNx. .dXl. ;KMX; cNx. .ckx.
lKc .,oO0d' ,Kk. .xWMX: oWd. 'k0,
.dN0k0NN0l'. ,K0' .oNMMX: .kWk:;:lok0O;
.lKWOc,,;:codxd:. .xNk. .oNXKWX; .oKX0Okxdoc,.
.dNl .'xXl 'kNKkdd0WKcc0O, .....
.dNl .,kXl .;odxxdl' ..
.xNc .,cdO0k:.
...:0WOodxxxdl;. .lddooc.
.:ddooolc;'.. . dKo;,'.
':. .lo. .O0'
.xx. .;cll:,. ,0d ;XXocc:.
cKl :kd;;o0N0: oXc cNKxooc.
.;' .O0, ;0o. ,d0O. .OK; dNo
;; lKk, oNo d0' .;k0' ;XO. .kN:
ox. lK0: ,0K, .x0' ,xKk. lNx. '0K,
oO' ;X0' .dNo. lXd. ,OWXc .xWo. ..... ,Kk.
lK; :XXc ,K0' .xX0dkXKOc. .xNOdddddoo:. ;Ko
cKc :kkK0lxXc .;cll:. .'..... .,.
;Ko.lk:.cXWWO.
'0KOx, .lXXc
.dKo. ..
..
MadJelly: Bad Wolf - A narrative NFT adventure world ...
@madjellyHQ
@duchessbetsy
@jasepostscript
@daweedeth
@supermakebeleeb
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
contract BadWolf is Context, ERC721Enumerable, ERC721Burnable, Ownable, ReentrancyGuard {
address internal duchessBetsy = 0x19661d0bfb4aD2FD1086cf6Bc1bCda0ad5A7797B;
address internal jase = 0xc2467e844a1FF5947a8E75B5beEcA4a5bC31A1Ef;
address internal daweed = 0xd4850927a6e3f30E2e3C3b14D98131Cf8e2D9634;
address internal superMakeBelieve = 0x4E9fD21519Cf3D1FeA8c0deBbB9F91814A3D0d62;
string public BAD_WOLF_PROVENANCE;
string private _baseTokenURI;
bool private _isSaleActive = false;
bool private _hasPromoTokens = false;
uint public constant BW_PRICE = 55500000000000000; // 0.0555 eth
uint public constant MAX_BW_SUPPLY = 5555;
uint public promoTokens = 29;
uint[MAX_BW_SUPPLY] private badWolves;
uint private nonce = 0;
mapping (uint256 => uint256) private _badWolfBirthDate;
constructor(string memory name, string memory symbol, string memory baseTokenURI) ERC721(name, symbol) {
}
function mintBadWolf(uint _count) external payable nonReentrant() {
require(_isSaleActive == true, "Sale must be active");
require(<FILL_ME>)
require(_count > 0 && _count <= 20, "Must mint from 1 to 20 Bad Wolves");
require(_count <= MAX_BW_SUPPLY - totalSupply(), "Not enough Bad Wolves left to mint");
require(msg.value >= _price(_count), "Value below price");
uint i;
uint id;
for(i = 0; i < _count; i++){
id = randomIndex();
_safeMint(msg.sender, id);
_badWolfBirthDate[id - 1] = block.timestamp;
}
}
function mintPromoBadWolf(uint _count) external onlyOwner {
}
function getBadWolfBirthdate(uint _tokenId) external view returns (uint) {
}
function tokensOfOwner(address _user) external view returns (uint[] memory ownerTokens) {
}
// Credits to derpy birbs who credited Meebits
function randomIndex() private returns (uint) {
}
function hasSaleStarted() external view returns (bool) {
}
function _price(uint _count) internal pure returns (uint256) {
}
function setBaseURI(string memory _baseUri) external onlyOwner {
}
function withdrawAll() external payable {
}
function _withdraw(address _address, uint256 _amount) private {
}
function toggleSale() external onlyOwner {
}
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint tokenId) public view virtual override returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
function uintToBytes(uint v) private pure returns (bytes32 ret) {
}
}
| totalSupply()<MAX_BW_SUPPLY,"No more Bad Wolves" | 20,273 | totalSupply()<MAX_BW_SUPPLY |
null | /**
*Submitted for verification at Etherscan.io on 2019-07-26
*/
pragma solidity ^0.5.4;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
}
function transfer(address _to, uint256 _value) public returns (bool) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function allowance(address _owner, address _spender) public view returns (uint256) {
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
address public distributionContract;
bool distributionContractAdded;
bool public paused = false;
function addDistributionContract(address _contract) external {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
function pause() onlyOwner whenNotPaused public {
}
function unpause() onlyOwner whenPaused public {
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
}
}
contract FreezableToken is StandardToken, Ownable {
mapping (address => bool) public frozenAccounts;
event FrozenFunds(address target, bool frozen);
function freezeAccount(address target) public onlyOwner {
}
function unFreezeAccount(address target) public onlyOwner {
}
function frozen(address _target) view public returns (bool){
}
modifier canTransfer(address _sender) {
require(<FILL_ME>)
_;
}
function transfer(address _to, uint256 _value) public canTransfer(msg.sender) returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public canTransfer(_from) returns (bool success) {
}
}
contract TimeLockToken is StandardToken, Ownable {
mapping (address => uint) public timelockAccounts;
event TimeLockFunds(address target, uint releasetime);
function timelockAccount(address target, uint releasetime) public onlyOwner {
}
function timeunlockAccount(address target) public onlyOwner {
}
function releasetime(address _target) view public returns (uint){
}
modifier ReleaseTimeTransfer(address _sender) {
}
function transfer(address _to, uint256 _value) public ReleaseTimeTransfer(msg.sender) returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public ReleaseTimeTransfer(_from) returns (bool success) {
}
}
contract LKTToken is TimeLockToken, FreezableToken, PausableToken, BurnableToken {
string public constant name = "Livek Token";
string public constant symbol = "LKT";
uint public constant decimals = 18;
uint public constant INITIAL_SUPPLY = 2980000000 * (10 ** decimals);
constructor() public {
}
}
| !frozenAccounts[_sender] | 20,300 | !frozenAccounts[_sender] |
"NOT ON ALLOWLIST" | // contracts/PMV.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Optimized.sol";
import "./PMVMixin.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
contract PiratesOfTheMetaverse is PMVMixin, ERC721Optimized, VRFConsumerBase {
using Strings for uint256;
using MerkleProof for bytes32[];
mapping (address => uint256) public presaleMints;
mapping (address => uint256) public freeMints;
bytes32 private s_keyHash;
uint256 private s_fee;
bool public allowBurning = false;
constructor(bytes32 merkleroot, string memory uri, bytes32 _rootMintFree,
bytes32 _provenanceHash, address vrfCoordinator,
address link, bytes32 keyhash, uint256 fee, address _multiSigWallet) ERC721Optimized("Pirates of the Metaverse", "POMV") VRFConsumerBase(vrfCoordinator, link){
}
function mintPresale(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external payable {
require(presaleActive, "PRESALE NOT ACTIVE");
require(<FILL_ME>)
require(presaleMints[msg.sender] + tokenQuantity <= allowance, "MINTING MORE THAN ALLOWED");
uint256 currentSupply = totalNonBurnedSupply();
require(tokenQuantity + currentSupply <= maxSupply, "NOT ENOUGH LEFT IN STOCK");
require(tokenQuantity * presalePrice <= msg.value, "INCORRECT PAYMENT AMOUNT");
for(uint256 i = 1; i <= tokenQuantity; i++) {
_mint(msg.sender, currentSupply + i);
}
presaleMints[msg.sender] += tokenQuantity;
}
function mintFree(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external {
}
function mint(uint256 tokenQuantity) external payable {
}
function ownerMint(uint256 tokenQuantity) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function generateRandomOffset() public onlyOwner returns (bytes32 requestId) {
}
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
}
function setAllowBurning(bool _allowBurning) external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| proof.verify(root,keccak256(abi.encodePacked(msg.sender,allowance))),"NOT ON ALLOWLIST" | 20,319 | proof.verify(root,keccak256(abi.encodePacked(msg.sender,allowance))) |
"MINTING MORE THAN ALLOWED" | // contracts/PMV.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Optimized.sol";
import "./PMVMixin.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
contract PiratesOfTheMetaverse is PMVMixin, ERC721Optimized, VRFConsumerBase {
using Strings for uint256;
using MerkleProof for bytes32[];
mapping (address => uint256) public presaleMints;
mapping (address => uint256) public freeMints;
bytes32 private s_keyHash;
uint256 private s_fee;
bool public allowBurning = false;
constructor(bytes32 merkleroot, string memory uri, bytes32 _rootMintFree,
bytes32 _provenanceHash, address vrfCoordinator,
address link, bytes32 keyhash, uint256 fee, address _multiSigWallet) ERC721Optimized("Pirates of the Metaverse", "POMV") VRFConsumerBase(vrfCoordinator, link){
}
function mintPresale(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external payable {
require(presaleActive, "PRESALE NOT ACTIVE");
require(proof.verify(root, keccak256(abi.encodePacked(msg.sender, allowance))), "NOT ON ALLOWLIST");
require(<FILL_ME>)
uint256 currentSupply = totalNonBurnedSupply();
require(tokenQuantity + currentSupply <= maxSupply, "NOT ENOUGH LEFT IN STOCK");
require(tokenQuantity * presalePrice <= msg.value, "INCORRECT PAYMENT AMOUNT");
for(uint256 i = 1; i <= tokenQuantity; i++) {
_mint(msg.sender, currentSupply + i);
}
presaleMints[msg.sender] += tokenQuantity;
}
function mintFree(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external {
}
function mint(uint256 tokenQuantity) external payable {
}
function ownerMint(uint256 tokenQuantity) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function generateRandomOffset() public onlyOwner returns (bytes32 requestId) {
}
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
}
function setAllowBurning(bool _allowBurning) external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| presaleMints[msg.sender]+tokenQuantity<=allowance,"MINTING MORE THAN ALLOWED" | 20,319 | presaleMints[msg.sender]+tokenQuantity<=allowance |
"NOT ENOUGH LEFT IN STOCK" | // contracts/PMV.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Optimized.sol";
import "./PMVMixin.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
contract PiratesOfTheMetaverse is PMVMixin, ERC721Optimized, VRFConsumerBase {
using Strings for uint256;
using MerkleProof for bytes32[];
mapping (address => uint256) public presaleMints;
mapping (address => uint256) public freeMints;
bytes32 private s_keyHash;
uint256 private s_fee;
bool public allowBurning = false;
constructor(bytes32 merkleroot, string memory uri, bytes32 _rootMintFree,
bytes32 _provenanceHash, address vrfCoordinator,
address link, bytes32 keyhash, uint256 fee, address _multiSigWallet) ERC721Optimized("Pirates of the Metaverse", "POMV") VRFConsumerBase(vrfCoordinator, link){
}
function mintPresale(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external payable {
require(presaleActive, "PRESALE NOT ACTIVE");
require(proof.verify(root, keccak256(abi.encodePacked(msg.sender, allowance))), "NOT ON ALLOWLIST");
require(presaleMints[msg.sender] + tokenQuantity <= allowance, "MINTING MORE THAN ALLOWED");
uint256 currentSupply = totalNonBurnedSupply();
require(<FILL_ME>)
require(tokenQuantity * presalePrice <= msg.value, "INCORRECT PAYMENT AMOUNT");
for(uint256 i = 1; i <= tokenQuantity; i++) {
_mint(msg.sender, currentSupply + i);
}
presaleMints[msg.sender] += tokenQuantity;
}
function mintFree(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external {
}
function mint(uint256 tokenQuantity) external payable {
}
function ownerMint(uint256 tokenQuantity) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function generateRandomOffset() public onlyOwner returns (bytes32 requestId) {
}
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
}
function setAllowBurning(bool _allowBurning) external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| tokenQuantity+currentSupply<=maxSupply,"NOT ENOUGH LEFT IN STOCK" | 20,319 | tokenQuantity+currentSupply<=maxSupply |
"INCORRECT PAYMENT AMOUNT" | // contracts/PMV.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Optimized.sol";
import "./PMVMixin.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
contract PiratesOfTheMetaverse is PMVMixin, ERC721Optimized, VRFConsumerBase {
using Strings for uint256;
using MerkleProof for bytes32[];
mapping (address => uint256) public presaleMints;
mapping (address => uint256) public freeMints;
bytes32 private s_keyHash;
uint256 private s_fee;
bool public allowBurning = false;
constructor(bytes32 merkleroot, string memory uri, bytes32 _rootMintFree,
bytes32 _provenanceHash, address vrfCoordinator,
address link, bytes32 keyhash, uint256 fee, address _multiSigWallet) ERC721Optimized("Pirates of the Metaverse", "POMV") VRFConsumerBase(vrfCoordinator, link){
}
function mintPresale(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external payable {
require(presaleActive, "PRESALE NOT ACTIVE");
require(proof.verify(root, keccak256(abi.encodePacked(msg.sender, allowance))), "NOT ON ALLOWLIST");
require(presaleMints[msg.sender] + tokenQuantity <= allowance, "MINTING MORE THAN ALLOWED");
uint256 currentSupply = totalNonBurnedSupply();
require(tokenQuantity + currentSupply <= maxSupply, "NOT ENOUGH LEFT IN STOCK");
require(<FILL_ME>)
for(uint256 i = 1; i <= tokenQuantity; i++) {
_mint(msg.sender, currentSupply + i);
}
presaleMints[msg.sender] += tokenQuantity;
}
function mintFree(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external {
}
function mint(uint256 tokenQuantity) external payable {
}
function ownerMint(uint256 tokenQuantity) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function generateRandomOffset() public onlyOwner returns (bytes32 requestId) {
}
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
}
function setAllowBurning(bool _allowBurning) external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| tokenQuantity*presalePrice<=msg.value,"INCORRECT PAYMENT AMOUNT" | 20,319 | tokenQuantity*presalePrice<=msg.value |
"NOT ON FREE MINT ALLOWLIST" | // contracts/PMV.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Optimized.sol";
import "./PMVMixin.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
contract PiratesOfTheMetaverse is PMVMixin, ERC721Optimized, VRFConsumerBase {
using Strings for uint256;
using MerkleProof for bytes32[];
mapping (address => uint256) public presaleMints;
mapping (address => uint256) public freeMints;
bytes32 private s_keyHash;
uint256 private s_fee;
bool public allowBurning = false;
constructor(bytes32 merkleroot, string memory uri, bytes32 _rootMintFree,
bytes32 _provenanceHash, address vrfCoordinator,
address link, bytes32 keyhash, uint256 fee, address _multiSigWallet) ERC721Optimized("Pirates of the Metaverse", "POMV") VRFConsumerBase(vrfCoordinator, link){
}
function mintPresale(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external payable {
}
function mintFree(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external {
require(presaleActive, "Free mint not allowed");
require(<FILL_ME>)
require(freeMints[msg.sender] + tokenQuantity <= allowance, "MINTING MORE THAN ALLOWED");
uint256 currentSupply = totalNonBurnedSupply();
require(tokenQuantity + currentSupply <= maxSupply, "NOT ENOUGH LEFT IN STOCK");
for(uint256 i = 1; i <= tokenQuantity; i++) {
_mint(msg.sender, currentSupply + i);
}
freeMints[msg.sender] += tokenQuantity;
}
function mint(uint256 tokenQuantity) external payable {
}
function ownerMint(uint256 tokenQuantity) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function generateRandomOffset() public onlyOwner returns (bytes32 requestId) {
}
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
}
function setAllowBurning(bool _allowBurning) external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| proof.verify(rootMintFree,keccak256(abi.encodePacked(msg.sender,allowance))),"NOT ON FREE MINT ALLOWLIST" | 20,319 | proof.verify(rootMintFree,keccak256(abi.encodePacked(msg.sender,allowance))) |
"MINTING MORE THAN ALLOWED" | // contracts/PMV.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Optimized.sol";
import "./PMVMixin.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
contract PiratesOfTheMetaverse is PMVMixin, ERC721Optimized, VRFConsumerBase {
using Strings for uint256;
using MerkleProof for bytes32[];
mapping (address => uint256) public presaleMints;
mapping (address => uint256) public freeMints;
bytes32 private s_keyHash;
uint256 private s_fee;
bool public allowBurning = false;
constructor(bytes32 merkleroot, string memory uri, bytes32 _rootMintFree,
bytes32 _provenanceHash, address vrfCoordinator,
address link, bytes32 keyhash, uint256 fee, address _multiSigWallet) ERC721Optimized("Pirates of the Metaverse", "POMV") VRFConsumerBase(vrfCoordinator, link){
}
function mintPresale(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external payable {
}
function mintFree(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external {
require(presaleActive, "Free mint not allowed");
require(proof.verify(rootMintFree, keccak256(abi.encodePacked(msg.sender, allowance))), "NOT ON FREE MINT ALLOWLIST");
require(<FILL_ME>)
uint256 currentSupply = totalNonBurnedSupply();
require(tokenQuantity + currentSupply <= maxSupply, "NOT ENOUGH LEFT IN STOCK");
for(uint256 i = 1; i <= tokenQuantity; i++) {
_mint(msg.sender, currentSupply + i);
}
freeMints[msg.sender] += tokenQuantity;
}
function mint(uint256 tokenQuantity) external payable {
}
function ownerMint(uint256 tokenQuantity) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function generateRandomOffset() public onlyOwner returns (bytes32 requestId) {
}
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
}
function setAllowBurning(bool _allowBurning) external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| freeMints[msg.sender]+tokenQuantity<=allowance,"MINTING MORE THAN ALLOWED" | 20,319 | freeMints[msg.sender]+tokenQuantity<=allowance |
"INCORRECT PAYMENT AMOUNT" | // contracts/PMV.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Optimized.sol";
import "./PMVMixin.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
contract PiratesOfTheMetaverse is PMVMixin, ERC721Optimized, VRFConsumerBase {
using Strings for uint256;
using MerkleProof for bytes32[];
mapping (address => uint256) public presaleMints;
mapping (address => uint256) public freeMints;
bytes32 private s_keyHash;
uint256 private s_fee;
bool public allowBurning = false;
constructor(bytes32 merkleroot, string memory uri, bytes32 _rootMintFree,
bytes32 _provenanceHash, address vrfCoordinator,
address link, bytes32 keyhash, uint256 fee, address _multiSigWallet) ERC721Optimized("Pirates of the Metaverse", "POMV") VRFConsumerBase(vrfCoordinator, link){
}
function mintPresale(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external payable {
}
function mintFree(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external {
}
function mint(uint256 tokenQuantity) external payable {
if (!letContractMint){
require(msg.sender == tx.origin, "CONTRACT NOT ALLOWED TO MINT IN PUBLIC SALE");
}
require(saleActive, "SALE NOT ACTIVE");
require(tokenQuantity <= maxPerTransaction, "MINTING MORE THAN ALLOWED IN A SINGLE TRANSACTION");
uint256 currentSupply = totalNonBurnedSupply();
require(tokenQuantity + currentSupply <= maxSupply, "NOT ENOUGH LEFT IN STOCK");
require(<FILL_ME>)
for(uint256 i = 1; i <= tokenQuantity; i++) {
_mint(msg.sender, currentSupply + i);
}
}
function ownerMint(uint256 tokenQuantity) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function generateRandomOffset() public onlyOwner returns (bytes32 requestId) {
}
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
}
function setAllowBurning(bool _allowBurning) external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| tokenQuantity*salePrice<=msg.value,"INCORRECT PAYMENT AMOUNT" | 20,319 | tokenQuantity*salePrice<=msg.value |
"NOT ENOUGH LEFT IN STOCK" | // contracts/PMV.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Optimized.sol";
import "./PMVMixin.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
contract PiratesOfTheMetaverse is PMVMixin, ERC721Optimized, VRFConsumerBase {
using Strings for uint256;
using MerkleProof for bytes32[];
mapping (address => uint256) public presaleMints;
mapping (address => uint256) public freeMints;
bytes32 private s_keyHash;
uint256 private s_fee;
bool public allowBurning = false;
constructor(bytes32 merkleroot, string memory uri, bytes32 _rootMintFree,
bytes32 _provenanceHash, address vrfCoordinator,
address link, bytes32 keyhash, uint256 fee, address _multiSigWallet) ERC721Optimized("Pirates of the Metaverse", "POMV") VRFConsumerBase(vrfCoordinator, link){
}
function mintPresale(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external payable {
}
function mintFree(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external {
}
function mint(uint256 tokenQuantity) external payable {
}
function ownerMint(uint256 tokenQuantity) external onlyOwner {
uint256 currentSupply = totalNonBurnedSupply();
require(<FILL_ME>)
for(uint256 i = 1; i <= tokenQuantity; i++) {
_mint(multiSigWallet, currentSupply + i);
}
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function generateRandomOffset() public onlyOwner returns (bytes32 requestId) {
}
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
}
function setAllowBurning(bool _allowBurning) external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| tokenQuantity+currentSupply<=ownerMintBuffer,"NOT ENOUGH LEFT IN STOCK" | 20,319 | tokenQuantity+currentSupply<=ownerMintBuffer |
"Not enough LINK to pay fee" | // contracts/PMV.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Optimized.sol";
import "./PMVMixin.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
contract PiratesOfTheMetaverse is PMVMixin, ERC721Optimized, VRFConsumerBase {
using Strings for uint256;
using MerkleProof for bytes32[];
mapping (address => uint256) public presaleMints;
mapping (address => uint256) public freeMints;
bytes32 private s_keyHash;
uint256 private s_fee;
bool public allowBurning = false;
constructor(bytes32 merkleroot, string memory uri, bytes32 _rootMintFree,
bytes32 _provenanceHash, address vrfCoordinator,
address link, bytes32 keyhash, uint256 fee, address _multiSigWallet) ERC721Optimized("Pirates of the Metaverse", "POMV") VRFConsumerBase(vrfCoordinator, link){
}
function mintPresale(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external payable {
}
function mintFree(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external {
}
function mint(uint256 tokenQuantity) external payable {
}
function ownerMint(uint256 tokenQuantity) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function generateRandomOffset() public onlyOwner returns (bytes32 requestId) {
require(<FILL_ME>)
require(!offsetRequested, "Already generated random offset");
requestId = requestRandomness(s_keyHash, s_fee);
}
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
}
function setAllowBurning(bool _allowBurning) external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| LINK.balanceOf(address(this))>=s_fee,"Not enough LINK to pay fee" | 20,319 | LINK.balanceOf(address(this))>=s_fee |
"Already generated random offset" | // contracts/PMV.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721Optimized.sol";
import "./PMVMixin.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
contract PiratesOfTheMetaverse is PMVMixin, ERC721Optimized, VRFConsumerBase {
using Strings for uint256;
using MerkleProof for bytes32[];
mapping (address => uint256) public presaleMints;
mapping (address => uint256) public freeMints;
bytes32 private s_keyHash;
uint256 private s_fee;
bool public allowBurning = false;
constructor(bytes32 merkleroot, string memory uri, bytes32 _rootMintFree,
bytes32 _provenanceHash, address vrfCoordinator,
address link, bytes32 keyhash, uint256 fee, address _multiSigWallet) ERC721Optimized("Pirates of the Metaverse", "POMV") VRFConsumerBase(vrfCoordinator, link){
}
function mintPresale(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external payable {
}
function mintFree(uint256 allowance, bytes32[] calldata proof, uint256 tokenQuantity) external {
}
function mint(uint256 tokenQuantity) external payable {
}
function ownerMint(uint256 tokenQuantity) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function generateRandomOffset() public onlyOwner returns (bytes32 requestId) {
require(LINK.balanceOf(address(this)) >= s_fee, "Not enough LINK to pay fee");
require(<FILL_ME>)
requestId = requestRandomness(s_keyHash, s_fee);
}
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
}
function setAllowBurning(bool _allowBurning) external onlyOwner {
}
function burn(uint256 tokenId) public virtual {
}
}
| !offsetRequested,"Already generated random offset" | 20,319 | !offsetRequested |
"Mult overflow" | pragma solidity ^0.6.6;
library SafeMath {
using SafeMath for uint256;
function add(uint256 x, uint256 y) internal pure returns (uint256) {
}
function sub(uint256 x, uint256 y) internal pure returns (uint256) {
}
function mult(uint256 x, uint256 y) internal pure returns (uint256) {
if (x == 0) {
return 0;
}
uint256 z = x * y;
require(<FILL_ME>)
return z;
}
function div(uint256 x, uint256 y) internal pure returns (uint256) {
}
function multdiv(uint256 x, uint256 y, uint256 z) internal pure returns (uint256) {
}
}
| z/x==y,"Mult overflow" | 20,359 | z/x==y |
"AccessControl: sender must be an admin to grant" | pragma solidity ^0.6.0;
import "../utils/EnumerableSet.sol";
import "../utils/Address.sol";
import "../GSN/Context.sol";
import "../Initializable.sol";
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```
* function foo() public {
* require(hasRole(MY_ROLE, _msgSender()));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*/
abstract contract AccessControlUpgradeSafe is Initializable, ContextUpgradeSafe {
function __AccessControl_init() internal initializer {
}
function __AccessControl_init_unchained() internal initializer {
}
using EnumerableSet for EnumerableSet.AddressSet;
using Address for address;
struct RoleData {
EnumerableSet.AddressSet members;
bytes32 adminRole;
}
mapping (bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call, an admin role
* bearer except when using {_setupRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view returns (bool) {
}
/**
* @dev Returns the number of accounts that have `role`. Can be used
* together with {getRoleMember} to enumerate all bearers of a role.
*/
function getRoleMemberCount(bytes32 role) public view returns (uint256) {
}
/**
* @dev Returns one of the accounts that have `role`. `index` must be a
* value between 0 and {getRoleMemberCount}, non-inclusive.
*
* Role bearers are not sorted in any particular way, and their ordering may
* change at any point.
*
* WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
* you perform all queries on the same block. See the following
* https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
* for more information.
*/
function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view returns (bytes32) {
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) public virtual {
require(<FILL_ME>)
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) public virtual {
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*/
function renounceRole(bytes32 role, address account) public virtual {
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event. Note that unlike {grantRole}, this function doesn't perform any
* checks on the calling account.
*
* [WARNING]
* ====
* This function should only be called from the constructor when setting
* up the initial roles for the system.
*
* Using this function in any other way is effectively circumventing the admin
* system imposed by {AccessControl}.
* ====
*/
function _setupRole(bytes32 role, address account) internal virtual {
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
}
function _grantRole(bytes32 role, address account) private {
}
function _revokeRole(bytes32 role, address account) private {
}
uint256[49] private __gap;
}
| hasRole(_roles[role].adminRole,_msgSender()),"AccessControl: sender must be an admin to grant" | 20,369 | hasRole(_roles[role].adminRole,_msgSender()) |
"leftover balance" | pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./external/interfaces/ILendingPool.sol";
import "./interfaces/IFlashRollover.sol";
import "./interfaces/ILoanCore.sol";
import "./interfaces/IOriginationController.sol";
import "./interfaces/IRepaymentController.sol";
import "./interfaces/IAssetWrapper.sol";
import "./interfaces/IFeeController.sol";
/**
*
* @dev FlashRollover allows a borrower to roll over
* a Pawn.fi loan into a new loan without having to
* repay capital. It integrate with AAVE's flash loans
* to provide repayment capital, which is then compensated
* for by the newly-issued loan.
*
* Full API docs at docs/FlashRollover.md
*
*/
contract FlashRollover is IFlashRollover, ReentrancyGuard {
using SafeERC20 for IERC20;
/* solhint-disable var-name-mixedcase */
// AAVE Contracts
// Variable names are in upper case to fulfill IFlashLoanReceiver interface
ILendingPoolAddressesProvider public immutable override ADDRESSES_PROVIDER;
ILendingPool public immutable override LENDING_POOL;
/* solhint-enable var-name-mixedcase */
address private owner;
constructor(ILendingPoolAddressesProvider _addressesProvider) {
}
function rolloverLoan(
RolloverContractParams calldata contracts,
uint256 loanId,
LoanLibrary.LoanTerms calldata newLoanTerms,
uint8 v,
bytes32 r,
bytes32 s
) external override {
ILoanCore sourceLoanCore = contracts.sourceLoanCore;
LoanLibrary.LoanData memory loanData = sourceLoanCore.getLoan(loanId);
LoanLibrary.LoanTerms memory loanTerms = loanData.terms;
_validateRollover(sourceLoanCore, contracts.targetLoanCore, loanTerms, newLoanTerms, loanData.borrowerNoteId);
{
address[] memory assets = new address[](1);
assets[0] = loanTerms.payableCurrency;
uint256[] memory amounts = new uint256[](1);
amounts[0] = loanTerms.principal + loanTerms.interest;
uint256[] memory modes = new uint256[](1);
modes[0] = 0;
bytes memory params = abi.encode(
OperationData({ contracts: contracts, loanId: loanId, newLoanTerms: newLoanTerms, v: v, r: r, s: s })
);
// Flash loan based on principal + interest
LENDING_POOL.flashLoan(address(this), assets, amounts, modes, address(this), params, 0);
}
// Should not have any funds leftover
require(<FILL_ME>)
}
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params
) external override nonReentrant returns (bool) {
}
function _executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
OperationData memory opData
) internal returns (bool) {
}
function _ensureFunds(
uint256 amount,
uint256 premium,
uint256 originationFee,
uint256 newPrincipal
)
internal
pure
returns (
uint256 flashAmountDue,
uint256 needFromBorrower,
uint256 leftoverPrincipal
)
{
}
function _repayLoan(
OperationContracts memory contracts,
LoanLibrary.LoanData memory loanData,
address borrower
) internal {
}
function _initializeNewLoan(
OperationContracts memory contracts,
address borrower,
address lender,
uint256 collateralTokenId,
OperationData memory opData
) internal returns (uint256) {
}
function _getContracts(RolloverContractParams memory contracts) internal returns (OperationContracts memory) {
}
function _validateRollover(
ILoanCore sourceLoanCore,
ILoanCore targetLoanCore,
LoanLibrary.LoanTerms memory sourceLoanTerms,
LoanLibrary.LoanTerms calldata newLoanTerms,
uint256 borrowerNoteId
) internal {
}
function setOwner(address _owner) external override {
}
function flushToken(IERC20 token, address to) external override {
}
}
| IERC20(loanTerms.payableCurrency).balanceOf(address(this))==0,"leftover balance" | 20,414 | IERC20(loanTerms.payableCurrency).balanceOf(address(this))==0 |
"borrower cannot pay" | pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./external/interfaces/ILendingPool.sol";
import "./interfaces/IFlashRollover.sol";
import "./interfaces/ILoanCore.sol";
import "./interfaces/IOriginationController.sol";
import "./interfaces/IRepaymentController.sol";
import "./interfaces/IAssetWrapper.sol";
import "./interfaces/IFeeController.sol";
/**
*
* @dev FlashRollover allows a borrower to roll over
* a Pawn.fi loan into a new loan without having to
* repay capital. It integrate with AAVE's flash loans
* to provide repayment capital, which is then compensated
* for by the newly-issued loan.
*
* Full API docs at docs/FlashRollover.md
*
*/
contract FlashRollover is IFlashRollover, ReentrancyGuard {
using SafeERC20 for IERC20;
/* solhint-disable var-name-mixedcase */
// AAVE Contracts
// Variable names are in upper case to fulfill IFlashLoanReceiver interface
ILendingPoolAddressesProvider public immutable override ADDRESSES_PROVIDER;
ILendingPool public immutable override LENDING_POOL;
/* solhint-enable var-name-mixedcase */
address private owner;
constructor(ILendingPoolAddressesProvider _addressesProvider) {
}
function rolloverLoan(
RolloverContractParams calldata contracts,
uint256 loanId,
LoanLibrary.LoanTerms calldata newLoanTerms,
uint8 v,
bytes32 r,
bytes32 s
) external override {
}
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params
) external override nonReentrant returns (bool) {
}
function _executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
OperationData memory opData
) internal returns (bool) {
OperationContracts memory opContracts = _getContracts(opData.contracts);
// Get loan details
LoanLibrary.LoanData memory loanData = opContracts.loanCore.getLoan(opData.loanId);
address borrower = opContracts.borrowerNote.ownerOf(loanData.borrowerNoteId);
address lender = opContracts.lenderNote.ownerOf(loanData.lenderNoteId);
// Do accounting to figure out amount each party needs to receive
(uint256 flashAmountDue, uint256 needFromBorrower, uint256 leftoverPrincipal) = _ensureFunds(
amounts[0],
premiums[0],
opContracts.feeController.getOriginationFee(),
opData.newLoanTerms.principal
);
IERC20 asset = IERC20(assets[0]);
if (needFromBorrower > 0) {
require(<FILL_ME>)
require(asset.allowance(borrower, address(this)) >= needFromBorrower, "lacks borrower approval");
}
_repayLoan(opContracts, loanData, borrower);
uint256 newLoanId = _initializeNewLoan(opContracts, borrower, lender, loanData.terms.collateralTokenId, opData);
if (leftoverPrincipal > 0) {
asset.safeTransfer(borrower, leftoverPrincipal);
} else if (needFromBorrower > 0) {
asset.safeTransferFrom(borrower, address(this), needFromBorrower);
}
// Approve all amounts for flash loan repayment
asset.approve(address(LENDING_POOL), flashAmountDue);
emit Rollover(lender, borrower, loanData.terms.collateralTokenId, newLoanId);
if (address(opData.contracts.sourceLoanCore) != address(opData.contracts.targetLoanCore)) {
emit Migration(address(opContracts.loanCore), address(opContracts.targetLoanCore), newLoanId);
}
return true;
}
function _ensureFunds(
uint256 amount,
uint256 premium,
uint256 originationFee,
uint256 newPrincipal
)
internal
pure
returns (
uint256 flashAmountDue,
uint256 needFromBorrower,
uint256 leftoverPrincipal
)
{
}
function _repayLoan(
OperationContracts memory contracts,
LoanLibrary.LoanData memory loanData,
address borrower
) internal {
}
function _initializeNewLoan(
OperationContracts memory contracts,
address borrower,
address lender,
uint256 collateralTokenId,
OperationData memory opData
) internal returns (uint256) {
}
function _getContracts(RolloverContractParams memory contracts) internal returns (OperationContracts memory) {
}
function _validateRollover(
ILoanCore sourceLoanCore,
ILoanCore targetLoanCore,
LoanLibrary.LoanTerms memory sourceLoanTerms,
LoanLibrary.LoanTerms calldata newLoanTerms,
uint256 borrowerNoteId
) internal {
}
function setOwner(address _owner) external override {
}
function flushToken(IERC20 token, address to) external override {
}
}
| asset.balanceOf(borrower)>=needFromBorrower,"borrower cannot pay" | 20,414 | asset.balanceOf(borrower)>=needFromBorrower |
"lacks borrower approval" | pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./external/interfaces/ILendingPool.sol";
import "./interfaces/IFlashRollover.sol";
import "./interfaces/ILoanCore.sol";
import "./interfaces/IOriginationController.sol";
import "./interfaces/IRepaymentController.sol";
import "./interfaces/IAssetWrapper.sol";
import "./interfaces/IFeeController.sol";
/**
*
* @dev FlashRollover allows a borrower to roll over
* a Pawn.fi loan into a new loan without having to
* repay capital. It integrate with AAVE's flash loans
* to provide repayment capital, which is then compensated
* for by the newly-issued loan.
*
* Full API docs at docs/FlashRollover.md
*
*/
contract FlashRollover is IFlashRollover, ReentrancyGuard {
using SafeERC20 for IERC20;
/* solhint-disable var-name-mixedcase */
// AAVE Contracts
// Variable names are in upper case to fulfill IFlashLoanReceiver interface
ILendingPoolAddressesProvider public immutable override ADDRESSES_PROVIDER;
ILendingPool public immutable override LENDING_POOL;
/* solhint-enable var-name-mixedcase */
address private owner;
constructor(ILendingPoolAddressesProvider _addressesProvider) {
}
function rolloverLoan(
RolloverContractParams calldata contracts,
uint256 loanId,
LoanLibrary.LoanTerms calldata newLoanTerms,
uint8 v,
bytes32 r,
bytes32 s
) external override {
}
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params
) external override nonReentrant returns (bool) {
}
function _executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
OperationData memory opData
) internal returns (bool) {
OperationContracts memory opContracts = _getContracts(opData.contracts);
// Get loan details
LoanLibrary.LoanData memory loanData = opContracts.loanCore.getLoan(opData.loanId);
address borrower = opContracts.borrowerNote.ownerOf(loanData.borrowerNoteId);
address lender = opContracts.lenderNote.ownerOf(loanData.lenderNoteId);
// Do accounting to figure out amount each party needs to receive
(uint256 flashAmountDue, uint256 needFromBorrower, uint256 leftoverPrincipal) = _ensureFunds(
amounts[0],
premiums[0],
opContracts.feeController.getOriginationFee(),
opData.newLoanTerms.principal
);
IERC20 asset = IERC20(assets[0]);
if (needFromBorrower > 0) {
require(asset.balanceOf(borrower) >= needFromBorrower, "borrower cannot pay");
require(<FILL_ME>)
}
_repayLoan(opContracts, loanData, borrower);
uint256 newLoanId = _initializeNewLoan(opContracts, borrower, lender, loanData.terms.collateralTokenId, opData);
if (leftoverPrincipal > 0) {
asset.safeTransfer(borrower, leftoverPrincipal);
} else if (needFromBorrower > 0) {
asset.safeTransferFrom(borrower, address(this), needFromBorrower);
}
// Approve all amounts for flash loan repayment
asset.approve(address(LENDING_POOL), flashAmountDue);
emit Rollover(lender, borrower, loanData.terms.collateralTokenId, newLoanId);
if (address(opData.contracts.sourceLoanCore) != address(opData.contracts.targetLoanCore)) {
emit Migration(address(opContracts.loanCore), address(opContracts.targetLoanCore), newLoanId);
}
return true;
}
function _ensureFunds(
uint256 amount,
uint256 premium,
uint256 originationFee,
uint256 newPrincipal
)
internal
pure
returns (
uint256 flashAmountDue,
uint256 needFromBorrower,
uint256 leftoverPrincipal
)
{
}
function _repayLoan(
OperationContracts memory contracts,
LoanLibrary.LoanData memory loanData,
address borrower
) internal {
}
function _initializeNewLoan(
OperationContracts memory contracts,
address borrower,
address lender,
uint256 collateralTokenId,
OperationData memory opData
) internal returns (uint256) {
}
function _getContracts(RolloverContractParams memory contracts) internal returns (OperationContracts memory) {
}
function _validateRollover(
ILoanCore sourceLoanCore,
ILoanCore targetLoanCore,
LoanLibrary.LoanTerms memory sourceLoanTerms,
LoanLibrary.LoanTerms calldata newLoanTerms,
uint256 borrowerNoteId
) internal {
}
function setOwner(address _owner) external override {
}
function flushToken(IERC20 token, address to) external override {
}
}
| asset.allowance(borrower,address(this))>=needFromBorrower,"lacks borrower approval" | 20,414 | asset.allowance(borrower,address(this))>=needFromBorrower |
"collateral ownership" | pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./external/interfaces/ILendingPool.sol";
import "./interfaces/IFlashRollover.sol";
import "./interfaces/ILoanCore.sol";
import "./interfaces/IOriginationController.sol";
import "./interfaces/IRepaymentController.sol";
import "./interfaces/IAssetWrapper.sol";
import "./interfaces/IFeeController.sol";
/**
*
* @dev FlashRollover allows a borrower to roll over
* a Pawn.fi loan into a new loan without having to
* repay capital. It integrate with AAVE's flash loans
* to provide repayment capital, which is then compensated
* for by the newly-issued loan.
*
* Full API docs at docs/FlashRollover.md
*
*/
contract FlashRollover is IFlashRollover, ReentrancyGuard {
using SafeERC20 for IERC20;
/* solhint-disable var-name-mixedcase */
// AAVE Contracts
// Variable names are in upper case to fulfill IFlashLoanReceiver interface
ILendingPoolAddressesProvider public immutable override ADDRESSES_PROVIDER;
ILendingPool public immutable override LENDING_POOL;
/* solhint-enable var-name-mixedcase */
address private owner;
constructor(ILendingPoolAddressesProvider _addressesProvider) {
}
function rolloverLoan(
RolloverContractParams calldata contracts,
uint256 loanId,
LoanLibrary.LoanTerms calldata newLoanTerms,
uint8 v,
bytes32 r,
bytes32 s
) external override {
}
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params
) external override nonReentrant returns (bool) {
}
function _executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
OperationData memory opData
) internal returns (bool) {
}
function _ensureFunds(
uint256 amount,
uint256 premium,
uint256 originationFee,
uint256 newPrincipal
)
internal
pure
returns (
uint256 flashAmountDue,
uint256 needFromBorrower,
uint256 leftoverPrincipal
)
{
}
function _repayLoan(
OperationContracts memory contracts,
LoanLibrary.LoanData memory loanData,
address borrower
) internal {
// Take BorrowerNote from borrower
// Must be approved for withdrawal
contracts.borrowerNote.transferFrom(borrower, address(this), loanData.borrowerNoteId);
// Approve repayment
IERC20(loanData.terms.payableCurrency).approve(
address(contracts.repaymentController),
loanData.terms.principal + loanData.terms.interest
);
// Repay loan
contracts.repaymentController.repay(loanData.borrowerNoteId);
// contract now has asset wrapper but has lost funds
require(<FILL_ME>)
}
function _initializeNewLoan(
OperationContracts memory contracts,
address borrower,
address lender,
uint256 collateralTokenId,
OperationData memory opData
) internal returns (uint256) {
}
function _getContracts(RolloverContractParams memory contracts) internal returns (OperationContracts memory) {
}
function _validateRollover(
ILoanCore sourceLoanCore,
ILoanCore targetLoanCore,
LoanLibrary.LoanTerms memory sourceLoanTerms,
LoanLibrary.LoanTerms calldata newLoanTerms,
uint256 borrowerNoteId
) internal {
}
function setOwner(address _owner) external override {
}
function flushToken(IERC20 token, address to) external override {
}
}
| contracts.assetWrapper.ownerOf(loanData.terms.collateralTokenId)==address(this),"collateral ownership" | 20,414 | contracts.assetWrapper.ownerOf(loanData.terms.collateralTokenId)==address(this) |
"caller not borrower" | pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./external/interfaces/ILendingPool.sol";
import "./interfaces/IFlashRollover.sol";
import "./interfaces/ILoanCore.sol";
import "./interfaces/IOriginationController.sol";
import "./interfaces/IRepaymentController.sol";
import "./interfaces/IAssetWrapper.sol";
import "./interfaces/IFeeController.sol";
/**
*
* @dev FlashRollover allows a borrower to roll over
* a Pawn.fi loan into a new loan without having to
* repay capital. It integrate with AAVE's flash loans
* to provide repayment capital, which is then compensated
* for by the newly-issued loan.
*
* Full API docs at docs/FlashRollover.md
*
*/
contract FlashRollover is IFlashRollover, ReentrancyGuard {
using SafeERC20 for IERC20;
/* solhint-disable var-name-mixedcase */
// AAVE Contracts
// Variable names are in upper case to fulfill IFlashLoanReceiver interface
ILendingPoolAddressesProvider public immutable override ADDRESSES_PROVIDER;
ILendingPool public immutable override LENDING_POOL;
/* solhint-enable var-name-mixedcase */
address private owner;
constructor(ILendingPoolAddressesProvider _addressesProvider) {
}
function rolloverLoan(
RolloverContractParams calldata contracts,
uint256 loanId,
LoanLibrary.LoanTerms calldata newLoanTerms,
uint8 v,
bytes32 r,
bytes32 s
) external override {
}
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params
) external override nonReentrant returns (bool) {
}
function _executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
OperationData memory opData
) internal returns (bool) {
}
function _ensureFunds(
uint256 amount,
uint256 premium,
uint256 originationFee,
uint256 newPrincipal
)
internal
pure
returns (
uint256 flashAmountDue,
uint256 needFromBorrower,
uint256 leftoverPrincipal
)
{
}
function _repayLoan(
OperationContracts memory contracts,
LoanLibrary.LoanData memory loanData,
address borrower
) internal {
}
function _initializeNewLoan(
OperationContracts memory contracts,
address borrower,
address lender,
uint256 collateralTokenId,
OperationData memory opData
) internal returns (uint256) {
}
function _getContracts(RolloverContractParams memory contracts) internal returns (OperationContracts memory) {
}
function _validateRollover(
ILoanCore sourceLoanCore,
ILoanCore targetLoanCore,
LoanLibrary.LoanTerms memory sourceLoanTerms,
LoanLibrary.LoanTerms calldata newLoanTerms,
uint256 borrowerNoteId
) internal {
require(<FILL_ME>)
require(newLoanTerms.payableCurrency == sourceLoanTerms.payableCurrency, "currency mismatch");
require(newLoanTerms.collateralTokenId == sourceLoanTerms.collateralTokenId, "collateral mismatch");
require(
address(sourceLoanCore.collateralToken()) == address(targetLoanCore.collateralToken()),
"non-compatible AssetWrapper"
);
}
function setOwner(address _owner) external override {
}
function flushToken(IERC20 token, address to) external override {
}
}
| sourceLoanCore.borrowerNote().ownerOf(borrowerNoteId)==msg.sender,"caller not borrower" | 20,414 | sourceLoanCore.borrowerNote().ownerOf(borrowerNoteId)==msg.sender |
"non-compatible AssetWrapper" | pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./external/interfaces/ILendingPool.sol";
import "./interfaces/IFlashRollover.sol";
import "./interfaces/ILoanCore.sol";
import "./interfaces/IOriginationController.sol";
import "./interfaces/IRepaymentController.sol";
import "./interfaces/IAssetWrapper.sol";
import "./interfaces/IFeeController.sol";
/**
*
* @dev FlashRollover allows a borrower to roll over
* a Pawn.fi loan into a new loan without having to
* repay capital. It integrate with AAVE's flash loans
* to provide repayment capital, which is then compensated
* for by the newly-issued loan.
*
* Full API docs at docs/FlashRollover.md
*
*/
contract FlashRollover is IFlashRollover, ReentrancyGuard {
using SafeERC20 for IERC20;
/* solhint-disable var-name-mixedcase */
// AAVE Contracts
// Variable names are in upper case to fulfill IFlashLoanReceiver interface
ILendingPoolAddressesProvider public immutable override ADDRESSES_PROVIDER;
ILendingPool public immutable override LENDING_POOL;
/* solhint-enable var-name-mixedcase */
address private owner;
constructor(ILendingPoolAddressesProvider _addressesProvider) {
}
function rolloverLoan(
RolloverContractParams calldata contracts,
uint256 loanId,
LoanLibrary.LoanTerms calldata newLoanTerms,
uint8 v,
bytes32 r,
bytes32 s
) external override {
}
function executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
address initiator,
bytes calldata params
) external override nonReentrant returns (bool) {
}
function _executeOperation(
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata premiums,
OperationData memory opData
) internal returns (bool) {
}
function _ensureFunds(
uint256 amount,
uint256 premium,
uint256 originationFee,
uint256 newPrincipal
)
internal
pure
returns (
uint256 flashAmountDue,
uint256 needFromBorrower,
uint256 leftoverPrincipal
)
{
}
function _repayLoan(
OperationContracts memory contracts,
LoanLibrary.LoanData memory loanData,
address borrower
) internal {
}
function _initializeNewLoan(
OperationContracts memory contracts,
address borrower,
address lender,
uint256 collateralTokenId,
OperationData memory opData
) internal returns (uint256) {
}
function _getContracts(RolloverContractParams memory contracts) internal returns (OperationContracts memory) {
}
function _validateRollover(
ILoanCore sourceLoanCore,
ILoanCore targetLoanCore,
LoanLibrary.LoanTerms memory sourceLoanTerms,
LoanLibrary.LoanTerms calldata newLoanTerms,
uint256 borrowerNoteId
) internal {
require(sourceLoanCore.borrowerNote().ownerOf(borrowerNoteId) == msg.sender, "caller not borrower");
require(newLoanTerms.payableCurrency == sourceLoanTerms.payableCurrency, "currency mismatch");
require(newLoanTerms.collateralTokenId == sourceLoanTerms.collateralTokenId, "collateral mismatch");
require(<FILL_ME>)
}
function setOwner(address _owner) external override {
}
function flushToken(IERC20 token, address to) external override {
}
}
| address(sourceLoanCore.collateralToken())==address(targetLoanCore.collateralToken()),"non-compatible AssetWrapper" | 20,414 | address(sourceLoanCore.collateralToken())==address(targetLoanCore.collateralToken()) |
"CypherTakesERC721: token must had been burned" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import {Pausable, Context} from "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "../../common/ContextMixin.sol";
import "../../common/NativeMetaTransaction.sol";
contract CypherTakesERC721 is
ERC721,
ERC721Enumerable,
Ownable,
Pausable,
ContextMixin,
NativeMetaTransaction
{
using SafeMath for uint256;
using Counters for Counters.Counter;
// The current count will be used to give a new mint it's ID.
Counters.Counter private _tokenIdCounter;
// The maximum amount of NFTs which can be minted. Remember that this is actually 6, as all integers start at 0.
uint256 public maxSupply = 1024;
// Initial BASE_TOKEN_URI
string private BASE_TOKEN_URI;
// Initial Contract URI
string private CONTRACT_URI;
// Mapping Token Burned
mapping (uint256 => address) private _burned;
// Proxy Regiter Address
address private _proxyRegistry;
constructor(
string memory name_,
string memory symbol_,
address proxyRegistry_
) public ERC721(name_, symbol_) {
}
// The Metadata uri, containing all the json files for this contract's NFTs.
function _baseURI() internal view override returns (string memory){
}
// Returns the json file of the corresponding token ID.
// Used for getting things like the NFT's name, properties, description etc.
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
/**
* Override isApprovedForAll to auto-approve OS's proxy contract
*/
function isApprovedForAll(
address _owner,
address _operator
) public override view returns (bool isOperator) {
}
/**
* @notice Method for reduce the friction with openSea allows to map the `tokenId`
* @dev into our NFT Smart contract and handle some metadata offchain in OpenSea
*/
function baseTokenURI() public view returns (string memory) {
}
/**
* @notice Method for reduce the friction with openSea allows update the Base Token URI
* @dev This method is only available for the owner of the contract
* @param _baseTokenURI The new base token URI
*/
function setBaseTokenURI(string memory _baseTokenURI) public onlyOwner() {
}
/**
* @notice Method for reduce the friction with openSea allows to map the `tokenId`
* @dev into our NFT Smart contract and handle some metadata offchain in OpenSea
*/
function contractURI() public view returns (string memory) {
}
/**
* @dev Implementation / Instance of paused methods() in the ERC721.
* @param status Setting the status boolean (True for paused, or False for unpaused)
* See {ERC721Pausable}.
*/
function pause(bool status) public onlyOwner() {
}
// The minting function, needed to create an NFT
function safeMint(address to) public onlyOwner() {
}
// The minting function, needed to create an NFT
function burn(uint256 tokenId) public {
}
// The minting function, needed to create an NFT
function safeMintAfterBurn(address to, uint256 tokenId) public onlyOwner() {
require(!_exists(tokenId), "CypherTakesERC721: token don't must be exist");
require(<FILL_ME>)
// Mints the NFT
_safeMint(to, tokenId);
}
/**
* This is used instead of msg.sender as transactions won't be sent by the original token owner, but by OpenSea.
*/
function _msgSender()
internal
override(Context)
view
returns (address sender)
{
}
/**
* @dev See {ERC721-_beforeTokenTransfer}.
*
* Requirements:
*
* - the contract must not be paused.
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 _tokenId
) internal virtual override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| _burned[tokenId]!=address(0),"CypherTakesERC721: token must had been burned" | 20,559 | _burned[tokenId]!=address(0) |
"ERC721Burnable: caller is not owner nor approved" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.4;
/**
* NOTE: This file is a clone of the OpenZeppelin ERC721.sol contract. It was forked from https://github.com/OpenZeppelin/openzeppelin-contracts
* at commit 1ada3b633e5bfd9d4ffe0207d64773a11f5a7c40
*
* The code was modified to inherit from our customized ERC721 contract.
*/
import "./ERC721.sol";
import "@openzeppelin/contracts/utils/Context.sol";
/**
* @title ERC721 Burnable Token
* @dev ERC721 Token that can be irreversibly burned (destroyed).
*/
abstract contract ERC721Burnable is Context, ERC721 {
/**
* @dev Burns `tokenID`. See {ERC721-_burn}.
*
* Requirements:
*
* - The caller must own `tokenID` or be an approved operator.
*/
function burn(uint256 tokenID) public virtual {
//solhint-disable-next-line max-line-length
require(<FILL_ME>)
_burn(tokenID);
}
}
| _isApprovedOrOwner(_msgSender(),tokenID),"ERC721Burnable: caller is not owner nor approved" | 20,564 | _isApprovedOrOwner(_msgSender(),tokenID) |
null | contract BRDToken is MintableToken {
using SafeMath for uint256;
string public name = "Bread Token";
string public symbol = "BRD";
uint256 public decimals = 18;
// override StandardToken#transferFrom
// ensures that minting has finished or the message sender is the token owner
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(<FILL_ME>)
return super.transferFrom(_from, _to, _value);
}
// override StandardToken#transfer
// ensures the minting has finished or the message sender is the token owner
function transfer(address _to, uint256 _value) public returns (bool) {
}
}
| mintingFinished||msg.sender==owner | 20,638 | mintingFinished||msg.sender==owner |
Subsets and Splits