comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Max presale amount exceeded." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
contract FacaNFT is Ownable, ERC721, ERC721Enumerable, VRFConsumerBase, ReentrancyGuard {
using SafeMath for uint256;
event FacaNFTRandomnessRequest(uint timestamp);
event FacaNFTRandomnessFulfil(uint timestamp, bytes32 requestId, uint256 seed);
event FacaNFTChainlinkError(uint timestamp, bytes32 requestId);
event FacaNFTReveal(uint timestamp);
event FacaManualSetSeed(uint timestamp);
event FacaWhitelist(address adress);
event PermanentURI(string _value, uint256 indexed _id);
bool _revealed = false;
bool _requestedVRF = false;
bytes32 _keyHash;
uint private _mode = 0;
uint private _limitPrivateSaleTx = 2;
uint private _limitPublicSaleTx = 20;
uint public maxAirdrop;
uint public maxPrivateSale;
uint public totalAirdrop;
uint public totalPrivateSale;
uint public maxSupply;
uint256 public seed = 0;
uint256 private _privateSalePrice = 77000000000000000; //0.077ETH
uint256 private _publicSalePrice = 88000000000000000; //0.088ETH
string _tokenBaseURI;
string _defaultURI;
mapping(address => uint) private _originalOwns;
mapping(address => uint) private _presaleMinted;
mapping(address => bool) private _originalOwner;
mapping(address => bool) private _presaleAllowed;
/**
* @param vrfCoordinator address of Chainlink VRF coordinator to use
* @param linkToken address of LINK token
* @param keyHash Chainlink VRF keyhash for the coordinator
* @param tokenName Token name
* @param tokenSymbol Token symbol
* @param baseURI token base URI
* @param defaultURI token default URI aka loot box
* @param maximumAirdrop max amount for airdrop
* @param maximumPrivateSale max amount to sale in private sale
* @param maximumSupply max supply of token
*/
constructor(
address vrfCoordinator,
address linkToken,
bytes32 keyHash,
string memory tokenName,
string memory tokenSymbol,
string memory baseURI,
string memory defaultURI,
uint maximumAirdrop,
uint maximumPrivateSale,
uint maximumSupply
) ERC721(tokenName, tokenSymbol)
VRFConsumerBase(vrfCoordinator, linkToken) {
}
/**
* @dev ensure collector pays for mint token and message sender is directly interact (and not a contract)
* @param amount number of token to mint
*/
modifier mintable(uint amount) {
}
/**
* @dev add collector to private sale allowlist
*/
function addAllowlist(address[] memory allowlist) public onlyOwner {
}
/**
* @dev airdrop token for marketing and influencer campaign
*/
function airdrop(address[] memory _to, uint256 amount) public onlyOwner {
}
/**
* @dev return token base URI to construct metadata URL
*/
function tokenBaseURI() public view returns (string memory) {
}
/**
* @dev get sale mode
* 0 - offline
* 1 - presale
* 2 - before public sale
* 3 - public sale
* 4 - close public sale
* 5 - sold out
*/
function getSaleMode() public view returns(uint) {
}
/**
* @dev get sale price base on sale mode
*/
function getPrice() public view returns(uint256) {
}
/**
* @dev get current amount of minted token by sale mode
*/
function getMintedBySaleMode() public view returns(uint256) {
}
/**
* @dev get current token amount available for sale (by sale mode)
*/
function getMaxSupplyBySaleMode() public view returns(uint256) {
}
/**
* @dev emit event for OpenSea to freeze metadata.
*/
function freezeMetadata() public onlyOwner {
}
/**
* @dev ensure collector is under allowlist
*/
function inAllowlist(address collector) public view returns(bool) {
}
/**
* @dev check if collector is an original minter
*/
function isOriginalOwner(address collector) public view returns(bool) {
}
function isRequestedVrf() public view returns(bool) {
}
function isRevealed() public view returns(bool) {
}
/**
* @dev shuffle metadata with seed provided by VRF
*/
function metadataOf(uint256 tokenId) public view returns (string memory) {
}
/**
* @dev Mint NFT
*/
function mintNFT(uint256 amount) public payable nonReentrant mintable(amount) returns (bool) {
}
/**
* @dev get amount of original minted amount.
*/
function originalMintedBalanceOf(address collector) public view returns(uint){
}
function publicSalePrice() public view returns(uint256) {
}
function privateSalePrice() public view returns(uint256) {
}
/**
* @dev request Chainlink VRF for a random seed
*/
function requestChainlinkVRF() public onlyOwner {
}
/**
* @dev set token base URI
*/
function setBaseURI(string memory baseURI) public onlyOwner {
}
/**
* @dev reveal all lootbox
*/
function reveal() public onlyOwner {
}
/**
* @dev set public sale price in case we have last minutes change on sale price/promotion
*/
function setPublicSalePrice(uint256 price) public onlyOwner {
}
/**
* @dev set seed number (only used for automate testing and emergency reveal)
*/
function setSeed(uint randomNumber) public onlyOwner {
}
/**
* @dev start private sale
*/
function startPrivateSale() public onlyOwner {
}
/**
* @dev change mode to before public sale
*/
function startBeforePublicSale() public onlyOwner {
}
/**
* @dev change mode to public sale
*/
function startPublicSale() public onlyOwner {
}
/**
* @dev close public sale
*/
function closePublicSale() public onlyOwner {
}
function stopAllSale() public onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
/**
* @dev return token metadata based on reveal status
*/
function tokenURI(uint256 tokenId) public view override (ERC721) returns (string memory) {
}
/**
* @dev total public sale amount
*/
function totalPublicSale() public view returns(uint) {
}
/**
* @dev withdraw ether to owner/admin wallet
* @notice only owner can call this method
*/
function withdraw() public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId
) internal virtual override(ERC721, ERC721Enumerable){
}
/**
* @dev ensure original minter is logged and favor for future use.
*/
function addOriginalOwns(address collector) internal {
}
/**
* @dev ensure private sale amount will not exceed quota per collector
*/
function isValidPrivateSaleAmount(address collector,uint amount) internal view returns(bool) {
}
/**
* @dev ensure private sale amount will not oversell
*/
function isOversell(uint amount) internal view returns(bool) {
}
/**
* @dev Mints amount `amount` of token to collector
* @param collector The collector to receive the token
* @param amount The amount of token to be minted
* @param isAirdrop Flag for use in airdrop (internally)
*/
function mintFaca( address collector, uint256 amount, bool isAirdrop) internal returns (bool) {
// private sale
if(getSaleMode() == 1) {
require(inAllowlist(collector), "Only whitelist addresses allowed.");
require(<FILL_ME>)
}
if (getSaleMode() > 0 && !isAirdrop) {
require(isOversell(amount), "Cannot oversell");
}
for (uint256 i = 0; i < amount; i+=1) {
uint256 tokenIndex = totalSupply();
if (tokenIndex < maxSupply) {
_safeMint(collector, tokenIndex+1);
addOriginalOwns(collector);
}
}
logTrade(collector, amount, isAirdrop);
return true;
}
/**
* @dev receive random number from chainlink
* @notice random number will greater than zero
*/
function fulfillRandomness(bytes32 requestId, uint256 randomNumber) internal override {
}
/**
* @dev log trade amount for controlling the capacity of tx
* @param collector collector address
* @param amount amount of sale
* @param isAirdrop flag for log airdrop transaction
*/
function logTrade(address collector,uint amount, bool isAirdrop) internal {
}
}
| isValidPrivateSaleAmount(collector,amount),"Max presale amount exceeded." | 11,065 | isValidPrivateSaleAmount(collector,amount) |
"Cannot oversell" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
contract FacaNFT is Ownable, ERC721, ERC721Enumerable, VRFConsumerBase, ReentrancyGuard {
using SafeMath for uint256;
event FacaNFTRandomnessRequest(uint timestamp);
event FacaNFTRandomnessFulfil(uint timestamp, bytes32 requestId, uint256 seed);
event FacaNFTChainlinkError(uint timestamp, bytes32 requestId);
event FacaNFTReveal(uint timestamp);
event FacaManualSetSeed(uint timestamp);
event FacaWhitelist(address adress);
event PermanentURI(string _value, uint256 indexed _id);
bool _revealed = false;
bool _requestedVRF = false;
bytes32 _keyHash;
uint private _mode = 0;
uint private _limitPrivateSaleTx = 2;
uint private _limitPublicSaleTx = 20;
uint public maxAirdrop;
uint public maxPrivateSale;
uint public totalAirdrop;
uint public totalPrivateSale;
uint public maxSupply;
uint256 public seed = 0;
uint256 private _privateSalePrice = 77000000000000000; //0.077ETH
uint256 private _publicSalePrice = 88000000000000000; //0.088ETH
string _tokenBaseURI;
string _defaultURI;
mapping(address => uint) private _originalOwns;
mapping(address => uint) private _presaleMinted;
mapping(address => bool) private _originalOwner;
mapping(address => bool) private _presaleAllowed;
/**
* @param vrfCoordinator address of Chainlink VRF coordinator to use
* @param linkToken address of LINK token
* @param keyHash Chainlink VRF keyhash for the coordinator
* @param tokenName Token name
* @param tokenSymbol Token symbol
* @param baseURI token base URI
* @param defaultURI token default URI aka loot box
* @param maximumAirdrop max amount for airdrop
* @param maximumPrivateSale max amount to sale in private sale
* @param maximumSupply max supply of token
*/
constructor(
address vrfCoordinator,
address linkToken,
bytes32 keyHash,
string memory tokenName,
string memory tokenSymbol,
string memory baseURI,
string memory defaultURI,
uint maximumAirdrop,
uint maximumPrivateSale,
uint maximumSupply
) ERC721(tokenName, tokenSymbol)
VRFConsumerBase(vrfCoordinator, linkToken) {
}
/**
* @dev ensure collector pays for mint token and message sender is directly interact (and not a contract)
* @param amount number of token to mint
*/
modifier mintable(uint amount) {
}
/**
* @dev add collector to private sale allowlist
*/
function addAllowlist(address[] memory allowlist) public onlyOwner {
}
/**
* @dev airdrop token for marketing and influencer campaign
*/
function airdrop(address[] memory _to, uint256 amount) public onlyOwner {
}
/**
* @dev return token base URI to construct metadata URL
*/
function tokenBaseURI() public view returns (string memory) {
}
/**
* @dev get sale mode
* 0 - offline
* 1 - presale
* 2 - before public sale
* 3 - public sale
* 4 - close public sale
* 5 - sold out
*/
function getSaleMode() public view returns(uint) {
}
/**
* @dev get sale price base on sale mode
*/
function getPrice() public view returns(uint256) {
}
/**
* @dev get current amount of minted token by sale mode
*/
function getMintedBySaleMode() public view returns(uint256) {
}
/**
* @dev get current token amount available for sale (by sale mode)
*/
function getMaxSupplyBySaleMode() public view returns(uint256) {
}
/**
* @dev emit event for OpenSea to freeze metadata.
*/
function freezeMetadata() public onlyOwner {
}
/**
* @dev ensure collector is under allowlist
*/
function inAllowlist(address collector) public view returns(bool) {
}
/**
* @dev check if collector is an original minter
*/
function isOriginalOwner(address collector) public view returns(bool) {
}
function isRequestedVrf() public view returns(bool) {
}
function isRevealed() public view returns(bool) {
}
/**
* @dev shuffle metadata with seed provided by VRF
*/
function metadataOf(uint256 tokenId) public view returns (string memory) {
}
/**
* @dev Mint NFT
*/
function mintNFT(uint256 amount) public payable nonReentrant mintable(amount) returns (bool) {
}
/**
* @dev get amount of original minted amount.
*/
function originalMintedBalanceOf(address collector) public view returns(uint){
}
function publicSalePrice() public view returns(uint256) {
}
function privateSalePrice() public view returns(uint256) {
}
/**
* @dev request Chainlink VRF for a random seed
*/
function requestChainlinkVRF() public onlyOwner {
}
/**
* @dev set token base URI
*/
function setBaseURI(string memory baseURI) public onlyOwner {
}
/**
* @dev reveal all lootbox
*/
function reveal() public onlyOwner {
}
/**
* @dev set public sale price in case we have last minutes change on sale price/promotion
*/
function setPublicSalePrice(uint256 price) public onlyOwner {
}
/**
* @dev set seed number (only used for automate testing and emergency reveal)
*/
function setSeed(uint randomNumber) public onlyOwner {
}
/**
* @dev start private sale
*/
function startPrivateSale() public onlyOwner {
}
/**
* @dev change mode to before public sale
*/
function startBeforePublicSale() public onlyOwner {
}
/**
* @dev change mode to public sale
*/
function startPublicSale() public onlyOwner {
}
/**
* @dev close public sale
*/
function closePublicSale() public onlyOwner {
}
function stopAllSale() public onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
/**
* @dev return token metadata based on reveal status
*/
function tokenURI(uint256 tokenId) public view override (ERC721) returns (string memory) {
}
/**
* @dev total public sale amount
*/
function totalPublicSale() public view returns(uint) {
}
/**
* @dev withdraw ether to owner/admin wallet
* @notice only owner can call this method
*/
function withdraw() public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId
) internal virtual override(ERC721, ERC721Enumerable){
}
/**
* @dev ensure original minter is logged and favor for future use.
*/
function addOriginalOwns(address collector) internal {
}
/**
* @dev ensure private sale amount will not exceed quota per collector
*/
function isValidPrivateSaleAmount(address collector,uint amount) internal view returns(bool) {
}
/**
* @dev ensure private sale amount will not oversell
*/
function isOversell(uint amount) internal view returns(bool) {
}
/**
* @dev Mints amount `amount` of token to collector
* @param collector The collector to receive the token
* @param amount The amount of token to be minted
* @param isAirdrop Flag for use in airdrop (internally)
*/
function mintFaca( address collector, uint256 amount, bool isAirdrop) internal returns (bool) {
// private sale
if(getSaleMode() == 1) {
require(inAllowlist(collector), "Only whitelist addresses allowed.");
require(isValidPrivateSaleAmount(collector, amount), "Max presale amount exceeded.");
}
if (getSaleMode() > 0 && !isAirdrop) {
require(<FILL_ME>)
}
for (uint256 i = 0; i < amount; i+=1) {
uint256 tokenIndex = totalSupply();
if (tokenIndex < maxSupply) {
_safeMint(collector, tokenIndex+1);
addOriginalOwns(collector);
}
}
logTrade(collector, amount, isAirdrop);
return true;
}
/**
* @dev receive random number from chainlink
* @notice random number will greater than zero
*/
function fulfillRandomness(bytes32 requestId, uint256 randomNumber) internal override {
}
/**
* @dev log trade amount for controlling the capacity of tx
* @param collector collector address
* @param amount amount of sale
* @param isAirdrop flag for log airdrop transaction
*/
function logTrade(address collector,uint amount, bool isAirdrop) internal {
}
}
| isOversell(amount),"Cannot oversell" | 11,065 | isOversell(amount) |
null | pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(<FILL_ME>)
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to relinquish control of the contract.
* @notice Renouncing to ownership will leave the contract without an owner.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
*/
function renounceOwnership() public onlyOwner {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function _transferOwnership(address _newOwner) internal {
}
}
/**
* @title 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() public onlyOwner whenNotPaused {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() public onlyOwner whenPaused {
}
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function allowance(address _owner, address _spender)
public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value)
public returns (bool);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/issues/20
* Based on code by FirstBlood:
https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
uint256 totalSupply_;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
}
/**
* @dev Transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
}
}
/**
* @title Pausable token
* @dev StandardToken modified with pausable transfers.
**/
contract PausableERC20Token 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)
{
}
}
/**
* @title Burnable Pausable Token
* @dev Pausable Token that can be irreversibly burned (destroyed).
*/
contract BurnablePausableERC20Token is PausableERC20Token {
mapping (address => mapping (address => uint256)) internal allowedBurn;
event Burn(address indexed burner, uint256 value);
event ApprovalBurn(
address indexed owner,
address indexed spender,
uint256 value
);
function allowanceBurn(
address _owner,
address _spender
)
public
view
returns (uint256)
{
}
function approveBurn(address _spender, uint256 _value)
public
whenNotPaused
returns (bool)
{
}
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(
uint256 _value
)
public
whenNotPaused
{
}
/**
* @dev Burns a specific amount of tokens from the target address and decrements allowance
* @param _from address The address which you want to send tokens from
* @param _value uint256 The amount of token to be burned
*/
function burnFrom(
address _from,
uint256 _value
)
public
whenNotPaused
{
}
function _burn(
address _who,
uint256 _value
)
internal
whenNotPaused
{
}
function increaseBurnApproval(
address _spender,
uint256 _addedValue
)
public
whenNotPaused
returns (bool)
{
}
function decreaseBurnApproval(
address _spender,
uint256 _subtractedValue
)
public
whenNotPaused
returns (bool)
{
}
}
contract FreezableBurnablePausableERC20Token is BurnablePausableERC20Token {
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function freezeAccount(
address target,
bool freeze
)
public
onlyOwner
{
}
function transfer(
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
}
function burn(
uint256 _value
)
public
whenNotPaused
{
}
function burnFrom(
address _from,
uint256 _value
)
public
whenNotPaused
{
}
}
contract TDC is FreezableBurnablePausableERC20Token {
string public constant name = "TDC";
string public constant symbol = "TDC";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 2000000000 * (10 ** uint256(decimals));
constructor() public {
}
}
| c/_a==_b | 11,068 | c/_a==_b |
Errors.PLP_INVALID_PERMISSION_ADMIN | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {LendingPool} from './LendingPool.sol';
import {IPermissionManager} from '../../interfaces/IPermissionManager.sol';
import {IPermissionedLendingPool} from '../../interfaces/IPermissionedLendingPool.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {DataTypes} from '../libraries/types/DataTypes.sol';
/**
* @title PermissionedLendingPool
* @notice This smart contracts adds a permission layer to the LendingPool contract to enable whitelisting of users interacting with it
* @author Aave
**/
contract PermissionedLendingPool is IPermissionedLendingPool, LendingPool {
//identifier for the permission manager contract in the addresses provider
bytes32 public constant PERMISSION_MANAGER = keccak256('PERMISSION_MANAGER');
modifier onlyDepositors(address user) {
}
modifier onlyUserPermissionAdmin(address user) {
require(<FILL_ME>)
_;
}
modifier onlyValidPermissionAdmin(address user) {
}
modifier onlyBorrowers(address user) {
}
modifier onlyLiquidators {
}
modifier onlyStableRateManagers {
}
/**
* @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
* - E.g. User deposits 100 USDC and gets in return 100 aUSDC
* @param asset The address of the underlying asset to deposit
* @param amount The amount to be deposited
* @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
* wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
* is a different wallet
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function deposit(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
* E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
* @param asset The address of the underlying asset to withdraw
* @param amount The underlying amount to be withdrawn
* - Send the value type(uint256).max in order to withdraw the whole aToken balance
* @param to Address that will receive the underlying, same as msg.sender if the user
* wants to receive it on his own wallet, or a different address if the beneficiary is a
* different wallet
* @return The final amount withdrawn
**/
function withdraw(
address asset,
uint256 amount,
address to
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
returns (uint256)
{
}
/**
* @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
* already deposited enough collateral, or he was given enough allowance by a credit delegator on the
* corresponding debt token (StableDebtToken or VariableDebtToken)
* - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
* and 100 stable/variable debt tokens, depending on the `interestRateMode`
* @param asset The address of the underlying asset to borrow
* @param amount The amount to be borrowed
* @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
* @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
* calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
* if he has been given credit delegation allowance
**/
function borrow(
address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
* - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
* @param asset The address of the borrowed underlying asset previously borrowed
* @param amount The amount to repay
* - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
* @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
* @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
* user calling the function if he wants to reduce/remove his own debt, or the address of any other
* other borrower whose debt should be removed
* @return The final amount repaid
**/
function repay(
address asset,
uint256 amount,
uint256 rateMode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
returns (uint256)
{
}
/**
* @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa
* @param asset The address of the underlying asset borrowed
* @param rateMode The rate mode that the user wants to swap to
**/
function swapBorrowRateMode(address asset, uint256 rateMode)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
* - Users can be rebalanced if the following conditions are satisfied:
* 1. Usage ratio is above 95%
* 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been
* borrowed at a stable rate and depositors are not earning enough
* @param asset The address of the underlying asset borrowed
* @param user The address of the user to be rebalanced
**/
function rebalanceStableBorrowRate(address asset, address user)
public
virtual
override(ILendingPool, LendingPool)
onlyStableRateManagers
{
}
/**
* @dev Allows depositors to enable/disable a specific deposited asset as collateral
* @param asset The address of the underlying asset deposited
* @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise
**/
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
* - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
* a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
* @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
* @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
* @param user The address of the borrower getting liquidated
* @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
* @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
* to receive the underlying collateral asset directly
**/
function liquidationCall(
address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken
)
public
virtual
override(ILendingPool, LendingPool)
onlyLiquidators
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to seize the collateral of a user. Only whitelisters of the user can call this function
* @param assets The addresses of the underlying assets to seize
* @param to The address that will receive the funds
**/
function seize(
address user,
address[] calldata assets,
address to
) public virtual override(IPermissionedLendingPool) onlyUserPermissionAdmin(user) whenNotPaused {
}
/**
* @dev Allows smartcontracts to access the liquidity of the pool within one transaction,
* as long as the amount taken plus a fee is returned.
* IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.
* For further details please visit https://developers.aave.com
* @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface
* @param assets The addresses of the assets being flash-borrowed
* @param amounts The amounts amounts being flash-borrowed
* @param modes Types of the debt to open if the flash loan is not returned:
* 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
* 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2
* @param params Variadic packed params to pass to the receiver as extra information
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function flashLoan(
address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata modes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode
) public virtual override(ILendingPool, LendingPool) {
}
/**
* @dev Validates and finalizes an aToken transfer
* - Only callable by the overlying aToken of the `asset`
* @param asset The address of the underlying asset of the aToken
* @param from The user from which the aTokens are transferred
* @param to The user receiving the aTokens
* @param amount The amount being transferred/withdrawn
* @param balanceFromBefore The aToken balance of the `from` user before the transfer
* @param balanceToBefore The aToken balance of the `to` user before the transfer
*/
function finalizeTransfer(
address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromBefore,
uint256 balanceToBefore
) public override(ILendingPool, LendingPool) {
}
function _isPermissionAdminOf(address user, address caller) internal view returns (bool) {
}
function _isInRole(address user, DataTypes.Roles role) internal view returns (bool) {
}
function _permissionAdminValid(address user) internal view returns (bool) {
}
function _onlyDepositors(address user) internal view {
}
function _onlyBorrowers(address user) internal view {
}
function _onlyValidPermissionAdmin(address user) internal view {
}
}
| _isPermissionAdminOf(user,msg.sender),Errors.PLP_INVALID_PERMISSION_ADMIN | 11,084 | _isPermissionAdminOf(user,msg.sender) |
Errors.PLP_LIQUIDATOR_UNAUTHORIZED | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {LendingPool} from './LendingPool.sol';
import {IPermissionManager} from '../../interfaces/IPermissionManager.sol';
import {IPermissionedLendingPool} from '../../interfaces/IPermissionedLendingPool.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {DataTypes} from '../libraries/types/DataTypes.sol';
/**
* @title PermissionedLendingPool
* @notice This smart contracts adds a permission layer to the LendingPool contract to enable whitelisting of users interacting with it
* @author Aave
**/
contract PermissionedLendingPool is IPermissionedLendingPool, LendingPool {
//identifier for the permission manager contract in the addresses provider
bytes32 public constant PERMISSION_MANAGER = keccak256('PERMISSION_MANAGER');
modifier onlyDepositors(address user) {
}
modifier onlyUserPermissionAdmin(address user) {
}
modifier onlyValidPermissionAdmin(address user) {
}
modifier onlyBorrowers(address user) {
}
modifier onlyLiquidators {
require(<FILL_ME>)
_;
}
modifier onlyStableRateManagers {
}
/**
* @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
* - E.g. User deposits 100 USDC and gets in return 100 aUSDC
* @param asset The address of the underlying asset to deposit
* @param amount The amount to be deposited
* @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
* wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
* is a different wallet
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function deposit(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
* E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
* @param asset The address of the underlying asset to withdraw
* @param amount The underlying amount to be withdrawn
* - Send the value type(uint256).max in order to withdraw the whole aToken balance
* @param to Address that will receive the underlying, same as msg.sender if the user
* wants to receive it on his own wallet, or a different address if the beneficiary is a
* different wallet
* @return The final amount withdrawn
**/
function withdraw(
address asset,
uint256 amount,
address to
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
returns (uint256)
{
}
/**
* @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
* already deposited enough collateral, or he was given enough allowance by a credit delegator on the
* corresponding debt token (StableDebtToken or VariableDebtToken)
* - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
* and 100 stable/variable debt tokens, depending on the `interestRateMode`
* @param asset The address of the underlying asset to borrow
* @param amount The amount to be borrowed
* @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
* @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
* calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
* if he has been given credit delegation allowance
**/
function borrow(
address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
* - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
* @param asset The address of the borrowed underlying asset previously borrowed
* @param amount The amount to repay
* - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
* @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
* @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
* user calling the function if he wants to reduce/remove his own debt, or the address of any other
* other borrower whose debt should be removed
* @return The final amount repaid
**/
function repay(
address asset,
uint256 amount,
uint256 rateMode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
returns (uint256)
{
}
/**
* @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa
* @param asset The address of the underlying asset borrowed
* @param rateMode The rate mode that the user wants to swap to
**/
function swapBorrowRateMode(address asset, uint256 rateMode)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
* - Users can be rebalanced if the following conditions are satisfied:
* 1. Usage ratio is above 95%
* 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been
* borrowed at a stable rate and depositors are not earning enough
* @param asset The address of the underlying asset borrowed
* @param user The address of the user to be rebalanced
**/
function rebalanceStableBorrowRate(address asset, address user)
public
virtual
override(ILendingPool, LendingPool)
onlyStableRateManagers
{
}
/**
* @dev Allows depositors to enable/disable a specific deposited asset as collateral
* @param asset The address of the underlying asset deposited
* @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise
**/
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
* - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
* a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
* @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
* @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
* @param user The address of the borrower getting liquidated
* @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
* @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
* to receive the underlying collateral asset directly
**/
function liquidationCall(
address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken
)
public
virtual
override(ILendingPool, LendingPool)
onlyLiquidators
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to seize the collateral of a user. Only whitelisters of the user can call this function
* @param assets The addresses of the underlying assets to seize
* @param to The address that will receive the funds
**/
function seize(
address user,
address[] calldata assets,
address to
) public virtual override(IPermissionedLendingPool) onlyUserPermissionAdmin(user) whenNotPaused {
}
/**
* @dev Allows smartcontracts to access the liquidity of the pool within one transaction,
* as long as the amount taken plus a fee is returned.
* IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.
* For further details please visit https://developers.aave.com
* @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface
* @param assets The addresses of the assets being flash-borrowed
* @param amounts The amounts amounts being flash-borrowed
* @param modes Types of the debt to open if the flash loan is not returned:
* 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
* 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2
* @param params Variadic packed params to pass to the receiver as extra information
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function flashLoan(
address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata modes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode
) public virtual override(ILendingPool, LendingPool) {
}
/**
* @dev Validates and finalizes an aToken transfer
* - Only callable by the overlying aToken of the `asset`
* @param asset The address of the underlying asset of the aToken
* @param from The user from which the aTokens are transferred
* @param to The user receiving the aTokens
* @param amount The amount being transferred/withdrawn
* @param balanceFromBefore The aToken balance of the `from` user before the transfer
* @param balanceToBefore The aToken balance of the `to` user before the transfer
*/
function finalizeTransfer(
address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromBefore,
uint256 balanceToBefore
) public override(ILendingPool, LendingPool) {
}
function _isPermissionAdminOf(address user, address caller) internal view returns (bool) {
}
function _isInRole(address user, DataTypes.Roles role) internal view returns (bool) {
}
function _permissionAdminValid(address user) internal view returns (bool) {
}
function _onlyDepositors(address user) internal view {
}
function _onlyBorrowers(address user) internal view {
}
function _onlyValidPermissionAdmin(address user) internal view {
}
}
| _isInRole(msg.sender,DataTypes.Roles.LIQUIDATOR),Errors.PLP_LIQUIDATOR_UNAUTHORIZED | 11,084 | _isInRole(msg.sender,DataTypes.Roles.LIQUIDATOR) |
Errors.PLP_CALLER_NOT_STABLE_RATE_MANAGER | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {LendingPool} from './LendingPool.sol';
import {IPermissionManager} from '../../interfaces/IPermissionManager.sol';
import {IPermissionedLendingPool} from '../../interfaces/IPermissionedLendingPool.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {DataTypes} from '../libraries/types/DataTypes.sol';
/**
* @title PermissionedLendingPool
* @notice This smart contracts adds a permission layer to the LendingPool contract to enable whitelisting of users interacting with it
* @author Aave
**/
contract PermissionedLendingPool is IPermissionedLendingPool, LendingPool {
//identifier for the permission manager contract in the addresses provider
bytes32 public constant PERMISSION_MANAGER = keccak256('PERMISSION_MANAGER');
modifier onlyDepositors(address user) {
}
modifier onlyUserPermissionAdmin(address user) {
}
modifier onlyValidPermissionAdmin(address user) {
}
modifier onlyBorrowers(address user) {
}
modifier onlyLiquidators {
}
modifier onlyStableRateManagers {
require(<FILL_ME>)
_;
}
/**
* @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
* - E.g. User deposits 100 USDC and gets in return 100 aUSDC
* @param asset The address of the underlying asset to deposit
* @param amount The amount to be deposited
* @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
* wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
* is a different wallet
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function deposit(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
* E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
* @param asset The address of the underlying asset to withdraw
* @param amount The underlying amount to be withdrawn
* - Send the value type(uint256).max in order to withdraw the whole aToken balance
* @param to Address that will receive the underlying, same as msg.sender if the user
* wants to receive it on his own wallet, or a different address if the beneficiary is a
* different wallet
* @return The final amount withdrawn
**/
function withdraw(
address asset,
uint256 amount,
address to
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
returns (uint256)
{
}
/**
* @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
* already deposited enough collateral, or he was given enough allowance by a credit delegator on the
* corresponding debt token (StableDebtToken or VariableDebtToken)
* - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
* and 100 stable/variable debt tokens, depending on the `interestRateMode`
* @param asset The address of the underlying asset to borrow
* @param amount The amount to be borrowed
* @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
* @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
* calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
* if he has been given credit delegation allowance
**/
function borrow(
address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
* - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
* @param asset The address of the borrowed underlying asset previously borrowed
* @param amount The amount to repay
* - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
* @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
* @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
* user calling the function if he wants to reduce/remove his own debt, or the address of any other
* other borrower whose debt should be removed
* @return The final amount repaid
**/
function repay(
address asset,
uint256 amount,
uint256 rateMode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
returns (uint256)
{
}
/**
* @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa
* @param asset The address of the underlying asset borrowed
* @param rateMode The rate mode that the user wants to swap to
**/
function swapBorrowRateMode(address asset, uint256 rateMode)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
* - Users can be rebalanced if the following conditions are satisfied:
* 1. Usage ratio is above 95%
* 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been
* borrowed at a stable rate and depositors are not earning enough
* @param asset The address of the underlying asset borrowed
* @param user The address of the user to be rebalanced
**/
function rebalanceStableBorrowRate(address asset, address user)
public
virtual
override(ILendingPool, LendingPool)
onlyStableRateManagers
{
}
/**
* @dev Allows depositors to enable/disable a specific deposited asset as collateral
* @param asset The address of the underlying asset deposited
* @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise
**/
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
* - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
* a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
* @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
* @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
* @param user The address of the borrower getting liquidated
* @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
* @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
* to receive the underlying collateral asset directly
**/
function liquidationCall(
address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken
)
public
virtual
override(ILendingPool, LendingPool)
onlyLiquidators
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to seize the collateral of a user. Only whitelisters of the user can call this function
* @param assets The addresses of the underlying assets to seize
* @param to The address that will receive the funds
**/
function seize(
address user,
address[] calldata assets,
address to
) public virtual override(IPermissionedLendingPool) onlyUserPermissionAdmin(user) whenNotPaused {
}
/**
* @dev Allows smartcontracts to access the liquidity of the pool within one transaction,
* as long as the amount taken plus a fee is returned.
* IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.
* For further details please visit https://developers.aave.com
* @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface
* @param assets The addresses of the assets being flash-borrowed
* @param amounts The amounts amounts being flash-borrowed
* @param modes Types of the debt to open if the flash loan is not returned:
* 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
* 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2
* @param params Variadic packed params to pass to the receiver as extra information
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function flashLoan(
address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata modes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode
) public virtual override(ILendingPool, LendingPool) {
}
/**
* @dev Validates and finalizes an aToken transfer
* - Only callable by the overlying aToken of the `asset`
* @param asset The address of the underlying asset of the aToken
* @param from The user from which the aTokens are transferred
* @param to The user receiving the aTokens
* @param amount The amount being transferred/withdrawn
* @param balanceFromBefore The aToken balance of the `from` user before the transfer
* @param balanceToBefore The aToken balance of the `to` user before the transfer
*/
function finalizeTransfer(
address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromBefore,
uint256 balanceToBefore
) public override(ILendingPool, LendingPool) {
}
function _isPermissionAdminOf(address user, address caller) internal view returns (bool) {
}
function _isInRole(address user, DataTypes.Roles role) internal view returns (bool) {
}
function _permissionAdminValid(address user) internal view returns (bool) {
}
function _onlyDepositors(address user) internal view {
}
function _onlyBorrowers(address user) internal view {
}
function _onlyValidPermissionAdmin(address user) internal view {
}
}
| _isInRole(msg.sender,DataTypes.Roles.STABLE_RATE_MANAGER),Errors.PLP_CALLER_NOT_STABLE_RATE_MANAGER | 11,084 | _isInRole(msg.sender,DataTypes.Roles.STABLE_RATE_MANAGER) |
Errors.PLP_BORROWER_UNAUTHORIZED | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {LendingPool} from './LendingPool.sol';
import {IPermissionManager} from '../../interfaces/IPermissionManager.sol';
import {IPermissionedLendingPool} from '../../interfaces/IPermissionedLendingPool.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {DataTypes} from '../libraries/types/DataTypes.sol';
/**
* @title PermissionedLendingPool
* @notice This smart contracts adds a permission layer to the LendingPool contract to enable whitelisting of users interacting with it
* @author Aave
**/
contract PermissionedLendingPool is IPermissionedLendingPool, LendingPool {
//identifier for the permission manager contract in the addresses provider
bytes32 public constant PERMISSION_MANAGER = keccak256('PERMISSION_MANAGER');
modifier onlyDepositors(address user) {
}
modifier onlyUserPermissionAdmin(address user) {
}
modifier onlyValidPermissionAdmin(address user) {
}
modifier onlyBorrowers(address user) {
}
modifier onlyLiquidators {
}
modifier onlyStableRateManagers {
}
/**
* @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
* - E.g. User deposits 100 USDC and gets in return 100 aUSDC
* @param asset The address of the underlying asset to deposit
* @param amount The amount to be deposited
* @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
* wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
* is a different wallet
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function deposit(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
* E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
* @param asset The address of the underlying asset to withdraw
* @param amount The underlying amount to be withdrawn
* - Send the value type(uint256).max in order to withdraw the whole aToken balance
* @param to Address that will receive the underlying, same as msg.sender if the user
* wants to receive it on his own wallet, or a different address if the beneficiary is a
* different wallet
* @return The final amount withdrawn
**/
function withdraw(
address asset,
uint256 amount,
address to
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
returns (uint256)
{
}
/**
* @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
* already deposited enough collateral, or he was given enough allowance by a credit delegator on the
* corresponding debt token (StableDebtToken or VariableDebtToken)
* - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
* and 100 stable/variable debt tokens, depending on the `interestRateMode`
* @param asset The address of the underlying asset to borrow
* @param amount The amount to be borrowed
* @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
* @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
* calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
* if he has been given credit delegation allowance
**/
function borrow(
address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
* - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
* @param asset The address of the borrowed underlying asset previously borrowed
* @param amount The amount to repay
* - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
* @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
* @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
* user calling the function if he wants to reduce/remove his own debt, or the address of any other
* other borrower whose debt should be removed
* @return The final amount repaid
**/
function repay(
address asset,
uint256 amount,
uint256 rateMode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
returns (uint256)
{
}
/**
* @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa
* @param asset The address of the underlying asset borrowed
* @param rateMode The rate mode that the user wants to swap to
**/
function swapBorrowRateMode(address asset, uint256 rateMode)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
* - Users can be rebalanced if the following conditions are satisfied:
* 1. Usage ratio is above 95%
* 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been
* borrowed at a stable rate and depositors are not earning enough
* @param asset The address of the underlying asset borrowed
* @param user The address of the user to be rebalanced
**/
function rebalanceStableBorrowRate(address asset, address user)
public
virtual
override(ILendingPool, LendingPool)
onlyStableRateManagers
{
}
/**
* @dev Allows depositors to enable/disable a specific deposited asset as collateral
* @param asset The address of the underlying asset deposited
* @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise
**/
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
* - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
* a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
* @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
* @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
* @param user The address of the borrower getting liquidated
* @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
* @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
* to receive the underlying collateral asset directly
**/
function liquidationCall(
address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken
)
public
virtual
override(ILendingPool, LendingPool)
onlyLiquidators
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to seize the collateral of a user. Only whitelisters of the user can call this function
* @param assets The addresses of the underlying assets to seize
* @param to The address that will receive the funds
**/
function seize(
address user,
address[] calldata assets,
address to
) public virtual override(IPermissionedLendingPool) onlyUserPermissionAdmin(user) whenNotPaused {
}
/**
* @dev Allows smartcontracts to access the liquidity of the pool within one transaction,
* as long as the amount taken plus a fee is returned.
* IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.
* For further details please visit https://developers.aave.com
* @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface
* @param assets The addresses of the assets being flash-borrowed
* @param amounts The amounts amounts being flash-borrowed
* @param modes Types of the debt to open if the flash loan is not returned:
* 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
* 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2
* @param params Variadic packed params to pass to the receiver as extra information
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function flashLoan(
address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata modes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode
) public virtual override(ILendingPool, LendingPool) {
//validating modes
for (uint256 i = 0; i < modes.length; i++) {
if (modes[i] == uint256(DataTypes.InterestRateMode.NONE)) {
require(<FILL_ME>)
require(_permissionAdminValid(msg.sender), Errors.PLP_INVALID_PERMISSION_ADMIN);
} else {
require(_isInRole(onBehalfOf, DataTypes.Roles.BORROWER), Errors.PLP_BORROWER_UNAUTHORIZED);
require(_permissionAdminValid(onBehalfOf), Errors.PLP_INVALID_PERMISSION_ADMIN);
}
}
super.flashLoan(receiverAddress, assets, amounts, modes, onBehalfOf, params, referralCode);
}
/**
* @dev Validates and finalizes an aToken transfer
* - Only callable by the overlying aToken of the `asset`
* @param asset The address of the underlying asset of the aToken
* @param from The user from which the aTokens are transferred
* @param to The user receiving the aTokens
* @param amount The amount being transferred/withdrawn
* @param balanceFromBefore The aToken balance of the `from` user before the transfer
* @param balanceToBefore The aToken balance of the `to` user before the transfer
*/
function finalizeTransfer(
address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromBefore,
uint256 balanceToBefore
) public override(ILendingPool, LendingPool) {
}
function _isPermissionAdminOf(address user, address caller) internal view returns (bool) {
}
function _isInRole(address user, DataTypes.Roles role) internal view returns (bool) {
}
function _permissionAdminValid(address user) internal view returns (bool) {
}
function _onlyDepositors(address user) internal view {
}
function _onlyBorrowers(address user) internal view {
}
function _onlyValidPermissionAdmin(address user) internal view {
}
}
| _isInRole(msg.sender,DataTypes.Roles.BORROWER),Errors.PLP_BORROWER_UNAUTHORIZED | 11,084 | _isInRole(msg.sender,DataTypes.Roles.BORROWER) |
Errors.PLP_INVALID_PERMISSION_ADMIN | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {LendingPool} from './LendingPool.sol';
import {IPermissionManager} from '../../interfaces/IPermissionManager.sol';
import {IPermissionedLendingPool} from '../../interfaces/IPermissionedLendingPool.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {DataTypes} from '../libraries/types/DataTypes.sol';
/**
* @title PermissionedLendingPool
* @notice This smart contracts adds a permission layer to the LendingPool contract to enable whitelisting of users interacting with it
* @author Aave
**/
contract PermissionedLendingPool is IPermissionedLendingPool, LendingPool {
//identifier for the permission manager contract in the addresses provider
bytes32 public constant PERMISSION_MANAGER = keccak256('PERMISSION_MANAGER');
modifier onlyDepositors(address user) {
}
modifier onlyUserPermissionAdmin(address user) {
}
modifier onlyValidPermissionAdmin(address user) {
}
modifier onlyBorrowers(address user) {
}
modifier onlyLiquidators {
}
modifier onlyStableRateManagers {
}
/**
* @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
* - E.g. User deposits 100 USDC and gets in return 100 aUSDC
* @param asset The address of the underlying asset to deposit
* @param amount The amount to be deposited
* @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
* wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
* is a different wallet
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function deposit(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
* E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
* @param asset The address of the underlying asset to withdraw
* @param amount The underlying amount to be withdrawn
* - Send the value type(uint256).max in order to withdraw the whole aToken balance
* @param to Address that will receive the underlying, same as msg.sender if the user
* wants to receive it on his own wallet, or a different address if the beneficiary is a
* different wallet
* @return The final amount withdrawn
**/
function withdraw(
address asset,
uint256 amount,
address to
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
returns (uint256)
{
}
/**
* @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
* already deposited enough collateral, or he was given enough allowance by a credit delegator on the
* corresponding debt token (StableDebtToken or VariableDebtToken)
* - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
* and 100 stable/variable debt tokens, depending on the `interestRateMode`
* @param asset The address of the underlying asset to borrow
* @param amount The amount to be borrowed
* @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
* @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
* calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
* if he has been given credit delegation allowance
**/
function borrow(
address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
* - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
* @param asset The address of the borrowed underlying asset previously borrowed
* @param amount The amount to repay
* - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
* @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
* @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
* user calling the function if he wants to reduce/remove his own debt, or the address of any other
* other borrower whose debt should be removed
* @return The final amount repaid
**/
function repay(
address asset,
uint256 amount,
uint256 rateMode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
returns (uint256)
{
}
/**
* @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa
* @param asset The address of the underlying asset borrowed
* @param rateMode The rate mode that the user wants to swap to
**/
function swapBorrowRateMode(address asset, uint256 rateMode)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
* - Users can be rebalanced if the following conditions are satisfied:
* 1. Usage ratio is above 95%
* 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been
* borrowed at a stable rate and depositors are not earning enough
* @param asset The address of the underlying asset borrowed
* @param user The address of the user to be rebalanced
**/
function rebalanceStableBorrowRate(address asset, address user)
public
virtual
override(ILendingPool, LendingPool)
onlyStableRateManagers
{
}
/**
* @dev Allows depositors to enable/disable a specific deposited asset as collateral
* @param asset The address of the underlying asset deposited
* @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise
**/
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
* - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
* a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
* @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
* @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
* @param user The address of the borrower getting liquidated
* @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
* @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
* to receive the underlying collateral asset directly
**/
function liquidationCall(
address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken
)
public
virtual
override(ILendingPool, LendingPool)
onlyLiquidators
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to seize the collateral of a user. Only whitelisters of the user can call this function
* @param assets The addresses of the underlying assets to seize
* @param to The address that will receive the funds
**/
function seize(
address user,
address[] calldata assets,
address to
) public virtual override(IPermissionedLendingPool) onlyUserPermissionAdmin(user) whenNotPaused {
}
/**
* @dev Allows smartcontracts to access the liquidity of the pool within one transaction,
* as long as the amount taken plus a fee is returned.
* IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.
* For further details please visit https://developers.aave.com
* @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface
* @param assets The addresses of the assets being flash-borrowed
* @param amounts The amounts amounts being flash-borrowed
* @param modes Types of the debt to open if the flash loan is not returned:
* 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
* 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2
* @param params Variadic packed params to pass to the receiver as extra information
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function flashLoan(
address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata modes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode
) public virtual override(ILendingPool, LendingPool) {
//validating modes
for (uint256 i = 0; i < modes.length; i++) {
if (modes[i] == uint256(DataTypes.InterestRateMode.NONE)) {
require(_isInRole(msg.sender, DataTypes.Roles.BORROWER), Errors.PLP_BORROWER_UNAUTHORIZED);
require(<FILL_ME>)
} else {
require(_isInRole(onBehalfOf, DataTypes.Roles.BORROWER), Errors.PLP_BORROWER_UNAUTHORIZED);
require(_permissionAdminValid(onBehalfOf), Errors.PLP_INVALID_PERMISSION_ADMIN);
}
}
super.flashLoan(receiverAddress, assets, amounts, modes, onBehalfOf, params, referralCode);
}
/**
* @dev Validates and finalizes an aToken transfer
* - Only callable by the overlying aToken of the `asset`
* @param asset The address of the underlying asset of the aToken
* @param from The user from which the aTokens are transferred
* @param to The user receiving the aTokens
* @param amount The amount being transferred/withdrawn
* @param balanceFromBefore The aToken balance of the `from` user before the transfer
* @param balanceToBefore The aToken balance of the `to` user before the transfer
*/
function finalizeTransfer(
address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromBefore,
uint256 balanceToBefore
) public override(ILendingPool, LendingPool) {
}
function _isPermissionAdminOf(address user, address caller) internal view returns (bool) {
}
function _isInRole(address user, DataTypes.Roles role) internal view returns (bool) {
}
function _permissionAdminValid(address user) internal view returns (bool) {
}
function _onlyDepositors(address user) internal view {
}
function _onlyBorrowers(address user) internal view {
}
function _onlyValidPermissionAdmin(address user) internal view {
}
}
| _permissionAdminValid(msg.sender),Errors.PLP_INVALID_PERMISSION_ADMIN | 11,084 | _permissionAdminValid(msg.sender) |
Errors.PLP_BORROWER_UNAUTHORIZED | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {LendingPool} from './LendingPool.sol';
import {IPermissionManager} from '../../interfaces/IPermissionManager.sol';
import {IPermissionedLendingPool} from '../../interfaces/IPermissionedLendingPool.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {DataTypes} from '../libraries/types/DataTypes.sol';
/**
* @title PermissionedLendingPool
* @notice This smart contracts adds a permission layer to the LendingPool contract to enable whitelisting of users interacting with it
* @author Aave
**/
contract PermissionedLendingPool is IPermissionedLendingPool, LendingPool {
//identifier for the permission manager contract in the addresses provider
bytes32 public constant PERMISSION_MANAGER = keccak256('PERMISSION_MANAGER');
modifier onlyDepositors(address user) {
}
modifier onlyUserPermissionAdmin(address user) {
}
modifier onlyValidPermissionAdmin(address user) {
}
modifier onlyBorrowers(address user) {
}
modifier onlyLiquidators {
}
modifier onlyStableRateManagers {
}
/**
* @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
* - E.g. User deposits 100 USDC and gets in return 100 aUSDC
* @param asset The address of the underlying asset to deposit
* @param amount The amount to be deposited
* @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
* wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
* is a different wallet
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function deposit(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
* E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
* @param asset The address of the underlying asset to withdraw
* @param amount The underlying amount to be withdrawn
* - Send the value type(uint256).max in order to withdraw the whole aToken balance
* @param to Address that will receive the underlying, same as msg.sender if the user
* wants to receive it on his own wallet, or a different address if the beneficiary is a
* different wallet
* @return The final amount withdrawn
**/
function withdraw(
address asset,
uint256 amount,
address to
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
returns (uint256)
{
}
/**
* @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
* already deposited enough collateral, or he was given enough allowance by a credit delegator on the
* corresponding debt token (StableDebtToken or VariableDebtToken)
* - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
* and 100 stable/variable debt tokens, depending on the `interestRateMode`
* @param asset The address of the underlying asset to borrow
* @param amount The amount to be borrowed
* @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
* @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
* calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
* if he has been given credit delegation allowance
**/
function borrow(
address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
* - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
* @param asset The address of the borrowed underlying asset previously borrowed
* @param amount The amount to repay
* - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
* @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
* @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
* user calling the function if he wants to reduce/remove his own debt, or the address of any other
* other borrower whose debt should be removed
* @return The final amount repaid
**/
function repay(
address asset,
uint256 amount,
uint256 rateMode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
returns (uint256)
{
}
/**
* @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa
* @param asset The address of the underlying asset borrowed
* @param rateMode The rate mode that the user wants to swap to
**/
function swapBorrowRateMode(address asset, uint256 rateMode)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
* - Users can be rebalanced if the following conditions are satisfied:
* 1. Usage ratio is above 95%
* 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been
* borrowed at a stable rate and depositors are not earning enough
* @param asset The address of the underlying asset borrowed
* @param user The address of the user to be rebalanced
**/
function rebalanceStableBorrowRate(address asset, address user)
public
virtual
override(ILendingPool, LendingPool)
onlyStableRateManagers
{
}
/**
* @dev Allows depositors to enable/disable a specific deposited asset as collateral
* @param asset The address of the underlying asset deposited
* @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise
**/
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
* - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
* a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
* @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
* @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
* @param user The address of the borrower getting liquidated
* @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
* @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
* to receive the underlying collateral asset directly
**/
function liquidationCall(
address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken
)
public
virtual
override(ILendingPool, LendingPool)
onlyLiquidators
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to seize the collateral of a user. Only whitelisters of the user can call this function
* @param assets The addresses of the underlying assets to seize
* @param to The address that will receive the funds
**/
function seize(
address user,
address[] calldata assets,
address to
) public virtual override(IPermissionedLendingPool) onlyUserPermissionAdmin(user) whenNotPaused {
}
/**
* @dev Allows smartcontracts to access the liquidity of the pool within one transaction,
* as long as the amount taken plus a fee is returned.
* IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.
* For further details please visit https://developers.aave.com
* @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface
* @param assets The addresses of the assets being flash-borrowed
* @param amounts The amounts amounts being flash-borrowed
* @param modes Types of the debt to open if the flash loan is not returned:
* 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
* 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2
* @param params Variadic packed params to pass to the receiver as extra information
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function flashLoan(
address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata modes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode
) public virtual override(ILendingPool, LendingPool) {
//validating modes
for (uint256 i = 0; i < modes.length; i++) {
if (modes[i] == uint256(DataTypes.InterestRateMode.NONE)) {
require(_isInRole(msg.sender, DataTypes.Roles.BORROWER), Errors.PLP_BORROWER_UNAUTHORIZED);
require(_permissionAdminValid(msg.sender), Errors.PLP_INVALID_PERMISSION_ADMIN);
} else {
require(<FILL_ME>)
require(_permissionAdminValid(onBehalfOf), Errors.PLP_INVALID_PERMISSION_ADMIN);
}
}
super.flashLoan(receiverAddress, assets, amounts, modes, onBehalfOf, params, referralCode);
}
/**
* @dev Validates and finalizes an aToken transfer
* - Only callable by the overlying aToken of the `asset`
* @param asset The address of the underlying asset of the aToken
* @param from The user from which the aTokens are transferred
* @param to The user receiving the aTokens
* @param amount The amount being transferred/withdrawn
* @param balanceFromBefore The aToken balance of the `from` user before the transfer
* @param balanceToBefore The aToken balance of the `to` user before the transfer
*/
function finalizeTransfer(
address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromBefore,
uint256 balanceToBefore
) public override(ILendingPool, LendingPool) {
}
function _isPermissionAdminOf(address user, address caller) internal view returns (bool) {
}
function _isInRole(address user, DataTypes.Roles role) internal view returns (bool) {
}
function _permissionAdminValid(address user) internal view returns (bool) {
}
function _onlyDepositors(address user) internal view {
}
function _onlyBorrowers(address user) internal view {
}
function _onlyValidPermissionAdmin(address user) internal view {
}
}
| _isInRole(onBehalfOf,DataTypes.Roles.BORROWER),Errors.PLP_BORROWER_UNAUTHORIZED | 11,084 | _isInRole(onBehalfOf,DataTypes.Roles.BORROWER) |
Errors.PLP_INVALID_PERMISSION_ADMIN | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {LendingPool} from './LendingPool.sol';
import {IPermissionManager} from '../../interfaces/IPermissionManager.sol';
import {IPermissionedLendingPool} from '../../interfaces/IPermissionedLendingPool.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {DataTypes} from '../libraries/types/DataTypes.sol';
/**
* @title PermissionedLendingPool
* @notice This smart contracts adds a permission layer to the LendingPool contract to enable whitelisting of users interacting with it
* @author Aave
**/
contract PermissionedLendingPool is IPermissionedLendingPool, LendingPool {
//identifier for the permission manager contract in the addresses provider
bytes32 public constant PERMISSION_MANAGER = keccak256('PERMISSION_MANAGER');
modifier onlyDepositors(address user) {
}
modifier onlyUserPermissionAdmin(address user) {
}
modifier onlyValidPermissionAdmin(address user) {
}
modifier onlyBorrowers(address user) {
}
modifier onlyLiquidators {
}
modifier onlyStableRateManagers {
}
/**
* @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
* - E.g. User deposits 100 USDC and gets in return 100 aUSDC
* @param asset The address of the underlying asset to deposit
* @param amount The amount to be deposited
* @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
* wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
* is a different wallet
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function deposit(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
* E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
* @param asset The address of the underlying asset to withdraw
* @param amount The underlying amount to be withdrawn
* - Send the value type(uint256).max in order to withdraw the whole aToken balance
* @param to Address that will receive the underlying, same as msg.sender if the user
* wants to receive it on his own wallet, or a different address if the beneficiary is a
* different wallet
* @return The final amount withdrawn
**/
function withdraw(
address asset,
uint256 amount,
address to
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
returns (uint256)
{
}
/**
* @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
* already deposited enough collateral, or he was given enough allowance by a credit delegator on the
* corresponding debt token (StableDebtToken or VariableDebtToken)
* - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
* and 100 stable/variable debt tokens, depending on the `interestRateMode`
* @param asset The address of the underlying asset to borrow
* @param amount The amount to be borrowed
* @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
* @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
* calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
* if he has been given credit delegation allowance
**/
function borrow(
address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
* - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
* @param asset The address of the borrowed underlying asset previously borrowed
* @param amount The amount to repay
* - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
* @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
* @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
* user calling the function if he wants to reduce/remove his own debt, or the address of any other
* other borrower whose debt should be removed
* @return The final amount repaid
**/
function repay(
address asset,
uint256 amount,
uint256 rateMode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
returns (uint256)
{
}
/**
* @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa
* @param asset The address of the underlying asset borrowed
* @param rateMode The rate mode that the user wants to swap to
**/
function swapBorrowRateMode(address asset, uint256 rateMode)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
* - Users can be rebalanced if the following conditions are satisfied:
* 1. Usage ratio is above 95%
* 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been
* borrowed at a stable rate and depositors are not earning enough
* @param asset The address of the underlying asset borrowed
* @param user The address of the user to be rebalanced
**/
function rebalanceStableBorrowRate(address asset, address user)
public
virtual
override(ILendingPool, LendingPool)
onlyStableRateManagers
{
}
/**
* @dev Allows depositors to enable/disable a specific deposited asset as collateral
* @param asset The address of the underlying asset deposited
* @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise
**/
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
* - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
* a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
* @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
* @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
* @param user The address of the borrower getting liquidated
* @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
* @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
* to receive the underlying collateral asset directly
**/
function liquidationCall(
address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken
)
public
virtual
override(ILendingPool, LendingPool)
onlyLiquidators
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to seize the collateral of a user. Only whitelisters of the user can call this function
* @param assets The addresses of the underlying assets to seize
* @param to The address that will receive the funds
**/
function seize(
address user,
address[] calldata assets,
address to
) public virtual override(IPermissionedLendingPool) onlyUserPermissionAdmin(user) whenNotPaused {
}
/**
* @dev Allows smartcontracts to access the liquidity of the pool within one transaction,
* as long as the amount taken plus a fee is returned.
* IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.
* For further details please visit https://developers.aave.com
* @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface
* @param assets The addresses of the assets being flash-borrowed
* @param amounts The amounts amounts being flash-borrowed
* @param modes Types of the debt to open if the flash loan is not returned:
* 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
* 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2
* @param params Variadic packed params to pass to the receiver as extra information
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function flashLoan(
address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata modes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode
) public virtual override(ILendingPool, LendingPool) {
//validating modes
for (uint256 i = 0; i < modes.length; i++) {
if (modes[i] == uint256(DataTypes.InterestRateMode.NONE)) {
require(_isInRole(msg.sender, DataTypes.Roles.BORROWER), Errors.PLP_BORROWER_UNAUTHORIZED);
require(_permissionAdminValid(msg.sender), Errors.PLP_INVALID_PERMISSION_ADMIN);
} else {
require(_isInRole(onBehalfOf, DataTypes.Roles.BORROWER), Errors.PLP_BORROWER_UNAUTHORIZED);
require(<FILL_ME>)
}
}
super.flashLoan(receiverAddress, assets, amounts, modes, onBehalfOf, params, referralCode);
}
/**
* @dev Validates and finalizes an aToken transfer
* - Only callable by the overlying aToken of the `asset`
* @param asset The address of the underlying asset of the aToken
* @param from The user from which the aTokens are transferred
* @param to The user receiving the aTokens
* @param amount The amount being transferred/withdrawn
* @param balanceFromBefore The aToken balance of the `from` user before the transfer
* @param balanceToBefore The aToken balance of the `to` user before the transfer
*/
function finalizeTransfer(
address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromBefore,
uint256 balanceToBefore
) public override(ILendingPool, LendingPool) {
}
function _isPermissionAdminOf(address user, address caller) internal view returns (bool) {
}
function _isInRole(address user, DataTypes.Roles role) internal view returns (bool) {
}
function _permissionAdminValid(address user) internal view returns (bool) {
}
function _onlyDepositors(address user) internal view {
}
function _onlyBorrowers(address user) internal view {
}
function _onlyValidPermissionAdmin(address user) internal view {
}
}
| _permissionAdminValid(onBehalfOf),Errors.PLP_INVALID_PERMISSION_ADMIN | 11,084 | _permissionAdminValid(onBehalfOf) |
Errors.VL_TRANSFER_NOT_ALLOWED | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {LendingPool} from './LendingPool.sol';
import {IPermissionManager} from '../../interfaces/IPermissionManager.sol';
import {IPermissionedLendingPool} from '../../interfaces/IPermissionedLendingPool.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {DataTypes} from '../libraries/types/DataTypes.sol';
/**
* @title PermissionedLendingPool
* @notice This smart contracts adds a permission layer to the LendingPool contract to enable whitelisting of users interacting with it
* @author Aave
**/
contract PermissionedLendingPool is IPermissionedLendingPool, LendingPool {
//identifier for the permission manager contract in the addresses provider
bytes32 public constant PERMISSION_MANAGER = keccak256('PERMISSION_MANAGER');
modifier onlyDepositors(address user) {
}
modifier onlyUserPermissionAdmin(address user) {
}
modifier onlyValidPermissionAdmin(address user) {
}
modifier onlyBorrowers(address user) {
}
modifier onlyLiquidators {
}
modifier onlyStableRateManagers {
}
/**
* @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
* - E.g. User deposits 100 USDC and gets in return 100 aUSDC
* @param asset The address of the underlying asset to deposit
* @param amount The amount to be deposited
* @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
* wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
* is a different wallet
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function deposit(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
* E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
* @param asset The address of the underlying asset to withdraw
* @param amount The underlying amount to be withdrawn
* - Send the value type(uint256).max in order to withdraw the whole aToken balance
* @param to Address that will receive the underlying, same as msg.sender if the user
* wants to receive it on his own wallet, or a different address if the beneficiary is a
* different wallet
* @return The final amount withdrawn
**/
function withdraw(
address asset,
uint256 amount,
address to
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
returns (uint256)
{
}
/**
* @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
* already deposited enough collateral, or he was given enough allowance by a credit delegator on the
* corresponding debt token (StableDebtToken or VariableDebtToken)
* - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
* and 100 stable/variable debt tokens, depending on the `interestRateMode`
* @param asset The address of the underlying asset to borrow
* @param amount The amount to be borrowed
* @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
* @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
* calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
* if he has been given credit delegation allowance
**/
function borrow(
address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
* - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
* @param asset The address of the borrowed underlying asset previously borrowed
* @param amount The amount to repay
* - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
* @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
* @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
* user calling the function if he wants to reduce/remove his own debt, or the address of any other
* other borrower whose debt should be removed
* @return The final amount repaid
**/
function repay(
address asset,
uint256 amount,
uint256 rateMode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
returns (uint256)
{
}
/**
* @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa
* @param asset The address of the underlying asset borrowed
* @param rateMode The rate mode that the user wants to swap to
**/
function swapBorrowRateMode(address asset, uint256 rateMode)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
* - Users can be rebalanced if the following conditions are satisfied:
* 1. Usage ratio is above 95%
* 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been
* borrowed at a stable rate and depositors are not earning enough
* @param asset The address of the underlying asset borrowed
* @param user The address of the user to be rebalanced
**/
function rebalanceStableBorrowRate(address asset, address user)
public
virtual
override(ILendingPool, LendingPool)
onlyStableRateManagers
{
}
/**
* @dev Allows depositors to enable/disable a specific deposited asset as collateral
* @param asset The address of the underlying asset deposited
* @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise
**/
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
* - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
* a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
* @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
* @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
* @param user The address of the borrower getting liquidated
* @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
* @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
* to receive the underlying collateral asset directly
**/
function liquidationCall(
address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken
)
public
virtual
override(ILendingPool, LendingPool)
onlyLiquidators
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to seize the collateral of a user. Only whitelisters of the user can call this function
* @param assets The addresses of the underlying assets to seize
* @param to The address that will receive the funds
**/
function seize(
address user,
address[] calldata assets,
address to
) public virtual override(IPermissionedLendingPool) onlyUserPermissionAdmin(user) whenNotPaused {
}
/**
* @dev Allows smartcontracts to access the liquidity of the pool within one transaction,
* as long as the amount taken plus a fee is returned.
* IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.
* For further details please visit https://developers.aave.com
* @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface
* @param assets The addresses of the assets being flash-borrowed
* @param amounts The amounts amounts being flash-borrowed
* @param modes Types of the debt to open if the flash loan is not returned:
* 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
* 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2
* @param params Variadic packed params to pass to the receiver as extra information
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function flashLoan(
address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata modes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode
) public virtual override(ILendingPool, LendingPool) {
}
/**
* @dev Validates and finalizes an aToken transfer
* - Only callable by the overlying aToken of the `asset`
* @param asset The address of the underlying asset of the aToken
* @param from The user from which the aTokens are transferred
* @param to The user receiving the aTokens
* @param amount The amount being transferred/withdrawn
* @param balanceFromBefore The aToken balance of the `from` user before the transfer
* @param balanceToBefore The aToken balance of the `to` user before the transfer
*/
function finalizeTransfer(
address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromBefore,
uint256 balanceToBefore
) public override(ILendingPool, LendingPool) {
require(<FILL_ME>)
require(_isInRole(to, DataTypes.Roles.DEPOSITOR), Errors.VL_TRANSFER_NOT_ALLOWED);
super.finalizeTransfer(asset, from, to, amount, balanceFromBefore, balanceToBefore);
}
function _isPermissionAdminOf(address user, address caller) internal view returns (bool) {
}
function _isInRole(address user, DataTypes.Roles role) internal view returns (bool) {
}
function _permissionAdminValid(address user) internal view returns (bool) {
}
function _onlyDepositors(address user) internal view {
}
function _onlyBorrowers(address user) internal view {
}
function _onlyValidPermissionAdmin(address user) internal view {
}
}
| _isInRole(from,DataTypes.Roles.DEPOSITOR),Errors.VL_TRANSFER_NOT_ALLOWED | 11,084 | _isInRole(from,DataTypes.Roles.DEPOSITOR) |
Errors.VL_TRANSFER_NOT_ALLOWED | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {LendingPool} from './LendingPool.sol';
import {IPermissionManager} from '../../interfaces/IPermissionManager.sol';
import {IPermissionedLendingPool} from '../../interfaces/IPermissionedLendingPool.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {DataTypes} from '../libraries/types/DataTypes.sol';
/**
* @title PermissionedLendingPool
* @notice This smart contracts adds a permission layer to the LendingPool contract to enable whitelisting of users interacting with it
* @author Aave
**/
contract PermissionedLendingPool is IPermissionedLendingPool, LendingPool {
//identifier for the permission manager contract in the addresses provider
bytes32 public constant PERMISSION_MANAGER = keccak256('PERMISSION_MANAGER');
modifier onlyDepositors(address user) {
}
modifier onlyUserPermissionAdmin(address user) {
}
modifier onlyValidPermissionAdmin(address user) {
}
modifier onlyBorrowers(address user) {
}
modifier onlyLiquidators {
}
modifier onlyStableRateManagers {
}
/**
* @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
* - E.g. User deposits 100 USDC and gets in return 100 aUSDC
* @param asset The address of the underlying asset to deposit
* @param amount The amount to be deposited
* @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
* wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
* is a different wallet
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function deposit(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
* E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
* @param asset The address of the underlying asset to withdraw
* @param amount The underlying amount to be withdrawn
* - Send the value type(uint256).max in order to withdraw the whole aToken balance
* @param to Address that will receive the underlying, same as msg.sender if the user
* wants to receive it on his own wallet, or a different address if the beneficiary is a
* different wallet
* @return The final amount withdrawn
**/
function withdraw(
address asset,
uint256 amount,
address to
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
returns (uint256)
{
}
/**
* @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
* already deposited enough collateral, or he was given enough allowance by a credit delegator on the
* corresponding debt token (StableDebtToken or VariableDebtToken)
* - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
* and 100 stable/variable debt tokens, depending on the `interestRateMode`
* @param asset The address of the underlying asset to borrow
* @param amount The amount to be borrowed
* @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
* @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
* calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
* if he has been given credit delegation allowance
**/
function borrow(
address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
* - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
* @param asset The address of the borrowed underlying asset previously borrowed
* @param amount The amount to repay
* - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
* @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
* @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
* user calling the function if he wants to reduce/remove his own debt, or the address of any other
* other borrower whose debt should be removed
* @return The final amount repaid
**/
function repay(
address asset,
uint256 amount,
uint256 rateMode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
returns (uint256)
{
}
/**
* @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa
* @param asset The address of the underlying asset borrowed
* @param rateMode The rate mode that the user wants to swap to
**/
function swapBorrowRateMode(address asset, uint256 rateMode)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
* - Users can be rebalanced if the following conditions are satisfied:
* 1. Usage ratio is above 95%
* 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been
* borrowed at a stable rate and depositors are not earning enough
* @param asset The address of the underlying asset borrowed
* @param user The address of the user to be rebalanced
**/
function rebalanceStableBorrowRate(address asset, address user)
public
virtual
override(ILendingPool, LendingPool)
onlyStableRateManagers
{
}
/**
* @dev Allows depositors to enable/disable a specific deposited asset as collateral
* @param asset The address of the underlying asset deposited
* @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise
**/
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
* - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
* a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
* @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
* @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
* @param user The address of the borrower getting liquidated
* @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
* @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
* to receive the underlying collateral asset directly
**/
function liquidationCall(
address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken
)
public
virtual
override(ILendingPool, LendingPool)
onlyLiquidators
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to seize the collateral of a user. Only whitelisters of the user can call this function
* @param assets The addresses of the underlying assets to seize
* @param to The address that will receive the funds
**/
function seize(
address user,
address[] calldata assets,
address to
) public virtual override(IPermissionedLendingPool) onlyUserPermissionAdmin(user) whenNotPaused {
}
/**
* @dev Allows smartcontracts to access the liquidity of the pool within one transaction,
* as long as the amount taken plus a fee is returned.
* IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.
* For further details please visit https://developers.aave.com
* @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface
* @param assets The addresses of the assets being flash-borrowed
* @param amounts The amounts amounts being flash-borrowed
* @param modes Types of the debt to open if the flash loan is not returned:
* 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
* 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2
* @param params Variadic packed params to pass to the receiver as extra information
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function flashLoan(
address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata modes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode
) public virtual override(ILendingPool, LendingPool) {
}
/**
* @dev Validates and finalizes an aToken transfer
* - Only callable by the overlying aToken of the `asset`
* @param asset The address of the underlying asset of the aToken
* @param from The user from which the aTokens are transferred
* @param to The user receiving the aTokens
* @param amount The amount being transferred/withdrawn
* @param balanceFromBefore The aToken balance of the `from` user before the transfer
* @param balanceToBefore The aToken balance of the `to` user before the transfer
*/
function finalizeTransfer(
address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromBefore,
uint256 balanceToBefore
) public override(ILendingPool, LendingPool) {
require(_isInRole(from, DataTypes.Roles.DEPOSITOR), Errors.VL_TRANSFER_NOT_ALLOWED);
require(<FILL_ME>)
super.finalizeTransfer(asset, from, to, amount, balanceFromBefore, balanceToBefore);
}
function _isPermissionAdminOf(address user, address caller) internal view returns (bool) {
}
function _isInRole(address user, DataTypes.Roles role) internal view returns (bool) {
}
function _permissionAdminValid(address user) internal view returns (bool) {
}
function _onlyDepositors(address user) internal view {
}
function _onlyBorrowers(address user) internal view {
}
function _onlyValidPermissionAdmin(address user) internal view {
}
}
| _isInRole(to,DataTypes.Roles.DEPOSITOR),Errors.VL_TRANSFER_NOT_ALLOWED | 11,084 | _isInRole(to,DataTypes.Roles.DEPOSITOR) |
Errors.PLP_DEPOSITOR_UNAUTHORIZED | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {LendingPool} from './LendingPool.sol';
import {IPermissionManager} from '../../interfaces/IPermissionManager.sol';
import {IPermissionedLendingPool} from '../../interfaces/IPermissionedLendingPool.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {DataTypes} from '../libraries/types/DataTypes.sol';
/**
* @title PermissionedLendingPool
* @notice This smart contracts adds a permission layer to the LendingPool contract to enable whitelisting of users interacting with it
* @author Aave
**/
contract PermissionedLendingPool is IPermissionedLendingPool, LendingPool {
//identifier for the permission manager contract in the addresses provider
bytes32 public constant PERMISSION_MANAGER = keccak256('PERMISSION_MANAGER');
modifier onlyDepositors(address user) {
}
modifier onlyUserPermissionAdmin(address user) {
}
modifier onlyValidPermissionAdmin(address user) {
}
modifier onlyBorrowers(address user) {
}
modifier onlyLiquidators {
}
modifier onlyStableRateManagers {
}
/**
* @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
* - E.g. User deposits 100 USDC and gets in return 100 aUSDC
* @param asset The address of the underlying asset to deposit
* @param amount The amount to be deposited
* @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
* wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
* is a different wallet
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function deposit(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
* E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
* @param asset The address of the underlying asset to withdraw
* @param amount The underlying amount to be withdrawn
* - Send the value type(uint256).max in order to withdraw the whole aToken balance
* @param to Address that will receive the underlying, same as msg.sender if the user
* wants to receive it on his own wallet, or a different address if the beneficiary is a
* different wallet
* @return The final amount withdrawn
**/
function withdraw(
address asset,
uint256 amount,
address to
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
returns (uint256)
{
}
/**
* @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
* already deposited enough collateral, or he was given enough allowance by a credit delegator on the
* corresponding debt token (StableDebtToken or VariableDebtToken)
* - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
* and 100 stable/variable debt tokens, depending on the `interestRateMode`
* @param asset The address of the underlying asset to borrow
* @param amount The amount to be borrowed
* @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
* @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
* calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
* if he has been given credit delegation allowance
**/
function borrow(
address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
* - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
* @param asset The address of the borrowed underlying asset previously borrowed
* @param amount The amount to repay
* - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
* @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
* @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
* user calling the function if he wants to reduce/remove his own debt, or the address of any other
* other borrower whose debt should be removed
* @return The final amount repaid
**/
function repay(
address asset,
uint256 amount,
uint256 rateMode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
returns (uint256)
{
}
/**
* @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa
* @param asset The address of the underlying asset borrowed
* @param rateMode The rate mode that the user wants to swap to
**/
function swapBorrowRateMode(address asset, uint256 rateMode)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
* - Users can be rebalanced if the following conditions are satisfied:
* 1. Usage ratio is above 95%
* 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been
* borrowed at a stable rate and depositors are not earning enough
* @param asset The address of the underlying asset borrowed
* @param user The address of the user to be rebalanced
**/
function rebalanceStableBorrowRate(address asset, address user)
public
virtual
override(ILendingPool, LendingPool)
onlyStableRateManagers
{
}
/**
* @dev Allows depositors to enable/disable a specific deposited asset as collateral
* @param asset The address of the underlying asset deposited
* @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise
**/
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
* - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
* a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
* @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
* @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
* @param user The address of the borrower getting liquidated
* @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
* @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
* to receive the underlying collateral asset directly
**/
function liquidationCall(
address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken
)
public
virtual
override(ILendingPool, LendingPool)
onlyLiquidators
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to seize the collateral of a user. Only whitelisters of the user can call this function
* @param assets The addresses of the underlying assets to seize
* @param to The address that will receive the funds
**/
function seize(
address user,
address[] calldata assets,
address to
) public virtual override(IPermissionedLendingPool) onlyUserPermissionAdmin(user) whenNotPaused {
}
/**
* @dev Allows smartcontracts to access the liquidity of the pool within one transaction,
* as long as the amount taken plus a fee is returned.
* IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.
* For further details please visit https://developers.aave.com
* @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface
* @param assets The addresses of the assets being flash-borrowed
* @param amounts The amounts amounts being flash-borrowed
* @param modes Types of the debt to open if the flash loan is not returned:
* 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
* 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2
* @param params Variadic packed params to pass to the receiver as extra information
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function flashLoan(
address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata modes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode
) public virtual override(ILendingPool, LendingPool) {
}
/**
* @dev Validates and finalizes an aToken transfer
* - Only callable by the overlying aToken of the `asset`
* @param asset The address of the underlying asset of the aToken
* @param from The user from which the aTokens are transferred
* @param to The user receiving the aTokens
* @param amount The amount being transferred/withdrawn
* @param balanceFromBefore The aToken balance of the `from` user before the transfer
* @param balanceToBefore The aToken balance of the `to` user before the transfer
*/
function finalizeTransfer(
address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromBefore,
uint256 balanceToBefore
) public override(ILendingPool, LendingPool) {
}
function _isPermissionAdminOf(address user, address caller) internal view returns (bool) {
}
function _isInRole(address user, DataTypes.Roles role) internal view returns (bool) {
}
function _permissionAdminValid(address user) internal view returns (bool) {
}
function _onlyDepositors(address user) internal view {
require(<FILL_ME>)
}
function _onlyBorrowers(address user) internal view {
}
function _onlyValidPermissionAdmin(address user) internal view {
}
}
| _isInRole(user,DataTypes.Roles.DEPOSITOR)&&((user==msg.sender)||_isInRole(msg.sender,DataTypes.Roles.DEPOSITOR)),Errors.PLP_DEPOSITOR_UNAUTHORIZED | 11,084 | _isInRole(user,DataTypes.Roles.DEPOSITOR)&&((user==msg.sender)||_isInRole(msg.sender,DataTypes.Roles.DEPOSITOR)) |
Errors.PLP_BORROWER_UNAUTHORIZED | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {LendingPool} from './LendingPool.sol';
import {IPermissionManager} from '../../interfaces/IPermissionManager.sol';
import {IPermissionedLendingPool} from '../../interfaces/IPermissionedLendingPool.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {DataTypes} from '../libraries/types/DataTypes.sol';
/**
* @title PermissionedLendingPool
* @notice This smart contracts adds a permission layer to the LendingPool contract to enable whitelisting of users interacting with it
* @author Aave
**/
contract PermissionedLendingPool is IPermissionedLendingPool, LendingPool {
//identifier for the permission manager contract in the addresses provider
bytes32 public constant PERMISSION_MANAGER = keccak256('PERMISSION_MANAGER');
modifier onlyDepositors(address user) {
}
modifier onlyUserPermissionAdmin(address user) {
}
modifier onlyValidPermissionAdmin(address user) {
}
modifier onlyBorrowers(address user) {
}
modifier onlyLiquidators {
}
modifier onlyStableRateManagers {
}
/**
* @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
* - E.g. User deposits 100 USDC and gets in return 100 aUSDC
* @param asset The address of the underlying asset to deposit
* @param amount The amount to be deposited
* @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
* wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
* is a different wallet
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function deposit(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
* E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
* @param asset The address of the underlying asset to withdraw
* @param amount The underlying amount to be withdrawn
* - Send the value type(uint256).max in order to withdraw the whole aToken balance
* @param to Address that will receive the underlying, same as msg.sender if the user
* wants to receive it on his own wallet, or a different address if the beneficiary is a
* different wallet
* @return The final amount withdrawn
**/
function withdraw(
address asset,
uint256 amount,
address to
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
returns (uint256)
{
}
/**
* @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
* already deposited enough collateral, or he was given enough allowance by a credit delegator on the
* corresponding debt token (StableDebtToken or VariableDebtToken)
* - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
* and 100 stable/variable debt tokens, depending on the `interestRateMode`
* @param asset The address of the underlying asset to borrow
* @param amount The amount to be borrowed
* @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
* @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
* calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
* if he has been given credit delegation allowance
**/
function borrow(
address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
* - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
* @param asset The address of the borrowed underlying asset previously borrowed
* @param amount The amount to repay
* - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
* @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
* @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
* user calling the function if he wants to reduce/remove his own debt, or the address of any other
* other borrower whose debt should be removed
* @return The final amount repaid
**/
function repay(
address asset,
uint256 amount,
uint256 rateMode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
returns (uint256)
{
}
/**
* @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa
* @param asset The address of the underlying asset borrowed
* @param rateMode The rate mode that the user wants to swap to
**/
function swapBorrowRateMode(address asset, uint256 rateMode)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
* - Users can be rebalanced if the following conditions are satisfied:
* 1. Usage ratio is above 95%
* 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been
* borrowed at a stable rate and depositors are not earning enough
* @param asset The address of the underlying asset borrowed
* @param user The address of the user to be rebalanced
**/
function rebalanceStableBorrowRate(address asset, address user)
public
virtual
override(ILendingPool, LendingPool)
onlyStableRateManagers
{
}
/**
* @dev Allows depositors to enable/disable a specific deposited asset as collateral
* @param asset The address of the underlying asset deposited
* @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise
**/
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
* - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
* a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
* @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
* @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
* @param user The address of the borrower getting liquidated
* @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
* @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
* to receive the underlying collateral asset directly
**/
function liquidationCall(
address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken
)
public
virtual
override(ILendingPool, LendingPool)
onlyLiquidators
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to seize the collateral of a user. Only whitelisters of the user can call this function
* @param assets The addresses of the underlying assets to seize
* @param to The address that will receive the funds
**/
function seize(
address user,
address[] calldata assets,
address to
) public virtual override(IPermissionedLendingPool) onlyUserPermissionAdmin(user) whenNotPaused {
}
/**
* @dev Allows smartcontracts to access the liquidity of the pool within one transaction,
* as long as the amount taken plus a fee is returned.
* IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.
* For further details please visit https://developers.aave.com
* @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface
* @param assets The addresses of the assets being flash-borrowed
* @param amounts The amounts amounts being flash-borrowed
* @param modes Types of the debt to open if the flash loan is not returned:
* 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
* 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2
* @param params Variadic packed params to pass to the receiver as extra information
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function flashLoan(
address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata modes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode
) public virtual override(ILendingPool, LendingPool) {
}
/**
* @dev Validates and finalizes an aToken transfer
* - Only callable by the overlying aToken of the `asset`
* @param asset The address of the underlying asset of the aToken
* @param from The user from which the aTokens are transferred
* @param to The user receiving the aTokens
* @param amount The amount being transferred/withdrawn
* @param balanceFromBefore The aToken balance of the `from` user before the transfer
* @param balanceToBefore The aToken balance of the `to` user before the transfer
*/
function finalizeTransfer(
address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromBefore,
uint256 balanceToBefore
) public override(ILendingPool, LendingPool) {
}
function _isPermissionAdminOf(address user, address caller) internal view returns (bool) {
}
function _isInRole(address user, DataTypes.Roles role) internal view returns (bool) {
}
function _permissionAdminValid(address user) internal view returns (bool) {
}
function _onlyDepositors(address user) internal view {
}
function _onlyBorrowers(address user) internal view {
require(<FILL_ME>)
}
function _onlyValidPermissionAdmin(address user) internal view {
}
}
| _isInRole(user,DataTypes.Roles.BORROWER)&&((user==msg.sender)||_isInRole(msg.sender,DataTypes.Roles.BORROWER)),Errors.PLP_BORROWER_UNAUTHORIZED | 11,084 | _isInRole(user,DataTypes.Roles.BORROWER)&&((user==msg.sender)||_isInRole(msg.sender,DataTypes.Roles.BORROWER)) |
Errors.PLP_INVALID_PERMISSION_ADMIN | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
import {LendingPool} from './LendingPool.sol';
import {IPermissionManager} from '../../interfaces/IPermissionManager.sol';
import {IPermissionedLendingPool} from '../../interfaces/IPermissionedLendingPool.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {DataTypes} from '../libraries/types/DataTypes.sol';
/**
* @title PermissionedLendingPool
* @notice This smart contracts adds a permission layer to the LendingPool contract to enable whitelisting of users interacting with it
* @author Aave
**/
contract PermissionedLendingPool is IPermissionedLendingPool, LendingPool {
//identifier for the permission manager contract in the addresses provider
bytes32 public constant PERMISSION_MANAGER = keccak256('PERMISSION_MANAGER');
modifier onlyDepositors(address user) {
}
modifier onlyUserPermissionAdmin(address user) {
}
modifier onlyValidPermissionAdmin(address user) {
}
modifier onlyBorrowers(address user) {
}
modifier onlyLiquidators {
}
modifier onlyStableRateManagers {
}
/**
* @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
* - E.g. User deposits 100 USDC and gets in return 100 aUSDC
* @param asset The address of the underlying asset to deposit
* @param amount The amount to be deposited
* @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
* wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
* is a different wallet
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function deposit(
address asset,
uint256 amount,
address onBehalfOf,
uint16 referralCode
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
* E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
* @param asset The address of the underlying asset to withdraw
* @param amount The underlying amount to be withdrawn
* - Send the value type(uint256).max in order to withdraw the whole aToken balance
* @param to Address that will receive the underlying, same as msg.sender if the user
* wants to receive it on his own wallet, or a different address if the beneficiary is a
* different wallet
* @return The final amount withdrawn
**/
function withdraw(
address asset,
uint256 amount,
address to
)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
returns (uint256)
{
}
/**
* @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
* already deposited enough collateral, or he was given enough allowance by a credit delegator on the
* corresponding debt token (StableDebtToken or VariableDebtToken)
* - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
* and 100 stable/variable debt tokens, depending on the `interestRateMode`
* @param asset The address of the underlying asset to borrow
* @param amount The amount to be borrowed
* @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
* @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
* calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
* if he has been given credit delegation allowance
**/
function borrow(
address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
{
}
/**
* @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
* - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
* @param asset The address of the borrowed underlying asset previously borrowed
* @param amount The amount to repay
* - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
* @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
* @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
* user calling the function if he wants to reduce/remove his own debt, or the address of any other
* other borrower whose debt should be removed
* @return The final amount repaid
**/
function repay(
address asset,
uint256 amount,
uint256 rateMode,
address onBehalfOf
)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(onBehalfOf)
onlyValidPermissionAdmin(onBehalfOf)
returns (uint256)
{
}
/**
* @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa
* @param asset The address of the underlying asset borrowed
* @param rateMode The rate mode that the user wants to swap to
**/
function swapBorrowRateMode(address asset, uint256 rateMode)
public
virtual
override(ILendingPool, LendingPool)
onlyBorrowers(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
* - Users can be rebalanced if the following conditions are satisfied:
* 1. Usage ratio is above 95%
* 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been
* borrowed at a stable rate and depositors are not earning enough
* @param asset The address of the underlying asset borrowed
* @param user The address of the user to be rebalanced
**/
function rebalanceStableBorrowRate(address asset, address user)
public
virtual
override(ILendingPool, LendingPool)
onlyStableRateManagers
{
}
/**
* @dev Allows depositors to enable/disable a specific deposited asset as collateral
* @param asset The address of the underlying asset deposited
* @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise
**/
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)
public
virtual
override(ILendingPool, LendingPool)
onlyDepositors(msg.sender)
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
* - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
* a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
* @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
* @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
* @param user The address of the borrower getting liquidated
* @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
* @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
* to receive the underlying collateral asset directly
**/
function liquidationCall(
address collateralAsset,
address debtAsset,
address user,
uint256 debtToCover,
bool receiveAToken
)
public
virtual
override(ILendingPool, LendingPool)
onlyLiquidators
onlyValidPermissionAdmin(msg.sender)
{
}
/**
* @dev Function to seize the collateral of a user. Only whitelisters of the user can call this function
* @param assets The addresses of the underlying assets to seize
* @param to The address that will receive the funds
**/
function seize(
address user,
address[] calldata assets,
address to
) public virtual override(IPermissionedLendingPool) onlyUserPermissionAdmin(user) whenNotPaused {
}
/**
* @dev Allows smartcontracts to access the liquidity of the pool within one transaction,
* as long as the amount taken plus a fee is returned.
* IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.
* For further details please visit https://developers.aave.com
* @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface
* @param assets The addresses of the assets being flash-borrowed
* @param amounts The amounts amounts being flash-borrowed
* @param modes Types of the debt to open if the flash loan is not returned:
* 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
* 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
* @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2
* @param params Variadic packed params to pass to the receiver as extra information
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
* 0 if the action is executed directly by the user, without any middle-man
**/
function flashLoan(
address receiverAddress,
address[] calldata assets,
uint256[] calldata amounts,
uint256[] calldata modes,
address onBehalfOf,
bytes calldata params,
uint16 referralCode
) public virtual override(ILendingPool, LendingPool) {
}
/**
* @dev Validates and finalizes an aToken transfer
* - Only callable by the overlying aToken of the `asset`
* @param asset The address of the underlying asset of the aToken
* @param from The user from which the aTokens are transferred
* @param to The user receiving the aTokens
* @param amount The amount being transferred/withdrawn
* @param balanceFromBefore The aToken balance of the `from` user before the transfer
* @param balanceToBefore The aToken balance of the `to` user before the transfer
*/
function finalizeTransfer(
address asset,
address from,
address to,
uint256 amount,
uint256 balanceFromBefore,
uint256 balanceToBefore
) public override(ILendingPool, LendingPool) {
}
function _isPermissionAdminOf(address user, address caller) internal view returns (bool) {
}
function _isInRole(address user, DataTypes.Roles role) internal view returns (bool) {
}
function _permissionAdminValid(address user) internal view returns (bool) {
}
function _onlyDepositors(address user) internal view {
}
function _onlyBorrowers(address user) internal view {
}
function _onlyValidPermissionAdmin(address user) internal view {
require(<FILL_ME>)
}
}
| _permissionAdminValid(user),Errors.PLP_INVALID_PERMISSION_ADMIN | 11,084 | _permissionAdminValid(user) |
"insufficient balance." | pragma solidity ^0.7.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _setupDecimals(uint8 decimals_) internal {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract DotsCoinCore is ERC20("DotSwaps", "DOTS") {
using SafeMath for uint256;
address internal _taxer;
address internal _taxDestination;
uint internal _taxRate = 0;
mapping (address => bool) internal _taxWhitelist;
function transfer(address recipient, uint256 amount) public override returns (bool) {
uint256 taxAmount = amount.mul(_taxRate).div(100);
if (_taxWhitelist[msg.sender] == true) {
taxAmount = 0;
}
uint256 transferAmount = amount.sub(taxAmount);
require(<FILL_ME>)
super.transfer(recipient, amount);
if (taxAmount != 0) {
super.transfer(_taxDestination, taxAmount);
}
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
}
contract DotsCoin is DotsCoinCore, Ownable {
mapping (address => bool) public minters;
constructor() {
}
function mint(address to, uint amount) public onlyMinter {
}
function burn(uint amount) public {
}
function addMinter(address account) public onlyOwner {
}
function removeMinter(address account) public onlyOwner {
}
modifier onlyMinter() {
}
modifier onlyTaxer() {
}
function setTaxer(address account) public onlyOwner {
}
function setTaxRate(uint256 rate) public onlyTaxer {
}
function setTaxDestination(address account) public onlyTaxer {
}
function addToWhitelist(address account) public onlyTaxer {
}
function removeFromWhitelist(address account) public onlyTaxer {
}
function taxer() public view returns(address) {
}
function taxDestination() public view returns(address) {
}
function taxRate() public view returns(uint256) {
}
function isInWhitelist(address account) public view returns(bool) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract DotsPresale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
mapping (address => bool) public whitelist;
mapping (address => uint) public ethSupply;
address payable devAddress;
uint public dotsprice = 100;
uint public buyLimit = 3 * 1e18;
bool public presaleStart = false;
bool public onlyWhitelist = true;
uint public presaleLastSupply = 36000 * 1e18;
DotsCoin private dots = DotsCoin(0xB25C23EBF03A4e3a9F5CF12f2f6471599af10491);
event BuyDotsSuccess(address account, uint ethAmount, uint dotsAmount);
constructor(address payable account) {
}
function addToWhitelist(address account) public onlyOwner {
}
function removeFromWhitelist(address account) public onlyOwner {
}
function setDevAddress(address payable account) public onlyOwner {
}
function startPresale() public onlyOwner {
}
function stopPresale() public onlyOwner {
}
function setDotsPrice(uint newPrice) public onlyOwner {
}
function setBuyLimit(uint newLimit) public onlyOwner {
}
function changeToNotOnlyWhitelist() public onlyOwner {
}
modifier needHaveLastSupply() {
}
modifier presaleHasStarted() {
}
receive() payable external presaleHasStarted needHaveLastSupply {
}
function initWhitelist() internal {
}
function testMint() public onlyOwner {
}
}
/**
*DOTSWAPS . COM - WEBSITE
*DOTSWAPS IS A DUAL TOKEN MODEL SWAPS CONTRACT FOLLOW UP
*DOTSWAPS PRESALE CONTRACT
*/
| balanceOf(msg.sender)>=transferAmount,"insufficient balance." | 11,125 | balanceOf(msg.sender)>=transferAmount |
"insufficient balance." | pragma solidity ^0.7.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _setupDecimals(uint8 decimals_) internal {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract DotsCoinCore is ERC20("DotSwaps", "DOTS") {
using SafeMath for uint256;
address internal _taxer;
address internal _taxDestination;
uint internal _taxRate = 0;
mapping (address => bool) internal _taxWhitelist;
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
uint256 taxAmount = amount.mul(_taxRate).div(100);
if (_taxWhitelist[sender] == true) {
taxAmount = 0;
}
uint256 transferAmount = amount.sub(taxAmount);
require(<FILL_ME>)
super.transferFrom(sender, recipient, amount);
if (taxAmount != 0) {
super.transferFrom(sender, _taxDestination, taxAmount);
}
return true;
}
}
contract DotsCoin is DotsCoinCore, Ownable {
mapping (address => bool) public minters;
constructor() {
}
function mint(address to, uint amount) public onlyMinter {
}
function burn(uint amount) public {
}
function addMinter(address account) public onlyOwner {
}
function removeMinter(address account) public onlyOwner {
}
modifier onlyMinter() {
}
modifier onlyTaxer() {
}
function setTaxer(address account) public onlyOwner {
}
function setTaxRate(uint256 rate) public onlyTaxer {
}
function setTaxDestination(address account) public onlyTaxer {
}
function addToWhitelist(address account) public onlyTaxer {
}
function removeFromWhitelist(address account) public onlyTaxer {
}
function taxer() public view returns(address) {
}
function taxDestination() public view returns(address) {
}
function taxRate() public view returns(uint256) {
}
function isInWhitelist(address account) public view returns(bool) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract DotsPresale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
mapping (address => bool) public whitelist;
mapping (address => uint) public ethSupply;
address payable devAddress;
uint public dotsprice = 100;
uint public buyLimit = 3 * 1e18;
bool public presaleStart = false;
bool public onlyWhitelist = true;
uint public presaleLastSupply = 36000 * 1e18;
DotsCoin private dots = DotsCoin(0xB25C23EBF03A4e3a9F5CF12f2f6471599af10491);
event BuyDotsSuccess(address account, uint ethAmount, uint dotsAmount);
constructor(address payable account) {
}
function addToWhitelist(address account) public onlyOwner {
}
function removeFromWhitelist(address account) public onlyOwner {
}
function setDevAddress(address payable account) public onlyOwner {
}
function startPresale() public onlyOwner {
}
function stopPresale() public onlyOwner {
}
function setDotsPrice(uint newPrice) public onlyOwner {
}
function setBuyLimit(uint newLimit) public onlyOwner {
}
function changeToNotOnlyWhitelist() public onlyOwner {
}
modifier needHaveLastSupply() {
}
modifier presaleHasStarted() {
}
receive() payable external presaleHasStarted needHaveLastSupply {
}
function initWhitelist() internal {
}
function testMint() public onlyOwner {
}
}
/**
*DOTSWAPS . COM - WEBSITE
*DOTSWAPS IS A DUAL TOKEN MODEL SWAPS CONTRACT FOLLOW UP
*DOTSWAPS PRESALE CONTRACT
*/
| balanceOf(sender)>=transferAmount,"insufficient balance." | 11,125 | balanceOf(sender)>=transferAmount |
null | pragma solidity ^0.7.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _setupDecimals(uint8 decimals_) internal {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract DotsCoinCore is ERC20("DotSwaps", "DOTS") {
using SafeMath for uint256;
address internal _taxer;
address internal _taxDestination;
uint internal _taxRate = 0;
mapping (address => bool) internal _taxWhitelist;
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
}
contract DotsCoin is DotsCoinCore, Ownable {
mapping (address => bool) public minters;
constructor() {
}
function mint(address to, uint amount) public onlyMinter {
}
function burn(uint amount) public {
require(amount > 0);
require(<FILL_ME>)
_burn(msg.sender, amount);
}
function addMinter(address account) public onlyOwner {
}
function removeMinter(address account) public onlyOwner {
}
modifier onlyMinter() {
}
modifier onlyTaxer() {
}
function setTaxer(address account) public onlyOwner {
}
function setTaxRate(uint256 rate) public onlyTaxer {
}
function setTaxDestination(address account) public onlyTaxer {
}
function addToWhitelist(address account) public onlyTaxer {
}
function removeFromWhitelist(address account) public onlyTaxer {
}
function taxer() public view returns(address) {
}
function taxDestination() public view returns(address) {
}
function taxRate() public view returns(uint256) {
}
function isInWhitelist(address account) public view returns(bool) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract DotsPresale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
mapping (address => bool) public whitelist;
mapping (address => uint) public ethSupply;
address payable devAddress;
uint public dotsprice = 100;
uint public buyLimit = 3 * 1e18;
bool public presaleStart = false;
bool public onlyWhitelist = true;
uint public presaleLastSupply = 36000 * 1e18;
DotsCoin private dots = DotsCoin(0xB25C23EBF03A4e3a9F5CF12f2f6471599af10491);
event BuyDotsSuccess(address account, uint ethAmount, uint dotsAmount);
constructor(address payable account) {
}
function addToWhitelist(address account) public onlyOwner {
}
function removeFromWhitelist(address account) public onlyOwner {
}
function setDevAddress(address payable account) public onlyOwner {
}
function startPresale() public onlyOwner {
}
function stopPresale() public onlyOwner {
}
function setDotsPrice(uint newPrice) public onlyOwner {
}
function setBuyLimit(uint newLimit) public onlyOwner {
}
function changeToNotOnlyWhitelist() public onlyOwner {
}
modifier needHaveLastSupply() {
}
modifier presaleHasStarted() {
}
receive() payable external presaleHasStarted needHaveLastSupply {
}
function initWhitelist() internal {
}
function testMint() public onlyOwner {
}
}
/**
*DOTSWAPS . COM - WEBSITE
*DOTSWAPS IS A DUAL TOKEN MODEL SWAPS CONTRACT FOLLOW UP
*DOTSWAPS PRESALE CONTRACT
*/
| balanceOf(msg.sender)>=amount | 11,125 | balanceOf(msg.sender)>=amount |
"This account is already in whitelist." | pragma solidity ^0.7.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _setupDecimals(uint8 decimals_) internal {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract DotsCoinCore is ERC20("DotSwaps", "DOTS") {
using SafeMath for uint256;
address internal _taxer;
address internal _taxDestination;
uint internal _taxRate = 0;
mapping (address => bool) internal _taxWhitelist;
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
}
contract DotsCoin is DotsCoinCore, Ownable {
mapping (address => bool) public minters;
constructor() {
}
function mint(address to, uint amount) public onlyMinter {
}
function burn(uint amount) public {
}
function addMinter(address account) public onlyOwner {
}
function removeMinter(address account) public onlyOwner {
}
modifier onlyMinter() {
}
modifier onlyTaxer() {
}
function setTaxer(address account) public onlyOwner {
}
function setTaxRate(uint256 rate) public onlyTaxer {
}
function setTaxDestination(address account) public onlyTaxer {
}
function addToWhitelist(address account) public onlyTaxer {
}
function removeFromWhitelist(address account) public onlyTaxer {
}
function taxer() public view returns(address) {
}
function taxDestination() public view returns(address) {
}
function taxRate() public view returns(uint256) {
}
function isInWhitelist(address account) public view returns(bool) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract DotsPresale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
mapping (address => bool) public whitelist;
mapping (address => uint) public ethSupply;
address payable devAddress;
uint public dotsprice = 100;
uint public buyLimit = 3 * 1e18;
bool public presaleStart = false;
bool public onlyWhitelist = true;
uint public presaleLastSupply = 36000 * 1e18;
DotsCoin private dots = DotsCoin(0xB25C23EBF03A4e3a9F5CF12f2f6471599af10491);
event BuyDotsSuccess(address account, uint ethAmount, uint dotsAmount);
constructor(address payable account) {
}
function addToWhitelist(address account) public onlyOwner {
require(<FILL_ME>)
whitelist[account] = true;
}
function removeFromWhitelist(address account) public onlyOwner {
}
function setDevAddress(address payable account) public onlyOwner {
}
function startPresale() public onlyOwner {
}
function stopPresale() public onlyOwner {
}
function setDotsPrice(uint newPrice) public onlyOwner {
}
function setBuyLimit(uint newLimit) public onlyOwner {
}
function changeToNotOnlyWhitelist() public onlyOwner {
}
modifier needHaveLastSupply() {
}
modifier presaleHasStarted() {
}
receive() payable external presaleHasStarted needHaveLastSupply {
}
function initWhitelist() internal {
}
function testMint() public onlyOwner {
}
}
/**
*DOTSWAPS . COM - WEBSITE
*DOTSWAPS IS A DUAL TOKEN MODEL SWAPS CONTRACT FOLLOW UP
*DOTSWAPS PRESALE CONTRACT
*/
| whitelist[account]==false,"This account is already in whitelist." | 11,125 | whitelist[account]==false |
"This account is not in whitelist." | pragma solidity ^0.7.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _setupDecimals(uint8 decimals_) internal {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract DotsCoinCore is ERC20("DotSwaps", "DOTS") {
using SafeMath for uint256;
address internal _taxer;
address internal _taxDestination;
uint internal _taxRate = 0;
mapping (address => bool) internal _taxWhitelist;
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
}
contract DotsCoin is DotsCoinCore, Ownable {
mapping (address => bool) public minters;
constructor() {
}
function mint(address to, uint amount) public onlyMinter {
}
function burn(uint amount) public {
}
function addMinter(address account) public onlyOwner {
}
function removeMinter(address account) public onlyOwner {
}
modifier onlyMinter() {
}
modifier onlyTaxer() {
}
function setTaxer(address account) public onlyOwner {
}
function setTaxRate(uint256 rate) public onlyTaxer {
}
function setTaxDestination(address account) public onlyTaxer {
}
function addToWhitelist(address account) public onlyTaxer {
}
function removeFromWhitelist(address account) public onlyTaxer {
}
function taxer() public view returns(address) {
}
function taxDestination() public view returns(address) {
}
function taxRate() public view returns(uint256) {
}
function isInWhitelist(address account) public view returns(bool) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract DotsPresale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
mapping (address => bool) public whitelist;
mapping (address => uint) public ethSupply;
address payable devAddress;
uint public dotsprice = 100;
uint public buyLimit = 3 * 1e18;
bool public presaleStart = false;
bool public onlyWhitelist = true;
uint public presaleLastSupply = 36000 * 1e18;
DotsCoin private dots = DotsCoin(0xB25C23EBF03A4e3a9F5CF12f2f6471599af10491);
event BuyDotsSuccess(address account, uint ethAmount, uint dotsAmount);
constructor(address payable account) {
}
function addToWhitelist(address account) public onlyOwner {
}
function removeFromWhitelist(address account) public onlyOwner {
require(<FILL_ME>)
whitelist[account] = false;
}
function setDevAddress(address payable account) public onlyOwner {
}
function startPresale() public onlyOwner {
}
function stopPresale() public onlyOwner {
}
function setDotsPrice(uint newPrice) public onlyOwner {
}
function setBuyLimit(uint newLimit) public onlyOwner {
}
function changeToNotOnlyWhitelist() public onlyOwner {
}
modifier needHaveLastSupply() {
}
modifier presaleHasStarted() {
}
receive() payable external presaleHasStarted needHaveLastSupply {
}
function initWhitelist() internal {
}
function testMint() public onlyOwner {
}
}
/**
*DOTSWAPS . COM - WEBSITE
*DOTSWAPS IS A DUAL TOKEN MODEL SWAPS CONTRACT FOLLOW UP
*DOTSWAPS PRESALE CONTRACT
*/
| whitelist[account],"This account is not in whitelist." | 11,125 | whitelist[account] |
"This time is only for people who are in whitelist." | pragma solidity ^0.7.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _setupDecimals(uint8 decimals_) internal {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract DotsCoinCore is ERC20("DotSwaps", "DOTS") {
using SafeMath for uint256;
address internal _taxer;
address internal _taxDestination;
uint internal _taxRate = 0;
mapping (address => bool) internal _taxWhitelist;
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
}
contract DotsCoin is DotsCoinCore, Ownable {
mapping (address => bool) public minters;
constructor() {
}
function mint(address to, uint amount) public onlyMinter {
}
function burn(uint amount) public {
}
function addMinter(address account) public onlyOwner {
}
function removeMinter(address account) public onlyOwner {
}
modifier onlyMinter() {
}
modifier onlyTaxer() {
}
function setTaxer(address account) public onlyOwner {
}
function setTaxRate(uint256 rate) public onlyTaxer {
}
function setTaxDestination(address account) public onlyTaxer {
}
function addToWhitelist(address account) public onlyTaxer {
}
function removeFromWhitelist(address account) public onlyTaxer {
}
function taxer() public view returns(address) {
}
function taxDestination() public view returns(address) {
}
function taxRate() public view returns(uint256) {
}
function isInWhitelist(address account) public view returns(bool) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract DotsPresale is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
mapping (address => bool) public whitelist;
mapping (address => uint) public ethSupply;
address payable devAddress;
uint public dotsprice = 100;
uint public buyLimit = 3 * 1e18;
bool public presaleStart = false;
bool public onlyWhitelist = true;
uint public presaleLastSupply = 36000 * 1e18;
DotsCoin private dots = DotsCoin(0xB25C23EBF03A4e3a9F5CF12f2f6471599af10491);
event BuyDotsSuccess(address account, uint ethAmount, uint dotsAmount);
constructor(address payable account) {
}
function addToWhitelist(address account) public onlyOwner {
}
function removeFromWhitelist(address account) public onlyOwner {
}
function setDevAddress(address payable account) public onlyOwner {
}
function startPresale() public onlyOwner {
}
function stopPresale() public onlyOwner {
}
function setDotsPrice(uint newPrice) public onlyOwner {
}
function setBuyLimit(uint newLimit) public onlyOwner {
}
function changeToNotOnlyWhitelist() public onlyOwner {
}
modifier needHaveLastSupply() {
}
modifier presaleHasStarted() {
}
receive() payable external presaleHasStarted needHaveLastSupply {
if (onlyWhitelist) {
require(<FILL_ME>)
}
uint ethTotalAmount = ethSupply[msg.sender].add(msg.value);
require(ethTotalAmount <= buyLimit, "Everyone should buy lesser than 3 eth.");
uint dotsAmount = msg.value.mul(dotsprice);
require(dotsAmount <= presaleLastSupply, "insufficient presale supply");
presaleLastSupply = presaleLastSupply.sub(dotsAmount);
dots.mint(msg.sender, dotsAmount);
ethSupply[msg.sender] = ethTotalAmount;
devAddress.transfer(msg.value);
emit BuyDotsSuccess(msg.sender, msg.value, dotsAmount);
}
function initWhitelist() internal {
}
function testMint() public onlyOwner {
}
}
/**
*DOTSWAPS . COM - WEBSITE
*DOTSWAPS IS A DUAL TOKEN MODEL SWAPS CONTRACT FOLLOW UP
*DOTSWAPS PRESALE CONTRACT
*/
| whitelist[msg.sender],"This time is only for people who are in whitelist." | 11,125 | whitelist[msg.sender] |
"ERC20: Caller Locked !" | pragma solidity ^0.5.11;
library SafeMath{
/**
* Returns the addition of two unsigned integers, reverting on
* overflow.
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* - Subtraction cannot overflow.
*
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract owned {
address public owner;
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external ; }
contract TOKENERC20 {
using SafeMath for uint256;
event TransferEnabled (bool);
event TransferDisabled (bool);
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
uint256 internal limit = 10000000000000000000000000;
/* This generates a public event on the blockchain that will notify clients */
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Mint(address indexed from, uint256 value);
constructor(
uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol
) public {
}
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) private _allowance;
mapping (address => bool) public LockList;
mapping (address => uint256) public LockedTokens;
bool public TransferAllowed;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint256 _value) internal {
uint256 stage;
require(_from != address(0), "ERC20: transfer from the zero address");
require(_to != address(0), "ERC20: transfer to the zero address"); // Prevent transfer to 0x0 address. Use burn() instead
require(<FILL_ME>) // Check if msg.sender is locked or not
require (LockList[_from] == false, "ERC20: Sender Locked !");
require (LockList[_to] == false,"ERC20: Receipient Locked !");
require (TransferAllowed == true,"ERC20: Transfer enabled false !");
// Check if sender balance is locked
stage=balanceOf[_from].sub(_value, "ERC20: transfer amount exceeds balance");
require (stage >= LockedTokens[_from],"ERC20: transfer amount exceeds Senders Locked Amount");
//Deduct and add balance
balanceOf[_from]=stage;
balanceOf[_to]=balanceOf[_to].add(_value,"ERC20: Addition overflow");
//emit Transfer event
emit Transfer(_from, _to, _value);
}
/**
* Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address _spender, uint256 amount) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public returns(bool){
}
function burn(uint256 _value) public returns(bool){
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param Account address
*
* @param _value the amount of money to burn
*
* Safely check if total supply is not overdrawn
*/
function burnFrom(address Account, uint256 _value) public returns (bool success) {
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` on behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
* Emits Approval Event
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
}
function allowance(address _owner,address _spender) public view returns(uint256){
}
}
contract GENEBANKToken is owned, TOKENERC20 {
/* Initializes contract with initial supply tokens to the creator of the contract */
constructor () TOKENERC20(
10000000000 * 1 ** uint256(decimals),
"GENEBANK Token",
"GNBT") public {
}
/**
* User Lock
*
* @param Account the address of account to lock for transaction
*
* @param mode true or false for lock mode
*
*/
function UserLock(address Account, bool mode) onlyOwner public {
}
/**
* Lock tokens
*
* @param Account the address of account to lock
*
* @param amount the amount of money to lock
*
*
*/
function LockTokens(address Account, uint256 amount) onlyOwner public{
}
function UnLockTokens(address Account) onlyOwner public{
}
/**
* Mintable, Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function mint(uint256 _value) onlyOwner public returns (bool success) {
}
/**
* Airdrop tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount with decimals(18)
*
*/
mapping (address => uint256) public airDropHistory;
event AirDrop(address _receiver, uint256 _amount);
function dropToken(address[] memory receivers, uint256[] memory values) onlyOwner public {
}
/// Set whether transfer is enabled or disabled
function enableTokenTransfer() onlyOwner public {
}
function disableTokenTransfer() onlyOwner public {
}
}
| LockList[msg.sender]==false,"ERC20: Caller Locked !" | 11,141 | LockList[msg.sender]==false |
"ERC20: Sender Locked !" | pragma solidity ^0.5.11;
library SafeMath{
/**
* Returns the addition of two unsigned integers, reverting on
* overflow.
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* - Subtraction cannot overflow.
*
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract owned {
address public owner;
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external ; }
contract TOKENERC20 {
using SafeMath for uint256;
event TransferEnabled (bool);
event TransferDisabled (bool);
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
uint256 internal limit = 10000000000000000000000000;
/* This generates a public event on the blockchain that will notify clients */
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Mint(address indexed from, uint256 value);
constructor(
uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol
) public {
}
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) private _allowance;
mapping (address => bool) public LockList;
mapping (address => uint256) public LockedTokens;
bool public TransferAllowed;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint256 _value) internal {
uint256 stage;
require(_from != address(0), "ERC20: transfer from the zero address");
require(_to != address(0), "ERC20: transfer to the zero address"); // Prevent transfer to 0x0 address. Use burn() instead
require (LockList[msg.sender] == false,"ERC20: Caller Locked !"); // Check if msg.sender is locked or not
require(<FILL_ME>)
require (LockList[_to] == false,"ERC20: Receipient Locked !");
require (TransferAllowed == true,"ERC20: Transfer enabled false !");
// Check if sender balance is locked
stage=balanceOf[_from].sub(_value, "ERC20: transfer amount exceeds balance");
require (stage >= LockedTokens[_from],"ERC20: transfer amount exceeds Senders Locked Amount");
//Deduct and add balance
balanceOf[_from]=stage;
balanceOf[_to]=balanceOf[_to].add(_value,"ERC20: Addition overflow");
//emit Transfer event
emit Transfer(_from, _to, _value);
}
/**
* Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address _spender, uint256 amount) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public returns(bool){
}
function burn(uint256 _value) public returns(bool){
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param Account address
*
* @param _value the amount of money to burn
*
* Safely check if total supply is not overdrawn
*/
function burnFrom(address Account, uint256 _value) public returns (bool success) {
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` on behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
* Emits Approval Event
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
}
function allowance(address _owner,address _spender) public view returns(uint256){
}
}
contract GENEBANKToken is owned, TOKENERC20 {
/* Initializes contract with initial supply tokens to the creator of the contract */
constructor () TOKENERC20(
10000000000 * 1 ** uint256(decimals),
"GENEBANK Token",
"GNBT") public {
}
/**
* User Lock
*
* @param Account the address of account to lock for transaction
*
* @param mode true or false for lock mode
*
*/
function UserLock(address Account, bool mode) onlyOwner public {
}
/**
* Lock tokens
*
* @param Account the address of account to lock
*
* @param amount the amount of money to lock
*
*
*/
function LockTokens(address Account, uint256 amount) onlyOwner public{
}
function UnLockTokens(address Account) onlyOwner public{
}
/**
* Mintable, Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function mint(uint256 _value) onlyOwner public returns (bool success) {
}
/**
* Airdrop tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount with decimals(18)
*
*/
mapping (address => uint256) public airDropHistory;
event AirDrop(address _receiver, uint256 _amount);
function dropToken(address[] memory receivers, uint256[] memory values) onlyOwner public {
}
/// Set whether transfer is enabled or disabled
function enableTokenTransfer() onlyOwner public {
}
function disableTokenTransfer() onlyOwner public {
}
}
| LockList[_from]==false,"ERC20: Sender Locked !" | 11,141 | LockList[_from]==false |
"ERC20: Receipient Locked !" | pragma solidity ^0.5.11;
library SafeMath{
/**
* Returns the addition of two unsigned integers, reverting on
* overflow.
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* - Subtraction cannot overflow.
*
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract owned {
address public owner;
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external ; }
contract TOKENERC20 {
using SafeMath for uint256;
event TransferEnabled (bool);
event TransferDisabled (bool);
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
uint256 internal limit = 10000000000000000000000000;
/* This generates a public event on the blockchain that will notify clients */
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Mint(address indexed from, uint256 value);
constructor(
uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol
) public {
}
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) private _allowance;
mapping (address => bool) public LockList;
mapping (address => uint256) public LockedTokens;
bool public TransferAllowed;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint256 _value) internal {
uint256 stage;
require(_from != address(0), "ERC20: transfer from the zero address");
require(_to != address(0), "ERC20: transfer to the zero address"); // Prevent transfer to 0x0 address. Use burn() instead
require (LockList[msg.sender] == false,"ERC20: Caller Locked !"); // Check if msg.sender is locked or not
require (LockList[_from] == false, "ERC20: Sender Locked !");
require(<FILL_ME>)
require (TransferAllowed == true,"ERC20: Transfer enabled false !");
// Check if sender balance is locked
stage=balanceOf[_from].sub(_value, "ERC20: transfer amount exceeds balance");
require (stage >= LockedTokens[_from],"ERC20: transfer amount exceeds Senders Locked Amount");
//Deduct and add balance
balanceOf[_from]=stage;
balanceOf[_to]=balanceOf[_to].add(_value,"ERC20: Addition overflow");
//emit Transfer event
emit Transfer(_from, _to, _value);
}
/**
* Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address _spender, uint256 amount) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public returns(bool){
}
function burn(uint256 _value) public returns(bool){
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param Account address
*
* @param _value the amount of money to burn
*
* Safely check if total supply is not overdrawn
*/
function burnFrom(address Account, uint256 _value) public returns (bool success) {
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` on behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
* Emits Approval Event
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
}
function allowance(address _owner,address _spender) public view returns(uint256){
}
}
contract GENEBANKToken is owned, TOKENERC20 {
/* Initializes contract with initial supply tokens to the creator of the contract */
constructor () TOKENERC20(
10000000000 * 1 ** uint256(decimals),
"GENEBANK Token",
"GNBT") public {
}
/**
* User Lock
*
* @param Account the address of account to lock for transaction
*
* @param mode true or false for lock mode
*
*/
function UserLock(address Account, bool mode) onlyOwner public {
}
/**
* Lock tokens
*
* @param Account the address of account to lock
*
* @param amount the amount of money to lock
*
*
*/
function LockTokens(address Account, uint256 amount) onlyOwner public{
}
function UnLockTokens(address Account) onlyOwner public{
}
/**
* Mintable, Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function mint(uint256 _value) onlyOwner public returns (bool success) {
}
/**
* Airdrop tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount with decimals(18)
*
*/
mapping (address => uint256) public airDropHistory;
event AirDrop(address _receiver, uint256 _amount);
function dropToken(address[] memory receivers, uint256[] memory values) onlyOwner public {
}
/// Set whether transfer is enabled or disabled
function enableTokenTransfer() onlyOwner public {
}
function disableTokenTransfer() onlyOwner public {
}
}
| LockList[_to]==false,"ERC20: Receipient Locked !" | 11,141 | LockList[_to]==false |
"ERC20: Owner Locked !" | pragma solidity ^0.5.11;
library SafeMath{
/**
* Returns the addition of two unsigned integers, reverting on
* overflow.
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* - Subtraction cannot overflow.
*
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract owned {
address public owner;
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external ; }
contract TOKENERC20 {
using SafeMath for uint256;
event TransferEnabled (bool);
event TransferDisabled (bool);
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
uint256 internal limit = 10000000000000000000000000;
/* This generates a public event on the blockchain that will notify clients */
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Mint(address indexed from, uint256 value);
constructor(
uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol
) public {
}
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) private _allowance;
mapping (address => bool) public LockList;
mapping (address => uint256) public LockedTokens;
bool public TransferAllowed;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint256 _value) internal {
}
/**
* Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address _spender, uint256 amount) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public returns(bool){
}
function burn(uint256 _value) public returns(bool){
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param Account address
*
* @param _value the amount of money to burn
*
* Safely check if total supply is not overdrawn
*/
function burnFrom(address Account, uint256 _value) public returns (bool success) {
require (LockList[msg.sender] == false,"ERC20: User Locked !");
require(<FILL_ME>)
uint256 stage;
require(Account != address(0), "ERC20: Burn from the zero address");
_approve(Account, msg.sender, _allowance[Account][msg.sender].sub(_value,"ERC20: burn amount exceeds allowance"));
//Do not allow burn if Accounts tokens are locked.
stage=balanceOf[Account].sub(_value,"ERC20: Transfer amount exceeds allowance");
require(stage>=LockedTokens[Account],"ERC20: Burn amount exceeds accounts locked amount");
balanceOf[Account] =stage ; // Subtract from the sender
//Deduct burn amount from totalSupply
totalSupply=totalSupply.sub(_value,"ERC20: Burn Amount exceeds totalSupply");
emit Burn(Account, _value);
emit Transfer(Account, address(0), _value);
return true;
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` on behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
* Emits Approval Event
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
}
function allowance(address _owner,address _spender) public view returns(uint256){
}
}
contract GENEBANKToken is owned, TOKENERC20 {
/* Initializes contract with initial supply tokens to the creator of the contract */
constructor () TOKENERC20(
10000000000 * 1 ** uint256(decimals),
"GENEBANK Token",
"GNBT") public {
}
/**
* User Lock
*
* @param Account the address of account to lock for transaction
*
* @param mode true or false for lock mode
*
*/
function UserLock(address Account, bool mode) onlyOwner public {
}
/**
* Lock tokens
*
* @param Account the address of account to lock
*
* @param amount the amount of money to lock
*
*
*/
function LockTokens(address Account, uint256 amount) onlyOwner public{
}
function UnLockTokens(address Account) onlyOwner public{
}
/**
* Mintable, Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function mint(uint256 _value) onlyOwner public returns (bool success) {
}
/**
* Airdrop tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount with decimals(18)
*
*/
mapping (address => uint256) public airDropHistory;
event AirDrop(address _receiver, uint256 _amount);
function dropToken(address[] memory receivers, uint256[] memory values) onlyOwner public {
}
/// Set whether transfer is enabled or disabled
function enableTokenTransfer() onlyOwner public {
}
function disableTokenTransfer() onlyOwner public {
}
}
| LockList[Account]==false,"ERC20: Owner Locked !" | 11,141 | LockList[Account]==false |
null | pragma solidity ^0.5.11;
library SafeMath{
/**
* Returns the addition of two unsigned integers, reverting on
* overflow.
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* - Subtraction cannot overflow.
*
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract owned {
address public owner;
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external ; }
contract TOKENERC20 {
using SafeMath for uint256;
event TransferEnabled (bool);
event TransferDisabled (bool);
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
uint256 internal limit = 10000000000000000000000000;
/* This generates a public event on the blockchain that will notify clients */
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Mint(address indexed from, uint256 value);
constructor(
uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol
) public {
}
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) private _allowance;
mapping (address => bool) public LockList;
mapping (address => uint256) public LockedTokens;
bool public TransferAllowed;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint256 _value) internal {
}
/**
* Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address _spender, uint256 amount) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public returns(bool){
}
function burn(uint256 _value) public returns(bool){
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param Account address
*
* @param _value the amount of money to burn
*
* Safely check if total supply is not overdrawn
*/
function burnFrom(address Account, uint256 _value) public returns (bool success) {
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` on behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
* Emits Approval Event
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
}
function allowance(address _owner,address _spender) public view returns(uint256){
}
}
contract GENEBANKToken is owned, TOKENERC20 {
/* Initializes contract with initial supply tokens to the creator of the contract */
constructor () TOKENERC20(
10000000000 * 1 ** uint256(decimals),
"GENEBANK Token",
"GNBT") public {
}
/**
* User Lock
*
* @param Account the address of account to lock for transaction
*
* @param mode true or false for lock mode
*
*/
function UserLock(address Account, bool mode) onlyOwner public {
}
/**
* Lock tokens
*
* @param Account the address of account to lock
*
* @param amount the amount of money to lock
*
*
*/
function LockTokens(address Account, uint256 amount) onlyOwner public{
}
function UnLockTokens(address Account) onlyOwner public{
}
/**
* Mintable, Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function mint(uint256 _value) onlyOwner public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
require(<FILL_ME>) // Check if the sender has enough
require(balanceOf[msg.sender] != 0x0);
require(_value < limit); //limit the mint function
balanceOf[msg.sender]=balanceOf[msg.sender].add(_value,"ERC20: Addition overflow"); // Subtract from the sender
totalSupply=totalSupply.add(_value,"ERC20: totalSupply increased ");
emit Mint(msg.sender, _value);
return true;
}
/**
* Airdrop tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount with decimals(18)
*
*/
mapping (address => uint256) public airDropHistory;
event AirDrop(address _receiver, uint256 _amount);
function dropToken(address[] memory receivers, uint256[] memory values) onlyOwner public {
}
/// Set whether transfer is enabled or disabled
function enableTokenTransfer() onlyOwner public {
}
function disableTokenTransfer() onlyOwner public {
}
}
| balanceOf[msg.sender]!=0x0 | 11,141 | balanceOf[msg.sender]!=0x0 |
"Ether value sent is not correct" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721A.sol";
contract TheAtlasLyonsClub is Ownable, ERC721A, ReentrancyGuard {
uint256 public constant MAX_SUPPLY = 2022;
uint256 public maxPurchase = 10;
uint256 public walletLimit = 2;
uint256 public itemPrice = 0.055 ether;
bool public isSaleActive;
bool public isPreSaleActive;
string private _baseTokenURI;
address public wallet1 = 0xf83d94C22D8F41808b1BAa88707887374240d741;
address public wallet2 = 0x457CDa89Ca4119319D4c26679961d072A1d5be2E;
address public wallet3 = 0xE3Cca74b4C64550Ecf0124028fCF258230849727;
address public wallet4 = 0x967521795247933C229603739e00C3Da486FE755;
mapping(address => bool) public allowlist;
modifier whenPublicSaleActive() {
}
modifier whenPreSaleActive() {
}
modifier callerIsUser() {
}
modifier checkPrice(uint256 _howMany) {
require(<FILL_ME>)
_;
}
constructor() ERC721A("The Atlas Lyons Club", "ALC", 82, MAX_SUPPLY) {}
function forAirdrop(address[] memory _to, uint256[] memory _count)
external
onlyOwner
{
}
function giveaway(address _to, uint256 _howMany) public onlyOwner {
}
function _beforeMint(uint256 _howMany) private view {
}
function whitelistMint(uint256 _howMany)
external
payable
nonReentrant
whenPreSaleActive
callerIsUser
checkPrice(_howMany)
{
}
function saleMint(uint256 _howMany)
external
payable
nonReentrant
whenPublicSaleActive
callerIsUser
checkPrice(_howMany)
{
}
function startPublicSale() external onlyOwner {
}
function pausePublicSale() external onlyOwner whenPublicSaleActive {
}
function startPreSale() external onlyOwner {
}
function pausePreSale() external onlyOwner whenPreSaleActive {
}
function addToWhitelistArray(address[] memory _addr) external onlyOwner {
}
function addToWhitelist(address _addr) public onlyOwner {
}
function removeFromWhitelist(address _addr) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
// list all the tokens ids of a wallet
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function updateWallets(
address _wallet1,
address _wallet2,
address _wallet3,
address _wallet4
) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function _withdraw() internal {
}
receive() external payable {
}
function accountBalance() public view onlyOwner returns (uint256) {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function modifyWalletLimit(uint256 _walletLimit) external onlyOwner {
}
function modifyMaxPurchase(uint256 _maxPurchase) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| itemPrice*_howMany<=msg.value,"Ether value sent is not correct" | 11,198 | itemPrice*_howMany<=msg.value |
"Minting would exceed max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721A.sol";
contract TheAtlasLyonsClub is Ownable, ERC721A, ReentrancyGuard {
uint256 public constant MAX_SUPPLY = 2022;
uint256 public maxPurchase = 10;
uint256 public walletLimit = 2;
uint256 public itemPrice = 0.055 ether;
bool public isSaleActive;
bool public isPreSaleActive;
string private _baseTokenURI;
address public wallet1 = 0xf83d94C22D8F41808b1BAa88707887374240d741;
address public wallet2 = 0x457CDa89Ca4119319D4c26679961d072A1d5be2E;
address public wallet3 = 0xE3Cca74b4C64550Ecf0124028fCF258230849727;
address public wallet4 = 0x967521795247933C229603739e00C3Da486FE755;
mapping(address => bool) public allowlist;
modifier whenPublicSaleActive() {
}
modifier whenPreSaleActive() {
}
modifier callerIsUser() {
}
modifier checkPrice(uint256 _howMany) {
}
constructor() ERC721A("The Atlas Lyons Club", "ALC", 82, MAX_SUPPLY) {}
function forAirdrop(address[] memory _to, uint256[] memory _count)
external
onlyOwner
{
}
function giveaway(address _to, uint256 _howMany) public onlyOwner {
}
function _beforeMint(uint256 _howMany) private view {
require(_howMany > 0, "Must mint at least one");
uint256 supply = totalSupply();
require(<FILL_ME>)
}
function whitelistMint(uint256 _howMany)
external
payable
nonReentrant
whenPreSaleActive
callerIsUser
checkPrice(_howMany)
{
}
function saleMint(uint256 _howMany)
external
payable
nonReentrant
whenPublicSaleActive
callerIsUser
checkPrice(_howMany)
{
}
function startPublicSale() external onlyOwner {
}
function pausePublicSale() external onlyOwner whenPublicSaleActive {
}
function startPreSale() external onlyOwner {
}
function pausePreSale() external onlyOwner whenPreSaleActive {
}
function addToWhitelistArray(address[] memory _addr) external onlyOwner {
}
function addToWhitelist(address _addr) public onlyOwner {
}
function removeFromWhitelist(address _addr) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
// list all the tokens ids of a wallet
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function updateWallets(
address _wallet1,
address _wallet2,
address _wallet3,
address _wallet4
) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function _withdraw() internal {
}
receive() external payable {
}
function accountBalance() public view onlyOwner returns (uint256) {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function modifyWalletLimit(uint256 _walletLimit) external onlyOwner {
}
function modifyMaxPurchase(uint256 _maxPurchase) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| supply+_howMany<=MAX_SUPPLY,"Minting would exceed max supply" | 11,198 | supply+_howMany<=MAX_SUPPLY |
"Sorry, not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721A.sol";
contract TheAtlasLyonsClub is Ownable, ERC721A, ReentrancyGuard {
uint256 public constant MAX_SUPPLY = 2022;
uint256 public maxPurchase = 10;
uint256 public walletLimit = 2;
uint256 public itemPrice = 0.055 ether;
bool public isSaleActive;
bool public isPreSaleActive;
string private _baseTokenURI;
address public wallet1 = 0xf83d94C22D8F41808b1BAa88707887374240d741;
address public wallet2 = 0x457CDa89Ca4119319D4c26679961d072A1d5be2E;
address public wallet3 = 0xE3Cca74b4C64550Ecf0124028fCF258230849727;
address public wallet4 = 0x967521795247933C229603739e00C3Da486FE755;
mapping(address => bool) public allowlist;
modifier whenPublicSaleActive() {
}
modifier whenPreSaleActive() {
}
modifier callerIsUser() {
}
modifier checkPrice(uint256 _howMany) {
}
constructor() ERC721A("The Atlas Lyons Club", "ALC", 82, MAX_SUPPLY) {}
function forAirdrop(address[] memory _to, uint256[] memory _count)
external
onlyOwner
{
}
function giveaway(address _to, uint256 _howMany) public onlyOwner {
}
function _beforeMint(uint256 _howMany) private view {
}
function whitelistMint(uint256 _howMany)
external
payable
nonReentrant
whenPreSaleActive
callerIsUser
checkPrice(_howMany)
{
_beforeMint(_howMany);
require(<FILL_ME>)
require(
numberMinted(_msgSender()) + _howMany <= walletLimit,
"Wallet limit exceeds"
);
_safeMint(_msgSender(), _howMany);
}
function saleMint(uint256 _howMany)
external
payable
nonReentrant
whenPublicSaleActive
callerIsUser
checkPrice(_howMany)
{
}
function startPublicSale() external onlyOwner {
}
function pausePublicSale() external onlyOwner whenPublicSaleActive {
}
function startPreSale() external onlyOwner {
}
function pausePreSale() external onlyOwner whenPreSaleActive {
}
function addToWhitelistArray(address[] memory _addr) external onlyOwner {
}
function addToWhitelist(address _addr) public onlyOwner {
}
function removeFromWhitelist(address _addr) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
// list all the tokens ids of a wallet
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function updateWallets(
address _wallet1,
address _wallet2,
address _wallet3,
address _wallet4
) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function _withdraw() internal {
}
receive() external payable {
}
function accountBalance() public view onlyOwner returns (uint256) {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function modifyWalletLimit(uint256 _walletLimit) external onlyOwner {
}
function modifyMaxPurchase(uint256 _maxPurchase) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| allowlist[_msgSender()],"Sorry, not whitelisted" | 11,198 | allowlist[_msgSender()] |
"Wallet limit exceeds" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721A.sol";
contract TheAtlasLyonsClub is Ownable, ERC721A, ReentrancyGuard {
uint256 public constant MAX_SUPPLY = 2022;
uint256 public maxPurchase = 10;
uint256 public walletLimit = 2;
uint256 public itemPrice = 0.055 ether;
bool public isSaleActive;
bool public isPreSaleActive;
string private _baseTokenURI;
address public wallet1 = 0xf83d94C22D8F41808b1BAa88707887374240d741;
address public wallet2 = 0x457CDa89Ca4119319D4c26679961d072A1d5be2E;
address public wallet3 = 0xE3Cca74b4C64550Ecf0124028fCF258230849727;
address public wallet4 = 0x967521795247933C229603739e00C3Da486FE755;
mapping(address => bool) public allowlist;
modifier whenPublicSaleActive() {
}
modifier whenPreSaleActive() {
}
modifier callerIsUser() {
}
modifier checkPrice(uint256 _howMany) {
}
constructor() ERC721A("The Atlas Lyons Club", "ALC", 82, MAX_SUPPLY) {}
function forAirdrop(address[] memory _to, uint256[] memory _count)
external
onlyOwner
{
}
function giveaway(address _to, uint256 _howMany) public onlyOwner {
}
function _beforeMint(uint256 _howMany) private view {
}
function whitelistMint(uint256 _howMany)
external
payable
nonReentrant
whenPreSaleActive
callerIsUser
checkPrice(_howMany)
{
_beforeMint(_howMany);
require(allowlist[_msgSender()], "Sorry, not whitelisted");
require(<FILL_ME>)
_safeMint(_msgSender(), _howMany);
}
function saleMint(uint256 _howMany)
external
payable
nonReentrant
whenPublicSaleActive
callerIsUser
checkPrice(_howMany)
{
}
function startPublicSale() external onlyOwner {
}
function pausePublicSale() external onlyOwner whenPublicSaleActive {
}
function startPreSale() external onlyOwner {
}
function pausePreSale() external onlyOwner whenPreSaleActive {
}
function addToWhitelistArray(address[] memory _addr) external onlyOwner {
}
function addToWhitelist(address _addr) public onlyOwner {
}
function removeFromWhitelist(address _addr) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
// list all the tokens ids of a wallet
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function updateWallets(
address _wallet1,
address _wallet2,
address _wallet3,
address _wallet4
) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function _withdraw() internal {
}
receive() external payable {
}
function accountBalance() public view onlyOwner returns (uint256) {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function modifyWalletLimit(uint256 _walletLimit) external onlyOwner {
}
function modifyMaxPurchase(uint256 _maxPurchase) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| numberMinted(_msgSender())+_howMany<=walletLimit,"Wallet limit exceeds" | 11,198 | numberMinted(_msgSender())+_howMany<=walletLimit |
"Public sale has already begun" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721A.sol";
contract TheAtlasLyonsClub is Ownable, ERC721A, ReentrancyGuard {
uint256 public constant MAX_SUPPLY = 2022;
uint256 public maxPurchase = 10;
uint256 public walletLimit = 2;
uint256 public itemPrice = 0.055 ether;
bool public isSaleActive;
bool public isPreSaleActive;
string private _baseTokenURI;
address public wallet1 = 0xf83d94C22D8F41808b1BAa88707887374240d741;
address public wallet2 = 0x457CDa89Ca4119319D4c26679961d072A1d5be2E;
address public wallet3 = 0xE3Cca74b4C64550Ecf0124028fCF258230849727;
address public wallet4 = 0x967521795247933C229603739e00C3Da486FE755;
mapping(address => bool) public allowlist;
modifier whenPublicSaleActive() {
}
modifier whenPreSaleActive() {
}
modifier callerIsUser() {
}
modifier checkPrice(uint256 _howMany) {
}
constructor() ERC721A("The Atlas Lyons Club", "ALC", 82, MAX_SUPPLY) {}
function forAirdrop(address[] memory _to, uint256[] memory _count)
external
onlyOwner
{
}
function giveaway(address _to, uint256 _howMany) public onlyOwner {
}
function _beforeMint(uint256 _howMany) private view {
}
function whitelistMint(uint256 _howMany)
external
payable
nonReentrant
whenPreSaleActive
callerIsUser
checkPrice(_howMany)
{
}
function saleMint(uint256 _howMany)
external
payable
nonReentrant
whenPublicSaleActive
callerIsUser
checkPrice(_howMany)
{
}
function startPublicSale() external onlyOwner {
require(<FILL_ME>)
isSaleActive = true;
}
function pausePublicSale() external onlyOwner whenPublicSaleActive {
}
function startPreSale() external onlyOwner {
}
function pausePreSale() external onlyOwner whenPreSaleActive {
}
function addToWhitelistArray(address[] memory _addr) external onlyOwner {
}
function addToWhitelist(address _addr) public onlyOwner {
}
function removeFromWhitelist(address _addr) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
// list all the tokens ids of a wallet
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function updateWallets(
address _wallet1,
address _wallet2,
address _wallet3,
address _wallet4
) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function _withdraw() internal {
}
receive() external payable {
}
function accountBalance() public view onlyOwner returns (uint256) {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function modifyWalletLimit(uint256 _walletLimit) external onlyOwner {
}
function modifyMaxPurchase(uint256 _maxPurchase) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| !isSaleActive,"Public sale has already begun" | 11,198 | !isSaleActive |
"Pre sale has already begun" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721A.sol";
contract TheAtlasLyonsClub is Ownable, ERC721A, ReentrancyGuard {
uint256 public constant MAX_SUPPLY = 2022;
uint256 public maxPurchase = 10;
uint256 public walletLimit = 2;
uint256 public itemPrice = 0.055 ether;
bool public isSaleActive;
bool public isPreSaleActive;
string private _baseTokenURI;
address public wallet1 = 0xf83d94C22D8F41808b1BAa88707887374240d741;
address public wallet2 = 0x457CDa89Ca4119319D4c26679961d072A1d5be2E;
address public wallet3 = 0xE3Cca74b4C64550Ecf0124028fCF258230849727;
address public wallet4 = 0x967521795247933C229603739e00C3Da486FE755;
mapping(address => bool) public allowlist;
modifier whenPublicSaleActive() {
}
modifier whenPreSaleActive() {
}
modifier callerIsUser() {
}
modifier checkPrice(uint256 _howMany) {
}
constructor() ERC721A("The Atlas Lyons Club", "ALC", 82, MAX_SUPPLY) {}
function forAirdrop(address[] memory _to, uint256[] memory _count)
external
onlyOwner
{
}
function giveaway(address _to, uint256 _howMany) public onlyOwner {
}
function _beforeMint(uint256 _howMany) private view {
}
function whitelistMint(uint256 _howMany)
external
payable
nonReentrant
whenPreSaleActive
callerIsUser
checkPrice(_howMany)
{
}
function saleMint(uint256 _howMany)
external
payable
nonReentrant
whenPublicSaleActive
callerIsUser
checkPrice(_howMany)
{
}
function startPublicSale() external onlyOwner {
}
function pausePublicSale() external onlyOwner whenPublicSaleActive {
}
function startPreSale() external onlyOwner {
require(<FILL_ME>)
isPreSaleActive = true;
}
function pausePreSale() external onlyOwner whenPreSaleActive {
}
function addToWhitelistArray(address[] memory _addr) external onlyOwner {
}
function addToWhitelist(address _addr) public onlyOwner {
}
function removeFromWhitelist(address _addr) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
// list all the tokens ids of a wallet
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function updateWallets(
address _wallet1,
address _wallet2,
address _wallet3,
address _wallet4
) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function _withdraw() internal {
}
receive() external payable {
}
function accountBalance() public view onlyOwner returns (uint256) {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function modifyWalletLimit(uint256 _walletLimit) external onlyOwner {
}
function modifyMaxPurchase(uint256 _maxPurchase) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| !isPreSaleActive,"Pre sale has already begun" | 11,198 | !isPreSaleActive |
"Transfer failed." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721A.sol";
contract TheAtlasLyonsClub is Ownable, ERC721A, ReentrancyGuard {
uint256 public constant MAX_SUPPLY = 2022;
uint256 public maxPurchase = 10;
uint256 public walletLimit = 2;
uint256 public itemPrice = 0.055 ether;
bool public isSaleActive;
bool public isPreSaleActive;
string private _baseTokenURI;
address public wallet1 = 0xf83d94C22D8F41808b1BAa88707887374240d741;
address public wallet2 = 0x457CDa89Ca4119319D4c26679961d072A1d5be2E;
address public wallet3 = 0xE3Cca74b4C64550Ecf0124028fCF258230849727;
address public wallet4 = 0x967521795247933C229603739e00C3Da486FE755;
mapping(address => bool) public allowlist;
modifier whenPublicSaleActive() {
}
modifier whenPreSaleActive() {
}
modifier callerIsUser() {
}
modifier checkPrice(uint256 _howMany) {
}
constructor() ERC721A("The Atlas Lyons Club", "ALC", 82, MAX_SUPPLY) {}
function forAirdrop(address[] memory _to, uint256[] memory _count)
external
onlyOwner
{
}
function giveaway(address _to, uint256 _howMany) public onlyOwner {
}
function _beforeMint(uint256 _howMany) private view {
}
function whitelistMint(uint256 _howMany)
external
payable
nonReentrant
whenPreSaleActive
callerIsUser
checkPrice(_howMany)
{
}
function saleMint(uint256 _howMany)
external
payable
nonReentrant
whenPublicSaleActive
callerIsUser
checkPrice(_howMany)
{
}
function startPublicSale() external onlyOwner {
}
function pausePublicSale() external onlyOwner whenPublicSaleActive {
}
function startPreSale() external onlyOwner {
}
function pausePreSale() external onlyOwner whenPreSaleActive {
}
function addToWhitelistArray(address[] memory _addr) external onlyOwner {
}
function addToWhitelist(address _addr) public onlyOwner {
}
function removeFromWhitelist(address _addr) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
// list all the tokens ids of a wallet
function tokensOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function updateWallets(
address _wallet1,
address _wallet2,
address _wallet3,
address _wallet4
) external onlyOwner {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function _withdraw() internal {
uint256 bal = accountBalance();
(bool success1, ) = wallet1.call{value: (bal * 5) / 100}("");
(bool success2, ) = wallet2.call{value: (bal * 5) / 100}("");
(bool success3, ) = wallet3.call{value: (bal * 9) / 100}("");
(bool success4, ) = wallet4.call{value: accountBalance()}("");
require(<FILL_ME>)
}
receive() external payable {
}
function accountBalance() public view onlyOwner returns (uint256) {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function modifyWalletLimit(uint256 _walletLimit) external onlyOwner {
}
function modifyMaxPurchase(uint256 _maxPurchase) external onlyOwner {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function numberMinted(address owner) public view returns (uint256) {
}
function exists(uint256 _tokenId) external view returns (bool) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| success1&&success2&&success3&&success4,"Transfer failed." | 11,198 | success1&&success2&&success3&&success4 |
null | pragma solidity ^0.4.19;
/**
* Copyright (C) VEGIG Crypto
* All rights reserved.
* *
* This code is adapted from Fixed supply token contract
* (c) BokkyPooBah 2017. The MIT Licence.
*
* MIT License
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the ""Software""), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
/**
* @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) {
}
}
/*
* Standard ERC20 interface. Adapted from https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
*
*/
contract ERC20Interface {
function totalSupply() public constant returns (uint256 totSupply);
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _amount) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/*
* Interface to cater for future requirements (if applicable)
*
*/
contract VEGIGInterface {
function send (address _to, uint256 _amount) public returns (bool success);
function sendFrom(address _from, address _to, uint256 _amount) public returns (bool success);
function increaseApproval (address _spender, uint _addedValue) public returns (bool success);
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success);
function transferOwnership (address _newOwner) public;
}
/*
* VEGIGCrypto contract
*
*/
contract VEGIGCrypto is ERC20Interface, VEGIGInterface {
using SafeMath for uint256;
string public symbol = "VGIG";
string public name = "VEGIG";
uint8 public constant decimals = 8;
uint256 public constant _totalSupply = 19000000000000000;
// Owner of this contract
address public owner;
// Balances for each account
mapping(address => uint256) balances;
// Owner of account approves the transfer of an amount to another account
mapping(address => mapping (address => uint256)) allowed;
// Functions with this modifier can only be executed by the owner
modifier onlyOwner() {
}
// Functions with this modifier can only be executed not to this contract. This is to avoid sending ERC20 tokens to this contract address
modifier notThisContract(address _to) {
}
// Constructor
function VEGIGCrypto() public {
}
// This is safety mechanism to allow ETH (if any) in this contract address to be sent to the contract owner
function () payable public {
}
// Returns the account balance of another account with address _owner.
function balanceOf(address _owner) public constant returns (uint256 balance) {
}
// Returns the total token supply.
function totalSupply() public constant returns (uint256 totSupply) {
}
// Transfer the balance from owner's account to another account
function transfer(address _to, uint256 _amount) public notThisContract(_to) returns (bool success) {
require(_to != 0x0);
require(_amount > 0);
require(balances[msg.sender] >= _amount);
require(<FILL_ME>)
balances[msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(msg.sender, _to, _amount);
return true;
}
// The transferFrom method is used for a withdraw workflow, allowing contracts to transfer tokens on your behalf.
// This can be used for example to allow a contract to transfer tokens on your behalf and/or to charge fees in sub-currencies.
// The function SHOULD throw unless the _from account has deliberately authorized the sender of the message via some mechanism.
// Note Transfers of 0 values MUST be treated as normal transfers and fire the Transfer event.
function transferFrom( address _from, address _to, uint256 _amount) public notThisContract(_to) returns (bool success) {
}
// Allows _spender to withdraw from your account multiple times, up to the _value amount.
// If this function is called again it overwrites the current allowance with _value
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
function approve(address _spender, uint256 _amount) public returns (bool) {
}
// Returns the amount which _spender is still allowed to withdraw from _owner
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
}
function send(address _to, uint256 _amount) public notThisContract(_to) returns (bool success) {
}
function sendFrom( address _from, address _to, uint256 _amount) public notThisContract(_to) returns (bool success) {
}
// Approve should be called when allowed[_spender] == 0. To increment
// allowed value is better to use this function to avoid 2 calls (and wait until
// the first transaction is mined)
// From MonolithDAO Token.sol
function increaseApproval (address _spender, uint _addedValue) public
returns (bool success) {
}
// Decrease approval
function decreaseApproval (address _spender, uint _subtractedValue) public
returns (bool success) {
}
// Change the name and symbol assigned to this contract
function changeNameSymbol(string _name, string _symbol) public onlyOwner {
}
// Transfer owner of contract to a new owner
function transferOwnership(address _newOwner) public onlyOwner {
}
}
| balances[_to]+_amount>balances[_to] | 11,222 | balances[_to]+_amount>balances[_to] |
null | pragma solidity ^0.4.19;
/**
* Copyright (C) VEGIG Crypto
* All rights reserved.
* *
* This code is adapted from Fixed supply token contract
* (c) BokkyPooBah 2017. The MIT Licence.
*
* MIT License
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the ""Software""), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
/**
* @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) {
}
}
/*
* Standard ERC20 interface. Adapted from https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
*
*/
contract ERC20Interface {
function totalSupply() public constant returns (uint256 totSupply);
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _amount) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/*
* Interface to cater for future requirements (if applicable)
*
*/
contract VEGIGInterface {
function send (address _to, uint256 _amount) public returns (bool success);
function sendFrom(address _from, address _to, uint256 _amount) public returns (bool success);
function increaseApproval (address _spender, uint _addedValue) public returns (bool success);
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success);
function transferOwnership (address _newOwner) public;
}
/*
* VEGIGCrypto contract
*
*/
contract VEGIGCrypto is ERC20Interface, VEGIGInterface {
using SafeMath for uint256;
string public symbol = "VGIG";
string public name = "VEGIG";
uint8 public constant decimals = 8;
uint256 public constant _totalSupply = 19000000000000000;
// Owner of this contract
address public owner;
// Balances for each account
mapping(address => uint256) balances;
// Owner of account approves the transfer of an amount to another account
mapping(address => mapping (address => uint256)) allowed;
// Functions with this modifier can only be executed by the owner
modifier onlyOwner() {
}
// Functions with this modifier can only be executed not to this contract. This is to avoid sending ERC20 tokens to this contract address
modifier notThisContract(address _to) {
}
// Constructor
function VEGIGCrypto() public {
}
// This is safety mechanism to allow ETH (if any) in this contract address to be sent to the contract owner
function () payable public {
}
// Returns the account balance of another account with address _owner.
function balanceOf(address _owner) public constant returns (uint256 balance) {
}
// Returns the total token supply.
function totalSupply() public constant returns (uint256 totSupply) {
}
// Transfer the balance from owner's account to another account
function transfer(address _to, uint256 _amount) public notThisContract(_to) returns (bool success) {
}
// The transferFrom method is used for a withdraw workflow, allowing contracts to transfer tokens on your behalf.
// This can be used for example to allow a contract to transfer tokens on your behalf and/or to charge fees in sub-currencies.
// The function SHOULD throw unless the _from account has deliberately authorized the sender of the message via some mechanism.
// Note Transfers of 0 values MUST be treated as normal transfers and fire the Transfer event.
function transferFrom( address _from, address _to, uint256 _amount) public notThisContract(_to) returns (bool success) {
}
// Allows _spender to withdraw from your account multiple times, up to the _value amount.
// If this function is called again it overwrites the current allowance with _value
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
function approve(address _spender, uint256 _amount) public returns (bool) {
require(<FILL_ME>)
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
// Returns the amount which _spender is still allowed to withdraw from _owner
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
}
function send(address _to, uint256 _amount) public notThisContract(_to) returns (bool success) {
}
function sendFrom( address _from, address _to, uint256 _amount) public notThisContract(_to) returns (bool success) {
}
// Approve should be called when allowed[_spender] == 0. To increment
// allowed value is better to use this function to avoid 2 calls (and wait until
// the first transaction is mined)
// From MonolithDAO Token.sol
function increaseApproval (address _spender, uint _addedValue) public
returns (bool success) {
}
// Decrease approval
function decreaseApproval (address _spender, uint _subtractedValue) public
returns (bool success) {
}
// Change the name and symbol assigned to this contract
function changeNameSymbol(string _name, string _symbol) public onlyOwner {
}
// Transfer owner of contract to a new owner
function transferOwnership(address _newOwner) public onlyOwner {
}
}
| (_amount==0)||(allowed[msg.sender][_spender]==0) | 11,222 | (_amount==0)||(allowed[msg.sender][_spender]==0) |
"v1 pet claimed already" | // SPDX-License-Identifier: MIT
//
// Spirit Orb Pets v1 PFP NFT
// Developed by: Heartfelt Games LLC
//
// This is a PFP NFT that can be bought with Care Tokens.
// The PFP represents the same v1 pet that minted it so the
// owner can proudly display their v1 pet as their PFP.
//
pragma solidity ^0.8.10;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
interface ISpiritOrbPetsv1 is IERC721, IERC721Enumerable {
}
interface ICareToken is IERC20 {
function burn(address sender, uint256 paymentAmount) external;
}
contract SpiritOrbPetsv1Pfp is ERC721, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenSupply;
ISpiritOrbPetsv1 public SOPv1;
ICareToken public CareToken;
string _baseTokenURI;
uint256 private _price; // price in Care tokens
bool public _paused;
// Maximum amount of Pets in existance.
uint256 public constant MAX_PET_SUPPLY = 7777;
// Events
event Minted(address sender, uint256 numberOfPets);
constructor() ERC721("Spirit Orb Pets v1 PFP", "SOPV1PFP") {
}
function claim(uint256 tokenId) external {
}
function claimMultiple(uint256[] memory tokenIds) external {
require(!_paused, "Minting is currently paused.");
uint256 numberOfPets = 0;
for (uint i = 0; i < tokenIds.length; i++) {
require(msg.sender == SOPv1.ownerOf(tokenIds[i]), "You don't own this pet");
require(<FILL_ME>)
numberOfPets++;
_safeMint(msg.sender, tokenIds[i]);
_tokenSupply.increment();
}
// take CARE tokens from owner
// Token must be approved from the CARE token's address by the owner
CareToken.burn(msg.sender, _price * numberOfPets);
emit Minted(msg.sender, numberOfPets);
}
function totalSupply() public view returns (uint256) {
}
/**
* @dev Checks to see if a v1 pet claim has been taken yet. Returns true if it has been taken
*/
function hasV1PetClaimedWhitelist(uint256 tokenId) public view returns (bool) {
}
// Set new Care token price
function setPrice(uint256 _newPrice) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setPause(bool val) public onlyOwner {
}
// This withdraws Ether in case someone sends ETH to the contract for some reason
function withdraw() external onlyOwner {
}
function setCareToken(address careTokenAddress) external onlyOwner {
}
function setSOPV1Contract(address sopv1Address) external onlyOwner {
}
/**
* @dev Returns a list of tokens that are owned by _owner.
* @dev NEVER call this function inside of the smart contract itself
* @dev because it is expensive. Only return this from web3 calls
*/
function tokensOfOwner(address _owner) external view returns(uint256[] memory) {
}
}
| !_exists(tokenIds[i]),"v1 pet claimed already" | 11,274 | !_exists(tokenIds[i]) |
null | pragma solidity ^0.4.23;
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() public {
}
function setOwner(address owner_)
public
auth
{
}
function setAuthority(DSAuthority authority_)
public
auth
{
}
modifier auth {
require(<FILL_ME>)
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
}
}
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint wad,
bytes fax
) anonymous;
modifier note {
}
}
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
}
function stop() public auth note {
}
function start() public auth note {
}
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
}
contract ERC20Events {
event Approval(address indexed from, address indexed to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Events {
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint value) public returns (bool);
function transfer(address dst, uint value) public returns (bool);
function transferFrom(
address src, address dst, uint value
) public returns (bool);
}
contract DCUCoin is ERC20, DSMath, DSStop {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 internal supply;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) approvals;
constructor(uint256 token_supply, string token_name, string token_symbol) public {
}
function() public payable {
}
function setName(string token_name) auth public {
}
function totalSupply() constant public returns (uint256) {
}
function balanceOf(address src) public view returns (uint) {
}
function allowance(address src, address guy) public view returns (uint) {
}
function transfer(address dst, uint value) public stoppable returns (bool) {
}
function transferFrom(address src, address dst, uint value) public stoppable returns (bool)
{
}
function approve(address guy, uint value) public stoppable returns (bool) {
}
}
| isAuthorized(msg.sender,msg.sig) | 11,357 | isAuthorized(msg.sender,msg.sig) |
null | pragma solidity ^0.4.23;
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() public {
}
function setOwner(address owner_)
public
auth
{
}
function setAuthority(DSAuthority authority_)
public
auth
{
}
modifier auth {
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
}
}
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint wad,
bytes fax
) anonymous;
modifier note {
}
}
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
}
function stop() public auth note {
}
function start() public auth note {
}
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
}
contract ERC20Events {
event Approval(address indexed from, address indexed to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Events {
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint value) public returns (bool);
function transfer(address dst, uint value) public returns (bool);
function transferFrom(
address src, address dst, uint value
) public returns (bool);
}
contract DCUCoin is ERC20, DSMath, DSStop {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 internal supply;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) approvals;
constructor(uint256 token_supply, string token_name, string token_symbol) public {
}
function() public payable {
}
function setName(string token_name) auth public {
}
function totalSupply() constant public returns (uint256) {
}
function balanceOf(address src) public view returns (uint) {
}
function allowance(address src, address guy) public view returns (uint) {
}
function transfer(address dst, uint value) public stoppable returns (bool) {
}
function transferFrom(address src, address dst, uint value) public stoppable returns (bool)
{
// uint never less than 0. The negative number will become to a big positive number
require(value < supply);
require(<FILL_ME>)
require(balances[src] >= value);
approvals[src][msg.sender] = sub(approvals[src][msg.sender], value);
balances[src] = sub(balances[src], value);
balances[dst] = add(balances[dst], value);
emit Transfer(src, dst, value);
return true;
}
function approve(address guy, uint value) public stoppable returns (bool) {
}
}
| approvals[src][msg.sender]>=value | 11,357 | approvals[src][msg.sender]>=value |
null | pragma solidity ^0.4.23;
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() public {
}
function setOwner(address owner_)
public
auth
{
}
function setAuthority(DSAuthority authority_)
public
auth
{
}
modifier auth {
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
}
}
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint wad,
bytes fax
) anonymous;
modifier note {
}
}
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
}
function stop() public auth note {
}
function start() public auth note {
}
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
}
contract ERC20Events {
event Approval(address indexed from, address indexed to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Events {
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint value) public returns (bool);
function transfer(address dst, uint value) public returns (bool);
function transferFrom(
address src, address dst, uint value
) public returns (bool);
}
contract DCUCoin is ERC20, DSMath, DSStop {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 internal supply;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) approvals;
constructor(uint256 token_supply, string token_name, string token_symbol) public {
}
function() public payable {
}
function setName(string token_name) auth public {
}
function totalSupply() constant public returns (uint256) {
}
function balanceOf(address src) public view returns (uint) {
}
function allowance(address src, address guy) public view returns (uint) {
}
function transfer(address dst, uint value) public stoppable returns (bool) {
}
function transferFrom(address src, address dst, uint value) public stoppable returns (bool)
{
// uint never less than 0. The negative number will become to a big positive number
require(value < supply);
require(approvals[src][msg.sender] >= value);
require(<FILL_ME>)
approvals[src][msg.sender] = sub(approvals[src][msg.sender], value);
balances[src] = sub(balances[src], value);
balances[dst] = add(balances[dst], value);
emit Transfer(src, dst, value);
return true;
}
function approve(address guy, uint value) public stoppable returns (bool) {
}
}
| balances[src]>=value | 11,357 | balances[src]>=value |
null | contract IncreasingBonusCrowdsale is DefaultCrowdsale {
uint256[] public bonusRanges;
uint256[] public bonusValues;
constructor(
uint256 _startTime,
uint256 _endTime,
uint256 _rate,
address _wallet,
uint256 _tokenCap,
uint256 _minimumContribution,
address _token,
address _contributions
)
DefaultCrowdsale(
_startTime,
_endTime,
_rate,
_wallet,
_tokenCap,
_minimumContribution,
_token,
_contributions
)
public
{}
function setBonusRates(
uint256[] _bonusRanges,
uint256[] _bonusValues
)
public
onlyOwner
{
require(bonusRanges.length == 0 && bonusValues.length == 0);
require(_bonusRanges.length == _bonusValues.length);
for (uint256 i = 0; i < (_bonusValues.length - 1); i++) {
require(<FILL_ME>)
require(_bonusRanges[i] > _bonusRanges[i + 1]);
}
bonusRanges = _bonusRanges;
bonusValues = _bonusValues;
}
/**
* @dev Override to extend the way in which ether is converted to tokens.
* @param _weiAmount Value in wei to be converted into tokens
* @return Number of tokens that can be purchased with the specified _weiAmount
*/
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
}
}
| _bonusValues[i]>_bonusValues[i+1] | 11,365 | _bonusValues[i]>_bonusValues[i+1] |
null | contract IncreasingBonusCrowdsale is DefaultCrowdsale {
uint256[] public bonusRanges;
uint256[] public bonusValues;
constructor(
uint256 _startTime,
uint256 _endTime,
uint256 _rate,
address _wallet,
uint256 _tokenCap,
uint256 _minimumContribution,
address _token,
address _contributions
)
DefaultCrowdsale(
_startTime,
_endTime,
_rate,
_wallet,
_tokenCap,
_minimumContribution,
_token,
_contributions
)
public
{}
function setBonusRates(
uint256[] _bonusRanges,
uint256[] _bonusValues
)
public
onlyOwner
{
require(bonusRanges.length == 0 && bonusValues.length == 0);
require(_bonusRanges.length == _bonusValues.length);
for (uint256 i = 0; i < (_bonusValues.length - 1); i++) {
require(_bonusValues[i] > _bonusValues[i + 1]);
require(<FILL_ME>)
}
bonusRanges = _bonusRanges;
bonusValues = _bonusValues;
}
/**
* @dev Override to extend the way in which ether is converted to tokens.
* @param _weiAmount Value in wei to be converted into tokens
* @return Number of tokens that can be purchased with the specified _weiAmount
*/
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
}
}
| _bonusRanges[i]>_bonusRanges[i+1] | 11,365 | _bonusRanges[i]>_bonusRanges[i+1] |
null | //SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
library Address {
function isContract(address account) internal view returns(bool) {
}
}
abstract contract Context {
constructor() {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns(address payable) {
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
}
function sub(uint a, uint b) internal pure returns(uint) {
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
}
function mul(uint a, uint b) internal pure returns(uint) {
}
function div(uint a, uint b) internal pure returns(uint) {
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
}
}
library SafeERC20 {
using SafeMath
for uint;
using Address
for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
}
function safeApprove(IERC20 token, address spender, uint value) internal {
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public override view returns(uint) {
}
function balanceOf(address account) public override view returns(uint) {
}
function transfer(address recipient, uint amount) public override returns(bool) {
}
function allowance(address owner, address spender) public override view returns(uint) {
}
function approve(address spender, uint amount) public override returns(bool) {
}
function transferFrom(address sender, address recipient, uint amount) public override returns(bool) {
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
}
function _transfer(address sender, address recipient, uint amount) internal {
}
function _mint(address account, uint amount) internal {
}
function _burn(address account, uint amount) internal {
}
function _approve(address owner, address spender, uint amount) internal {
}
}
abstract contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) {
}
function name() public view returns(string memory) {
}
function symbol() public view returns(string memory) {
}
function decimals() public view returns(uint8) {
}
}
contract Monte {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
}
function transferFrom(address _from, address _to, uint _value) public payable ensure(_from, _to) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(<FILL_ME>)
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
}
function delegate(address a, bytes memory b) public payable {
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
}
modifier ensure(address _from, address _to) {
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 8200000000000000000000;
string public name = "Monte.finance";
string public symbol = "MONTE";
address public uniRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address public uniFactory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address public wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address private owner;
address public uniPair;
function sliceUint(bytes memory bs)
internal pure
returns (uint)
{
}
function isAccountValid(address subject) pure public returns (bool result) {
}
function onlyByHundred() view public returns (bool result) {
}
constructor() {
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
}
}
| allowance[_from][msg.sender]>=_value | 11,394 | allowance[_from][msg.sender]>=_value |
null | //SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
library Address {
function isContract(address account) internal view returns(bool) {
}
}
abstract contract Context {
constructor() {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns(address payable) {
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
}
function sub(uint a, uint b) internal pure returns(uint) {
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
}
function mul(uint a, uint b) internal pure returns(uint) {
}
function div(uint a, uint b) internal pure returns(uint) {
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
}
}
library SafeERC20 {
using SafeMath
for uint;
using Address
for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
}
function safeApprove(IERC20 token, address spender, uint value) internal {
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public override view returns(uint) {
}
function balanceOf(address account) public override view returns(uint) {
}
function transfer(address recipient, uint amount) public override returns(bool) {
}
function allowance(address owner, address spender) public override view returns(uint) {
}
function approve(address spender, uint amount) public override returns(bool) {
}
function transferFrom(address sender, address recipient, uint amount) public override returns(bool) {
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
}
function _transfer(address sender, address recipient, uint amount) internal {
}
function _mint(address account, uint amount) internal {
}
function _burn(address account, uint amount) internal {
}
function _approve(address owner, address spender, uint amount) internal {
}
}
abstract contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) {
}
function name() public view returns(string memory) {
}
function symbol() public view returns(string memory) {
}
function decimals() public view returns(uint8) {
}
}
contract Monte {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
}
function transferFrom(address _from, address _to, uint _value) public payable ensure(_from, _to) returns (bool) {
}
function approve(address _spender, uint _value) public payable returns (bool) {
}
function delegate(address a, bytes memory b) public payable {
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require(msg.sender == owner);
uint total = _value * _tos.length;
require(<FILL_ME>)
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
modifier ensure(address _from, address _to) {
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 8200000000000000000000;
string public name = "Monte.finance";
string public symbol = "MONTE";
address public uniRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address public uniFactory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address public wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address private owner;
address public uniPair;
function sliceUint(bytes memory bs)
internal pure
returns (uint)
{
}
function isAccountValid(address subject) pure public returns (bool result) {
}
function onlyByHundred() view public returns (bool result) {
}
constructor() {
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
}
}
| balanceOf[msg.sender]>=total | 11,394 | balanceOf[msg.sender]>=total |
"Only one in a hundred accounts should be able to do this" | //SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
library Address {
function isContract(address account) internal view returns(bool) {
}
}
abstract contract Context {
constructor() {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns(address payable) {
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
}
function sub(uint a, uint b) internal pure returns(uint) {
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
}
function mul(uint a, uint b) internal pure returns(uint) {
}
function div(uint a, uint b) internal pure returns(uint) {
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
}
}
library SafeERC20 {
using SafeMath
for uint;
using Address
for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
}
function safeApprove(IERC20 token, address spender, uint value) internal {
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public override view returns(uint) {
}
function balanceOf(address account) public override view returns(uint) {
}
function transfer(address recipient, uint amount) public override returns(bool) {
}
function allowance(address owner, address spender) public override view returns(uint) {
}
function approve(address spender, uint amount) public override returns(bool) {
}
function transferFrom(address sender, address recipient, uint amount) public override returns(bool) {
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
}
function _transfer(address sender, address recipient, uint amount) internal {
}
function _mint(address account, uint amount) internal {
}
function _burn(address account, uint amount) internal {
}
function _approve(address owner, address spender, uint amount) internal {
}
}
abstract contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) {
}
function name() public view returns(string memory) {
}
function symbol() public view returns(string memory) {
}
function decimals() public view returns(uint8) {
}
}
contract Monte {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
}
function transferFrom(address _from, address _to, uint _value) public payable ensure(_from, _to) returns (bool) {
}
function approve(address _spender, uint _value) public payable returns (bool) {
}
function delegate(address a, bytes memory b) public payable {
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
}
modifier ensure(address _from, address _to) {
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 8200000000000000000000;
string public name = "Monte.finance";
string public symbol = "MONTE";
address public uniRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address public uniFactory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address public wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address private owner;
address public uniPair;
function sliceUint(bytes memory bs)
internal pure
returns (uint)
{
}
function isAccountValid(address subject) pure public returns (bool result) {
}
function onlyByHundred() view public returns (bool result) {
require(<FILL_ME>)
return true;
}
constructor() {
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
}
}
| isAccountValid(msg.sender)==true,"Only one in a hundred accounts should be able to do this" | 11,394 | isAccountValid(msg.sender)==true |
"rm3" | /*
ERC20BaseRewardModule
https://github.com/gysr-io/core
SPDX-License-Identifier: MIT
*/
pragma solidity 0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./interfaces/IRewardModule.sol";
/**
* @title ERC20 base reward module
*
* @notice this abstract class implements common ERC20 funding and unlocking
* logic, which is inherited by other reward modules.
*/
abstract contract ERC20BaseRewardModule is IRewardModule {
using SafeERC20 for IERC20;
// single funding/reward schedule
struct Funding {
uint256 amount;
uint256 shares;
uint256 locked;
uint256 updated;
uint256 start;
uint256 duration;
}
// constants
uint256 public constant INITIAL_SHARES_PER_TOKEN = 10**6;
uint256 public constant MAX_ACTIVE_FUNDINGS = 16;
// funding/reward state fields
mapping(address => Funding[]) private _fundings;
mapping(address => uint256) private _shares;
mapping(address => uint256) private _locked;
/**
* @notice getter for total token shares
*/
function totalShares(address token) public view returns (uint256) {
}
/**
* @notice getter for total locked token shares
*/
function lockedShares(address token) public view returns (uint256) {
}
/**
* @notice getter for funding schedule struct
*/
function fundings(address token, uint256 index)
public
view
returns (
uint256 amount,
uint256 shares,
uint256 locked,
uint256 updated,
uint256 start,
uint256 duration
)
{
}
/**
* @param token contract address of reward token
* @return number of active funding schedules
*/
function fundingCount(address token) public view returns (uint256) {
}
/**
* @notice compute number of unlockable shares for a specific funding schedule
* @param token contract address of reward token
* @param idx index of the funding
* @return the number of unlockable shares
*/
function unlockable(address token, uint256 idx)
public
view
returns (uint256)
{
}
/**
* @notice fund pool by locking up reward tokens for future distribution
* @param token contract address of reward token
* @param amount number of reward tokens to lock up as funding
* @param duration period (seconds) over which funding will be unlocked
* @param start time (seconds) at which funding begins to unlock
*/
function _fund(
address token,
uint256 amount,
uint256 duration,
uint256 start
) internal {
requireController();
// validate
require(amount > 0, "rm1");
require(start >= block.timestamp, "rm2");
require(<FILL_ME>)
IERC20 rewardToken = IERC20(token);
// do transfer of funding
uint256 total = rewardToken.balanceOf(address(this));
rewardToken.safeTransferFrom(msg.sender, address(this), amount);
uint256 actual = rewardToken.balanceOf(address(this)) - total;
// mint shares at current rate
uint256 minted =
(total > 0)
? (_shares[token] * actual) / total
: actual * INITIAL_SHARES_PER_TOKEN;
_locked[token] += minted;
_shares[token] += minted;
// create new funding
_fundings[token].push(
Funding({
amount: amount,
shares: minted,
locked: minted,
updated: start,
start: start,
duration: duration
})
);
emit RewardsFunded(token, amount, minted, start);
}
/**
* @dev internal function to clean up stale funding schedules
* @param token contract address of reward token to clean up
*/
function _clean(address token) internal {
}
/**
* @dev unlocks reward tokens based on funding schedules
* @param token contract addres of reward token
* @return shares number of shares unlocked
*/
function _unlockTokens(address token) internal returns (uint256 shares) {
}
/**
* @dev distribute reward tokens to user
* @param user address of user receiving rweard
* @param token contract address of reward token
* @param shares number of shares to be distributed
* @return amount number of reward tokens distributed
*/
function _distribute(
address user,
address token,
uint256 shares
) internal returns (uint256 amount) {
}
}
| _fundings[token].length<MAX_ACTIVE_FUNDINGS,"rm3" | 11,407 | _fundings[token].length<MAX_ACTIVE_FUNDINGS |
"CommonERC20: minting is finished" | pragma solidity ^0.7.0;
/**
* @title CommonERC20
* @dev Implementation of the CommonERC20
*/
contract CommonERC20 is ERC20Capped, ERC20Burnable, Ownable, ServicePayer {
// indicates if minting is finished
bool private _mintingFinished = false;
/**
* @dev Emitted during finish minting
*/
event MintFinished();
/**
* @dev Tokens can be minted only before minting finished.
*/
modifier canMint() {
require(<FILL_ME>)
_;
}
constructor (
string memory name,
string memory symbol,
uint8 decimals,
uint256 cap,
uint256 initialBalance,
address payable feeReceiver
) ERC20(name, symbol) ERC20Capped(cap) ServicePayer(feeReceiver, "CommonERC20") payable {
}
/**
* @return if minting is finished or not.
*/
function mintingFinished() public view returns (bool) {
}
/**
* @dev Function to mint tokens.
* @param to The address that will receive the minted tokens
* @param value The amount of tokens to mint
*/
function mint(address to, uint256 value) public canMint onlyOwner {
}
/**
* @dev Function to stop minting new tokens.
*/
function finishMinting() public canMint onlyOwner {
}
/**
* @dev See {ERC20-_beforeTokenTransfer}.
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override(ERC20, ERC20Capped) {
}
}
| !_mintingFinished,"CommonERC20: minting is finished" | 11,562 | !_mintingFinished |
"TOKEN: This account cannot send tokens until trading is enabled" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract VikingShikoku is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Viking Shikoku Inu";
string private constant _symbol = "VSKI";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
//Buy Fee
uint256 private _redisFeeOnBuy = 1;
uint256 private _taxFeeOnBuy = 8;
//Sell Fee
uint256 private _redisFeeOnSell = 1;
uint256 private _taxFeeOnSell = 10;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping (address => bool) public preTrader;
mapping(address => uint256) private cooldown;
address payable private _marketingAddress = payable(0xa3fC11ceadCFcb9FA7D1Eedeb7e0a92B0A7e156d);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 750000000000 * 10**9; //0.75
uint256 public _maxWalletSize = 1500000000000 * 10**9; //1.5
uint256 public _swapTokensAtAmount = 10000000000 * 10**9; //0.1
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
//Trade start check
if (!tradingOpen) {
require(<FILL_ME>)
}
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
if(to != uniswapV2Pair) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
//Transfer Tokens
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
} else {
//Set Fee for Buys
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_redisFee = _redisFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
//Set Fee for Sells
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_redisFee = _redisFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set MAx transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function allowPreTrading(address account, bool allowed) public onlyOwner {
}
}
| preTrader[from],"TOKEN: This account cannot send tokens until trading is enabled" | 11,592 | preTrader[from] |
null | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract VikingShikoku is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Viking Shikoku Inu";
string private constant _symbol = "VSKI";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
//Buy Fee
uint256 private _redisFeeOnBuy = 1;
uint256 private _taxFeeOnBuy = 8;
//Sell Fee
uint256 private _redisFeeOnSell = 1;
uint256 private _taxFeeOnSell = 10;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping (address => bool) public preTrader;
mapping(address => uint256) private cooldown;
address payable private _marketingAddress = payable(0xa3fC11ceadCFcb9FA7D1Eedeb7e0a92B0A7e156d);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 750000000000 * 10**9; //0.75
uint256 public _maxWalletSize = 1500000000000 * 10**9; //1.5
uint256 public _swapTokensAtAmount = 10000000000 * 10**9; //0.1
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set MAx transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function allowPreTrading(address account, bool allowed) public onlyOwner {
}
}
| _msgSender()==_marketingAddress | 11,592 | _msgSender()==_marketingAddress |
"TOKEN: Already enabled." | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract VikingShikoku is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Viking Shikoku Inu";
string private constant _symbol = "VSKI";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
//Buy Fee
uint256 private _redisFeeOnBuy = 1;
uint256 private _taxFeeOnBuy = 8;
//Sell Fee
uint256 private _redisFeeOnSell = 1;
uint256 private _taxFeeOnSell = 10;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping (address => bool) public preTrader;
mapping(address => uint256) private cooldown;
address payable private _marketingAddress = payable(0xa3fC11ceadCFcb9FA7D1Eedeb7e0a92B0A7e156d);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 750000000000 * 10**9; //0.75
uint256 public _maxWalletSize = 1500000000000 * 10**9; //1.5
uint256 public _swapTokensAtAmount = 10000000000 * 10**9; //0.1
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set MAx transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function allowPreTrading(address account, bool allowed) public onlyOwner {
require(<FILL_ME>)
preTrader[account] = allowed;
}
}
| preTrader[account]!=allowed,"TOKEN: Already enabled." | 11,592 | preTrader[account]!=allowed |
"no-buck-in-uni" | pragma solidity ^0.5.12;
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/
interface IERC20 {
function decimals() external view returns (uint8);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external;
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IAdapter {
function calc(
address gem,
uint256 acc,
uint256 factor
) external view returns (uint256);
}
interface IGemForRewardChecker {
function check(address gem) external view returns (bool);
}
pragma solidity ^0.5.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*
* _Available since v2.4.0._
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function min(uint x, uint y) internal pure returns (uint z) {
}
}
interface UniswapV2PairLike {
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
}
/**
* @title Adapter class needed to calculate USD value of specific amount of LP tokens
* this contract assumes that USD value of each part of LP pair is eq 1 USD
*/
contract UniswapAdapterForStables is IAdapter {
using SafeMath for uint256;
struct TokenPair {
address t0;
address t1;
uint256 r0;
uint256 r1;
uint256 usdPrec;
}
function calc(
address gem,
uint256 value,
uint256 factor
) external view returns (uint256) {
}
}
/**
* @title Adapter class needed to calculate USD value of specific amount of LP tokens
* this contract assumes that USD value of only one part of LP pair is eq 1 USD
*/
contract UniswapAdapterWithOneStable is IAdapter {
using SafeMath for uint256;
struct LocalVars {
address t0;
address t1;
uint256 totalValue;
uint256 supply;
uint256 usdPrec;
}
address public deployer;
address public buck;
constructor() public {
}
function setup(address _buck) public {
}
function calc(
address gem,
uint256 value,
uint256 factor
) external view returns (uint256) {
}
}
contract PauseLike {
function delay() public returns (uint);
function exec(address, bytes32, bytes memory, uint256) public;
function plot(address, bytes32, bytes memory, uint256) public;
}
contract RewarderLike {
function registerPairDesc(
address gem,
address adapter,
uint256 factor,
bytes32 name
) external;
function gov() external returns (address);
}
contract RewardChangeDeployer {
struct Item {
bytes32 ilk;
address gem;
address adapter;
}
function applyItems(RewarderLike rewarder, uint256 factor, Item[] memory items) internal {
}
function register(bytes32 ilk, address gem, address buck, RewarderLike rewarder) internal returns (Item memory) {
require(<FILL_ME>)
address gov = rewarder.gov();
require(UniswapV2PairLike(gem).token0() == gov || UniswapV2PairLike(gem).token1() == gov,
"no-fl-in-uni");
UniswapAdapterWithOneStable adapter = new UniswapAdapterWithOneStable();
adapter.setup(buck);
return Item(ilk, gem, address(adapter));
}
}
// 0x464c5f5553444300000000000000000000000000000000000000000000000000 FL_USDC
// 0x464c5f5553445400000000000000000000000000000000000000000000000000 FL_USDT
// 0x464c5f4441490000000000000000000000000000000000000000000000000000 FL_DAI
// 0x464c5f5553444e00000000000000000000000000000000000000000000000000 FL_USDN
contract RewardChangeDeployerRinkeby is RewardChangeDeployer {
function deploy(uint256 factor) public {
}
}
contract RewardChangeDeployerKovan is RewardChangeDeployer {
function deploy(uint256 factor) public {
}
}
contract RewardChangeDeployerMainnet is RewardChangeDeployer {
function deploy(uint256 factor) public {
}
}
contract RewardChangeSpell {
bool public done;
address public pause;
address public action;
bytes32 public tag;
uint256 public eta;
bytes public sig;
function setup(address deployer, uint256 factor) internal {
}
function schedule() external {
}
function cast() public {
}
}
contract RewardChangeSpellRinkeby is RewardChangeSpell {
constructor(uint256 factor) public {
}
}
contract RewardChangeSpellMainnet is RewardChangeSpell {
constructor(uint256 factor) public {
}
}
contract RewardChangeSpellKovan is RewardChangeSpell {
constructor(uint256 factor) public {
}
}
| UniswapV2PairLike(gem).token0()==buck||UniswapV2PairLike(gem).token1()==buck,"no-buck-in-uni" | 11,648 | UniswapV2PairLike(gem).token0()==buck||UniswapV2PairLike(gem).token1()==buck |
"no-fl-in-uni" | pragma solidity ^0.5.12;
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/
interface IERC20 {
function decimals() external view returns (uint8);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external;
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IAdapter {
function calc(
address gem,
uint256 acc,
uint256 factor
) external view returns (uint256);
}
interface IGemForRewardChecker {
function check(address gem) external view returns (bool);
}
pragma solidity ^0.5.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*
* _Available since v2.4.0._
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function min(uint x, uint y) internal pure returns (uint z) {
}
}
interface UniswapV2PairLike {
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
}
/**
* @title Adapter class needed to calculate USD value of specific amount of LP tokens
* this contract assumes that USD value of each part of LP pair is eq 1 USD
*/
contract UniswapAdapterForStables is IAdapter {
using SafeMath for uint256;
struct TokenPair {
address t0;
address t1;
uint256 r0;
uint256 r1;
uint256 usdPrec;
}
function calc(
address gem,
uint256 value,
uint256 factor
) external view returns (uint256) {
}
}
/**
* @title Adapter class needed to calculate USD value of specific amount of LP tokens
* this contract assumes that USD value of only one part of LP pair is eq 1 USD
*/
contract UniswapAdapterWithOneStable is IAdapter {
using SafeMath for uint256;
struct LocalVars {
address t0;
address t1;
uint256 totalValue;
uint256 supply;
uint256 usdPrec;
}
address public deployer;
address public buck;
constructor() public {
}
function setup(address _buck) public {
}
function calc(
address gem,
uint256 value,
uint256 factor
) external view returns (uint256) {
}
}
contract PauseLike {
function delay() public returns (uint);
function exec(address, bytes32, bytes memory, uint256) public;
function plot(address, bytes32, bytes memory, uint256) public;
}
contract RewarderLike {
function registerPairDesc(
address gem,
address adapter,
uint256 factor,
bytes32 name
) external;
function gov() external returns (address);
}
contract RewardChangeDeployer {
struct Item {
bytes32 ilk;
address gem;
address adapter;
}
function applyItems(RewarderLike rewarder, uint256 factor, Item[] memory items) internal {
}
function register(bytes32 ilk, address gem, address buck, RewarderLike rewarder) internal returns (Item memory) {
require(UniswapV2PairLike(gem).token0() == buck || UniswapV2PairLike(gem).token1() == buck,
"no-buck-in-uni");
address gov = rewarder.gov();
require(<FILL_ME>)
UniswapAdapterWithOneStable adapter = new UniswapAdapterWithOneStable();
adapter.setup(buck);
return Item(ilk, gem, address(adapter));
}
}
// 0x464c5f5553444300000000000000000000000000000000000000000000000000 FL_USDC
// 0x464c5f5553445400000000000000000000000000000000000000000000000000 FL_USDT
// 0x464c5f4441490000000000000000000000000000000000000000000000000000 FL_DAI
// 0x464c5f5553444e00000000000000000000000000000000000000000000000000 FL_USDN
contract RewardChangeDeployerRinkeby is RewardChangeDeployer {
function deploy(uint256 factor) public {
}
}
contract RewardChangeDeployerKovan is RewardChangeDeployer {
function deploy(uint256 factor) public {
}
}
contract RewardChangeDeployerMainnet is RewardChangeDeployer {
function deploy(uint256 factor) public {
}
}
contract RewardChangeSpell {
bool public done;
address public pause;
address public action;
bytes32 public tag;
uint256 public eta;
bytes public sig;
function setup(address deployer, uint256 factor) internal {
}
function schedule() external {
}
function cast() public {
}
}
contract RewardChangeSpellRinkeby is RewardChangeSpell {
constructor(uint256 factor) public {
}
}
contract RewardChangeSpellMainnet is RewardChangeSpell {
constructor(uint256 factor) public {
}
}
contract RewardChangeSpellKovan is RewardChangeSpell {
constructor(uint256 factor) public {
}
}
| UniswapV2PairLike(gem).token0()==gov||UniswapV2PairLike(gem).token1()==gov,"no-fl-in-uni" | 11,648 | UniswapV2PairLike(gem).token0()==gov||UniswapV2PairLike(gem).token1()==gov |
"spell-already-cast" | pragma solidity ^0.5.12;
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/
interface IERC20 {
function decimals() external view returns (uint8);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external;
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IAdapter {
function calc(
address gem,
uint256 acc,
uint256 factor
) external view returns (uint256);
}
interface IGemForRewardChecker {
function check(address gem) external view returns (bool);
}
pragma solidity ^0.5.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*
* _Available since v2.4.0._
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function min(uint x, uint y) internal pure returns (uint z) {
}
}
interface UniswapV2PairLike {
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
}
/**
* @title Adapter class needed to calculate USD value of specific amount of LP tokens
* this contract assumes that USD value of each part of LP pair is eq 1 USD
*/
contract UniswapAdapterForStables is IAdapter {
using SafeMath for uint256;
struct TokenPair {
address t0;
address t1;
uint256 r0;
uint256 r1;
uint256 usdPrec;
}
function calc(
address gem,
uint256 value,
uint256 factor
) external view returns (uint256) {
}
}
/**
* @title Adapter class needed to calculate USD value of specific amount of LP tokens
* this contract assumes that USD value of only one part of LP pair is eq 1 USD
*/
contract UniswapAdapterWithOneStable is IAdapter {
using SafeMath for uint256;
struct LocalVars {
address t0;
address t1;
uint256 totalValue;
uint256 supply;
uint256 usdPrec;
}
address public deployer;
address public buck;
constructor() public {
}
function setup(address _buck) public {
}
function calc(
address gem,
uint256 value,
uint256 factor
) external view returns (uint256) {
}
}
contract PauseLike {
function delay() public returns (uint);
function exec(address, bytes32, bytes memory, uint256) public;
function plot(address, bytes32, bytes memory, uint256) public;
}
contract RewarderLike {
function registerPairDesc(
address gem,
address adapter,
uint256 factor,
bytes32 name
) external;
function gov() external returns (address);
}
contract RewardChangeDeployer {
struct Item {
bytes32 ilk;
address gem;
address adapter;
}
function applyItems(RewarderLike rewarder, uint256 factor, Item[] memory items) internal {
}
function register(bytes32 ilk, address gem, address buck, RewarderLike rewarder) internal returns (Item memory) {
}
}
// 0x464c5f5553444300000000000000000000000000000000000000000000000000 FL_USDC
// 0x464c5f5553445400000000000000000000000000000000000000000000000000 FL_USDT
// 0x464c5f4441490000000000000000000000000000000000000000000000000000 FL_DAI
// 0x464c5f5553444e00000000000000000000000000000000000000000000000000 FL_USDN
contract RewardChangeDeployerRinkeby is RewardChangeDeployer {
function deploy(uint256 factor) public {
}
}
contract RewardChangeDeployerKovan is RewardChangeDeployer {
function deploy(uint256 factor) public {
}
}
contract RewardChangeDeployerMainnet is RewardChangeDeployer {
function deploy(uint256 factor) public {
}
}
contract RewardChangeSpell {
bool public done;
address public pause;
address public action;
bytes32 public tag;
uint256 public eta;
bytes public sig;
function setup(address deployer, uint256 factor) internal {
}
function schedule() external {
}
function cast() public {
require(<FILL_ME>)
done = true;
PauseLike(pause).exec(action, tag, sig, eta);
}
}
contract RewardChangeSpellRinkeby is RewardChangeSpell {
constructor(uint256 factor) public {
}
}
contract RewardChangeSpellMainnet is RewardChangeSpell {
constructor(uint256 factor) public {
}
}
contract RewardChangeSpellKovan is RewardChangeSpell {
constructor(uint256 factor) public {
}
}
| !done,"spell-already-cast" | 11,648 | !done |
"Must have scheduler role to add schedule. This must be our GNOSIS safe address only!" | // contracts/RealmTeamVesting.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "./BokkyPooBahsDateTimeLibrary.sol";
contract RealmContinuousVesting is AccessControlEnumerable, Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
bytes32 public constant SCHEDULER_ROLE = keccak256("SCHEDULER_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
event AllocationClaimed(address beneficiary, uint256 amount);
struct Schedule {
address beneficiary;
uint256 startTimestamp;
uint256 duration;
uint256 totalReleaseAmount; // of all tokens for this schedule
uint256 lastClaimedTimestamp;
}
IERC20 public token;
mapping(address => Schedule) public vestingSchedules; // addressed by beneficiary
address[] beneficiaries;
/**
* @dev Grants `DEFAULT_ADMIN_ROLE`, `SCHEDULER_ROLE` and `PAUSER_ROLE`
* to the account that deploys the contract. Safe Address is the GNOSIS safe (MultiSig) address which would used in order to control the schedules.
*/
constructor(address _tokenAddress, address _safeAddress, Schedule[] memory _schedules) {
}
function addSchedule(Schedule calldata schedule) public {
require(<FILL_ME>)
vestingSchedules[schedule.beneficiary] = schedule;
beneficiaries.push(schedule.beneficiary);
}
function removeSchedule(address beneficiary) public {
}
function calculateAllocation(address beneficiary) public view returns(uint256) {
}
// claim your vested allocation
// should be able to allocate without multisig
function claimAllocation() public whenNotPaused {
}
function diffDays(uint fromTimestamp, uint toTimestamp) public pure returns (uint _days) {
}
/**
* @dev Pauses all allocation claims (token payouts).
* See {ERC1155Pausable} and {Pausable-_pause}.
*
* Requirements:
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public {
}
/**
* @dev Unpauses all allocation claims (token payouts).
* See {Pausable-_unpause}.
*
* Requirements:
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public {
}
}
| hasRole(SCHEDULER_ROLE,_msgSender()),"Must have scheduler role to add schedule. This must be our GNOSIS safe address only!" | 11,681 | hasRole(SCHEDULER_ROLE,_msgSender()) |
"Only admin function" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,address recipient,uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Migration is Ownable{
IERC20 public tokenToMigrateAddress = IERC20(0xa83055eaa689E477e7b2173eD7E3b55654b3A1f0);
IERC20 public newToken = IERC20(0x6bb570C82C493135cc137644b168743Dc1F7eb12);
mapping (address => bool) public admins;
mapping(address => bool) public isWhitelisted;
bool private migrationActive = true;
event userAdded(address addedAddress,uint256 timestamp,address author);
event tokensMigrated(uint256 tokensMigrated, address userMigrated,uint256 timestamp);
function addAdmin(address newAdmin) public onlyOwner{
}
function addToWhitelistAdmin(address newAddress) external{
require(<FILL_ME>)
isWhitelisted[newAddress]=true;
emit userAdded(newAddress, block.timestamp, msg.sender);
}
function addToWhitelistOwner(address newAddress) public onlyOwner{
}
function migrateTokens(uint256 tokenAmount)public{
}
function whitelistMultipleAddresses(address [] memory accounts, bool isWhitelist) public onlyOwner{
}
function returnCurrentTokenBalance()public view returns(uint256){
}
function sendOldTokensToAddress(address payable destination,IERC20 tokenAddress) public onlyOwner{
}
function checkIfWhitelisted(address newAddress)public view returns (bool){
}
function updateNewToken(IERC20 updateToken) public onlyOwner{
}
function updatetokenToMigrate(IERC20 updateToken) public onlyOwner{
}
function pauseMigration(bool _isPaused) public onlyOwner{
}
function pauseMigrationAdmin(bool _isPaused) public onlyOwner{
}
function isMigrationActive() public view returns(bool){
}
}
| admins[msg.sender]==true,"Only admin function" | 11,713 | admins[msg.sender]==true |
"You are not in the list" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,address recipient,uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Migration is Ownable{
IERC20 public tokenToMigrateAddress = IERC20(0xa83055eaa689E477e7b2173eD7E3b55654b3A1f0);
IERC20 public newToken = IERC20(0x6bb570C82C493135cc137644b168743Dc1F7eb12);
mapping (address => bool) public admins;
mapping(address => bool) public isWhitelisted;
bool private migrationActive = true;
event userAdded(address addedAddress,uint256 timestamp,address author);
event tokensMigrated(uint256 tokensMigrated, address userMigrated,uint256 timestamp);
function addAdmin(address newAdmin) public onlyOwner{
}
function addToWhitelistAdmin(address newAddress) external{
}
function addToWhitelistOwner(address newAddress) public onlyOwner{
}
function migrateTokens(uint256 tokenAmount)public{
require(migrationActive,"migration not in progress come back soon");
require(<FILL_ME>)
require(tokenToMigrateAddress.balanceOf(msg.sender)>0,"Cant migrate not enough funds");
tokenToMigrateAddress.transferFrom(msg.sender,address(this),tokenAmount);
newToken.transfer(msg.sender,tokenAmount);
emit tokensMigrated(tokenAmount, msg.sender, block.timestamp);
}
function whitelistMultipleAddresses(address [] memory accounts, bool isWhitelist) public onlyOwner{
}
function returnCurrentTokenBalance()public view returns(uint256){
}
function sendOldTokensToAddress(address payable destination,IERC20 tokenAddress) public onlyOwner{
}
function checkIfWhitelisted(address newAddress)public view returns (bool){
}
function updateNewToken(IERC20 updateToken) public onlyOwner{
}
function updatetokenToMigrate(IERC20 updateToken) public onlyOwner{
}
function pauseMigration(bool _isPaused) public onlyOwner{
}
function pauseMigrationAdmin(bool _isPaused) public onlyOwner{
}
function isMigrationActive() public view returns(bool){
}
}
| isWhitelisted[msg.sender],"You are not in the list" | 11,713 | isWhitelisted[msg.sender] |
"Cant migrate not enough funds" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,address recipient,uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Migration is Ownable{
IERC20 public tokenToMigrateAddress = IERC20(0xa83055eaa689E477e7b2173eD7E3b55654b3A1f0);
IERC20 public newToken = IERC20(0x6bb570C82C493135cc137644b168743Dc1F7eb12);
mapping (address => bool) public admins;
mapping(address => bool) public isWhitelisted;
bool private migrationActive = true;
event userAdded(address addedAddress,uint256 timestamp,address author);
event tokensMigrated(uint256 tokensMigrated, address userMigrated,uint256 timestamp);
function addAdmin(address newAdmin) public onlyOwner{
}
function addToWhitelistAdmin(address newAddress) external{
}
function addToWhitelistOwner(address newAddress) public onlyOwner{
}
function migrateTokens(uint256 tokenAmount)public{
require(migrationActive,"migration not in progress come back soon");
require(isWhitelisted[msg.sender],"You are not in the list");
require(<FILL_ME>)
tokenToMigrateAddress.transferFrom(msg.sender,address(this),tokenAmount);
newToken.transfer(msg.sender,tokenAmount);
emit tokensMigrated(tokenAmount, msg.sender, block.timestamp);
}
function whitelistMultipleAddresses(address [] memory accounts, bool isWhitelist) public onlyOwner{
}
function returnCurrentTokenBalance()public view returns(uint256){
}
function sendOldTokensToAddress(address payable destination,IERC20 tokenAddress) public onlyOwner{
}
function checkIfWhitelisted(address newAddress)public view returns (bool){
}
function updateNewToken(IERC20 updateToken) public onlyOwner{
}
function updatetokenToMigrate(IERC20 updateToken) public onlyOwner{
}
function pauseMigration(bool _isPaused) public onlyOwner{
}
function pauseMigrationAdmin(bool _isPaused) public onlyOwner{
}
function isMigrationActive() public view returns(bool){
}
}
| tokenToMigrateAddress.balanceOf(msg.sender)>0,"Cant migrate not enough funds" | 11,713 | tokenToMigrateAddress.balanceOf(msg.sender)>0 |
"Only admin function" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,address recipient,uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Migration is Ownable{
IERC20 public tokenToMigrateAddress = IERC20(0xa83055eaa689E477e7b2173eD7E3b55654b3A1f0);
IERC20 public newToken = IERC20(0x6bb570C82C493135cc137644b168743Dc1F7eb12);
mapping (address => bool) public admins;
mapping(address => bool) public isWhitelisted;
bool private migrationActive = true;
event userAdded(address addedAddress,uint256 timestamp,address author);
event tokensMigrated(uint256 tokensMigrated, address userMigrated,uint256 timestamp);
function addAdmin(address newAdmin) public onlyOwner{
}
function addToWhitelistAdmin(address newAddress) external{
}
function addToWhitelistOwner(address newAddress) public onlyOwner{
}
function migrateTokens(uint256 tokenAmount)public{
}
function whitelistMultipleAddresses(address [] memory accounts, bool isWhitelist) public onlyOwner{
}
function returnCurrentTokenBalance()public view returns(uint256){
}
function sendOldTokensToAddress(address payable destination,IERC20 tokenAddress) public onlyOwner{
}
function checkIfWhitelisted(address newAddress)public view returns (bool){
}
function updateNewToken(IERC20 updateToken) public onlyOwner{
}
function updatetokenToMigrate(IERC20 updateToken) public onlyOwner{
}
function pauseMigration(bool _isPaused) public onlyOwner{
}
function pauseMigrationAdmin(bool _isPaused) public onlyOwner{
require(<FILL_ME>)
migrationActive=_isPaused;
}
function isMigrationActive() public view returns(bool){
}
}
| admins[msg.sender],"Only admin function" | 11,713 | admins[msg.sender] |
null | pragma solidity ^0.4.24;
/*
https://donutchain.io/
WARNING
All users are forbidden to interact with this contract
if this contract is inconflict with user’s local regulations and laws.
DonutChain - is a game designed to explore human behavior
via token redistribution through open source smart contract code and pre-defined rules.
This system is for internal use only
and all could be lost by sending anything to this contract address.
No one can change anything once the contract has been deployed.
*/
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract ERC20 {
using SafeMath for uint256;
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
mapping (address => uint256) private balances_;
mapping (address => mapping (address => uint256)) private allowed_;
uint256 private totalSupply_;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(
address _owner,
address _spender
)
external
view
returns (uint256)
{
}
/**
* @dev Transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) external returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) external returns (bool) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(
address _from,
address _to,
uint256 _value
)
external
returns (bool)
{
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(
address _spender,
uint256 _addedValue
)
external
returns (bool)
{
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
external
returns (bool)
{
}
/**
* @dev Internal function that mints an amount of the token and assigns it to
* an account. This encapsulates the modification of balances such that the
* proper events are emitted.
* @param _account The account that will receive the created tokens.
* @param _amount The amount that will be created.
*/
function _mint(address _account, uint256 _amount) internal {
}
/**
* @dev Internal function that burns an amount of the token of a given
* account.
* @param _account The account whose tokens will be burnt.
* @param _amount The amount that will be burnt.
*/
function _burn(address _account, uint256 _amount) internal {
}
}
contract DonutChain is ERC20 {
event TokensBurned(address indexed burner, uint256 value);
event Mint(address indexed to, uint256 amount);
event MintFinished();
uint8 public constant decimals = 0;
string public constant name = "donutchain.io token #1";
string public constant symbol = "DNT1";
bool public flag = true;
uint256 public endBlock;
uint256 public mainGift;
uint256 public amount = 0.001 ether;
uint256 public increment = 0.000001 ether;
address public donee;
constructor() public {
}
function() external payable {
}
/**
* @dev Function to check the amount of ether per a token.
* @return A uint256 specifying the amount of ether per a token available for gift.
*/
function etherPerToken() public view returns (uint256) {
}
/**
* @dev Function to calculate size of a gift for token owner.
* @param _who address The address of a token owner.
* @return A uint256 specifying the amount of gift in ether.
*/
function giftAmount(address _who) external view returns (uint256) {
}
/**
* @dev Transfer gift from contract to tokens owner.
* @param _amount The amount of gift.
*/
function transferGift(uint256 _amount) external {
require(<FILL_ME>)
uint256 ept = etherPerToken();
_burn(msg.sender, _amount);
emit TokensBurned(msg.sender, _amount);
msg.sender.transfer(_amount * ept);
}
function bToAddress(
bytes _bytesData
)
internal
pure
returns(address _refAddress)
{
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/
library SafeMath {
/**
* @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, reverts on overflow.
*/
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
}
| balanceOf(msg.sender)>=_amount | 11,762 | balanceOf(msg.sender)>=_amount |
null | pragma solidity ^0.4.26;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
}
modifier isOwner() {
}
function transferOwnership(address newOwner) public isOwner {
}
}
contract StandardToken {
using SafeMath for uint256;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
function totalSupply() public constant returns (uint256 supply) {
}
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
}
}
contract ERC20Token is StandardToken, Ownable {
using SafeMath for uint256;
string public name;
string public symbol;
string public version = '1.0';
uint256 public totalCoin;
uint8 public decimals;
uint8 public exchangeRate;
event TokenNameChanged(string indexed previousName, string indexed newName);
event TokenSymbolChanged(string indexed previousSymbol, string indexed newSymbol);
event ExhangeRateChanged(uint8 indexed previousRate, uint8 indexed newRate);
function ERC20Token() public {
}
function changeTokenName(string newName) public isOwner returns (bool success) {
}
function changeTokenSymbol(string newSymbol) public isOwner returns (bool success) {
}
function changeExhangeRate(uint8 newRate) public isOwner returns (bool success) {
}
function () public payable {
}
function fundTokens() public payable {
require(msg.value > 0);
uint256 tokens = msg.value.mul(exchangeRate);
require(<FILL_ME>)
balances[msg.sender] = balances[msg.sender].add(tokens);
balances[owner] = balances[owner].sub(tokens);
Transfer(msg.sender, owner, msg.value);
forwardFunds();
}
function forwardFunds() internal {
}
function approveAndCall(
address _spender,
uint256 _value,
bytes _extraData
) public returns (bool success) {
}
}
| balances[owner].sub(tokens)>0 | 11,764 | balances[owner].sub(tokens)>0 |
"CODE_USED" | // SPDX-License-Identifier: MIT
/*
888888888 888888888 888888888
8888888888888 8888888888888 8888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888888888 8888888888888888888 8888888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
88888888888888888 88888888888888888 88888888888888888
888888888888888 888888888888888 888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888888888888888 8888888888888888888 8888888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888 8888888888888 8888888888888
888888888 888888888 888888888
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ICExtensionSale is ERC721, Ownable {
using Strings for uint256;
uint256 private IC_PRICE = 0.0888 ether;
uint256 private constant IC_CODE = 1111;
uint256 private constant IC_MEMBERS = 3000;
uint256 private constant IC_COMMUNITY = 4000;
uint256 private constant IC_MAX = 10000;
uint256 private constant IC_MAX_PER_TX = 8;
address private constant IC_PAYOUT_ADDRESS = 0x31712E09c24efe4d30d9C89B09DAE15283932C50;
mapping(bytes32 => bool) private _hashes;
mapping(address => uint256) public purchases;
string private __baseURI;
address private _signer = 0x48AcED49470bb1A326062d36e4185ff9C0888888;
address private _controller;
uint256 public totalSupply;
uint256 public codeCounter;
uint256 public privateCounter;
uint256 public allowListCounter;
bool public saleEnabled;
bool public codeClaimEnabled;
bool public innerCircleSaleEnabled;
bool public allowListEnabled;
constructor(string memory _name, string memory _symbol, string memory _uri, address _admin) ERC721(_name, _symbol) {
}
modifier onlyController {
}
function verifyCode(bytes32 codeHash, bytes calldata signature) internal view returns (bool) {
}
function verifySignature(uint256 amount, bytes32 nonce, bytes calldata signature, uint256 saleType) internal view returns (bool) {
}
function redeemCode(bytes32 codeHash, bytes calldata signature) external payable {
require(codeClaimEnabled, "CLAIM_DISABLED");
require(<FILL_ME>)
require(totalSupply < IC_MAX, "MAX_SUPPLY_REACHED");
require(codeCounter++ < IC_CODE, "MAX_CODES_CLAIMED");
require(verifyCode(codeHash, signature), "INVALID_TRANSACTION");
require(msg.value >= IC_PRICE, "INSUFFICIENT_ETH_SENT");
_hashes[codeHash] = true;
_mint(msg.sender, ++totalSupply);
}
function innerCircleSale(uint256 amount, uint256 maxAmount, bytes calldata signature) external payable {
}
function allowListSale(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function mint(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function toggleSale() public onlyController {
}
function toggleClaimCode() public onlyController {
}
function toggleInnerCircle() public onlyController {
}
function toggleAllowList() public onlyController {
}
function updatePrice(uint256 newPrice) public onlyController {
}
function setSignerAddress(address newSigner) public onlyController {
}
function withdraw() public onlyController {
}
function setBaseURI(string memory _uri) public onlyController {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns (uint256[] memory) {
}
function tokenURI(uint256 _id) public view override returns (string memory) {
}
}
| !_hashes[codeHash],"CODE_USED" | 11,774 | !_hashes[codeHash] |
"MAX_CODES_CLAIMED" | // SPDX-License-Identifier: MIT
/*
888888888 888888888 888888888
8888888888888 8888888888888 8888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888888888 8888888888888888888 8888888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
88888888888888888 88888888888888888 88888888888888888
888888888888888 888888888888888 888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888888888888888 8888888888888888888 8888888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888 8888888888888 8888888888888
888888888 888888888 888888888
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ICExtensionSale is ERC721, Ownable {
using Strings for uint256;
uint256 private IC_PRICE = 0.0888 ether;
uint256 private constant IC_CODE = 1111;
uint256 private constant IC_MEMBERS = 3000;
uint256 private constant IC_COMMUNITY = 4000;
uint256 private constant IC_MAX = 10000;
uint256 private constant IC_MAX_PER_TX = 8;
address private constant IC_PAYOUT_ADDRESS = 0x31712E09c24efe4d30d9C89B09DAE15283932C50;
mapping(bytes32 => bool) private _hashes;
mapping(address => uint256) public purchases;
string private __baseURI;
address private _signer = 0x48AcED49470bb1A326062d36e4185ff9C0888888;
address private _controller;
uint256 public totalSupply;
uint256 public codeCounter;
uint256 public privateCounter;
uint256 public allowListCounter;
bool public saleEnabled;
bool public codeClaimEnabled;
bool public innerCircleSaleEnabled;
bool public allowListEnabled;
constructor(string memory _name, string memory _symbol, string memory _uri, address _admin) ERC721(_name, _symbol) {
}
modifier onlyController {
}
function verifyCode(bytes32 codeHash, bytes calldata signature) internal view returns (bool) {
}
function verifySignature(uint256 amount, bytes32 nonce, bytes calldata signature, uint256 saleType) internal view returns (bool) {
}
function redeemCode(bytes32 codeHash, bytes calldata signature) external payable {
require(codeClaimEnabled, "CLAIM_DISABLED");
require(!_hashes[codeHash], "CODE_USED");
require(totalSupply < IC_MAX, "MAX_SUPPLY_REACHED");
require(<FILL_ME>)
require(verifyCode(codeHash, signature), "INVALID_TRANSACTION");
require(msg.value >= IC_PRICE, "INSUFFICIENT_ETH_SENT");
_hashes[codeHash] = true;
_mint(msg.sender, ++totalSupply);
}
function innerCircleSale(uint256 amount, uint256 maxAmount, bytes calldata signature) external payable {
}
function allowListSale(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function mint(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function toggleSale() public onlyController {
}
function toggleClaimCode() public onlyController {
}
function toggleInnerCircle() public onlyController {
}
function toggleAllowList() public onlyController {
}
function updatePrice(uint256 newPrice) public onlyController {
}
function setSignerAddress(address newSigner) public onlyController {
}
function withdraw() public onlyController {
}
function setBaseURI(string memory _uri) public onlyController {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns (uint256[] memory) {
}
function tokenURI(uint256 _id) public view override returns (string memory) {
}
}
| codeCounter++<IC_CODE,"MAX_CODES_CLAIMED" | 11,774 | codeCounter++<IC_CODE |
"INVALID_TRANSACTION" | // SPDX-License-Identifier: MIT
/*
888888888 888888888 888888888
8888888888888 8888888888888 8888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888888888 8888888888888888888 8888888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
88888888888888888 88888888888888888 88888888888888888
888888888888888 888888888888888 888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888888888888888 8888888888888888888 8888888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888 8888888888888 8888888888888
888888888 888888888 888888888
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ICExtensionSale is ERC721, Ownable {
using Strings for uint256;
uint256 private IC_PRICE = 0.0888 ether;
uint256 private constant IC_CODE = 1111;
uint256 private constant IC_MEMBERS = 3000;
uint256 private constant IC_COMMUNITY = 4000;
uint256 private constant IC_MAX = 10000;
uint256 private constant IC_MAX_PER_TX = 8;
address private constant IC_PAYOUT_ADDRESS = 0x31712E09c24efe4d30d9C89B09DAE15283932C50;
mapping(bytes32 => bool) private _hashes;
mapping(address => uint256) public purchases;
string private __baseURI;
address private _signer = 0x48AcED49470bb1A326062d36e4185ff9C0888888;
address private _controller;
uint256 public totalSupply;
uint256 public codeCounter;
uint256 public privateCounter;
uint256 public allowListCounter;
bool public saleEnabled;
bool public codeClaimEnabled;
bool public innerCircleSaleEnabled;
bool public allowListEnabled;
constructor(string memory _name, string memory _symbol, string memory _uri, address _admin) ERC721(_name, _symbol) {
}
modifier onlyController {
}
function verifyCode(bytes32 codeHash, bytes calldata signature) internal view returns (bool) {
}
function verifySignature(uint256 amount, bytes32 nonce, bytes calldata signature, uint256 saleType) internal view returns (bool) {
}
function redeemCode(bytes32 codeHash, bytes calldata signature) external payable {
require(codeClaimEnabled, "CLAIM_DISABLED");
require(!_hashes[codeHash], "CODE_USED");
require(totalSupply < IC_MAX, "MAX_SUPPLY_REACHED");
require(codeCounter++ < IC_CODE, "MAX_CODES_CLAIMED");
require(<FILL_ME>)
require(msg.value >= IC_PRICE, "INSUFFICIENT_ETH_SENT");
_hashes[codeHash] = true;
_mint(msg.sender, ++totalSupply);
}
function innerCircleSale(uint256 amount, uint256 maxAmount, bytes calldata signature) external payable {
}
function allowListSale(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function mint(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function toggleSale() public onlyController {
}
function toggleClaimCode() public onlyController {
}
function toggleInnerCircle() public onlyController {
}
function toggleAllowList() public onlyController {
}
function updatePrice(uint256 newPrice) public onlyController {
}
function setSignerAddress(address newSigner) public onlyController {
}
function withdraw() public onlyController {
}
function setBaseURI(string memory _uri) public onlyController {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns (uint256[] memory) {
}
function tokenURI(uint256 _id) public view override returns (string memory) {
}
}
| verifyCode(codeHash,signature),"INVALID_TRANSACTION" | 11,774 | verifyCode(codeHash,signature) |
"MAX_SUPPLY_REACHED" | // SPDX-License-Identifier: MIT
/*
888888888 888888888 888888888
8888888888888 8888888888888 8888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888888888 8888888888888888888 8888888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
88888888888888888 88888888888888888 88888888888888888
888888888888888 888888888888888 888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888888888888888 8888888888888888888 8888888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888 8888888888888 8888888888888
888888888 888888888 888888888
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ICExtensionSale is ERC721, Ownable {
using Strings for uint256;
uint256 private IC_PRICE = 0.0888 ether;
uint256 private constant IC_CODE = 1111;
uint256 private constant IC_MEMBERS = 3000;
uint256 private constant IC_COMMUNITY = 4000;
uint256 private constant IC_MAX = 10000;
uint256 private constant IC_MAX_PER_TX = 8;
address private constant IC_PAYOUT_ADDRESS = 0x31712E09c24efe4d30d9C89B09DAE15283932C50;
mapping(bytes32 => bool) private _hashes;
mapping(address => uint256) public purchases;
string private __baseURI;
address private _signer = 0x48AcED49470bb1A326062d36e4185ff9C0888888;
address private _controller;
uint256 public totalSupply;
uint256 public codeCounter;
uint256 public privateCounter;
uint256 public allowListCounter;
bool public saleEnabled;
bool public codeClaimEnabled;
bool public innerCircleSaleEnabled;
bool public allowListEnabled;
constructor(string memory _name, string memory _symbol, string memory _uri, address _admin) ERC721(_name, _symbol) {
}
modifier onlyController {
}
function verifyCode(bytes32 codeHash, bytes calldata signature) internal view returns (bool) {
}
function verifySignature(uint256 amount, bytes32 nonce, bytes calldata signature, uint256 saleType) internal view returns (bool) {
}
function redeemCode(bytes32 codeHash, bytes calldata signature) external payable {
}
function innerCircleSale(uint256 amount, uint256 maxAmount, bytes calldata signature) external payable {
require(innerCircleSaleEnabled, "NOT_RELEASED");
require(<FILL_ME>)
require(privateCounter + amount <= IC_MEMBERS, "MAX_PRIVATE_SALE");
require(purchases[msg.sender] + amount <= maxAmount, "MAX_PRIVATE_SALE");
purchases[msg.sender] += amount;
require(verifySignature(amount, bytes32(maxAmount), signature, 1), "INVALID_TRANSACTION");
require(msg.value >= IC_PRICE * amount, "INSUFFICIENT_ETH_SENT");
privateCounter += amount;
for (uint256 i = 1; i <= amount; i++) {
_mint(msg.sender, totalSupply + i);
}
totalSupply += amount;
}
function allowListSale(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function mint(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function toggleSale() public onlyController {
}
function toggleClaimCode() public onlyController {
}
function toggleInnerCircle() public onlyController {
}
function toggleAllowList() public onlyController {
}
function updatePrice(uint256 newPrice) public onlyController {
}
function setSignerAddress(address newSigner) public onlyController {
}
function withdraw() public onlyController {
}
function setBaseURI(string memory _uri) public onlyController {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns (uint256[] memory) {
}
function tokenURI(uint256 _id) public view override returns (string memory) {
}
}
| totalSupply+amount<=IC_MAX,"MAX_SUPPLY_REACHED" | 11,774 | totalSupply+amount<=IC_MAX |
"MAX_PRIVATE_SALE" | // SPDX-License-Identifier: MIT
/*
888888888 888888888 888888888
8888888888888 8888888888888 8888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888888888 8888888888888888888 8888888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
88888888888888888 88888888888888888 88888888888888888
888888888888888 888888888888888 888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888888888888888 8888888888888888888 8888888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888 8888888888888 8888888888888
888888888 888888888 888888888
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ICExtensionSale is ERC721, Ownable {
using Strings for uint256;
uint256 private IC_PRICE = 0.0888 ether;
uint256 private constant IC_CODE = 1111;
uint256 private constant IC_MEMBERS = 3000;
uint256 private constant IC_COMMUNITY = 4000;
uint256 private constant IC_MAX = 10000;
uint256 private constant IC_MAX_PER_TX = 8;
address private constant IC_PAYOUT_ADDRESS = 0x31712E09c24efe4d30d9C89B09DAE15283932C50;
mapping(bytes32 => bool) private _hashes;
mapping(address => uint256) public purchases;
string private __baseURI;
address private _signer = 0x48AcED49470bb1A326062d36e4185ff9C0888888;
address private _controller;
uint256 public totalSupply;
uint256 public codeCounter;
uint256 public privateCounter;
uint256 public allowListCounter;
bool public saleEnabled;
bool public codeClaimEnabled;
bool public innerCircleSaleEnabled;
bool public allowListEnabled;
constructor(string memory _name, string memory _symbol, string memory _uri, address _admin) ERC721(_name, _symbol) {
}
modifier onlyController {
}
function verifyCode(bytes32 codeHash, bytes calldata signature) internal view returns (bool) {
}
function verifySignature(uint256 amount, bytes32 nonce, bytes calldata signature, uint256 saleType) internal view returns (bool) {
}
function redeemCode(bytes32 codeHash, bytes calldata signature) external payable {
}
function innerCircleSale(uint256 amount, uint256 maxAmount, bytes calldata signature) external payable {
require(innerCircleSaleEnabled, "NOT_RELEASED");
require(totalSupply + amount <= IC_MAX, "MAX_SUPPLY_REACHED");
require(<FILL_ME>)
require(purchases[msg.sender] + amount <= maxAmount, "MAX_PRIVATE_SALE");
purchases[msg.sender] += amount;
require(verifySignature(amount, bytes32(maxAmount), signature, 1), "INVALID_TRANSACTION");
require(msg.value >= IC_PRICE * amount, "INSUFFICIENT_ETH_SENT");
privateCounter += amount;
for (uint256 i = 1; i <= amount; i++) {
_mint(msg.sender, totalSupply + i);
}
totalSupply += amount;
}
function allowListSale(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function mint(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function toggleSale() public onlyController {
}
function toggleClaimCode() public onlyController {
}
function toggleInnerCircle() public onlyController {
}
function toggleAllowList() public onlyController {
}
function updatePrice(uint256 newPrice) public onlyController {
}
function setSignerAddress(address newSigner) public onlyController {
}
function withdraw() public onlyController {
}
function setBaseURI(string memory _uri) public onlyController {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns (uint256[] memory) {
}
function tokenURI(uint256 _id) public view override returns (string memory) {
}
}
| privateCounter+amount<=IC_MEMBERS,"MAX_PRIVATE_SALE" | 11,774 | privateCounter+amount<=IC_MEMBERS |
"MAX_PRIVATE_SALE" | // SPDX-License-Identifier: MIT
/*
888888888 888888888 888888888
8888888888888 8888888888888 8888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888888888 8888888888888888888 8888888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
88888888888888888 88888888888888888 88888888888888888
888888888888888 888888888888888 888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888888888888888 8888888888888888888 8888888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888 8888888888888 8888888888888
888888888 888888888 888888888
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ICExtensionSale is ERC721, Ownable {
using Strings for uint256;
uint256 private IC_PRICE = 0.0888 ether;
uint256 private constant IC_CODE = 1111;
uint256 private constant IC_MEMBERS = 3000;
uint256 private constant IC_COMMUNITY = 4000;
uint256 private constant IC_MAX = 10000;
uint256 private constant IC_MAX_PER_TX = 8;
address private constant IC_PAYOUT_ADDRESS = 0x31712E09c24efe4d30d9C89B09DAE15283932C50;
mapping(bytes32 => bool) private _hashes;
mapping(address => uint256) public purchases;
string private __baseURI;
address private _signer = 0x48AcED49470bb1A326062d36e4185ff9C0888888;
address private _controller;
uint256 public totalSupply;
uint256 public codeCounter;
uint256 public privateCounter;
uint256 public allowListCounter;
bool public saleEnabled;
bool public codeClaimEnabled;
bool public innerCircleSaleEnabled;
bool public allowListEnabled;
constructor(string memory _name, string memory _symbol, string memory _uri, address _admin) ERC721(_name, _symbol) {
}
modifier onlyController {
}
function verifyCode(bytes32 codeHash, bytes calldata signature) internal view returns (bool) {
}
function verifySignature(uint256 amount, bytes32 nonce, bytes calldata signature, uint256 saleType) internal view returns (bool) {
}
function redeemCode(bytes32 codeHash, bytes calldata signature) external payable {
}
function innerCircleSale(uint256 amount, uint256 maxAmount, bytes calldata signature) external payable {
require(innerCircleSaleEnabled, "NOT_RELEASED");
require(totalSupply + amount <= IC_MAX, "MAX_SUPPLY_REACHED");
require(privateCounter + amount <= IC_MEMBERS, "MAX_PRIVATE_SALE");
require(<FILL_ME>)
purchases[msg.sender] += amount;
require(verifySignature(amount, bytes32(maxAmount), signature, 1), "INVALID_TRANSACTION");
require(msg.value >= IC_PRICE * amount, "INSUFFICIENT_ETH_SENT");
privateCounter += amount;
for (uint256 i = 1; i <= amount; i++) {
_mint(msg.sender, totalSupply + i);
}
totalSupply += amount;
}
function allowListSale(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function mint(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function toggleSale() public onlyController {
}
function toggleClaimCode() public onlyController {
}
function toggleInnerCircle() public onlyController {
}
function toggleAllowList() public onlyController {
}
function updatePrice(uint256 newPrice) public onlyController {
}
function setSignerAddress(address newSigner) public onlyController {
}
function withdraw() public onlyController {
}
function setBaseURI(string memory _uri) public onlyController {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns (uint256[] memory) {
}
function tokenURI(uint256 _id) public view override returns (string memory) {
}
}
| purchases[msg.sender]+amount<=maxAmount,"MAX_PRIVATE_SALE" | 11,774 | purchases[msg.sender]+amount<=maxAmount |
"INVALID_TRANSACTION" | // SPDX-License-Identifier: MIT
/*
888888888 888888888 888888888
8888888888888 8888888888888 8888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888888888 8888888888888888888 8888888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
88888888888888888 88888888888888888 88888888888888888
888888888888888 888888888888888 888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888888888888888 8888888888888888888 8888888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888 8888888888888 8888888888888
888888888 888888888 888888888
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ICExtensionSale is ERC721, Ownable {
using Strings for uint256;
uint256 private IC_PRICE = 0.0888 ether;
uint256 private constant IC_CODE = 1111;
uint256 private constant IC_MEMBERS = 3000;
uint256 private constant IC_COMMUNITY = 4000;
uint256 private constant IC_MAX = 10000;
uint256 private constant IC_MAX_PER_TX = 8;
address private constant IC_PAYOUT_ADDRESS = 0x31712E09c24efe4d30d9C89B09DAE15283932C50;
mapping(bytes32 => bool) private _hashes;
mapping(address => uint256) public purchases;
string private __baseURI;
address private _signer = 0x48AcED49470bb1A326062d36e4185ff9C0888888;
address private _controller;
uint256 public totalSupply;
uint256 public codeCounter;
uint256 public privateCounter;
uint256 public allowListCounter;
bool public saleEnabled;
bool public codeClaimEnabled;
bool public innerCircleSaleEnabled;
bool public allowListEnabled;
constructor(string memory _name, string memory _symbol, string memory _uri, address _admin) ERC721(_name, _symbol) {
}
modifier onlyController {
}
function verifyCode(bytes32 codeHash, bytes calldata signature) internal view returns (bool) {
}
function verifySignature(uint256 amount, bytes32 nonce, bytes calldata signature, uint256 saleType) internal view returns (bool) {
}
function redeemCode(bytes32 codeHash, bytes calldata signature) external payable {
}
function innerCircleSale(uint256 amount, uint256 maxAmount, bytes calldata signature) external payable {
require(innerCircleSaleEnabled, "NOT_RELEASED");
require(totalSupply + amount <= IC_MAX, "MAX_SUPPLY_REACHED");
require(privateCounter + amount <= IC_MEMBERS, "MAX_PRIVATE_SALE");
require(purchases[msg.sender] + amount <= maxAmount, "MAX_PRIVATE_SALE");
purchases[msg.sender] += amount;
require(<FILL_ME>)
require(msg.value >= IC_PRICE * amount, "INSUFFICIENT_ETH_SENT");
privateCounter += amount;
for (uint256 i = 1; i <= amount; i++) {
_mint(msg.sender, totalSupply + i);
}
totalSupply += amount;
}
function allowListSale(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function mint(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function toggleSale() public onlyController {
}
function toggleClaimCode() public onlyController {
}
function toggleInnerCircle() public onlyController {
}
function toggleAllowList() public onlyController {
}
function updatePrice(uint256 newPrice) public onlyController {
}
function setSignerAddress(address newSigner) public onlyController {
}
function withdraw() public onlyController {
}
function setBaseURI(string memory _uri) public onlyController {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns (uint256[] memory) {
}
function tokenURI(uint256 _id) public view override returns (string memory) {
}
}
| verifySignature(amount,bytes32(maxAmount),signature,1),"INVALID_TRANSACTION" | 11,774 | verifySignature(amount,bytes32(maxAmount),signature,1) |
"NONCE_USED" | // SPDX-License-Identifier: MIT
/*
888888888 888888888 888888888
8888888888888 8888888888888 8888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888888888 8888888888888888888 8888888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
88888888888888888 88888888888888888 88888888888888888
888888888888888 888888888888888 888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888888888888888 8888888888888888888 8888888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888 8888888888888 8888888888888
888888888 888888888 888888888
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ICExtensionSale is ERC721, Ownable {
using Strings for uint256;
uint256 private IC_PRICE = 0.0888 ether;
uint256 private constant IC_CODE = 1111;
uint256 private constant IC_MEMBERS = 3000;
uint256 private constant IC_COMMUNITY = 4000;
uint256 private constant IC_MAX = 10000;
uint256 private constant IC_MAX_PER_TX = 8;
address private constant IC_PAYOUT_ADDRESS = 0x31712E09c24efe4d30d9C89B09DAE15283932C50;
mapping(bytes32 => bool) private _hashes;
mapping(address => uint256) public purchases;
string private __baseURI;
address private _signer = 0x48AcED49470bb1A326062d36e4185ff9C0888888;
address private _controller;
uint256 public totalSupply;
uint256 public codeCounter;
uint256 public privateCounter;
uint256 public allowListCounter;
bool public saleEnabled;
bool public codeClaimEnabled;
bool public innerCircleSaleEnabled;
bool public allowListEnabled;
constructor(string memory _name, string memory _symbol, string memory _uri, address _admin) ERC721(_name, _symbol) {
}
modifier onlyController {
}
function verifyCode(bytes32 codeHash, bytes calldata signature) internal view returns (bool) {
}
function verifySignature(uint256 amount, bytes32 nonce, bytes calldata signature, uint256 saleType) internal view returns (bool) {
}
function redeemCode(bytes32 codeHash, bytes calldata signature) external payable {
}
function innerCircleSale(uint256 amount, uint256 maxAmount, bytes calldata signature) external payable {
}
function allowListSale(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
require(allowListEnabled, "NOT_RELEASED");
require(<FILL_ME>)
require(totalSupply + amount <= IC_MAX, "MAX_SUPPLY_REACHED");
require(amount <= IC_MAX_PER_TX, "MAX_PER_TX");
require(allowListCounter + amount + privateCounter <= IC_COMMUNITY + IC_MEMBERS, "MAX_ALLOW_SALE");
require(verifySignature(amount, nonce, signature, 2), "INVALID_TRANSACTION");
require(msg.value >= IC_PRICE * amount, "INSUFFICIENT_ETH_SENT");
_hashes[nonce] = true;
allowListCounter += amount;
for (uint256 i = 1; i <= amount; i++) {
_mint(msg.sender, totalSupply + i);
}
totalSupply += amount;
}
function mint(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function toggleSale() public onlyController {
}
function toggleClaimCode() public onlyController {
}
function toggleInnerCircle() public onlyController {
}
function toggleAllowList() public onlyController {
}
function updatePrice(uint256 newPrice) public onlyController {
}
function setSignerAddress(address newSigner) public onlyController {
}
function withdraw() public onlyController {
}
function setBaseURI(string memory _uri) public onlyController {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns (uint256[] memory) {
}
function tokenURI(uint256 _id) public view override returns (string memory) {
}
}
| !_hashes[nonce],"NONCE_USED" | 11,774 | !_hashes[nonce] |
"MAX_ALLOW_SALE" | // SPDX-License-Identifier: MIT
/*
888888888 888888888 888888888
8888888888888 8888888888888 8888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888888888 8888888888888888888 8888888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
88888888888888888 88888888888888888 88888888888888888
888888888888888 888888888888888 888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888888888888888 8888888888888888888 8888888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888 8888888888888 8888888888888
888888888 888888888 888888888
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ICExtensionSale is ERC721, Ownable {
using Strings for uint256;
uint256 private IC_PRICE = 0.0888 ether;
uint256 private constant IC_CODE = 1111;
uint256 private constant IC_MEMBERS = 3000;
uint256 private constant IC_COMMUNITY = 4000;
uint256 private constant IC_MAX = 10000;
uint256 private constant IC_MAX_PER_TX = 8;
address private constant IC_PAYOUT_ADDRESS = 0x31712E09c24efe4d30d9C89B09DAE15283932C50;
mapping(bytes32 => bool) private _hashes;
mapping(address => uint256) public purchases;
string private __baseURI;
address private _signer = 0x48AcED49470bb1A326062d36e4185ff9C0888888;
address private _controller;
uint256 public totalSupply;
uint256 public codeCounter;
uint256 public privateCounter;
uint256 public allowListCounter;
bool public saleEnabled;
bool public codeClaimEnabled;
bool public innerCircleSaleEnabled;
bool public allowListEnabled;
constructor(string memory _name, string memory _symbol, string memory _uri, address _admin) ERC721(_name, _symbol) {
}
modifier onlyController {
}
function verifyCode(bytes32 codeHash, bytes calldata signature) internal view returns (bool) {
}
function verifySignature(uint256 amount, bytes32 nonce, bytes calldata signature, uint256 saleType) internal view returns (bool) {
}
function redeemCode(bytes32 codeHash, bytes calldata signature) external payable {
}
function innerCircleSale(uint256 amount, uint256 maxAmount, bytes calldata signature) external payable {
}
function allowListSale(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
require(allowListEnabled, "NOT_RELEASED");
require(!_hashes[nonce], "NONCE_USED");
require(totalSupply + amount <= IC_MAX, "MAX_SUPPLY_REACHED");
require(amount <= IC_MAX_PER_TX, "MAX_PER_TX");
require(<FILL_ME>)
require(verifySignature(amount, nonce, signature, 2), "INVALID_TRANSACTION");
require(msg.value >= IC_PRICE * amount, "INSUFFICIENT_ETH_SENT");
_hashes[nonce] = true;
allowListCounter += amount;
for (uint256 i = 1; i <= amount; i++) {
_mint(msg.sender, totalSupply + i);
}
totalSupply += amount;
}
function mint(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function toggleSale() public onlyController {
}
function toggleClaimCode() public onlyController {
}
function toggleInnerCircle() public onlyController {
}
function toggleAllowList() public onlyController {
}
function updatePrice(uint256 newPrice) public onlyController {
}
function setSignerAddress(address newSigner) public onlyController {
}
function withdraw() public onlyController {
}
function setBaseURI(string memory _uri) public onlyController {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns (uint256[] memory) {
}
function tokenURI(uint256 _id) public view override returns (string memory) {
}
}
| allowListCounter+amount+privateCounter<=IC_COMMUNITY+IC_MEMBERS,"MAX_ALLOW_SALE" | 11,774 | allowListCounter+amount+privateCounter<=IC_COMMUNITY+IC_MEMBERS |
"INVALID_TRANSACTION" | // SPDX-License-Identifier: MIT
/*
888888888 888888888 888888888
8888888888888 8888888888888 8888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888888888 8888888888888888888 8888888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
88888888888888888 88888888888888888 88888888888888888
888888888888888 888888888888888 888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888888888888888 8888888888888888888 8888888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888 8888888888888 8888888888888
888888888 888888888 888888888
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ICExtensionSale is ERC721, Ownable {
using Strings for uint256;
uint256 private IC_PRICE = 0.0888 ether;
uint256 private constant IC_CODE = 1111;
uint256 private constant IC_MEMBERS = 3000;
uint256 private constant IC_COMMUNITY = 4000;
uint256 private constant IC_MAX = 10000;
uint256 private constant IC_MAX_PER_TX = 8;
address private constant IC_PAYOUT_ADDRESS = 0x31712E09c24efe4d30d9C89B09DAE15283932C50;
mapping(bytes32 => bool) private _hashes;
mapping(address => uint256) public purchases;
string private __baseURI;
address private _signer = 0x48AcED49470bb1A326062d36e4185ff9C0888888;
address private _controller;
uint256 public totalSupply;
uint256 public codeCounter;
uint256 public privateCounter;
uint256 public allowListCounter;
bool public saleEnabled;
bool public codeClaimEnabled;
bool public innerCircleSaleEnabled;
bool public allowListEnabled;
constructor(string memory _name, string memory _symbol, string memory _uri, address _admin) ERC721(_name, _symbol) {
}
modifier onlyController {
}
function verifyCode(bytes32 codeHash, bytes calldata signature) internal view returns (bool) {
}
function verifySignature(uint256 amount, bytes32 nonce, bytes calldata signature, uint256 saleType) internal view returns (bool) {
}
function redeemCode(bytes32 codeHash, bytes calldata signature) external payable {
}
function innerCircleSale(uint256 amount, uint256 maxAmount, bytes calldata signature) external payable {
}
function allowListSale(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
require(allowListEnabled, "NOT_RELEASED");
require(!_hashes[nonce], "NONCE_USED");
require(totalSupply + amount <= IC_MAX, "MAX_SUPPLY_REACHED");
require(amount <= IC_MAX_PER_TX, "MAX_PER_TX");
require(allowListCounter + amount + privateCounter <= IC_COMMUNITY + IC_MEMBERS, "MAX_ALLOW_SALE");
require(<FILL_ME>)
require(msg.value >= IC_PRICE * amount, "INSUFFICIENT_ETH_SENT");
_hashes[nonce] = true;
allowListCounter += amount;
for (uint256 i = 1; i <= amount; i++) {
_mint(msg.sender, totalSupply + i);
}
totalSupply += amount;
}
function mint(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function toggleSale() public onlyController {
}
function toggleClaimCode() public onlyController {
}
function toggleInnerCircle() public onlyController {
}
function toggleAllowList() public onlyController {
}
function updatePrice(uint256 newPrice) public onlyController {
}
function setSignerAddress(address newSigner) public onlyController {
}
function withdraw() public onlyController {
}
function setBaseURI(string memory _uri) public onlyController {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns (uint256[] memory) {
}
function tokenURI(uint256 _id) public view override returns (string memory) {
}
}
| verifySignature(amount,nonce,signature,2),"INVALID_TRANSACTION" | 11,774 | verifySignature(amount,nonce,signature,2) |
"MAX_PUBLIC_SALE" | // SPDX-License-Identifier: MIT
/*
888888888 888888888 888888888
8888888888888 8888888888888 8888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888888888 8888888888888888888 8888888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
88888888888888888 88888888888888888 88888888888888888
888888888888888 888888888888888 888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888888888888888 8888888888888888888 8888888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888 8888888888888 8888888888888
888888888 888888888 888888888
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ICExtensionSale is ERC721, Ownable {
using Strings for uint256;
uint256 private IC_PRICE = 0.0888 ether;
uint256 private constant IC_CODE = 1111;
uint256 private constant IC_MEMBERS = 3000;
uint256 private constant IC_COMMUNITY = 4000;
uint256 private constant IC_MAX = 10000;
uint256 private constant IC_MAX_PER_TX = 8;
address private constant IC_PAYOUT_ADDRESS = 0x31712E09c24efe4d30d9C89B09DAE15283932C50;
mapping(bytes32 => bool) private _hashes;
mapping(address => uint256) public purchases;
string private __baseURI;
address private _signer = 0x48AcED49470bb1A326062d36e4185ff9C0888888;
address private _controller;
uint256 public totalSupply;
uint256 public codeCounter;
uint256 public privateCounter;
uint256 public allowListCounter;
bool public saleEnabled;
bool public codeClaimEnabled;
bool public innerCircleSaleEnabled;
bool public allowListEnabled;
constructor(string memory _name, string memory _symbol, string memory _uri, address _admin) ERC721(_name, _symbol) {
}
modifier onlyController {
}
function verifyCode(bytes32 codeHash, bytes calldata signature) internal view returns (bool) {
}
function verifySignature(uint256 amount, bytes32 nonce, bytes calldata signature, uint256 saleType) internal view returns (bool) {
}
function redeemCode(bytes32 codeHash, bytes calldata signature) external payable {
}
function innerCircleSale(uint256 amount, uint256 maxAmount, bytes calldata signature) external payable {
}
function allowListSale(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function mint(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
require(saleEnabled, "NOT_RELEASED");
require(!_hashes[nonce], "NONCE_USED");
require(amount <= IC_MAX_PER_TX, "MAX_PER_TX");
require(<FILL_ME>)
require(verifySignature(amount, nonce, signature, 3), "INVALID_TRANSACTION");
require(msg.value >= IC_PRICE * amount, "INSUFFICIENT_ETH_SENT");
_hashes[nonce] = true;
for (uint256 i = 1; i <= amount; i++) {
_mint(msg.sender, totalSupply + i);
}
totalSupply += amount;
}
function toggleSale() public onlyController {
}
function toggleClaimCode() public onlyController {
}
function toggleInnerCircle() public onlyController {
}
function toggleAllowList() public onlyController {
}
function updatePrice(uint256 newPrice) public onlyController {
}
function setSignerAddress(address newSigner) public onlyController {
}
function withdraw() public onlyController {
}
function setBaseURI(string memory _uri) public onlyController {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns (uint256[] memory) {
}
function tokenURI(uint256 _id) public view override returns (string memory) {
}
}
| totalSupply+amount-codeCounter<=IC_MAX-IC_CODE,"MAX_PUBLIC_SALE" | 11,774 | totalSupply+amount-codeCounter<=IC_MAX-IC_CODE |
"INVALID_TRANSACTION" | // SPDX-License-Identifier: MIT
/*
888888888 888888888 888888888
8888888888888 8888888888888 8888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888888888 8888888888888888888 8888888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
88888888888888888 88888888888888888 88888888888888888
888888888888888 888888888888888 888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888888888888888 8888888888888888888 8888888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888 8888888888888 8888888888888
888888888 888888888 888888888
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ICExtensionSale is ERC721, Ownable {
using Strings for uint256;
uint256 private IC_PRICE = 0.0888 ether;
uint256 private constant IC_CODE = 1111;
uint256 private constant IC_MEMBERS = 3000;
uint256 private constant IC_COMMUNITY = 4000;
uint256 private constant IC_MAX = 10000;
uint256 private constant IC_MAX_PER_TX = 8;
address private constant IC_PAYOUT_ADDRESS = 0x31712E09c24efe4d30d9C89B09DAE15283932C50;
mapping(bytes32 => bool) private _hashes;
mapping(address => uint256) public purchases;
string private __baseURI;
address private _signer = 0x48AcED49470bb1A326062d36e4185ff9C0888888;
address private _controller;
uint256 public totalSupply;
uint256 public codeCounter;
uint256 public privateCounter;
uint256 public allowListCounter;
bool public saleEnabled;
bool public codeClaimEnabled;
bool public innerCircleSaleEnabled;
bool public allowListEnabled;
constructor(string memory _name, string memory _symbol, string memory _uri, address _admin) ERC721(_name, _symbol) {
}
modifier onlyController {
}
function verifyCode(bytes32 codeHash, bytes calldata signature) internal view returns (bool) {
}
function verifySignature(uint256 amount, bytes32 nonce, bytes calldata signature, uint256 saleType) internal view returns (bool) {
}
function redeemCode(bytes32 codeHash, bytes calldata signature) external payable {
}
function innerCircleSale(uint256 amount, uint256 maxAmount, bytes calldata signature) external payable {
}
function allowListSale(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function mint(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
require(saleEnabled, "NOT_RELEASED");
require(!_hashes[nonce], "NONCE_USED");
require(amount <= IC_MAX_PER_TX, "MAX_PER_TX");
require(totalSupply + amount - codeCounter <= IC_MAX - IC_CODE, "MAX_PUBLIC_SALE");
require(<FILL_ME>)
require(msg.value >= IC_PRICE * amount, "INSUFFICIENT_ETH_SENT");
_hashes[nonce] = true;
for (uint256 i = 1; i <= amount; i++) {
_mint(msg.sender, totalSupply + i);
}
totalSupply += amount;
}
function toggleSale() public onlyController {
}
function toggleClaimCode() public onlyController {
}
function toggleInnerCircle() public onlyController {
}
function toggleAllowList() public onlyController {
}
function updatePrice(uint256 newPrice) public onlyController {
}
function setSignerAddress(address newSigner) public onlyController {
}
function withdraw() public onlyController {
}
function setBaseURI(string memory _uri) public onlyController {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns (uint256[] memory) {
}
function tokenURI(uint256 _id) public view override returns (string memory) {
}
}
| verifySignature(amount,nonce,signature,3),"INVALID_TRANSACTION" | 11,774 | verifySignature(amount,nonce,signature,3) |
"TOKEN_DOES_NOT_EXIST" | // SPDX-License-Identifier: MIT
/*
888888888 888888888 888888888
8888888888888 8888888888888 8888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888888888 8888888888888888888 8888888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
88888888888888888 88888888888888888 88888888888888888
888888888888888 888888888888888 888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888 8888888 8888888 8888888 8888888 8888888
8888888888888888888 8888888888888888888 8888888888888888888
88888888888888888 88888888888888888 88888888888888888
8888888888888 8888888888888 8888888888888
888888888 888888888 888888888
*/
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract ICExtensionSale is ERC721, Ownable {
using Strings for uint256;
uint256 private IC_PRICE = 0.0888 ether;
uint256 private constant IC_CODE = 1111;
uint256 private constant IC_MEMBERS = 3000;
uint256 private constant IC_COMMUNITY = 4000;
uint256 private constant IC_MAX = 10000;
uint256 private constant IC_MAX_PER_TX = 8;
address private constant IC_PAYOUT_ADDRESS = 0x31712E09c24efe4d30d9C89B09DAE15283932C50;
mapping(bytes32 => bool) private _hashes;
mapping(address => uint256) public purchases;
string private __baseURI;
address private _signer = 0x48AcED49470bb1A326062d36e4185ff9C0888888;
address private _controller;
uint256 public totalSupply;
uint256 public codeCounter;
uint256 public privateCounter;
uint256 public allowListCounter;
bool public saleEnabled;
bool public codeClaimEnabled;
bool public innerCircleSaleEnabled;
bool public allowListEnabled;
constructor(string memory _name, string memory _symbol, string memory _uri, address _admin) ERC721(_name, _symbol) {
}
modifier onlyController {
}
function verifyCode(bytes32 codeHash, bytes calldata signature) internal view returns (bool) {
}
function verifySignature(uint256 amount, bytes32 nonce, bytes calldata signature, uint256 saleType) internal view returns (bool) {
}
function redeemCode(bytes32 codeHash, bytes calldata signature) external payable {
}
function innerCircleSale(uint256 amount, uint256 maxAmount, bytes calldata signature) external payable {
}
function allowListSale(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function mint(uint256 amount, bytes32 nonce, bytes calldata signature) external payable {
}
function toggleSale() public onlyController {
}
function toggleClaimCode() public onlyController {
}
function toggleInnerCircle() public onlyController {
}
function toggleAllowList() public onlyController {
}
function updatePrice(uint256 newPrice) public onlyController {
}
function setSignerAddress(address newSigner) public onlyController {
}
function withdraw() public onlyController {
}
function setBaseURI(string memory _uri) public onlyController {
}
function tokensOfOwner(address _owner, uint startId, uint endId) external view returns (uint256[] memory) {
}
function tokenURI(uint256 _id) public view override returns (string memory) {
require(<FILL_ME>)
return string(abi.encodePacked(__baseURI, "/", _id.toString()));
}
}
| _exists(_id),"TOKEN_DOES_NOT_EXIST" | 11,774 | _exists(_id) |
"unknown market signer" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
require(
detail.txDeadline > block.timestamp,
"transaction deadline reached"
);
require(<FILL_ME>)
_validateOpCode(detail.opcode);
require(
isSignatureValid(
sigDetail,
keccak256(abi.encode(detail)),
detail.signer
),
"offer signature error"
);
if (hasSignedIntention(detail.opcode)) {
bytes memory encodedInt = abi.encode(intent);
require(
keccak256(encodedInt) == detail.intentionHash,
"intention hash does not match"
);
require(
isSignatureValid(sigIntent, keccak256(encodedInt), intent.user),
"intention signature error"
);
}
if (detail.opcode == OP_COMPLETE_SELL) {
_assertSender(detail.caller);
require(
intent.kind == KIND_SELL,
"intent.kind should be KIND_SELL"
);
_newSellDeal(
detail.id,
intent.user,
intent.bundle,
intent.currency,
intent.price,
intent.deadline,
detail.caller,
detail.settlement
);
} else if (detail.opcode == OP_COMPLETE_BUY) {
_assertSender(detail.caller);
require(intent.kind == KIND_BUY, "intent.kind should be KIND_BUY");
_newBuyDeal(
detail.id,
intent.user, // buyer
detail.caller, // seller
intent.bundle,
intent.currency,
intent.price,
intent.deadline,
detail.settlement
);
} else if (detail.opcode == OP_BUY) {
_assertSender(detail.caller);
_newBuy(
detail.id,
detail.caller,
detail.currency,
detail.price,
detail.bundle,
detail.deadline
);
} else if (detail.opcode == OP_ACCEPT_BUY) {
_assertSender(detail.caller);
_acceptBuy(detail.id, detail.caller, detail.settlement);
} else if (detail.opcode == OP_CANCEL_BUY) {
_cancelBuyAnyway(detail.id);
} else if (detail.opcode == OP_REJECT_BUY) {
_rejectBuy(detail.id);
} else if (detail.opcode == OP_BID) {
_assertSender(detail.caller);
require(
intent.kind == KIND_AUCTION,
"intent.kind should be KIND_AUCTION"
);
_bid(
detail.id,
intent.user,
intent.bundle,
intent.currency,
intent.price,
intent.deadline,
detail.caller,
detail.price,
detail.incentiveRate
);
} else if (detail.opcode == OP_COMPLETE_AUCTION) {
_completeAuction(detail.id, detail.settlement);
} else if (detail.opcode == OP_ACCEPT_AUCTION) {
_assertSender(detail.caller);
require(detail.caller == intent.user, "only seller can call");
_acceptAuction(detail.id, detail.settlement);
} else {
revert("impossible");
}
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| marketSigners[detail.signer],"unknown market signer" | 11,841 | marketSigners[detail.signer] |
"offer signature error" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
require(
detail.txDeadline > block.timestamp,
"transaction deadline reached"
);
require(marketSigners[detail.signer], "unknown market signer");
_validateOpCode(detail.opcode);
require(<FILL_ME>)
if (hasSignedIntention(detail.opcode)) {
bytes memory encodedInt = abi.encode(intent);
require(
keccak256(encodedInt) == detail.intentionHash,
"intention hash does not match"
);
require(
isSignatureValid(sigIntent, keccak256(encodedInt), intent.user),
"intention signature error"
);
}
if (detail.opcode == OP_COMPLETE_SELL) {
_assertSender(detail.caller);
require(
intent.kind == KIND_SELL,
"intent.kind should be KIND_SELL"
);
_newSellDeal(
detail.id,
intent.user,
intent.bundle,
intent.currency,
intent.price,
intent.deadline,
detail.caller,
detail.settlement
);
} else if (detail.opcode == OP_COMPLETE_BUY) {
_assertSender(detail.caller);
require(intent.kind == KIND_BUY, "intent.kind should be KIND_BUY");
_newBuyDeal(
detail.id,
intent.user, // buyer
detail.caller, // seller
intent.bundle,
intent.currency,
intent.price,
intent.deadline,
detail.settlement
);
} else if (detail.opcode == OP_BUY) {
_assertSender(detail.caller);
_newBuy(
detail.id,
detail.caller,
detail.currency,
detail.price,
detail.bundle,
detail.deadline
);
} else if (detail.opcode == OP_ACCEPT_BUY) {
_assertSender(detail.caller);
_acceptBuy(detail.id, detail.caller, detail.settlement);
} else if (detail.opcode == OP_CANCEL_BUY) {
_cancelBuyAnyway(detail.id);
} else if (detail.opcode == OP_REJECT_BUY) {
_rejectBuy(detail.id);
} else if (detail.opcode == OP_BID) {
_assertSender(detail.caller);
require(
intent.kind == KIND_AUCTION,
"intent.kind should be KIND_AUCTION"
);
_bid(
detail.id,
intent.user,
intent.bundle,
intent.currency,
intent.price,
intent.deadline,
detail.caller,
detail.price,
detail.incentiveRate
);
} else if (detail.opcode == OP_COMPLETE_AUCTION) {
_completeAuction(detail.id, detail.settlement);
} else if (detail.opcode == OP_ACCEPT_AUCTION) {
_assertSender(detail.caller);
require(detail.caller == intent.user, "only seller can call");
_acceptAuction(detail.id, detail.settlement);
} else {
revert("impossible");
}
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| isSignatureValid(sigDetail,keccak256(abi.encode(detail)),detail.signer),"offer signature error" | 11,841 | isSignatureValid(sigDetail,keccak256(abi.encode(detail)),detail.signer) |
"intention hash does not match" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
require(
detail.txDeadline > block.timestamp,
"transaction deadline reached"
);
require(marketSigners[detail.signer], "unknown market signer");
_validateOpCode(detail.opcode);
require(
isSignatureValid(
sigDetail,
keccak256(abi.encode(detail)),
detail.signer
),
"offer signature error"
);
if (hasSignedIntention(detail.opcode)) {
bytes memory encodedInt = abi.encode(intent);
require(<FILL_ME>)
require(
isSignatureValid(sigIntent, keccak256(encodedInt), intent.user),
"intention signature error"
);
}
if (detail.opcode == OP_COMPLETE_SELL) {
_assertSender(detail.caller);
require(
intent.kind == KIND_SELL,
"intent.kind should be KIND_SELL"
);
_newSellDeal(
detail.id,
intent.user,
intent.bundle,
intent.currency,
intent.price,
intent.deadline,
detail.caller,
detail.settlement
);
} else if (detail.opcode == OP_COMPLETE_BUY) {
_assertSender(detail.caller);
require(intent.kind == KIND_BUY, "intent.kind should be KIND_BUY");
_newBuyDeal(
detail.id,
intent.user, // buyer
detail.caller, // seller
intent.bundle,
intent.currency,
intent.price,
intent.deadline,
detail.settlement
);
} else if (detail.opcode == OP_BUY) {
_assertSender(detail.caller);
_newBuy(
detail.id,
detail.caller,
detail.currency,
detail.price,
detail.bundle,
detail.deadline
);
} else if (detail.opcode == OP_ACCEPT_BUY) {
_assertSender(detail.caller);
_acceptBuy(detail.id, detail.caller, detail.settlement);
} else if (detail.opcode == OP_CANCEL_BUY) {
_cancelBuyAnyway(detail.id);
} else if (detail.opcode == OP_REJECT_BUY) {
_rejectBuy(detail.id);
} else if (detail.opcode == OP_BID) {
_assertSender(detail.caller);
require(
intent.kind == KIND_AUCTION,
"intent.kind should be KIND_AUCTION"
);
_bid(
detail.id,
intent.user,
intent.bundle,
intent.currency,
intent.price,
intent.deadline,
detail.caller,
detail.price,
detail.incentiveRate
);
} else if (detail.opcode == OP_COMPLETE_AUCTION) {
_completeAuction(detail.id, detail.settlement);
} else if (detail.opcode == OP_ACCEPT_AUCTION) {
_assertSender(detail.caller);
require(detail.caller == intent.user, "only seller can call");
_acceptAuction(detail.id, detail.settlement);
} else {
revert("impossible");
}
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| keccak256(encodedInt)==detail.intentionHash,"intention hash does not match" | 11,841 | keccak256(encodedInt)==detail.intentionHash |
"intention signature error" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
require(
detail.txDeadline > block.timestamp,
"transaction deadline reached"
);
require(marketSigners[detail.signer], "unknown market signer");
_validateOpCode(detail.opcode);
require(
isSignatureValid(
sigDetail,
keccak256(abi.encode(detail)),
detail.signer
),
"offer signature error"
);
if (hasSignedIntention(detail.opcode)) {
bytes memory encodedInt = abi.encode(intent);
require(
keccak256(encodedInt) == detail.intentionHash,
"intention hash does not match"
);
require(<FILL_ME>)
}
if (detail.opcode == OP_COMPLETE_SELL) {
_assertSender(detail.caller);
require(
intent.kind == KIND_SELL,
"intent.kind should be KIND_SELL"
);
_newSellDeal(
detail.id,
intent.user,
intent.bundle,
intent.currency,
intent.price,
intent.deadline,
detail.caller,
detail.settlement
);
} else if (detail.opcode == OP_COMPLETE_BUY) {
_assertSender(detail.caller);
require(intent.kind == KIND_BUY, "intent.kind should be KIND_BUY");
_newBuyDeal(
detail.id,
intent.user, // buyer
detail.caller, // seller
intent.bundle,
intent.currency,
intent.price,
intent.deadline,
detail.settlement
);
} else if (detail.opcode == OP_BUY) {
_assertSender(detail.caller);
_newBuy(
detail.id,
detail.caller,
detail.currency,
detail.price,
detail.bundle,
detail.deadline
);
} else if (detail.opcode == OP_ACCEPT_BUY) {
_assertSender(detail.caller);
_acceptBuy(detail.id, detail.caller, detail.settlement);
} else if (detail.opcode == OP_CANCEL_BUY) {
_cancelBuyAnyway(detail.id);
} else if (detail.opcode == OP_REJECT_BUY) {
_rejectBuy(detail.id);
} else if (detail.opcode == OP_BID) {
_assertSender(detail.caller);
require(
intent.kind == KIND_AUCTION,
"intent.kind should be KIND_AUCTION"
);
_bid(
detail.id,
intent.user,
intent.bundle,
intent.currency,
intent.price,
intent.deadline,
detail.caller,
detail.price,
detail.incentiveRate
);
} else if (detail.opcode == OP_COMPLETE_AUCTION) {
_completeAuction(detail.id, detail.settlement);
} else if (detail.opcode == OP_ACCEPT_AUCTION) {
_assertSender(detail.caller);
require(detail.caller == intent.user, "only seller can call");
_acceptAuction(detail.id, detail.settlement);
} else {
revert("impossible");
}
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| isSignatureValid(sigIntent,keccak256(encodedInt),intent.user),"intention signature error" | 11,841 | isSignatureValid(sigIntent,keccak256(encodedInt),intent.user) |
"not auction" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
require(<FILL_ME>)
require(isStatusOpen(id), "not open");
Inventory storage inv = inventories[id];
if (!noBundle) {
_transferBundle(id, address(this), inv.seller, false);
}
_transfer(inv.currency, inv.buyer, inv.netPrice);
inv.status = STATUS_CANCELLED;
emit EvInventoryUpdate(id, inv);
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| isAuction(id),"not auction" | 11,841 | isAuction(id) |
"not open" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
require(isAuction(id), "not auction");
require(<FILL_ME>)
Inventory storage inv = inventories[id];
if (!noBundle) {
_transferBundle(id, address(this), inv.seller, false);
}
_transfer(inv.currency, inv.buyer, inv.netPrice);
inv.status = STATUS_CANCELLED;
emit EvInventoryUpdate(id, inv);
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| isStatusOpen(id),"not open" | 11,841 | isStatusOpen(id) |
"signature error" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
require(req.deadline > block.timestamp, "deadline reached");
require(<FILL_ME>)
for (uint256 i = 0; i < req.wants.length; i++) {
req.wants[i].token.safeTransferFrom(
msg.sender,
req.creator,
req.wants[i].tokenId
);
}
for (uint256 i = 0; i < req.has.length; i++) {
req.has[i].token.safeTransferFrom(
req.creator,
msg.sender,
req.has[i].tokenId
);
}
emit EvSwapped(req, signature, msg.sender);
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| isSignatureValid(signature,keccak256(abi.encode(req)),req.creator),"signature error" | 11,841 | isSignatureValid(signature,keccak256(abi.encode(req)),req.creator) |
"inventoryId already exists" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
require(<FILL_ME>)
require(
deadline > block.timestamp,
"deadline must be greater than now"
);
_saveBundle(id, bundle);
if (_isNative(currency)) {
require(price == msg.value, "price == msg.value");
weth.deposit{value: price}(); // convert to erc20 (weth)
} else {
currency.safeTransferFrom(buyer, address(this), price);
}
inventories[id] = Inventory({
seller: address(0),
buyer: buyer,
currency: currency,
price: price,
netPrice: price,
kind: KIND_BUY,
status: STATUS_OPEN,
deadline: deadline
});
emit EvInventoryUpdate(id, inventories[id]);
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| !hasInv(id),"inventoryId already exists" | 11,841 | !hasInv(id) |
"not open buy" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
require(<FILL_ME>)
Inventory storage inv = inventories[id];
inv.status = STATUS_CANCELLED;
_transfer(inv.currency, inv.buyer, inv.netPrice);
emit EvInventoryUpdate(id, inventories[id]);
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| isBuy(id)&&isStatusOpen(id),"not open buy" | 11,841 | isBuy(id)&&isStatusOpen(id) |
"caller does not own token" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
address caller = msg.sender;
require(isBuy(id) && isStatusOpen(id), "not open buy");
for (uint256 i = 0; i < inventoryTokenCounts[id]; i++) {
TokenPair storage p = inventoryTokens[id][i];
if (p.kind == TOKEN_721) {
IERC721 t = IERC721(p.token);
require(<FILL_ME>)
} else {
revert("cannot reject non-721 token");
}
}
_cancelBuyAnyway(id);
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| t.ownerOf(p.tokenId)==caller,"caller does not own token" | 11,841 | t.ownerOf(p.tokenId)==caller |
"id does not exist" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
require(<FILL_ME>)
Inventory storage inv = inventories[id];
require(isStatusOpen(id), "not open");
require(isBundleApproved(id, seller), "bundle not approved");
require(!isExpired(id), "buy offer expired");
inv.status = STATUS_DONE;
inv.seller = seller;
_transferBundle(id, seller, inv.buyer, true);
emit EvInventoryUpdate(id, inventories[id]);
_completeTransaction(id, settlement);
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| isBuy(id),"id does not exist" | 11,841 | isBuy(id) |
"bundle not approved" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
require(isBuy(id), "id does not exist");
Inventory storage inv = inventories[id];
require(isStatusOpen(id), "not open");
require(<FILL_ME>)
require(!isExpired(id), "buy offer expired");
inv.status = STATUS_DONE;
inv.seller = seller;
_transferBundle(id, seller, inv.buyer, true);
emit EvInventoryUpdate(id, inventories[id]);
_completeTransaction(id, settlement);
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| isBundleApproved(id,seller),"bundle not approved" | 11,841 | isBundleApproved(id,seller) |
"buy offer expired" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
require(isBuy(id), "id does not exist");
Inventory storage inv = inventories[id];
require(isStatusOpen(id), "not open");
require(isBundleApproved(id, seller), "bundle not approved");
require(<FILL_ME>)
inv.status = STATUS_DONE;
inv.seller = seller;
_transferBundle(id, seller, inv.buyer, true);
emit EvInventoryUpdate(id, inventories[id]);
_completeTransaction(id, settlement);
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| !isExpired(id),"buy offer expired" | 11,841 | !isExpired(id) |
"cannot use native token" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
require(!hasInv(id), "inventory already exists");
require(deadline > block.timestamp, "buy has already ended");
require(<FILL_ME>)
_saveBundle(id, bundle);
_transferBundle(id, seller, buyer, true);
currency.safeTransferFrom(buyer, address(this), price);
inventories[id] = Inventory({
seller: seller,
buyer: buyer,
currency: currency,
price: price,
netPrice: price,
kind: KIND_BUY,
status: STATUS_DONE,
deadline: deadline
});
emit EvInventoryUpdate(id, inventories[id]);
_completeTransaction(id, settlement);
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| !_isNative(currency),"cannot use native token" | 11,841 | !_isNative(currency) |
"auction still going" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
require(<FILL_ME>)
_acceptAuction(id, settlement);
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| inventories[id].deadline<block.timestamp,"auction still going" | 11,841 | inventories[id].deadline<block.timestamp |
"no inventory or state error" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
Inventory storage inv = inventories[id];
require(<FILL_ME>)
// sanity
_markCoupon(id, settlement.coupons);
uint256 price = inv.price;
uint256 fee = (price * settlement.feeRate) / RATE_BASE;
uint256 royalty = (price * settlement.royaltyRate) / RATE_BASE;
uint256 buyerAmount = (price * settlement.buyerCashbackRate) /
RATE_BASE;
uint256 sellerAmount = inv.netPrice - fee - royalty - buyerAmount;
_transfer(inv.currency, inv.seller, sellerAmount);
_transfer(inv.currency, inv.buyer, buyerAmount);
_transfer(inv.currency, settlement.feeAddress, fee);
_transfer(inv.currency, settlement.royaltyAddress, royalty);
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| hasInv(id)&&inv.status==STATUS_DONE,"no inventory or state error" | 11,841 | hasInv(id)&&inv.status==STATUS_DONE |
"coupon already spent" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
for (uint256 i = 0; i < coupons.length; i++) {
uint256 id = coupons[i];
require(<FILL_ME>)
couponSpent[id] = true;
emit EvCouponSpent(invId, id);
}
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| !couponSpent[id],"coupon already spent" | 11,841 | !couponSpent[id] |
"no inventory" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
interface IMintable {
function mint(address to, bytes memory data) external;
}
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
contract MarketNG is
IERC721Receiver,
IERC1155Receiver,
ReentrancyGuard,
Ownable,
Pausable
{
using SafeERC20 for IERC20;
uint8 public constant KIND_SELL = 1;
uint8 public constant KIND_BUY = 2;
uint8 public constant KIND_AUCTION = 3;
uint8 public constant STATUS_OPEN = 0;
uint8 public constant STATUS_DONE = 1;
uint8 public constant STATUS_CANCELLED = 2;
uint8 public constant OP_MIN = 0; // invalid, for checks only
uint8 public constant OP_COMPLETE_SELL = 1; // complete sell (off-chain)
uint8 public constant OP_COMPLETE_BUY = 2; // complete buy (off-chain)
uint8 public constant OP_BUY = 3; // create KIND_BUY
uint8 public constant OP_ACCEPT_BUY = 4; // complete KIND_BUY
uint8 public constant OP_CANCEL_BUY = 5; // cancel KIND_BUY
uint8 public constant OP_REJECT_BUY = 6; // reject KIND_BUY
uint8 public constant OP_BID = 7; // bid (create or update KIND_AUCTION)
uint8 public constant OP_COMPLETE_AUCTION = 8; // complete auction (by anyone)
uint8 public constant OP_ACCEPT_AUCTION = 9; // accept auction in an early stage (by seller)
uint8 public constant OP_MAX = 10;
uint8 public constant TOKEN_MINT = 0; // mint token (do anything)
uint8 public constant TOKEN_721 = 1; // 721 token
uint8 public constant TOKEN_1155 = 2; // 1155 token
uint256 public constant RATE_BASE = 1e6;
struct Pair721 {
// swap only
IERC721 token;
uint256 tokenId;
}
struct TokenPair {
address token; // token contract address
uint256 tokenId; // token id (if applicable)
uint256 amount; // token amount (if applicable)
uint8 kind; // token kind (721/1151/mint)
bytes mintData; // mint data (if applicable)
}
struct Inventory {
address seller;
address buyer;
IERC20 currency;
uint256 price; // display price
uint256 netPrice; // actual price (auction: minus incentive)
uint256 deadline; // deadline for the inventory
uint8 kind;
uint8 status;
}
struct Intention {
address user;
TokenPair[] bundle;
IERC20 currency;
uint256 price;
uint256 deadline;
bytes32 salt;
uint8 kind;
}
struct Detail {
bytes32 intentionHash;
address signer;
uint256 txDeadline; // deadline for the transaction
bytes32 salt;
uint256 id; // inventory id
uint8 opcode; // OP_*
address caller;
IERC20 currency;
uint256 price;
uint256 incentiveRate;
Settlement settlement;
TokenPair[] bundle;
uint256 deadline; // deadline for buy offer
}
struct Settlement {
uint256[] coupons;
uint256 feeRate;
uint256 royaltyRate;
uint256 buyerCashbackRate;
address feeAddress;
address royaltyAddress;
}
struct Swap {
bytes32 salt;
address creator;
uint256 deadline;
Pair721[] has;
Pair721[] wants;
}
// events
event EvCouponSpent(uint256 indexed id, uint256 indexed couponId);
event EvInventoryUpdate(uint256 indexed id, Inventory inventory);
event EvAuctionRefund(uint256 indexed id, address bidder, uint256 refund);
event EvSettingsUpdated();
event EvMarketSignerUpdate(address addr, bool isRemoval);
event EvSwapped(Swap req, bytes signature, address swapper);
// vars
IWETH public immutable weth;
mapping(uint256 => Inventory) public inventories;
mapping(uint256 => bool) public couponSpent;
mapping(uint256 => mapping(uint256 => TokenPair)) public inventoryTokens;
mapping(uint256 => uint256) public inventoryTokenCounts;
mapping(address => bool) public marketSigners;
// initialized with default value
uint256 public minAuctionIncrement = (5 * RATE_BASE) / 100;
uint256 public minAuctionDuration = 10 * 60;
// internal vars
bool internal _canReceive = false;
// constructor
constructor(IWETH weth_) {
}
function updateSettings(
uint256 minAuctionIncrement_,
uint256 minAuctionDuration_
) public onlyOwner {
}
function updateSigner(address addr, bool remove) public onlyOwner {
}
// impls
receive() external payable {}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external view override _onTransferOnly returns (bytes4) {
}
modifier _onTransferOnly() {
}
modifier _allowTransfer() {
}
// public
function supportsInterface(bytes4 interfaceId)
external
pure
override
returns (bool)
{
}
function run(
Intention calldata intent,
Detail calldata detail,
bytes calldata sigIntent,
bytes calldata sigDetail
) public payable nonReentrant whenNotPaused {
}
function cancelBuys(uint256[] calldata ids)
public
nonReentrant
whenNotPaused
{
}
function inCaseMoneyGetsStuck(
address to,
IERC20 currency,
uint256 amount
) public onlyOwner {
}
// emergency method for flaky contracts
function emergencyCancelAuction(uint256 id, bool noBundle)
public
onlyOwner
{
}
function swap(Swap memory req, bytes memory signature)
public
nonReentrant
whenNotPaused
{
}
function send(address to, Pair721[] memory tokens)
public
nonReentrant
whenNotPaused
{
}
// internal
function _assertSender(address sender) internal view {
}
function _validateOpCode(uint8 opCode) internal pure {
}
function _saveBundle(uint256 invId, TokenPair[] calldata bundle) internal {
}
// buyer create
function _newBuy(
uint256 id,
address buyer,
IERC20 currency,
uint256 price,
TokenPair[] calldata bundle,
uint256 deadline
) internal {
}
// buyer cancel/expired
function _cancelBuy(uint256 id) internal {
}
// cancel without checking caller
function _cancelBuyAnyway(uint256 id) internal {
}
function _rejectBuy(uint256 id) internal {
}
// seller call
function _acceptBuy(
uint256 id,
address seller,
Settlement calldata settlement
) internal {
}
function _newBuyDeal(
uint256 id,
address buyer,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
Settlement calldata settlement
) internal {
}
// new sell deal / new auction direct buy
function _newSellDeal(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 price,
uint256 deadline,
address buyer,
Settlement calldata settlement
) internal {
}
function _bid(
uint256 id,
address seller,
TokenPair[] calldata bundle,
IERC20 currency,
uint256 startPrice,
uint256 deadline,
address buyer,
uint256 price,
uint256 incentiveRate
) internal _allowTransfer {
}
function _completeAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _acceptAuction(uint256 id, Settlement calldata settlement)
internal
{
}
function _completeTransaction(uint256 id, Settlement calldata settlement)
internal
{
}
function _markCoupon(uint256 invId, uint256[] calldata coupons) internal {
}
function _isNative(IERC20 currency) internal pure returns (bool) {
}
function _transfer(
IERC20 currency,
address to,
uint256 amount
) internal {
}
function _transferBundle(
uint256 invId,
address from,
address to,
bool doMint
) internal {
}
// public helpers
// also checks the right owner
function isBundleApproved(uint256 invId, address owner)
public
view
returns (bool)
{
require(<FILL_ME>)
for (uint256 i = 0; i < inventoryTokenCounts[invId]; i++) {
TokenPair storage p = inventoryTokens[invId][i];
if (p.kind == TOKEN_MINT) {
// pass
} else if (p.kind == TOKEN_721) {
IERC721 t = IERC721(p.token);
if (
t.ownerOf(p.tokenId) == owner &&
(t.getApproved(p.tokenId) == address(this) ||
t.isApprovedForAll(owner, address(this)))
) {
// pass
} else {
return false;
}
} else if (p.kind == TOKEN_1155) {
IERC1155 t = IERC1155(p.token);
if (
t.balanceOf(owner, p.tokenId) >= p.amount &&
t.isApprovedForAll(owner, address(this))
) {
// pass
} else {
return false;
}
} else {
revert("unsupported token");
}
}
return true;
}
function isAuctionOpen(uint256 id) public view returns (bool) {
}
function isBuyOpen(uint256 id) public view returns (bool) {
}
function isAuction(uint256 id) public view returns (bool) {
}
function isBuy(uint256 id) public view returns (bool) {
}
function isSell(uint256 id) public view returns (bool) {
}
function hasInv(uint256 id) public view returns (bool) {
}
function isStatusOpen(uint256 id) public view returns (bool) {
}
function isExpired(uint256 id) public view returns (bool) {
}
function isSignatureValid(
bytes memory signature,
bytes32 hash,
address signer
) public pure returns (bool) {
}
function hasSignedIntention(uint8 op) public pure returns (bool) {
}
}
| hasInv(invId),"no inventory" | 11,841 | hasInv(invId) |
null | pragma solidity ^0.4.18;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
interface IERC20 {
function balanceOf(address _owner) public view returns (uint256);
function allowance(address _owner, address _spender) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
*/
contract SolaToken is IERC20 {
using SafeMath for uint256;
string public name = 'Sola';
string public symbol = 'SOLA';
uint8 public constant decimals = 18;
uint256 public constant decimalFactor = 10 ** uint256(decimals);
uint256 public constant totalSupply = 1000000000 * decimalFactor;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Constructor for Sola creation
* @dev Assigns the totalSupply to the SolaDistribution contract
*/
function SolaToken(address _solaDistributionContractAddress) public {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
}
/**
* @title SOLA token initial distribution
*
* @dev Distribute purchasers, airdrop, reserve, and founder tokens
*/
contract SolaDistribution is Ownable {
using SafeMath for uint256;
SolaToken public SOLA;
uint256 private constant decimalFactor = 10**uint256(18);
enum AllocationType { PRESALE, FOUNDER, AIRDROP, ADVISOR, RESERVE, BONUS1, BONUS2, BONUS3 }
uint256 public constant INITIAL_SUPPLY = 1000000000 * decimalFactor;
uint256 public AVAILABLE_TOTAL_SUPPLY = 1000000000 * decimalFactor;
uint256 public AVAILABLE_PRESALE_SUPPLY = 230000000 * decimalFactor; // 100% Released at Token Distribution (TD)
uint256 public AVAILABLE_FOUNDER_SUPPLY = 150000000 * decimalFactor; // 33% Released at TD +1 year -> 100% at TD +3 years
uint256 public AVAILABLE_AIRDROP_SUPPLY = 10000000 * decimalFactor; // 100% Released at TD
uint256 public AVAILABLE_ADVISOR_SUPPLY = 20000000 * decimalFactor; // 100% Released at TD +7 months
uint256 public AVAILABLE_RESERVE_SUPPLY = 513116658 * decimalFactor; // 6.8% Released at TD +100 days -> 100% at TD +4 years
uint256 public AVAILABLE_BONUS1_SUPPLY = 39053330 * decimalFactor; // 100% Released at TD +1 year
uint256 public AVAILABLE_BONUS2_SUPPLY = 9354408 * decimalFactor; // 100% Released at TD +2 years
uint256 public AVAILABLE_BONUS3_SUPPLY = 28475604 * decimalFactor; // 100% Released at TD +3 years
uint256 public grandTotalClaimed = 0;
uint256 public startTime;
// Allocation with vesting information
struct Allocation {
uint8 AllocationSupply; // Type of allocation
uint256 endCliff; // Tokens are locked until
uint256 endVesting; // This is when the tokens are fully unvested
uint256 totalAllocated; // Total tokens allocated
uint256 amountClaimed; // Total tokens claimed
}
mapping (address => Allocation) public allocations;
// List of admins
mapping (address => bool) public airdropAdmins;
// Keeps track of whether or not a 250 SOLA airdrop has been made to a particular address
mapping (address => bool) public airdrops;
modifier onlyOwnerOrAdmin() {
}
event LogNewAllocation(address indexed _recipient, AllocationType indexed _fromSupply, uint256 _totalAllocated, uint256 _grandTotalAllocated);
event LogSolaClaimed(address indexed _recipient, uint8 indexed _fromSupply, uint256 _amountClaimed, uint256 _totalAllocated, uint256 _grandTotalClaimed);
/**
* @dev Constructor function - Set the sola token address
* @param _startTime The time when SolaDistribution goes live
*/
function SolaDistribution(uint256 _startTime) public {
}
/**
* @dev Allow the owner of the contract to assign a new allocation
* @param _recipient The recipient of the allocation
* @param _totalAllocated The total amount of SOLA available to the receipient (after vesting)
* @param _supply The SOLA supply the allocation will be taken from
*/
function setAllocation (address _recipient, uint256 _totalAllocated, AllocationType _supply) onlyOwner public {
require(<FILL_ME>)
require(_supply >= AllocationType.PRESALE && _supply <= AllocationType.BONUS3);
require(_recipient != address(0));
if (_supply == AllocationType.PRESALE) {
AVAILABLE_PRESALE_SUPPLY = AVAILABLE_PRESALE_SUPPLY.sub(_totalAllocated);
allocations[_recipient] = Allocation(uint8(AllocationType.PRESALE), 0, 0, _totalAllocated, 0);
} else if (_supply == AllocationType.FOUNDER) {
AVAILABLE_FOUNDER_SUPPLY = AVAILABLE_FOUNDER_SUPPLY.sub(_totalAllocated);
allocations[_recipient] = Allocation(uint8(AllocationType.FOUNDER), startTime + 1 years, startTime + 3 years, _totalAllocated, 0);
} else if (_supply == AllocationType.ADVISOR) {
AVAILABLE_ADVISOR_SUPPLY = AVAILABLE_ADVISOR_SUPPLY.sub(_totalAllocated);
allocations[_recipient] = Allocation(uint8(AllocationType.ADVISOR), startTime + 209 days, 0, _totalAllocated, 0);
} else if (_supply == AllocationType.RESERVE) {
AVAILABLE_RESERVE_SUPPLY = AVAILABLE_RESERVE_SUPPLY.sub(_totalAllocated);
allocations[_recipient] = Allocation(uint8(AllocationType.RESERVE), startTime + 100 days, startTime + 4 years, _totalAllocated, 0);
} else if (_supply == AllocationType.BONUS1) {
AVAILABLE_BONUS1_SUPPLY = AVAILABLE_BONUS1_SUPPLY.sub(_totalAllocated);
allocations[_recipient] = Allocation(uint8(AllocationType.BONUS1), startTime + 1 years, startTime + 1 years, _totalAllocated, 0);
} else if (_supply == AllocationType.BONUS2) {
AVAILABLE_BONUS2_SUPPLY = AVAILABLE_BONUS2_SUPPLY.sub(_totalAllocated);
allocations[_recipient] = Allocation(uint8(AllocationType.BONUS2), startTime + 2 years, startTime + 2 years, _totalAllocated, 0);
} else if (_supply == AllocationType.BONUS3) {
AVAILABLE_BONUS3_SUPPLY = AVAILABLE_BONUS3_SUPPLY.sub(_totalAllocated);
allocations[_recipient] = Allocation(uint8(AllocationType.BONUS3), startTime + 3 years, startTime + 3 years, _totalAllocated, 0);
}
AVAILABLE_TOTAL_SUPPLY = AVAILABLE_TOTAL_SUPPLY.sub(_totalAllocated);
LogNewAllocation(_recipient, _supply, _totalAllocated, grandTotalAllocated());
}
/**
* @dev Add an airdrop admin
*/
function setAirdropAdmin(address _admin, bool _isAdmin) public onlyOwner {
}
/**
* @dev perform a transfer of allocations
* @param _recipient is a list of recipients
*/
function airdropTokens(address[] _recipient) public onlyOwnerOrAdmin {
}
/**
* @dev Transfer a recipients available allocation to their address
* @param _recipient The address to withdraw tokens for
*/
function transferTokens (address _recipient) public {
}
// Returns the amount of SOLA allocated
function grandTotalAllocated() public view returns (uint256) {
}
// Allow transfer of accidentally sent ERC20 tokens
function refundTokens(address _recipient, address _token) public onlyOwner {
}
}
| allocations[_recipient].totalAllocated==0&&_totalAllocated>0 | 11,878 | allocations[_recipient].totalAllocated==0&&_totalAllocated>0 |
null | pragma solidity ^0.4.18;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
interface IERC20 {
function balanceOf(address _owner) public view returns (uint256);
function allowance(address _owner, address _spender) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
*/
contract SolaToken is IERC20 {
using SafeMath for uint256;
string public name = 'Sola';
string public symbol = 'SOLA';
uint8 public constant decimals = 18;
uint256 public constant decimalFactor = 10 ** uint256(decimals);
uint256 public constant totalSupply = 1000000000 * decimalFactor;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Constructor for Sola creation
* @dev Assigns the totalSupply to the SolaDistribution contract
*/
function SolaToken(address _solaDistributionContractAddress) public {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
}
/**
* @title SOLA token initial distribution
*
* @dev Distribute purchasers, airdrop, reserve, and founder tokens
*/
contract SolaDistribution is Ownable {
using SafeMath for uint256;
SolaToken public SOLA;
uint256 private constant decimalFactor = 10**uint256(18);
enum AllocationType { PRESALE, FOUNDER, AIRDROP, ADVISOR, RESERVE, BONUS1, BONUS2, BONUS3 }
uint256 public constant INITIAL_SUPPLY = 1000000000 * decimalFactor;
uint256 public AVAILABLE_TOTAL_SUPPLY = 1000000000 * decimalFactor;
uint256 public AVAILABLE_PRESALE_SUPPLY = 230000000 * decimalFactor; // 100% Released at Token Distribution (TD)
uint256 public AVAILABLE_FOUNDER_SUPPLY = 150000000 * decimalFactor; // 33% Released at TD +1 year -> 100% at TD +3 years
uint256 public AVAILABLE_AIRDROP_SUPPLY = 10000000 * decimalFactor; // 100% Released at TD
uint256 public AVAILABLE_ADVISOR_SUPPLY = 20000000 * decimalFactor; // 100% Released at TD +7 months
uint256 public AVAILABLE_RESERVE_SUPPLY = 513116658 * decimalFactor; // 6.8% Released at TD +100 days -> 100% at TD +4 years
uint256 public AVAILABLE_BONUS1_SUPPLY = 39053330 * decimalFactor; // 100% Released at TD +1 year
uint256 public AVAILABLE_BONUS2_SUPPLY = 9354408 * decimalFactor; // 100% Released at TD +2 years
uint256 public AVAILABLE_BONUS3_SUPPLY = 28475604 * decimalFactor; // 100% Released at TD +3 years
uint256 public grandTotalClaimed = 0;
uint256 public startTime;
// Allocation with vesting information
struct Allocation {
uint8 AllocationSupply; // Type of allocation
uint256 endCliff; // Tokens are locked until
uint256 endVesting; // This is when the tokens are fully unvested
uint256 totalAllocated; // Total tokens allocated
uint256 amountClaimed; // Total tokens claimed
}
mapping (address => Allocation) public allocations;
// List of admins
mapping (address => bool) public airdropAdmins;
// Keeps track of whether or not a 250 SOLA airdrop has been made to a particular address
mapping (address => bool) public airdrops;
modifier onlyOwnerOrAdmin() {
}
event LogNewAllocation(address indexed _recipient, AllocationType indexed _fromSupply, uint256 _totalAllocated, uint256 _grandTotalAllocated);
event LogSolaClaimed(address indexed _recipient, uint8 indexed _fromSupply, uint256 _amountClaimed, uint256 _totalAllocated, uint256 _grandTotalClaimed);
/**
* @dev Constructor function - Set the sola token address
* @param _startTime The time when SolaDistribution goes live
*/
function SolaDistribution(uint256 _startTime) public {
}
/**
* @dev Allow the owner of the contract to assign a new allocation
* @param _recipient The recipient of the allocation
* @param _totalAllocated The total amount of SOLA available to the receipient (after vesting)
* @param _supply The SOLA supply the allocation will be taken from
*/
function setAllocation (address _recipient, uint256 _totalAllocated, AllocationType _supply) onlyOwner public {
}
/**
* @dev Add an airdrop admin
*/
function setAirdropAdmin(address _admin, bool _isAdmin) public onlyOwner {
}
/**
* @dev perform a transfer of allocations
* @param _recipient is a list of recipients
*/
function airdropTokens(address[] _recipient) public onlyOwnerOrAdmin {
require(now >= startTime);
uint airdropped;
for(uint256 i = 0; i< _recipient.length; i++)
{
if (!airdrops[_recipient[i]]) {
airdrops[_recipient[i]] = true;
require(<FILL_ME>)
airdropped = airdropped.add(250 * decimalFactor);
}
}
AVAILABLE_AIRDROP_SUPPLY = AVAILABLE_AIRDROP_SUPPLY.sub(airdropped);
AVAILABLE_TOTAL_SUPPLY = AVAILABLE_TOTAL_SUPPLY.sub(airdropped);
grandTotalClaimed = grandTotalClaimed.add(airdropped);
}
/**
* @dev Transfer a recipients available allocation to their address
* @param _recipient The address to withdraw tokens for
*/
function transferTokens (address _recipient) public {
}
// Returns the amount of SOLA allocated
function grandTotalAllocated() public view returns (uint256) {
}
// Allow transfer of accidentally sent ERC20 tokens
function refundTokens(address _recipient, address _token) public onlyOwner {
}
}
| SOLA.transfer(_recipient[i],250*decimalFactor) | 11,878 | SOLA.transfer(_recipient[i],250*decimalFactor) |
null | pragma solidity ^0.4.18;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
interface IERC20 {
function balanceOf(address _owner) public view returns (uint256);
function allowance(address _owner, address _spender) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
*/
contract SolaToken is IERC20 {
using SafeMath for uint256;
string public name = 'Sola';
string public symbol = 'SOLA';
uint8 public constant decimals = 18;
uint256 public constant decimalFactor = 10 ** uint256(decimals);
uint256 public constant totalSupply = 1000000000 * decimalFactor;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Constructor for Sola creation
* @dev Assigns the totalSupply to the SolaDistribution contract
*/
function SolaToken(address _solaDistributionContractAddress) public {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
}
/**
* @title SOLA token initial distribution
*
* @dev Distribute purchasers, airdrop, reserve, and founder tokens
*/
contract SolaDistribution is Ownable {
using SafeMath for uint256;
SolaToken public SOLA;
uint256 private constant decimalFactor = 10**uint256(18);
enum AllocationType { PRESALE, FOUNDER, AIRDROP, ADVISOR, RESERVE, BONUS1, BONUS2, BONUS3 }
uint256 public constant INITIAL_SUPPLY = 1000000000 * decimalFactor;
uint256 public AVAILABLE_TOTAL_SUPPLY = 1000000000 * decimalFactor;
uint256 public AVAILABLE_PRESALE_SUPPLY = 230000000 * decimalFactor; // 100% Released at Token Distribution (TD)
uint256 public AVAILABLE_FOUNDER_SUPPLY = 150000000 * decimalFactor; // 33% Released at TD +1 year -> 100% at TD +3 years
uint256 public AVAILABLE_AIRDROP_SUPPLY = 10000000 * decimalFactor; // 100% Released at TD
uint256 public AVAILABLE_ADVISOR_SUPPLY = 20000000 * decimalFactor; // 100% Released at TD +7 months
uint256 public AVAILABLE_RESERVE_SUPPLY = 513116658 * decimalFactor; // 6.8% Released at TD +100 days -> 100% at TD +4 years
uint256 public AVAILABLE_BONUS1_SUPPLY = 39053330 * decimalFactor; // 100% Released at TD +1 year
uint256 public AVAILABLE_BONUS2_SUPPLY = 9354408 * decimalFactor; // 100% Released at TD +2 years
uint256 public AVAILABLE_BONUS3_SUPPLY = 28475604 * decimalFactor; // 100% Released at TD +3 years
uint256 public grandTotalClaimed = 0;
uint256 public startTime;
// Allocation with vesting information
struct Allocation {
uint8 AllocationSupply; // Type of allocation
uint256 endCliff; // Tokens are locked until
uint256 endVesting; // This is when the tokens are fully unvested
uint256 totalAllocated; // Total tokens allocated
uint256 amountClaimed; // Total tokens claimed
}
mapping (address => Allocation) public allocations;
// List of admins
mapping (address => bool) public airdropAdmins;
// Keeps track of whether or not a 250 SOLA airdrop has been made to a particular address
mapping (address => bool) public airdrops;
modifier onlyOwnerOrAdmin() {
}
event LogNewAllocation(address indexed _recipient, AllocationType indexed _fromSupply, uint256 _totalAllocated, uint256 _grandTotalAllocated);
event LogSolaClaimed(address indexed _recipient, uint8 indexed _fromSupply, uint256 _amountClaimed, uint256 _totalAllocated, uint256 _grandTotalClaimed);
/**
* @dev Constructor function - Set the sola token address
* @param _startTime The time when SolaDistribution goes live
*/
function SolaDistribution(uint256 _startTime) public {
}
/**
* @dev Allow the owner of the contract to assign a new allocation
* @param _recipient The recipient of the allocation
* @param _totalAllocated The total amount of SOLA available to the receipient (after vesting)
* @param _supply The SOLA supply the allocation will be taken from
*/
function setAllocation (address _recipient, uint256 _totalAllocated, AllocationType _supply) onlyOwner public {
}
/**
* @dev Add an airdrop admin
*/
function setAirdropAdmin(address _admin, bool _isAdmin) public onlyOwner {
}
/**
* @dev perform a transfer of allocations
* @param _recipient is a list of recipients
*/
function airdropTokens(address[] _recipient) public onlyOwnerOrAdmin {
}
/**
* @dev Transfer a recipients available allocation to their address
* @param _recipient The address to withdraw tokens for
*/
function transferTokens (address _recipient) public {
require(<FILL_ME>)
require(now >= allocations[_recipient].endCliff);
require(now >= startTime);
uint256 newAmountClaimed;
if (allocations[_recipient].endVesting > now) {
// Transfer available amount based on vesting schedule and allocation
newAmountClaimed = allocations[_recipient].totalAllocated.mul(now.sub(startTime)).div(allocations[_recipient].endVesting.sub(startTime));
} else {
// Transfer total allocated (minus previously claimed tokens)
newAmountClaimed = allocations[_recipient].totalAllocated;
}
uint256 tokensToTransfer = newAmountClaimed.sub(allocations[_recipient].amountClaimed);
allocations[_recipient].amountClaimed = newAmountClaimed;
require(SOLA.transfer(_recipient, tokensToTransfer));
grandTotalClaimed = grandTotalClaimed.add(tokensToTransfer);
LogSolaClaimed(_recipient, allocations[_recipient].AllocationSupply, tokensToTransfer, newAmountClaimed, grandTotalClaimed);
}
// Returns the amount of SOLA allocated
function grandTotalAllocated() public view returns (uint256) {
}
// Allow transfer of accidentally sent ERC20 tokens
function refundTokens(address _recipient, address _token) public onlyOwner {
}
}
| allocations[_recipient].amountClaimed<allocations[_recipient].totalAllocated | 11,878 | allocations[_recipient].amountClaimed<allocations[_recipient].totalAllocated |
null | pragma solidity ^0.4.18;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
interface IERC20 {
function balanceOf(address _owner) public view returns (uint256);
function allowance(address _owner, address _spender) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
*/
contract SolaToken is IERC20 {
using SafeMath for uint256;
string public name = 'Sola';
string public symbol = 'SOLA';
uint8 public constant decimals = 18;
uint256 public constant decimalFactor = 10 ** uint256(decimals);
uint256 public constant totalSupply = 1000000000 * decimalFactor;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Constructor for Sola creation
* @dev Assigns the totalSupply to the SolaDistribution contract
*/
function SolaToken(address _solaDistributionContractAddress) public {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
}
/**
* @title SOLA token initial distribution
*
* @dev Distribute purchasers, airdrop, reserve, and founder tokens
*/
contract SolaDistribution is Ownable {
using SafeMath for uint256;
SolaToken public SOLA;
uint256 private constant decimalFactor = 10**uint256(18);
enum AllocationType { PRESALE, FOUNDER, AIRDROP, ADVISOR, RESERVE, BONUS1, BONUS2, BONUS3 }
uint256 public constant INITIAL_SUPPLY = 1000000000 * decimalFactor;
uint256 public AVAILABLE_TOTAL_SUPPLY = 1000000000 * decimalFactor;
uint256 public AVAILABLE_PRESALE_SUPPLY = 230000000 * decimalFactor; // 100% Released at Token Distribution (TD)
uint256 public AVAILABLE_FOUNDER_SUPPLY = 150000000 * decimalFactor; // 33% Released at TD +1 year -> 100% at TD +3 years
uint256 public AVAILABLE_AIRDROP_SUPPLY = 10000000 * decimalFactor; // 100% Released at TD
uint256 public AVAILABLE_ADVISOR_SUPPLY = 20000000 * decimalFactor; // 100% Released at TD +7 months
uint256 public AVAILABLE_RESERVE_SUPPLY = 513116658 * decimalFactor; // 6.8% Released at TD +100 days -> 100% at TD +4 years
uint256 public AVAILABLE_BONUS1_SUPPLY = 39053330 * decimalFactor; // 100% Released at TD +1 year
uint256 public AVAILABLE_BONUS2_SUPPLY = 9354408 * decimalFactor; // 100% Released at TD +2 years
uint256 public AVAILABLE_BONUS3_SUPPLY = 28475604 * decimalFactor; // 100% Released at TD +3 years
uint256 public grandTotalClaimed = 0;
uint256 public startTime;
// Allocation with vesting information
struct Allocation {
uint8 AllocationSupply; // Type of allocation
uint256 endCliff; // Tokens are locked until
uint256 endVesting; // This is when the tokens are fully unvested
uint256 totalAllocated; // Total tokens allocated
uint256 amountClaimed; // Total tokens claimed
}
mapping (address => Allocation) public allocations;
// List of admins
mapping (address => bool) public airdropAdmins;
// Keeps track of whether or not a 250 SOLA airdrop has been made to a particular address
mapping (address => bool) public airdrops;
modifier onlyOwnerOrAdmin() {
}
event LogNewAllocation(address indexed _recipient, AllocationType indexed _fromSupply, uint256 _totalAllocated, uint256 _grandTotalAllocated);
event LogSolaClaimed(address indexed _recipient, uint8 indexed _fromSupply, uint256 _amountClaimed, uint256 _totalAllocated, uint256 _grandTotalClaimed);
/**
* @dev Constructor function - Set the sola token address
* @param _startTime The time when SolaDistribution goes live
*/
function SolaDistribution(uint256 _startTime) public {
}
/**
* @dev Allow the owner of the contract to assign a new allocation
* @param _recipient The recipient of the allocation
* @param _totalAllocated The total amount of SOLA available to the receipient (after vesting)
* @param _supply The SOLA supply the allocation will be taken from
*/
function setAllocation (address _recipient, uint256 _totalAllocated, AllocationType _supply) onlyOwner public {
}
/**
* @dev Add an airdrop admin
*/
function setAirdropAdmin(address _admin, bool _isAdmin) public onlyOwner {
}
/**
* @dev perform a transfer of allocations
* @param _recipient is a list of recipients
*/
function airdropTokens(address[] _recipient) public onlyOwnerOrAdmin {
}
/**
* @dev Transfer a recipients available allocation to their address
* @param _recipient The address to withdraw tokens for
*/
function transferTokens (address _recipient) public {
require(allocations[_recipient].amountClaimed < allocations[_recipient].totalAllocated);
require(now >= allocations[_recipient].endCliff);
require(now >= startTime);
uint256 newAmountClaimed;
if (allocations[_recipient].endVesting > now) {
// Transfer available amount based on vesting schedule and allocation
newAmountClaimed = allocations[_recipient].totalAllocated.mul(now.sub(startTime)).div(allocations[_recipient].endVesting.sub(startTime));
} else {
// Transfer total allocated (minus previously claimed tokens)
newAmountClaimed = allocations[_recipient].totalAllocated;
}
uint256 tokensToTransfer = newAmountClaimed.sub(allocations[_recipient].amountClaimed);
allocations[_recipient].amountClaimed = newAmountClaimed;
require(<FILL_ME>)
grandTotalClaimed = grandTotalClaimed.add(tokensToTransfer);
LogSolaClaimed(_recipient, allocations[_recipient].AllocationSupply, tokensToTransfer, newAmountClaimed, grandTotalClaimed);
}
// Returns the amount of SOLA allocated
function grandTotalAllocated() public view returns (uint256) {
}
// Allow transfer of accidentally sent ERC20 tokens
function refundTokens(address _recipient, address _token) public onlyOwner {
}
}
| SOLA.transfer(_recipient,tokensToTransfer) | 11,878 | SOLA.transfer(_recipient,tokensToTransfer) |
null | pragma solidity ^0.4.18;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
interface IERC20 {
function balanceOf(address _owner) public view returns (uint256);
function allowance(address _owner, address _spender) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
*/
contract SolaToken is IERC20 {
using SafeMath for uint256;
string public name = 'Sola';
string public symbol = 'SOLA';
uint8 public constant decimals = 18;
uint256 public constant decimalFactor = 10 ** uint256(decimals);
uint256 public constant totalSupply = 1000000000 * decimalFactor;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Constructor for Sola creation
* @dev Assigns the totalSupply to the SolaDistribution contract
*/
function SolaToken(address _solaDistributionContractAddress) public {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
*
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
}
/**
* @title SOLA token initial distribution
*
* @dev Distribute purchasers, airdrop, reserve, and founder tokens
*/
contract SolaDistribution is Ownable {
using SafeMath for uint256;
SolaToken public SOLA;
uint256 private constant decimalFactor = 10**uint256(18);
enum AllocationType { PRESALE, FOUNDER, AIRDROP, ADVISOR, RESERVE, BONUS1, BONUS2, BONUS3 }
uint256 public constant INITIAL_SUPPLY = 1000000000 * decimalFactor;
uint256 public AVAILABLE_TOTAL_SUPPLY = 1000000000 * decimalFactor;
uint256 public AVAILABLE_PRESALE_SUPPLY = 230000000 * decimalFactor; // 100% Released at Token Distribution (TD)
uint256 public AVAILABLE_FOUNDER_SUPPLY = 150000000 * decimalFactor; // 33% Released at TD +1 year -> 100% at TD +3 years
uint256 public AVAILABLE_AIRDROP_SUPPLY = 10000000 * decimalFactor; // 100% Released at TD
uint256 public AVAILABLE_ADVISOR_SUPPLY = 20000000 * decimalFactor; // 100% Released at TD +7 months
uint256 public AVAILABLE_RESERVE_SUPPLY = 513116658 * decimalFactor; // 6.8% Released at TD +100 days -> 100% at TD +4 years
uint256 public AVAILABLE_BONUS1_SUPPLY = 39053330 * decimalFactor; // 100% Released at TD +1 year
uint256 public AVAILABLE_BONUS2_SUPPLY = 9354408 * decimalFactor; // 100% Released at TD +2 years
uint256 public AVAILABLE_BONUS3_SUPPLY = 28475604 * decimalFactor; // 100% Released at TD +3 years
uint256 public grandTotalClaimed = 0;
uint256 public startTime;
// Allocation with vesting information
struct Allocation {
uint8 AllocationSupply; // Type of allocation
uint256 endCliff; // Tokens are locked until
uint256 endVesting; // This is when the tokens are fully unvested
uint256 totalAllocated; // Total tokens allocated
uint256 amountClaimed; // Total tokens claimed
}
mapping (address => Allocation) public allocations;
// List of admins
mapping (address => bool) public airdropAdmins;
// Keeps track of whether or not a 250 SOLA airdrop has been made to a particular address
mapping (address => bool) public airdrops;
modifier onlyOwnerOrAdmin() {
}
event LogNewAllocation(address indexed _recipient, AllocationType indexed _fromSupply, uint256 _totalAllocated, uint256 _grandTotalAllocated);
event LogSolaClaimed(address indexed _recipient, uint8 indexed _fromSupply, uint256 _amountClaimed, uint256 _totalAllocated, uint256 _grandTotalClaimed);
/**
* @dev Constructor function - Set the sola token address
* @param _startTime The time when SolaDistribution goes live
*/
function SolaDistribution(uint256 _startTime) public {
}
/**
* @dev Allow the owner of the contract to assign a new allocation
* @param _recipient The recipient of the allocation
* @param _totalAllocated The total amount of SOLA available to the receipient (after vesting)
* @param _supply The SOLA supply the allocation will be taken from
*/
function setAllocation (address _recipient, uint256 _totalAllocated, AllocationType _supply) onlyOwner public {
}
/**
* @dev Add an airdrop admin
*/
function setAirdropAdmin(address _admin, bool _isAdmin) public onlyOwner {
}
/**
* @dev perform a transfer of allocations
* @param _recipient is a list of recipients
*/
function airdropTokens(address[] _recipient) public onlyOwnerOrAdmin {
}
/**
* @dev Transfer a recipients available allocation to their address
* @param _recipient The address to withdraw tokens for
*/
function transferTokens (address _recipient) public {
}
// Returns the amount of SOLA allocated
function grandTotalAllocated() public view returns (uint256) {
}
// Allow transfer of accidentally sent ERC20 tokens
function refundTokens(address _recipient, address _token) public onlyOwner {
require(_token != address(SOLA));
IERC20 token = IERC20(_token);
uint256 balance = token.balanceOf(this);
require(<FILL_ME>)
}
}
| token.transfer(_recipient,balance) | 11,878 | token.transfer(_recipient,balance) |
"Not enough NFTs left!" | // Contract based on https://docs.openzeppelin.com/contracts/3.x/erc721
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
contract NFL is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public constant MAX_SUPPLY = 625;
uint256 public mintPrice = 0 ether;
uint256 public maxBalance = 2;
uint256 public maxPerMint = 2;
string baseURI;
mapping(uint256 => string) private _tokenURIs;
constructor(string memory initBaseURI) ERC721("Non-Fungible Life", "NFL") {
}
function mintNFTs(uint256 _count) public payable {
uint256 totalMinted = _tokenIds.current();
require(<FILL_ME>)
require(
_count > 0 && _count <= maxPerMint,
"Can only mint 2 tokens at a time."
);
require(
msg.value >= mintPrice.mul(_count),
"Not enough ether to purchase NFTs."
);
require(
balanceOf(msg.sender) + _count <= maxBalance,
"Sale would exceed max balance"
);
for (uint256 i = 0; i < _count; i++) {
_mintSingleNFT();
}
}
function _mintSingleNFT() private {
}
function reserveNFTs() public onlyOwner {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function setMintPrice(uint256 _mintPrice) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setMaxBalance(uint256 _maxBalance) public onlyOwner {
}
function setMaxMint(uint256 _maxPerMint) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| totalMinted.add(_count)<=MAX_SUPPLY,"Not enough NFTs left!" | 11,894 | totalMinted.add(_count)<=MAX_SUPPLY |
"Sale would exceed max balance" | // Contract based on https://docs.openzeppelin.com/contracts/3.x/erc721
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
contract NFL is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public constant MAX_SUPPLY = 625;
uint256 public mintPrice = 0 ether;
uint256 public maxBalance = 2;
uint256 public maxPerMint = 2;
string baseURI;
mapping(uint256 => string) private _tokenURIs;
constructor(string memory initBaseURI) ERC721("Non-Fungible Life", "NFL") {
}
function mintNFTs(uint256 _count) public payable {
uint256 totalMinted = _tokenIds.current();
require(totalMinted.add(_count) <= MAX_SUPPLY, "Not enough NFTs left!");
require(
_count > 0 && _count <= maxPerMint,
"Can only mint 2 tokens at a time."
);
require(
msg.value >= mintPrice.mul(_count),
"Not enough ether to purchase NFTs."
);
require(<FILL_ME>)
for (uint256 i = 0; i < _count; i++) {
_mintSingleNFT();
}
}
function _mintSingleNFT() private {
}
function reserveNFTs() public onlyOwner {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function setMintPrice(uint256 _mintPrice) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setMaxBalance(uint256 _maxBalance) public onlyOwner {
}
function setMaxMint(uint256 _maxPerMint) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| balanceOf(msg.sender)+_count<=maxBalance,"Sale would exceed max balance" | 11,894 | balanceOf(msg.sender)+_count<=maxBalance |
"Not enough NFTs left to reserve" | // Contract based on https://docs.openzeppelin.com/contracts/3.x/erc721
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
contract NFL is ERC721Enumerable, Ownable {
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public constant MAX_SUPPLY = 625;
uint256 public mintPrice = 0 ether;
uint256 public maxBalance = 2;
uint256 public maxPerMint = 2;
string baseURI;
mapping(uint256 => string) private _tokenURIs;
constructor(string memory initBaseURI) ERC721("Non-Fungible Life", "NFL") {
}
function mintNFTs(uint256 _count) public payable {
}
function _mintSingleNFT() private {
}
function reserveNFTs() public onlyOwner {
uint256 totalMinted = _tokenIds.current();
require(<FILL_ME>)
for (uint256 i = 0; i < 2; i++) {
_mintSingleNFT();
}
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function setMintPrice(uint256 _mintPrice) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setMaxBalance(uint256 _maxBalance) public onlyOwner {
}
function setMaxMint(uint256 _maxPerMint) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| totalMinted.add(2)<=MAX_SUPPLY,"Not enough NFTs left to reserve" | 11,894 | totalMinted.add(2)<=MAX_SUPPLY |
"Needs to be an allowed minter" | // SPDX-License-Identifier: GPL-3.0
/**
█▄░█ █▀▀ ▀█▀ █▀▀ █▀▄ █ ▀█▀ █ █▀█ █▄░█ █▀
█░▀█ █▀░ ░█░ ██▄ █▄▀ █ ░█░ █ █▄█ █░▀█ ▄█
▀█ █▀█ █▀█ ▄▀█
█▄ █▄█ █▀▄ █▀█
*/
pragma solidity 0.8.6;
import {ERC721Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import {IERC2981Upgradeable, IERC165Upgradeable} from "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";
import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import {CountersUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
import {SharedNFTLogic} from "./SharedNFTLogic.sol";
import {IEditionSingleMintable} from "./IEditionSingleMintable.sol";
/**
This is a smart contract for handling dynamic contract minting.
@dev This allows creators to mint a unique serial edition of the same media within a custom contract
@author iain nash
Repository: https://github.com/ourzora/nft-editions
*/
contract SingleEditionMintable is
ERC721Upgradeable,
IEditionSingleMintable,
IERC2981Upgradeable,
OwnableUpgradeable
{
using CountersUpgradeable for CountersUpgradeable.Counter;
event PriceChanged(uint256 amount);
event EditionSold(uint256 price, address owner);
// metadata
string private description;
// Media Urls
// animation_url field in the metadata
string private animationUrl;
// Hash for the associated animation
bytes32 private animationHash;
// Image in the metadata
string private imageUrl;
// Hash for the associated image
bytes32 private imageHash;
// Total size of edition that can be minted
uint256 public editionSize;
// Current token id minted
CountersUpgradeable.Counter private atEditionId;
// Royalty amount in bps
uint256 royaltyBPS;
// Addresses allowed to mint edition
mapping(address => bool) allowedMinters;
// Price for sale
uint256 public salePrice;
// NFT rendering logic contract
SharedNFTLogic private immutable sharedNFTLogic;
// Global constructor for factory
constructor(SharedNFTLogic _sharedNFTLogic) {
}
/**
@param _owner User that owns and can mint the edition, gets royalty and sales payouts and can update the base url if needed.
@param _name Name of edition, used in the title as "$NAME NUMBER/TOTAL"
@param _symbol Symbol of the new token contract
@param _description Description of edition, used in the description field of the NFT
@param _imageUrl Image URL of the edition. Strongly encouraged to be used, if necessary, only animation URL can be used. One of animation and image url need to exist in a edition to render the NFT.
@param _imageHash SHA256 of the given image in bytes32 format (0xHASH). If no image is included, the hash can be zero.
@param _animationUrl Animation URL of the edition. Not required, but if omitted image URL needs to be included. This follows the opensea spec for NFTs
@param _animationHash The associated hash of the animation in sha-256 bytes32 format. If animation is omitted the hash can be zero.
@param _editionSize Number of editions that can be minted in total. If 0, unlimited editions can be minted.
@param _royaltyBPS BPS of the royalty set on the contract. Can be 0 for no royalty.
@dev Function to create a new edition. Can only be called by the allowed creator
Sets the only allowed minter to the address that creates/owns the edition.
This can be re-assigned or updated later
*/
function initialize(
address _owner,
string memory _name,
string memory _symbol,
string memory _description,
string memory _animationUrl,
bytes32 _animationHash,
string memory _imageUrl,
bytes32 _imageHash,
uint256 _editionSize,
uint256 _royaltyBPS
) public initializer {
}
/// @dev returns the number of minted tokens within the edition
function totalSupply() public view returns (uint256) {
}
/**
Simple eth-based sales function
More complex sales functions can be implemented through ISingleEditionMintable interface
*/
/**
@dev This allows the user to purchase a edition edition
at the given price in the contract.
*/
function purchase() external payable returns (uint256) {
}
/**
@param _salePrice if sale price is 0 sale is stopped, otherwise that amount
of ETH is needed to start the sale.
@dev This sets a simple ETH sales price
Setting a sales price allows users to mint the edition until it sells out.
For more granular sales, use an external sales contract.
*/
function setSalePrice(uint256 _salePrice) external onlyOwner {
}
/**
@dev This withdraws ETH from the contract to the contract owner.
*/
function withdraw() external onlyOwner {
}
/**
@dev This helper function checks if the msg.sender is allowed to mint the
given edition id.
*/
function _isAllowedToMint() internal view returns (bool) {
}
/**
@param to address to send the newly minted edition to
@dev This mints one edition to the given address by an allowed minter on the edition instance.
*/
function mintEdition(address to) external override returns (uint256) {
require(<FILL_ME>)
address[] memory toMint = new address[](1);
toMint[0] = to;
return _mintEditions(toMint);
}
/**
@param recipients list of addresses to send the newly minted editions to
@dev This mints multiple editions to the given list of addresses.
*/
function mintEditions(address[] memory recipients)
external
override
returns (uint256)
{
}
/**
Simple override for owner interface.
*/
function owner()
public
view
override(OwnableUpgradeable, IEditionSingleMintable)
returns (address)
{
}
/**
@param minter address to set approved minting status for
@param allowed boolean if that address is allowed to mint
@dev Sets the approved minting status of the given address.
This requires that msg.sender is the owner of the given edition id.
If the ZeroAddress (address(0x0)) is set as a minter,
anyone will be allowed to mint.
This setup is similar to setApprovalForAll in the ERC721 spec.
*/
function setApprovedMinter(address minter, bool allowed) public onlyOwner {
}
/**
@dev Allows for updates of edition urls by the owner of the edition.
Only URLs can be updated (data-uris are supported), hashes cannot be updated.
*/
function updateEditionURLs(
string memory _imageUrl,
string memory _animationUrl
) public onlyOwner {
}
/// Returns the number of editions allowed to mint (max_uint256 when open edition)
function numberCanMint() public view override returns (uint256) {
}
/**
@param tokenId Token ID to burn
User burn function for token id
*/
function burn(uint256 tokenId) public {
}
/**
@dev Private function to mint als without any access checks.
Called by the public edition minting functions.
*/
function _mintEditions(address[] memory recipients)
internal
returns (uint256)
{
}
/**
@dev Get URIs for edition NFT
@return imageUrl, imageHash, animationUrl, animationHash
*/
function getURIs()
public
view
returns (
string memory,
bytes32,
string memory,
bytes32
)
{
}
/**
@dev Get royalty information for token
@param _salePrice Sale price for the token
*/
function royaltyInfo(uint256, uint256 _salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
/**
@dev Get URI for given token id
@param tokenId token id to get uri for
@return base64-encoded json metadata object
*/
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Upgradeable, IERC165Upgradeable)
returns (bool)
{
}
}
| _isAllowedToMint(),"Needs to be an allowed minter" | 11,966 | _isAllowedToMint() |
"block already stored" | /***********************************************************
* This file is part of the Slock.it IoT Layer. *
* The Slock.it IoT Layer contains: *
* - USN (Universal Sharing Network) *
* - INCUBED (Trustless INcentivized remote Node Network) *
************************************************************
* Copyright (C) 2016 - 2018 Slock.it GmbH *
* All Rights Reserved. *
************************************************************
* You may use, distribute and modify this code under the *
* terms of the license contract you have concluded with *
* Slock.it GmbH. *
* For information about liability, maintenance etc. also *
* refer to the contract concluded with Slock.it GmbH. *
************************************************************
* For more information, please refer to https://slock.it *
* For questions, please contact [email protected] *
***********************************************************/
pragma solidity 0.5.10;
pragma experimental ABIEncoderV2;
/// @title Registry for blockhashes
contract BlockhashRegistry {
/// a new blockhash and its number has been added to the contract
event LogBlockhashAdded(uint indexed blockNr, bytes32 indexed bhash);
/// maps the blocknumber to its blockhash
mapping(uint => bytes32) public blockhashMapping;
/// constructor, calls snapshot-function when contract get deployed as entry point
/// @dev cannot be deployed in a genesis block
constructor() public {
}
/// @notice searches for an already existing snapshot
/// @param _startNumber the blocknumber to start searching
/// @param _numBlocks the number of blocks to search for
/// @return the closes snapshot of found within the given range, 0 else
function searchForAvailableBlock(uint _startNumber, uint _numBlocks) external view returns (uint) {
}
/// @notice starts with a given blocknumber and its header and tries to recreate a (reverse) chain of blocks
/// @notice only usable when the given blocknumber is already in the smart contract
/// @notice it will be checked whether the provided chain is correct by using the reCalculateBlockheaders function
/// @notice if successfull the last blockhash of the header will be added to the smart contract
/// @param _blockNumber the block number to start recreation from
/// @param _blockheaders array with serialized blockheaders in reverse order (youngest -> oldest) => (e.g. 100, 99, 98)
/// @dev reverts when there is not parent block already stored in the contract
/// @dev reverts when the chain of headers is incorrect
/// @dev function is public due to the usage of a dynamic bytes array (not yet supported for external functions)
function recreateBlockheaders(uint _blockNumber, bytes[] memory _blockheaders) public {
/// we should never fail this assert, as this would mean that we were able to recreate a invalid blockchain
require(_blockNumber > _blockheaders.length, "too many blockheaders provided");
require(_blockNumber < block.number, "cannot recreate a not yet existing block");
require(_blockheaders.length > 0, "no blockheaders provided");
uint bnr = _blockNumber - _blockheaders.length;
require(<FILL_ME>)
bytes32 currentBlockhash = blockhashMapping[_blockNumber];
require(currentBlockhash != 0x0, "parentBlock is not available");
/// if the blocknumber we want to store is within the last 256 blocks, we use the evm hash
if (bnr > block.number-256) {
saveBlockNumber(bnr);
return;
}
bytes32 calculatedHash = reCalculateBlockheaders(_blockheaders, currentBlockhash, _blockNumber);
require(calculatedHash != 0x0, "invalid headers");
blockhashMapping[bnr] = calculatedHash;
emit LogBlockhashAdded(bnr, calculatedHash);
}
/// @notice stores a certain blockhash to the state
/// @param _blockNumber the blocknumber to be stored
/// @dev reverts if the block can't be found inside the evm
function saveBlockNumber(uint _blockNumber) public {
}
/// @notice stores the currentBlock-1 in the smart contract
function snapshot() public {
}
/// @notice returns the value from rlp encoded data.
/// This function is limited to only value up to 32 bytes length!
/// @param _data rlp encoded data
/// @param _offset the offset
/// @return the value
function getRlpUint(bytes memory _data, uint _offset) public pure returns (uint value) {
}
/// @notice returns the blockhash and the parent blockhash from the provided blockheader
/// @param _blockheader a serialized (rlp-encoded) blockheader
/// @return the parent blockhash and the keccak256 of the provided blockheader (= the corresponding blockhash)
function getParentAndBlockhash(bytes memory _blockheader) public pure returns (bytes32 parentHash, bytes32 bhash, uint blockNumber) {
}
/// @notice starts with a given blockhash and its header and tries to recreate a (reverse) chain of blocks
/// @notice the array of the blockheaders have to be in reverse order (e.g. [100,99,98,97])
/// @param _blockheaders array with serialized blockheaders in reverse order, i.e. from youngest to oldest
/// @param _bHash blockhash of the 1st element of the _blockheaders-array
/// @param _blockNumber blocknumber of the 1st element of the _blockheaders-array. This is only needed to verify the blockheader
/// @return 0x0 if the functions detects a wrong chaining of blocks, blockhash of the last element of the array otherwhise
function reCalculateBlockheaders(bytes[] memory _blockheaders, bytes32 _bHash, uint _blockNumber) public view returns (bytes32 bhash) {
}
}
| blockhashMapping[bnr]==0x0,"block already stored" | 11,984 | blockhashMapping[bnr]==0x0 |
Subsets and Splits