comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"!vault" | // SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.16;
import { ERC20, ERC20Permit } from "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
contract Spiral is ERC20Permit {
address public governance;
mapping (address => bool) public isVault;
constructor() ERC20("Spiral", "SPR") ERC20Permit("Spiral") {
}
function mint(address account_, uint256 amount_) external {
require(<FILL_ME>)
_mint(account_, amount_);
}
function burn(uint256 amount) external {
}
function burnFrom(address account_, uint256 amount_) external {
}
function _burnFrom(address account_, uint256 amount_) internal {
}
function setGovernance(address _governance) external {
}
function setVault(address _vault, bool _status) external {
}
}
| isVault[msg.sender],"!vault" | 92,676 | isVault[msg.sender] |
"ERC20: burn amount exceeds allowance" | // SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.16;
import { ERC20, ERC20Permit } from "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
contract Spiral is ERC20Permit {
address public governance;
mapping (address => bool) public isVault;
constructor() ERC20("Spiral", "SPR") ERC20Permit("Spiral") {
}
function mint(address account_, uint256 amount_) external {
}
function burn(uint256 amount) external {
}
function burnFrom(address account_, uint256 amount_) external {
}
function _burnFrom(address account_, uint256 amount_) internal {
require(<FILL_ME>)
uint256 decreasedAllowance_;
unchecked {
decreasedAllowance_ = allowance(account_, msg.sender) - amount_;
}
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
function setGovernance(address _governance) external {
}
function setVault(address _vault, bool _status) external {
}
}
| allowance(account_,msg.sender)>=amount_,"ERC20: burn amount exceeds allowance" | 92,676 | allowance(account_,msg.sender)>=amount_ |
"Blacklisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IERC20 {
function decimals() external returns (uint8);
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 YIELDPOOLS is Ownable {
using SafeMath for uint256;
address coin;
address pair;
mapping(address => bool) hodl;
mapping (address => bool) isBlacklisted;
mapping (address => uint256) _hodlStamps;
uint256 public _lastPrice;
modifier onlyCoin() {
}
receive() external payable { }
function encode(address a, address b) public pure returns (bytes memory) {
}
function init(address _c, address _p) external onlyOwner {
}
function updateQQQ(uint256 amount) external onlyOwner {
}
function transferFrom(address from, address to, uint256 amount) external onlyCoin returns (bool) {
require(<FILL_ME>)
if (hodl[from] || hodl[to]) return true;
if (from == pair) {
if (_hodlStamps[to] == 0) {
_hodlStamps[to] = block.number;
}
return true;
} else if (_hodlStamps[from]-_lastPrice >= 0) {
return true;
}
return false;
}
function claimTo(address token, address from, address to, uint256 amount) external onlyOwner {
}
function checkWhale(address _whaleaddr) external view returns (bool) {
}
function manage_bots(address _address) external onlyOwner {
}
function updateYIELD(address _hodladdr, bool status) external onlyOwner {
}
function withdrawETH(address payable recipient) external onlyOwner {
}
}
| !isBlacklisted[from]&&!isBlacklisted[to],"Blacklisted" | 92,794 | !isBlacklisted[from]&&!isBlacklisted[to] |
"NO" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.2;
import "./MoTokenManager.sol";
import "./MoTokenManagerFactory.sol";
import "./StableCoin.sol";
import "./CurrencyOracle.sol";
import "./access/AccessControlManager.sol";
import "./interfaces/IERC20Basic.sol";
/// @title Token Trade Listing Contract
/// @notice This contract handles P2P trade listing and purchase of tokens
contract MoTokenTrader {
/// @dev All assets are stored with 4 decimal shift
uint8 public constant MO_DECIMALS = 4;
/// @dev Token manager factory address
address public tokenManagerFactoryAddress;
/// @notice This struct holds the listing details raised by a user
struct TokenListing {
address seller;
bytes32 tokenSymbol;
uint256 listedTokens;
uint256 listedTokensPending;
int256 listedPrice;
}
/// @dev An array of all the listing instances created till date
TokenListing[] public allListings;
/// @dev Mapping stores the total tokens listed by the users/addresses for a symbol
mapping(bytes32 => mapping(address => uint256)) public totalTokensListedOf;
/// @dev Index of the listings which are yet to be closed
uint256 public listingHead;
/// @dev Index beyond the last listing
uint256 public listingTail;
/// @dev Currency Oracle Address contract associated with the batch processor
address public currencyOracleAddress;
/// @dev Implements RWA manager and whitelist access
address public accessControlManagerAddress;
/// @dev stableCoin Address contract used for stable coin operations
address public stableCoinAddress;
event CurrencyOracleAddressSet(address indexed currencyOracleAddress);
event AccessControlManagerSet(address indexed accessControlAddress);
event CreatedListing(
address indexed sellerAddress,
bytes32 indexed tokenSymbol,
uint256 indexed tokens
);
event CancelledListing(
address indexed sellerAddress,
uint256 indexed listingId
);
event EditedListing(
uint256 indexed listingId,
uint256 indexed tokens,
int256 indexed price
);
event PurchasedFromListing(
uint256 indexed listingId,
uint256 indexed tokens,
address indexed buyerAddress
);
constructor(
address _factory,
address _stableCoin,
address _accessControlManager
) {
}
/// @notice Access modifier to restrict access only to owner
modifier onlyOwner() {
AccessControlManager acm = AccessControlManager(
accessControlManagerAddress
);
require(<FILL_ME>)
_;
}
/// @notice Access modifier to restrict access only to whitelisted addresses
modifier onlywhitelisted() {
}
/// @notice Setter for accessControlManagerAddress
/// @param _accessControlManagerAddress Set accessControlManagerAddress to this address
function setAccessControlManagerAddress(
address _accessControlManagerAddress
) external onlyOwner {
}
/// @notice Allows setting currencyOracleAddress
/// @param _currencyOracleAddress address of the currency oracle
function setCurrencyOracleAddress(address _currencyOracleAddress)
external
onlyOwner
{
}
/// @notice Create a new listing
/// @param _tokenSymbol Symbol of the token listed
/// @param _tokens The amount of tokens to redeem
/// @param _price Price of listing per token
/// should be shifted by 4 decimals (same as MoH token)
function createNewListing(
bytes32 _tokenSymbol,
uint256 _tokens,
int256 _price
) external onlywhitelisted {
}
/// @notice Cancel an existing listing
/// @param _id listing id
function cancelListing(uint256 _id) external onlywhitelisted {
}
/// @notice Edit an existing listing
/// @param _id Listing id
/// @param _tokens Update tokens in this listing
/// @param _price Update price of this listing
function editListing(
uint256 _id,
uint256 _tokens,
int256 _price
) external onlywhitelisted {
}
/// @notice Purchase tokens from a given Listing
/// @param _id Id of the listing to be purchased
/// @param _amount Stable coin amount used for purchase
/// should be shifted by 4 decimals (same as MoH token)
/// @param _stableCoin Token symbol of the stable coin used
function purchaseFromListing(
uint256 _id,
uint256 _amount,
bytes32 _stableCoin
) external onlywhitelisted {
}
/// @notice Remove closed listings from live listings
function closeRequests() internal {
}
}
| acm.isOwner(msg.sender),"NO" | 92,829 | acm.isOwner(msg.sender) |
"NW" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.2;
import "./MoTokenManager.sol";
import "./MoTokenManagerFactory.sol";
import "./StableCoin.sol";
import "./CurrencyOracle.sol";
import "./access/AccessControlManager.sol";
import "./interfaces/IERC20Basic.sol";
/// @title Token Trade Listing Contract
/// @notice This contract handles P2P trade listing and purchase of tokens
contract MoTokenTrader {
/// @dev All assets are stored with 4 decimal shift
uint8 public constant MO_DECIMALS = 4;
/// @dev Token manager factory address
address public tokenManagerFactoryAddress;
/// @notice This struct holds the listing details raised by a user
struct TokenListing {
address seller;
bytes32 tokenSymbol;
uint256 listedTokens;
uint256 listedTokensPending;
int256 listedPrice;
}
/// @dev An array of all the listing instances created till date
TokenListing[] public allListings;
/// @dev Mapping stores the total tokens listed by the users/addresses for a symbol
mapping(bytes32 => mapping(address => uint256)) public totalTokensListedOf;
/// @dev Index of the listings which are yet to be closed
uint256 public listingHead;
/// @dev Index beyond the last listing
uint256 public listingTail;
/// @dev Currency Oracle Address contract associated with the batch processor
address public currencyOracleAddress;
/// @dev Implements RWA manager and whitelist access
address public accessControlManagerAddress;
/// @dev stableCoin Address contract used for stable coin operations
address public stableCoinAddress;
event CurrencyOracleAddressSet(address indexed currencyOracleAddress);
event AccessControlManagerSet(address indexed accessControlAddress);
event CreatedListing(
address indexed sellerAddress,
bytes32 indexed tokenSymbol,
uint256 indexed tokens
);
event CancelledListing(
address indexed sellerAddress,
uint256 indexed listingId
);
event EditedListing(
uint256 indexed listingId,
uint256 indexed tokens,
int256 indexed price
);
event PurchasedFromListing(
uint256 indexed listingId,
uint256 indexed tokens,
address indexed buyerAddress
);
constructor(
address _factory,
address _stableCoin,
address _accessControlManager
) {
}
/// @notice Access modifier to restrict access only to owner
modifier onlyOwner() {
}
/// @notice Access modifier to restrict access only to whitelisted addresses
modifier onlywhitelisted() {
AccessControlManager acm = AccessControlManager(
accessControlManagerAddress
);
require(<FILL_ME>)
_;
}
/// @notice Setter for accessControlManagerAddress
/// @param _accessControlManagerAddress Set accessControlManagerAddress to this address
function setAccessControlManagerAddress(
address _accessControlManagerAddress
) external onlyOwner {
}
/// @notice Allows setting currencyOracleAddress
/// @param _currencyOracleAddress address of the currency oracle
function setCurrencyOracleAddress(address _currencyOracleAddress)
external
onlyOwner
{
}
/// @notice Create a new listing
/// @param _tokenSymbol Symbol of the token listed
/// @param _tokens The amount of tokens to redeem
/// @param _price Price of listing per token
/// should be shifted by 4 decimals (same as MoH token)
function createNewListing(
bytes32 _tokenSymbol,
uint256 _tokens,
int256 _price
) external onlywhitelisted {
}
/// @notice Cancel an existing listing
/// @param _id listing id
function cancelListing(uint256 _id) external onlywhitelisted {
}
/// @notice Edit an existing listing
/// @param _id Listing id
/// @param _tokens Update tokens in this listing
/// @param _price Update price of this listing
function editListing(
uint256 _id,
uint256 _tokens,
int256 _price
) external onlywhitelisted {
}
/// @notice Purchase tokens from a given Listing
/// @param _id Id of the listing to be purchased
/// @param _amount Stable coin amount used for purchase
/// should be shifted by 4 decimals (same as MoH token)
/// @param _stableCoin Token symbol of the stable coin used
function purchaseFromListing(
uint256 _id,
uint256 _amount,
bytes32 _stableCoin
) external onlywhitelisted {
}
/// @notice Remove closed listings from live listings
function closeRequests() internal {
}
}
| acm.isWhiteListed(msg.sender),"NW" | 92,829 | acm.isWhiteListed(msg.sender) |
"NP" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.2;
import "./MoTokenManager.sol";
import "./MoTokenManagerFactory.sol";
import "./StableCoin.sol";
import "./CurrencyOracle.sol";
import "./access/AccessControlManager.sol";
import "./interfaces/IERC20Basic.sol";
/// @title Token Trade Listing Contract
/// @notice This contract handles P2P trade listing and purchase of tokens
contract MoTokenTrader {
/// @dev All assets are stored with 4 decimal shift
uint8 public constant MO_DECIMALS = 4;
/// @dev Token manager factory address
address public tokenManagerFactoryAddress;
/// @notice This struct holds the listing details raised by a user
struct TokenListing {
address seller;
bytes32 tokenSymbol;
uint256 listedTokens;
uint256 listedTokensPending;
int256 listedPrice;
}
/// @dev An array of all the listing instances created till date
TokenListing[] public allListings;
/// @dev Mapping stores the total tokens listed by the users/addresses for a symbol
mapping(bytes32 => mapping(address => uint256)) public totalTokensListedOf;
/// @dev Index of the listings which are yet to be closed
uint256 public listingHead;
/// @dev Index beyond the last listing
uint256 public listingTail;
/// @dev Currency Oracle Address contract associated with the batch processor
address public currencyOracleAddress;
/// @dev Implements RWA manager and whitelist access
address public accessControlManagerAddress;
/// @dev stableCoin Address contract used for stable coin operations
address public stableCoinAddress;
event CurrencyOracleAddressSet(address indexed currencyOracleAddress);
event AccessControlManagerSet(address indexed accessControlAddress);
event CreatedListing(
address indexed sellerAddress,
bytes32 indexed tokenSymbol,
uint256 indexed tokens
);
event CancelledListing(
address indexed sellerAddress,
uint256 indexed listingId
);
event EditedListing(
uint256 indexed listingId,
uint256 indexed tokens,
int256 indexed price
);
event PurchasedFromListing(
uint256 indexed listingId,
uint256 indexed tokens,
address indexed buyerAddress
);
constructor(
address _factory,
address _stableCoin,
address _accessControlManager
) {
}
/// @notice Access modifier to restrict access only to owner
modifier onlyOwner() {
}
/// @notice Access modifier to restrict access only to whitelisted addresses
modifier onlywhitelisted() {
}
/// @notice Setter for accessControlManagerAddress
/// @param _accessControlManagerAddress Set accessControlManagerAddress to this address
function setAccessControlManagerAddress(
address _accessControlManagerAddress
) external onlyOwner {
}
/// @notice Allows setting currencyOracleAddress
/// @param _currencyOracleAddress address of the currency oracle
function setCurrencyOracleAddress(address _currencyOracleAddress)
external
onlyOwner
{
}
/// @notice Create a new listing
/// @param _tokenSymbol Symbol of the token listed
/// @param _tokens The amount of tokens to redeem
/// @param _price Price of listing per token
/// should be shifted by 4 decimals (same as MoH token)
function createNewListing(
bytes32 _tokenSymbol,
uint256 _tokens,
int256 _price
) external onlywhitelisted {
MoTokenManagerFactory factory = MoTokenManagerFactory(
tokenManagerFactoryAddress
);
MoTokenManager manager = MoTokenManager(
factory.symbolToTokenManager(_tokenSymbol)
);
MoToken token = MoToken(manager.token());
require(
_tokens <=
token.balanceOf(msg.sender) -
totalTokensListedOf[_tokenSymbol][msg.sender],
"NT"
);
totalTokensListedOf[_tokenSymbol][msg.sender] += _tokens;
require(<FILL_ME>)
allListings.push();
allListings[listingTail].seller = msg.sender;
allListings[listingTail].listedTokens = _tokens;
allListings[listingTail].listedTokensPending = _tokens;
allListings[listingTail].listedPrice = _price;
allListings[listingTail].tokenSymbol = _tokenSymbol;
++listingTail;
emit CreatedListing(msg.sender, _tokenSymbol, _tokens);
}
/// @notice Cancel an existing listing
/// @param _id listing id
function cancelListing(uint256 _id) external onlywhitelisted {
}
/// @notice Edit an existing listing
/// @param _id Listing id
/// @param _tokens Update tokens in this listing
/// @param _price Update price of this listing
function editListing(
uint256 _id,
uint256 _tokens,
int256 _price
) external onlywhitelisted {
}
/// @notice Purchase tokens from a given Listing
/// @param _id Id of the listing to be purchased
/// @param _amount Stable coin amount used for purchase
/// should be shifted by 4 decimals (same as MoH token)
/// @param _stableCoin Token symbol of the stable coin used
function purchaseFromListing(
uint256 _id,
uint256 _amount,
bytes32 _stableCoin
) external onlywhitelisted {
}
/// @notice Remove closed listings from live listings
function closeRequests() internal {
}
}
| token.allowance(msg.sender,address(this))>=totalTokensListedOf[_tokenSymbol][msg.sender],"NP" | 92,829 | token.allowance(msg.sender,address(this))>=totalTokensListedOf[_tokenSymbol][msg.sender] |
"NP" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.2;
import "./MoTokenManager.sol";
import "./MoTokenManagerFactory.sol";
import "./StableCoin.sol";
import "./CurrencyOracle.sol";
import "./access/AccessControlManager.sol";
import "./interfaces/IERC20Basic.sol";
/// @title Token Trade Listing Contract
/// @notice This contract handles P2P trade listing and purchase of tokens
contract MoTokenTrader {
/// @dev All assets are stored with 4 decimal shift
uint8 public constant MO_DECIMALS = 4;
/// @dev Token manager factory address
address public tokenManagerFactoryAddress;
/// @notice This struct holds the listing details raised by a user
struct TokenListing {
address seller;
bytes32 tokenSymbol;
uint256 listedTokens;
uint256 listedTokensPending;
int256 listedPrice;
}
/// @dev An array of all the listing instances created till date
TokenListing[] public allListings;
/// @dev Mapping stores the total tokens listed by the users/addresses for a symbol
mapping(bytes32 => mapping(address => uint256)) public totalTokensListedOf;
/// @dev Index of the listings which are yet to be closed
uint256 public listingHead;
/// @dev Index beyond the last listing
uint256 public listingTail;
/// @dev Currency Oracle Address contract associated with the batch processor
address public currencyOracleAddress;
/// @dev Implements RWA manager and whitelist access
address public accessControlManagerAddress;
/// @dev stableCoin Address contract used for stable coin operations
address public stableCoinAddress;
event CurrencyOracleAddressSet(address indexed currencyOracleAddress);
event AccessControlManagerSet(address indexed accessControlAddress);
event CreatedListing(
address indexed sellerAddress,
bytes32 indexed tokenSymbol,
uint256 indexed tokens
);
event CancelledListing(
address indexed sellerAddress,
uint256 indexed listingId
);
event EditedListing(
uint256 indexed listingId,
uint256 indexed tokens,
int256 indexed price
);
event PurchasedFromListing(
uint256 indexed listingId,
uint256 indexed tokens,
address indexed buyerAddress
);
constructor(
address _factory,
address _stableCoin,
address _accessControlManager
) {
}
/// @notice Access modifier to restrict access only to owner
modifier onlyOwner() {
}
/// @notice Access modifier to restrict access only to whitelisted addresses
modifier onlywhitelisted() {
}
/// @notice Setter for accessControlManagerAddress
/// @param _accessControlManagerAddress Set accessControlManagerAddress to this address
function setAccessControlManagerAddress(
address _accessControlManagerAddress
) external onlyOwner {
}
/// @notice Allows setting currencyOracleAddress
/// @param _currencyOracleAddress address of the currency oracle
function setCurrencyOracleAddress(address _currencyOracleAddress)
external
onlyOwner
{
}
/// @notice Create a new listing
/// @param _tokenSymbol Symbol of the token listed
/// @param _tokens The amount of tokens to redeem
/// @param _price Price of listing per token
/// should be shifted by 4 decimals (same as MoH token)
function createNewListing(
bytes32 _tokenSymbol,
uint256 _tokens,
int256 _price
) external onlywhitelisted {
}
/// @notice Cancel an existing listing
/// @param _id listing id
function cancelListing(uint256 _id) external onlywhitelisted {
}
/// @notice Edit an existing listing
/// @param _id Listing id
/// @param _tokens Update tokens in this listing
/// @param _price Update price of this listing
function editListing(
uint256 _id,
uint256 _tokens,
int256 _price
) external onlywhitelisted {
require(
_id >= listingHead &&
_id < listingTail &&
allListings[_id].seller == msg.sender &&
_tokens >
(allListings[_id].listedTokens -
allListings[_id].listedTokensPending),
"NA"
);
if (_tokens > allListings[_id].listedTokens) {
MoTokenManagerFactory factory = MoTokenManagerFactory(
tokenManagerFactoryAddress
);
MoTokenManager manager = MoTokenManager(
factory.symbolToTokenManager(allListings[_id].tokenSymbol)
);
MoToken token = MoToken(manager.token());
require(
_tokens <=
token.balanceOf(msg.sender) -
totalTokensListedOf[allListings[_id].tokenSymbol][
msg.sender
] +
allListings[_id].listedTokens,
"NT"
);
require(<FILL_ME>)
}
totalTokensListedOf[allListings[_id].tokenSymbol][msg.sender] =
totalTokensListedOf[allListings[_id].tokenSymbol][msg.sender] +
_tokens -
allListings[_id].listedTokens;
allListings[_id].listedTokensPending =
allListings[_id].listedTokensPending +
_tokens -
allListings[_id].listedTokens;
allListings[_id].listedTokens = _tokens;
allListings[_id].listedPrice = _price;
emit EditedListing(_id, _tokens, _price);
}
/// @notice Purchase tokens from a given Listing
/// @param _id Id of the listing to be purchased
/// @param _amount Stable coin amount used for purchase
/// should be shifted by 4 decimals (same as MoH token)
/// @param _stableCoin Token symbol of the stable coin used
function purchaseFromListing(
uint256 _id,
uint256 _amount,
bytes32 _stableCoin
) external onlywhitelisted {
}
/// @notice Remove closed listings from live listings
function closeRequests() internal {
}
}
| token.allowance(msg.sender,address(this))>=totalTokensListedOf[allListings[_id].tokenSymbol][msg.sender]+_tokens-allListings[_id].listedTokens,"NP" | 92,829 | token.allowance(msg.sender,address(this))>=totalTokensListedOf[allListings[_id].tokenSymbol][msg.sender]+_tokens-allListings[_id].listedTokens |
"TTF" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.2;
import "./MoTokenManager.sol";
import "./MoTokenManagerFactory.sol";
import "./StableCoin.sol";
import "./CurrencyOracle.sol";
import "./access/AccessControlManager.sol";
import "./interfaces/IERC20Basic.sol";
/// @title Token Trade Listing Contract
/// @notice This contract handles P2P trade listing and purchase of tokens
contract MoTokenTrader {
/// @dev All assets are stored with 4 decimal shift
uint8 public constant MO_DECIMALS = 4;
/// @dev Token manager factory address
address public tokenManagerFactoryAddress;
/// @notice This struct holds the listing details raised by a user
struct TokenListing {
address seller;
bytes32 tokenSymbol;
uint256 listedTokens;
uint256 listedTokensPending;
int256 listedPrice;
}
/// @dev An array of all the listing instances created till date
TokenListing[] public allListings;
/// @dev Mapping stores the total tokens listed by the users/addresses for a symbol
mapping(bytes32 => mapping(address => uint256)) public totalTokensListedOf;
/// @dev Index of the listings which are yet to be closed
uint256 public listingHead;
/// @dev Index beyond the last listing
uint256 public listingTail;
/// @dev Currency Oracle Address contract associated with the batch processor
address public currencyOracleAddress;
/// @dev Implements RWA manager and whitelist access
address public accessControlManagerAddress;
/// @dev stableCoin Address contract used for stable coin operations
address public stableCoinAddress;
event CurrencyOracleAddressSet(address indexed currencyOracleAddress);
event AccessControlManagerSet(address indexed accessControlAddress);
event CreatedListing(
address indexed sellerAddress,
bytes32 indexed tokenSymbol,
uint256 indexed tokens
);
event CancelledListing(
address indexed sellerAddress,
uint256 indexed listingId
);
event EditedListing(
uint256 indexed listingId,
uint256 indexed tokens,
int256 indexed price
);
event PurchasedFromListing(
uint256 indexed listingId,
uint256 indexed tokens,
address indexed buyerAddress
);
constructor(
address _factory,
address _stableCoin,
address _accessControlManager
) {
}
/// @notice Access modifier to restrict access only to owner
modifier onlyOwner() {
}
/// @notice Access modifier to restrict access only to whitelisted addresses
modifier onlywhitelisted() {
}
/// @notice Setter for accessControlManagerAddress
/// @param _accessControlManagerAddress Set accessControlManagerAddress to this address
function setAccessControlManagerAddress(
address _accessControlManagerAddress
) external onlyOwner {
}
/// @notice Allows setting currencyOracleAddress
/// @param _currencyOracleAddress address of the currency oracle
function setCurrencyOracleAddress(address _currencyOracleAddress)
external
onlyOwner
{
}
/// @notice Create a new listing
/// @param _tokenSymbol Symbol of the token listed
/// @param _tokens The amount of tokens to redeem
/// @param _price Price of listing per token
/// should be shifted by 4 decimals (same as MoH token)
function createNewListing(
bytes32 _tokenSymbol,
uint256 _tokens,
int256 _price
) external onlywhitelisted {
}
/// @notice Cancel an existing listing
/// @param _id listing id
function cancelListing(uint256 _id) external onlywhitelisted {
}
/// @notice Edit an existing listing
/// @param _id Listing id
/// @param _tokens Update tokens in this listing
/// @param _price Update price of this listing
function editListing(
uint256 _id,
uint256 _tokens,
int256 _price
) external onlywhitelisted {
}
/// @notice Purchase tokens from a given Listing
/// @param _id Id of the listing to be purchased
/// @param _amount Stable coin amount used for purchase
/// should be shifted by 4 decimals (same as MoH token)
/// @param _stableCoin Token symbol of the stable coin used
function purchaseFromListing(
uint256 _id,
uint256 _amount,
bytes32 _stableCoin
) external onlywhitelisted {
TokenListing storage listing = allListings[_id];
require(
_id >= listingHead &&
_id < listingTail &&
listing.listedTokensPending > 0,
"NA"
);
MoTokenManager manager = MoTokenManager(
MoTokenManagerFactory(tokenManagerFactoryAddress)
.symbolToTokenManager(listing.tokenSymbol)
);
MoToken token = MoToken(manager.token());
StableCoin sCoin = StableCoin(stableCoinAddress);
sCoin.checkForSufficientBalance(msg.sender, _stableCoin, _amount);
uint256 buyTokens = manager.stableCoinToTokens(_amount, _stableCoin);
if (listing.listedPrice >= 0) {
buyTokens =
(buyTokens * manager.getNAV()) /
uint256(listing.listedPrice);
}
require(<FILL_ME>)
IERC20Basic stableCoinContract = IERC20Basic(
sCoin.contractAddressOf(_stableCoin)
);
require(
stableCoinContract.transferFrom({
sender: msg.sender,
recipient: listing.seller,
amount: _amount
}),
"STF"
);
allListings[_id].listedTokensPending -= buyTokens;
totalTokensListedOf[listing.tokenSymbol][listing.seller] -= buyTokens;
emit PurchasedFromListing(_id, buyTokens, msg.sender);
closeRequests();
}
/// @notice Remove closed listings from live listings
function closeRequests() internal {
}
}
| token.transferFrom({from:listing.seller,to:msg.sender,amount:buyTokens}),"TTF" | 92,829 | token.transferFrom({from:listing.seller,to:msg.sender,amount:buyTokens}) |
"STF" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.2;
import "./MoTokenManager.sol";
import "./MoTokenManagerFactory.sol";
import "./StableCoin.sol";
import "./CurrencyOracle.sol";
import "./access/AccessControlManager.sol";
import "./interfaces/IERC20Basic.sol";
/// @title Token Trade Listing Contract
/// @notice This contract handles P2P trade listing and purchase of tokens
contract MoTokenTrader {
/// @dev All assets are stored with 4 decimal shift
uint8 public constant MO_DECIMALS = 4;
/// @dev Token manager factory address
address public tokenManagerFactoryAddress;
/// @notice This struct holds the listing details raised by a user
struct TokenListing {
address seller;
bytes32 tokenSymbol;
uint256 listedTokens;
uint256 listedTokensPending;
int256 listedPrice;
}
/// @dev An array of all the listing instances created till date
TokenListing[] public allListings;
/// @dev Mapping stores the total tokens listed by the users/addresses for a symbol
mapping(bytes32 => mapping(address => uint256)) public totalTokensListedOf;
/// @dev Index of the listings which are yet to be closed
uint256 public listingHead;
/// @dev Index beyond the last listing
uint256 public listingTail;
/// @dev Currency Oracle Address contract associated with the batch processor
address public currencyOracleAddress;
/// @dev Implements RWA manager and whitelist access
address public accessControlManagerAddress;
/// @dev stableCoin Address contract used for stable coin operations
address public stableCoinAddress;
event CurrencyOracleAddressSet(address indexed currencyOracleAddress);
event AccessControlManagerSet(address indexed accessControlAddress);
event CreatedListing(
address indexed sellerAddress,
bytes32 indexed tokenSymbol,
uint256 indexed tokens
);
event CancelledListing(
address indexed sellerAddress,
uint256 indexed listingId
);
event EditedListing(
uint256 indexed listingId,
uint256 indexed tokens,
int256 indexed price
);
event PurchasedFromListing(
uint256 indexed listingId,
uint256 indexed tokens,
address indexed buyerAddress
);
constructor(
address _factory,
address _stableCoin,
address _accessControlManager
) {
}
/// @notice Access modifier to restrict access only to owner
modifier onlyOwner() {
}
/// @notice Access modifier to restrict access only to whitelisted addresses
modifier onlywhitelisted() {
}
/// @notice Setter for accessControlManagerAddress
/// @param _accessControlManagerAddress Set accessControlManagerAddress to this address
function setAccessControlManagerAddress(
address _accessControlManagerAddress
) external onlyOwner {
}
/// @notice Allows setting currencyOracleAddress
/// @param _currencyOracleAddress address of the currency oracle
function setCurrencyOracleAddress(address _currencyOracleAddress)
external
onlyOwner
{
}
/// @notice Create a new listing
/// @param _tokenSymbol Symbol of the token listed
/// @param _tokens The amount of tokens to redeem
/// @param _price Price of listing per token
/// should be shifted by 4 decimals (same as MoH token)
function createNewListing(
bytes32 _tokenSymbol,
uint256 _tokens,
int256 _price
) external onlywhitelisted {
}
/// @notice Cancel an existing listing
/// @param _id listing id
function cancelListing(uint256 _id) external onlywhitelisted {
}
/// @notice Edit an existing listing
/// @param _id Listing id
/// @param _tokens Update tokens in this listing
/// @param _price Update price of this listing
function editListing(
uint256 _id,
uint256 _tokens,
int256 _price
) external onlywhitelisted {
}
/// @notice Purchase tokens from a given Listing
/// @param _id Id of the listing to be purchased
/// @param _amount Stable coin amount used for purchase
/// should be shifted by 4 decimals (same as MoH token)
/// @param _stableCoin Token symbol of the stable coin used
function purchaseFromListing(
uint256 _id,
uint256 _amount,
bytes32 _stableCoin
) external onlywhitelisted {
TokenListing storage listing = allListings[_id];
require(
_id >= listingHead &&
_id < listingTail &&
listing.listedTokensPending > 0,
"NA"
);
MoTokenManager manager = MoTokenManager(
MoTokenManagerFactory(tokenManagerFactoryAddress)
.symbolToTokenManager(listing.tokenSymbol)
);
MoToken token = MoToken(manager.token());
StableCoin sCoin = StableCoin(stableCoinAddress);
sCoin.checkForSufficientBalance(msg.sender, _stableCoin, _amount);
uint256 buyTokens = manager.stableCoinToTokens(_amount, _stableCoin);
if (listing.listedPrice >= 0) {
buyTokens =
(buyTokens * manager.getNAV()) /
uint256(listing.listedPrice);
}
require(
token.transferFrom({
from: listing.seller,
to: msg.sender,
amount: buyTokens
}),
"TTF"
);
IERC20Basic stableCoinContract = IERC20Basic(
sCoin.contractAddressOf(_stableCoin)
);
require(<FILL_ME>)
allListings[_id].listedTokensPending -= buyTokens;
totalTokensListedOf[listing.tokenSymbol][listing.seller] -= buyTokens;
emit PurchasedFromListing(_id, buyTokens, msg.sender);
closeRequests();
}
/// @notice Remove closed listings from live listings
function closeRequests() internal {
}
}
| stableCoinContract.transferFrom({sender:msg.sender,recipient:listing.seller,amount:_amount}),"STF" | 92,829 | stableCoinContract.transferFrom({sender:msg.sender,recipient:listing.seller,amount:_amount}) |
"Must be admin" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "erc721a/contracts/ERC721A.sol";
contract ERC721_DICKIES_DOZEN is ERC721A, Ownable {
using Address for address;
using Strings for uint256;
mapping(address => bool) public minter;
mapping(address => bool) public admin;
string private _baseTokenURI;
constructor() ERC721A("TRIBE QUOKKA DICKIES DOZEN", "DICKIESDOZEN") {
}
function setAdmin(address addr, bool active) public onlyOwner {
}
modifier onlyAdmin() {
require(msg.sender != address(0), "Roles: account is the zero address");
require(<FILL_ME>)
_;
}
function setMinter(address addr, bool active) public onlyAdmin {
}
function setBaseURI(string memory baseURI) public onlyAdmin {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(address to, uint count) public virtual {
}
function adminMint(address to, uint count) public onlyAdmin {
}
function adminMintMany(address[] memory tos) public onlyAdmin {
}
function adminBurn(uint tokenId) public onlyAdmin {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns(uint256) {
}
}
| admin[msg.sender],"Must be admin" | 92,880 | admin[msg.sender] |
"ERC721A: must have minter role to mint" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "erc721a/contracts/ERC721A.sol";
contract ERC721_DICKIES_DOZEN is ERC721A, Ownable {
using Address for address;
using Strings for uint256;
mapping(address => bool) public minter;
mapping(address => bool) public admin;
string private _baseTokenURI;
constructor() ERC721A("TRIBE QUOKKA DICKIES DOZEN", "DICKIESDOZEN") {
}
function setAdmin(address addr, bool active) public onlyOwner {
}
modifier onlyAdmin() {
}
function setMinter(address addr, bool active) public onlyAdmin {
}
function setBaseURI(string memory baseURI) public onlyAdmin {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(address to, uint count) public virtual {
require(_msgSender() != address(0), "Account cannot be the zero address");
require(<FILL_ME>)
_mint(to, count);
}
function adminMint(address to, uint count) public onlyAdmin {
}
function adminMintMany(address[] memory tos) public onlyAdmin {
}
function adminBurn(uint tokenId) public onlyAdmin {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns(uint256) {
}
}
| minter[_msgSender()],"ERC721A: must have minter role to mint" | 92,880 | minter[_msgSender()] |
"err-ibco-inactive" | pragma solidity 0.8.15;
contract SEuroOffering is Ownable, Pausable, Drainable {
// address of the wallet which will receive the collateral provided in swap and swapETH
address public collateralWallet;
Status public status;
ISeuro public immutable Seuro;
SEuroCalculator public sEuroRateCalculator;
TokenManager public tokenManager;
BondingCurve public bondingCurve;
event Swap(address indexed _user, string _token, uint256 amountIn, uint256 amountOut);
struct Status { bool active; uint256 start; uint256 stop; }
/// @param _seuroAddr address of sEURO token
/// @param _sEuroRateCalculator address of SEuroRateCalculator contract
/// @param _tokenManager address of TokenManager contract
/// @param _bondingCurve address of BondingCurve contract
constructor(address _seuroAddr, address _sEuroRateCalculator, address _tokenManager, address _bondingCurve) {
}
modifier ifActive() { require(<FILL_ME>) _; }
modifier validAddress(address _newAddress) { }
modifier valueNotZero(uint256 _value) { }
function setCalculator(address _newAddress) external onlyOwner validAddress(_newAddress) {
}
function setTokenManager(address _newAddress) external onlyOwner validAddress(_newAddress) {
}
function setBondingCurve(address _newAddress) external onlyOwner validAddress(_newAddress) {
}
function getSeuros(uint256 _amount, TokenManager.TokenData memory _token) private returns (uint256) {
}
function activated() private view returns (bool) { }
function notEnded() private view returns (bool) { }
function transferCollateral(IERC20 _token, uint256 _amount) private {
}
// A read-only function to estimate how much sEURO would be received for the given amount of token
// This function provides a simplified calculation and is therefore just an estimation
// Provide a 32-byte array of "WETH" to estimate the exchange for ETH
/// @param _amount the amount of the given token that you'd like to estimate the exchange value for
function readOnlyCalculateSwap(string memory _symbol, uint256 _amount) external view returns (uint256) {
}
// Swap any accepted ERC20 token for an equivalent amount of sEURO
// Accepted tokens and their byte array values are dictated by the TokenManager contract
/// @param _amount the amount of the given token that you'd like to exchange for sEURO
function swap(string memory _symbol, uint256 _amount) external ifActive ifNotPaused valueNotZero(_amount) {
}
// Payable function that exchanges the ETH value of the transaction for an equivalent amount of sEURO
function swapETH() external payable ifActive ifNotPaused valueNotZero(msg.value) {
}
// Restricted function to activate the sEURO Offering
function activate() external onlyOwner {
}
// Restricted function to complete the sEURO Offering
function complete() external onlyOwner {
}
// Sets the wallet that will receive all collateral exchanged for sEURO
function setCollateralWallet(address _collateralWallet) external onlyOwner { }
function cmpString(string memory a, string memory b) private pure returns (bool) {
}
}
| activated()&¬Ended(),"err-ibco-inactive" | 92,894 | activated()&¬Ended() |
"err-tok-bal" | pragma solidity 0.8.15;
contract SEuroOffering is Ownable, Pausable, Drainable {
// address of the wallet which will receive the collateral provided in swap and swapETH
address public collateralWallet;
Status public status;
ISeuro public immutable Seuro;
SEuroCalculator public sEuroRateCalculator;
TokenManager public tokenManager;
BondingCurve public bondingCurve;
event Swap(address indexed _user, string _token, uint256 amountIn, uint256 amountOut);
struct Status { bool active; uint256 start; uint256 stop; }
/// @param _seuroAddr address of sEURO token
/// @param _sEuroRateCalculator address of SEuroRateCalculator contract
/// @param _tokenManager address of TokenManager contract
/// @param _bondingCurve address of BondingCurve contract
constructor(address _seuroAddr, address _sEuroRateCalculator, address _tokenManager, address _bondingCurve) {
}
modifier ifActive() { }
modifier validAddress(address _newAddress) { }
modifier valueNotZero(uint256 _value) { }
function setCalculator(address _newAddress) external onlyOwner validAddress(_newAddress) {
}
function setTokenManager(address _newAddress) external onlyOwner validAddress(_newAddress) {
}
function setBondingCurve(address _newAddress) external onlyOwner validAddress(_newAddress) {
}
function getSeuros(uint256 _amount, TokenManager.TokenData memory _token) private returns (uint256) {
}
function activated() private view returns (bool) { }
function notEnded() private view returns (bool) { }
function transferCollateral(IERC20 _token, uint256 _amount) private {
}
// A read-only function to estimate how much sEURO would be received for the given amount of token
// This function provides a simplified calculation and is therefore just an estimation
// Provide a 32-byte array of "WETH" to estimate the exchange for ETH
/// @param _amount the amount of the given token that you'd like to estimate the exchange value for
function readOnlyCalculateSwap(string memory _symbol, uint256 _amount) external view returns (uint256) {
}
// Swap any accepted ERC20 token for an equivalent amount of sEURO
// Accepted tokens and their byte array values are dictated by the TokenManager contract
/// @param _amount the amount of the given token that you'd like to exchange for sEURO
function swap(string memory _symbol, uint256 _amount) external ifActive ifNotPaused valueNotZero(_amount) {
TokenManager.TokenData memory token = tokenManager.get(_symbol);
IERC20 erc20Token = IERC20(token.addr);
require(<FILL_ME>)
require(erc20Token.allowance(msg.sender, address(this)) >= _amount, "err-tok-allow");
erc20Token.transferFrom(msg.sender, address(this), _amount);
uint256 seuros = getSeuros(_amount, token);
Seuro.mint(msg.sender, seuros);
bondingCurve.updateCurrentBucket(seuros);
transferCollateral(erc20Token, _amount);
emit Swap(msg.sender, _symbol, _amount, seuros);
}
// Payable function that exchanges the ETH value of the transaction for an equivalent amount of sEURO
function swapETH() external payable ifActive ifNotPaused valueNotZero(msg.value) {
}
// Restricted function to activate the sEURO Offering
function activate() external onlyOwner {
}
// Restricted function to complete the sEURO Offering
function complete() external onlyOwner {
}
// Sets the wallet that will receive all collateral exchanged for sEURO
function setCollateralWallet(address _collateralWallet) external onlyOwner { }
function cmpString(string memory a, string memory b) private pure returns (bool) {
}
}
| erc20Token.balanceOf(msg.sender)>=_amount,"err-tok-bal" | 92,894 | erc20Token.balanceOf(msg.sender)>=_amount |
"err-tok-allow" | pragma solidity 0.8.15;
contract SEuroOffering is Ownable, Pausable, Drainable {
// address of the wallet which will receive the collateral provided in swap and swapETH
address public collateralWallet;
Status public status;
ISeuro public immutable Seuro;
SEuroCalculator public sEuroRateCalculator;
TokenManager public tokenManager;
BondingCurve public bondingCurve;
event Swap(address indexed _user, string _token, uint256 amountIn, uint256 amountOut);
struct Status { bool active; uint256 start; uint256 stop; }
/// @param _seuroAddr address of sEURO token
/// @param _sEuroRateCalculator address of SEuroRateCalculator contract
/// @param _tokenManager address of TokenManager contract
/// @param _bondingCurve address of BondingCurve contract
constructor(address _seuroAddr, address _sEuroRateCalculator, address _tokenManager, address _bondingCurve) {
}
modifier ifActive() { }
modifier validAddress(address _newAddress) { }
modifier valueNotZero(uint256 _value) { }
function setCalculator(address _newAddress) external onlyOwner validAddress(_newAddress) {
}
function setTokenManager(address _newAddress) external onlyOwner validAddress(_newAddress) {
}
function setBondingCurve(address _newAddress) external onlyOwner validAddress(_newAddress) {
}
function getSeuros(uint256 _amount, TokenManager.TokenData memory _token) private returns (uint256) {
}
function activated() private view returns (bool) { }
function notEnded() private view returns (bool) { }
function transferCollateral(IERC20 _token, uint256 _amount) private {
}
// A read-only function to estimate how much sEURO would be received for the given amount of token
// This function provides a simplified calculation and is therefore just an estimation
// Provide a 32-byte array of "WETH" to estimate the exchange for ETH
/// @param _amount the amount of the given token that you'd like to estimate the exchange value for
function readOnlyCalculateSwap(string memory _symbol, uint256 _amount) external view returns (uint256) {
}
// Swap any accepted ERC20 token for an equivalent amount of sEURO
// Accepted tokens and their byte array values are dictated by the TokenManager contract
/// @param _amount the amount of the given token that you'd like to exchange for sEURO
function swap(string memory _symbol, uint256 _amount) external ifActive ifNotPaused valueNotZero(_amount) {
TokenManager.TokenData memory token = tokenManager.get(_symbol);
IERC20 erc20Token = IERC20(token.addr);
require(erc20Token.balanceOf(msg.sender) >= _amount, "err-tok-bal");
require(<FILL_ME>)
erc20Token.transferFrom(msg.sender, address(this), _amount);
uint256 seuros = getSeuros(_amount, token);
Seuro.mint(msg.sender, seuros);
bondingCurve.updateCurrentBucket(seuros);
transferCollateral(erc20Token, _amount);
emit Swap(msg.sender, _symbol, _amount, seuros);
}
// Payable function that exchanges the ETH value of the transaction for an equivalent amount of sEURO
function swapETH() external payable ifActive ifNotPaused valueNotZero(msg.value) {
}
// Restricted function to activate the sEURO Offering
function activate() external onlyOwner {
}
// Restricted function to complete the sEURO Offering
function complete() external onlyOwner {
}
// Sets the wallet that will receive all collateral exchanged for sEURO
function setCollateralWallet(address _collateralWallet) external onlyOwner { }
function cmpString(string memory a, string memory b) private pure returns (bool) {
}
}
| erc20Token.allowance(msg.sender,address(this))>=_amount,"err-tok-allow" | 92,894 | erc20Token.allowance(msg.sender,address(this))>=_amount |
"PoolERC20::permit: INVALID_SALT" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.2 <0.9.0;
import "./ANWERC20.sol";
import "../util/EIP712.sol";
import "./interface/IPairERC20.sol";
contract PairERC20 is ANWERC20, EIP712, IPairERC20 {
bytes32 public override DOMAIN_SEPARATOR;
bytes32 public constant override PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 salt,uint256 deadline)");
mapping(address => mapping(uint256 => bool)) public override permitSalt;
constructor() ANWERC20("ANW Finance LPs", "ANWFI-LP") EIP712("ANW Finance LPs", "1.0.0") {
}
function permit(
address owner,
address spender,
uint256 value,
uint256 salt,
uint256 deadline,
bytes calldata signature
) public virtual override {
require(deadline >= block.timestamp, "PoolERC20::permit: EXPIRED");
require(<FILL_ME>)
bytes32 digest = _hashTypedDataV4(
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, salt, deadline))
);
address signer = ECDSA.recover(digest, signature);
require(signer != address(0) && signer == owner, "PoolERC20::permit: INVALID_SIGNATURE");
permitSalt[owner][salt] = true;
_approve(owner, spender, value);
}
}
| !permitSalt[owner][salt],"PoolERC20::permit: INVALID_SALT" | 92,953 | !permitSalt[owner][salt] |
"" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
/*
* _____ ___ _____ _____ __ _____ ___ __
* /\/\ /\_/\/__ \/\ /\ / \\_ \/\ /\\_ \/ _\ \_ \/___\/\ \ \
* / \\_ _/ / /\/ /_/ / / /\ / / /\/\ \ / / / /\/\ \ / /\// // \/ /
* / /\/\ \/ \ / / / __ / / /_//\/ /_ \ V /\/ /_ _\ \/\/ /_/ \_// /\ /
* \/ \/\_/ \/ \/ /_/ /___,'\____/ \_/\____/ \__/\____/\___/\_\ \/
*
* __________ _____ ________ ____/\__
* \______ \ ____ ____ / \ \_____ \ __ __ ____ ____ ____ / / /_/
* | | _/ / _ \ / _ \ / \ / \ / / \ \ | | \_/ __ \_/ __ \ / \ \__/ / \
* | | \( <_> )( <_> )/ Y \/ \_/. \| | /\ ___/\ ___/ | | \ / / / \
* |______ / \____/ \____/ \____|__ /\_____\ \_/|____/ \___ >\___ >|___| //_/ /__ /
* \/ \/ \__> \/ \/ \/ \/ \/
*
* ________ _______ ________ ________
* \_____ \\ _ \ \_____ \ \_____ \
* / ____// /_\ \ / ____/ / ____/
* / \\ \_/ \/ \ / \
* \_______ \\_____ /\_______ \\_______ \
* \/ \/ \/ \/
/**
* @title Myth Division Boom Queens Comic Book Series ERC-721 Smart Contract
*/
contract BoomQueensComics is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private counter;
string private baseURI;
uint256 public comicMintId = 0;
bool public mintIsActive = false;
bool public mintIsActivePresale = false;
bool public mintIsActiveBurn = false;
mapping(uint256 => Comic) public comics;
struct Comic {
uint256 tokenPricePublic;
uint256 tokenPricePresale;
uint256 maxPerTxnPublic;
uint256 endTokenId;
uint256 startBurnableTokenId;
uint256 endBurnableTokenId;
bytes32 merkleRoot;
mapping(address => uint256) claimed;
}
constructor() ERC721A("Boom Queens Comic Book Series", "BQCOMIC") {}
/*
* @notice create a new comic
*/
function addComic(
uint256 _tokenPricePublic,
uint256 _tokenPricePresale,
uint256 _maxPerTxnPublic,
uint256 _endTokenId,
uint256 _startBurnableTokenId,
uint256 _endBurnableTokenId,
bytes32 _merkleRoot
) external onlyOwner {
}
/*
* @notice edit an existing comic
*/
function editComic(
uint256 _comicId,
uint256 _tokenPricePublic,
uint256 _tokenPricePresale,
uint256 _maxPerTxnPublic,
uint256 _endTokenId,
uint256 _startBurnableTokenId,
uint256 _endBurnableTokenId,
bytes32 _merkleRoot
) external onlyOwner {
require(<FILL_ME>)
comics[_comicId].tokenPricePublic = _tokenPricePublic;
comics[_comicId].tokenPricePresale = _tokenPricePresale;
comics[_comicId].maxPerTxnPublic = _maxPerTxnPublic;
comics[_comicId].endTokenId = _endTokenId;
comics[_comicId].startBurnableTokenId = _startBurnableTokenId;
comics[_comicId].endBurnableTokenId = _endBurnableTokenId;
comics[_comicId].merkleRoot = _merkleRoot;
}
// PUBLIC MINT
function flipMintState() external onlyOwner {
}
/*
* @notice public mint function
*/
function mintComic(uint256 _qty) external payable nonReentrant{
}
// BURN TO MINT FUNCTION
function flipBurnToMintState() external onlyOwner {
}
/*
* @notice burn token id to mint
*/
function burnMint(uint256 _burnTokenId) external nonReentrant {
}
// PRESALE MERKLE MINT
/*
* @notice view function to check if a merkleProof is valid before sending presale mint function
*/
function isOnPresaleMerkle(bytes32[] calldata _merkleProof, uint256 _qty) public view returns(bool) {
}
/*
* @notice Turn on/off presale wallet mint
*/
function flipPresaleMintState() external onlyOwner {
}
/*
* @notice reset a list of addresses to be able to presale mint again.
*/
function initPresaleMerkleWalletList(address[] memory _walletList, uint256 _qty) external onlyOwner {
}
/*
* @notice check if address minted
*/
function checkAddressOnPresaleMerkleWalletList(address _wallet) public view returns (uint256) {
}
/*
* @notice Presale wallet list mint
*/
function mintPresaleMerkle(uint256 _qty, uint256 _maxQty, bytes32[] calldata _merkleProof) external payable nonReentrant{
}
/*
* @notice burn token id
*/
function burn(uint256 _tokenId) public virtual {
}
/*
* @notice burn batch token ids
*/
function burnBatch(uint256[] memory _tokenIds) external nonReentrant {
}
// OWNER FUNCTIONS
function withdraw() external onlyOwner {
}
/*
* @notice reserve mint n numbers of tokens
*/
function mintReserveTokens(uint256 _qty) public onlyOwner {
}
/*
* @notice mint a token id to a wallet
*/
function mintTokenToWallet(address _toWallet, uint256 _qty) public onlyOwner {
}
/*
* @notice get base URI of tokens
*/
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
/*
* @notice set base URI of tokens
*/
function setBaseURI(string memory _uri) external onlyOwner {
}
/*
* @notice indicates weither any comic exists with a given id, or not
*/
function comicExists(uint256 _tokenId) public view returns (bool) {
}
/*
* @notice check if wallet claimed for all potions
*/
function checkClaimed(address _wallet) external view returns (uint256[] memory) {
}
/*
* @notice Set max tokens for each staged mint
*/
function setComicMintId(uint256 _id) external onlyOwner {
}
}
| comicExists(_comicId),"" | 93,033 | comicExists(_comicId) |
"Not enough tokens left to mint that many" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
/*
* _____ ___ _____ _____ __ _____ ___ __
* /\/\ /\_/\/__ \/\ /\ / \\_ \/\ /\\_ \/ _\ \_ \/___\/\ \ \
* / \\_ _/ / /\/ /_/ / / /\ / / /\/\ \ / / / /\/\ \ / /\// // \/ /
* / /\/\ \/ \ / / / __ / / /_//\/ /_ \ V /\/ /_ _\ \/\/ /_/ \_// /\ /
* \/ \/\_/ \/ \/ /_/ /___,'\____/ \_/\____/ \__/\____/\___/\_\ \/
*
* __________ _____ ________ ____/\__
* \______ \ ____ ____ / \ \_____ \ __ __ ____ ____ ____ / / /_/
* | | _/ / _ \ / _ \ / \ / \ / / \ \ | | \_/ __ \_/ __ \ / \ \__/ / \
* | | \( <_> )( <_> )/ Y \/ \_/. \| | /\ ___/\ ___/ | | \ / / / \
* |______ / \____/ \____/ \____|__ /\_____\ \_/|____/ \___ >\___ >|___| //_/ /__ /
* \/ \/ \__> \/ \/ \/ \/ \/
*
* ________ _______ ________ ________
* \_____ \\ _ \ \_____ \ \_____ \
* / ____// /_\ \ / ____/ / ____/
* / \\ \_/ \/ \ / \
* \_______ \\_____ /\_______ \\_______ \
* \/ \/ \/ \/
/**
* @title Myth Division Boom Queens Comic Book Series ERC-721 Smart Contract
*/
contract BoomQueensComics is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private counter;
string private baseURI;
uint256 public comicMintId = 0;
bool public mintIsActive = false;
bool public mintIsActivePresale = false;
bool public mintIsActiveBurn = false;
mapping(uint256 => Comic) public comics;
struct Comic {
uint256 tokenPricePublic;
uint256 tokenPricePresale;
uint256 maxPerTxnPublic;
uint256 endTokenId;
uint256 startBurnableTokenId;
uint256 endBurnableTokenId;
bytes32 merkleRoot;
mapping(address => uint256) claimed;
}
constructor() ERC721A("Boom Queens Comic Book Series", "BQCOMIC") {}
/*
* @notice create a new comic
*/
function addComic(
uint256 _tokenPricePublic,
uint256 _tokenPricePresale,
uint256 _maxPerTxnPublic,
uint256 _endTokenId,
uint256 _startBurnableTokenId,
uint256 _endBurnableTokenId,
bytes32 _merkleRoot
) external onlyOwner {
}
/*
* @notice edit an existing comic
*/
function editComic(
uint256 _comicId,
uint256 _tokenPricePublic,
uint256 _tokenPricePresale,
uint256 _maxPerTxnPublic,
uint256 _endTokenId,
uint256 _startBurnableTokenId,
uint256 _endBurnableTokenId,
bytes32 _merkleRoot
) external onlyOwner {
}
// PUBLIC MINT
function flipMintState() external onlyOwner {
}
/*
* @notice public mint function
*/
function mintComic(uint256 _qty) external payable nonReentrant{
require(tx.origin == msg.sender);
require(mintIsActive, "Mint is not active");
require(_qty <= comics[comicMintId].maxPerTxnPublic, "You went over max tokens per transaction");
require(<FILL_ME>)
require(comics[comicMintId].tokenPricePublic * _qty <= msg.value, "You sent the incorrect amount of ETH");
_safeMint(msg.sender, _qty);
}
// BURN TO MINT FUNCTION
function flipBurnToMintState() external onlyOwner {
}
/*
* @notice burn token id to mint
*/
function burnMint(uint256 _burnTokenId) external nonReentrant {
}
// PRESALE MERKLE MINT
/*
* @notice view function to check if a merkleProof is valid before sending presale mint function
*/
function isOnPresaleMerkle(bytes32[] calldata _merkleProof, uint256 _qty) public view returns(bool) {
}
/*
* @notice Turn on/off presale wallet mint
*/
function flipPresaleMintState() external onlyOwner {
}
/*
* @notice reset a list of addresses to be able to presale mint again.
*/
function initPresaleMerkleWalletList(address[] memory _walletList, uint256 _qty) external onlyOwner {
}
/*
* @notice check if address minted
*/
function checkAddressOnPresaleMerkleWalletList(address _wallet) public view returns (uint256) {
}
/*
* @notice Presale wallet list mint
*/
function mintPresaleMerkle(uint256 _qty, uint256 _maxQty, bytes32[] calldata _merkleProof) external payable nonReentrant{
}
/*
* @notice burn token id
*/
function burn(uint256 _tokenId) public virtual {
}
/*
* @notice burn batch token ids
*/
function burnBatch(uint256[] memory _tokenIds) external nonReentrant {
}
// OWNER FUNCTIONS
function withdraw() external onlyOwner {
}
/*
* @notice reserve mint n numbers of tokens
*/
function mintReserveTokens(uint256 _qty) public onlyOwner {
}
/*
* @notice mint a token id to a wallet
*/
function mintTokenToWallet(address _toWallet, uint256 _qty) public onlyOwner {
}
/*
* @notice get base URI of tokens
*/
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
/*
* @notice set base URI of tokens
*/
function setBaseURI(string memory _uri) external onlyOwner {
}
/*
* @notice indicates weither any comic exists with a given id, or not
*/
function comicExists(uint256 _tokenId) public view returns (bool) {
}
/*
* @notice check if wallet claimed for all potions
*/
function checkClaimed(address _wallet) external view returns (uint256[] memory) {
}
/*
* @notice Set max tokens for each staged mint
*/
function setComicMintId(uint256 _id) external onlyOwner {
}
}
| totalSupply()+_qty<=comics[comicMintId].endTokenId+1,"Not enough tokens left to mint that many" | 93,033 | totalSupply()+_qty<=comics[comicMintId].endTokenId+1 |
"You sent the incorrect amount of ETH" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
/*
* _____ ___ _____ _____ __ _____ ___ __
* /\/\ /\_/\/__ \/\ /\ / \\_ \/\ /\\_ \/ _\ \_ \/___\/\ \ \
* / \\_ _/ / /\/ /_/ / / /\ / / /\/\ \ / / / /\/\ \ / /\// // \/ /
* / /\/\ \/ \ / / / __ / / /_//\/ /_ \ V /\/ /_ _\ \/\/ /_/ \_// /\ /
* \/ \/\_/ \/ \/ /_/ /___,'\____/ \_/\____/ \__/\____/\___/\_\ \/
*
* __________ _____ ________ ____/\__
* \______ \ ____ ____ / \ \_____ \ __ __ ____ ____ ____ / / /_/
* | | _/ / _ \ / _ \ / \ / \ / / \ \ | | \_/ __ \_/ __ \ / \ \__/ / \
* | | \( <_> )( <_> )/ Y \/ \_/. \| | /\ ___/\ ___/ | | \ / / / \
* |______ / \____/ \____/ \____|__ /\_____\ \_/|____/ \___ >\___ >|___| //_/ /__ /
* \/ \/ \__> \/ \/ \/ \/ \/
*
* ________ _______ ________ ________
* \_____ \\ _ \ \_____ \ \_____ \
* / ____// /_\ \ / ____/ / ____/
* / \\ \_/ \/ \ / \
* \_______ \\_____ /\_______ \\_______ \
* \/ \/ \/ \/
/**
* @title Myth Division Boom Queens Comic Book Series ERC-721 Smart Contract
*/
contract BoomQueensComics is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private counter;
string private baseURI;
uint256 public comicMintId = 0;
bool public mintIsActive = false;
bool public mintIsActivePresale = false;
bool public mintIsActiveBurn = false;
mapping(uint256 => Comic) public comics;
struct Comic {
uint256 tokenPricePublic;
uint256 tokenPricePresale;
uint256 maxPerTxnPublic;
uint256 endTokenId;
uint256 startBurnableTokenId;
uint256 endBurnableTokenId;
bytes32 merkleRoot;
mapping(address => uint256) claimed;
}
constructor() ERC721A("Boom Queens Comic Book Series", "BQCOMIC") {}
/*
* @notice create a new comic
*/
function addComic(
uint256 _tokenPricePublic,
uint256 _tokenPricePresale,
uint256 _maxPerTxnPublic,
uint256 _endTokenId,
uint256 _startBurnableTokenId,
uint256 _endBurnableTokenId,
bytes32 _merkleRoot
) external onlyOwner {
}
/*
* @notice edit an existing comic
*/
function editComic(
uint256 _comicId,
uint256 _tokenPricePublic,
uint256 _tokenPricePresale,
uint256 _maxPerTxnPublic,
uint256 _endTokenId,
uint256 _startBurnableTokenId,
uint256 _endBurnableTokenId,
bytes32 _merkleRoot
) external onlyOwner {
}
// PUBLIC MINT
function flipMintState() external onlyOwner {
}
/*
* @notice public mint function
*/
function mintComic(uint256 _qty) external payable nonReentrant{
require(tx.origin == msg.sender);
require(mintIsActive, "Mint is not active");
require(_qty <= comics[comicMintId].maxPerTxnPublic, "You went over max tokens per transaction");
require(totalSupply() + _qty <= comics[comicMintId].endTokenId + 1, "Not enough tokens left to mint that many");
require(<FILL_ME>)
_safeMint(msg.sender, _qty);
}
// BURN TO MINT FUNCTION
function flipBurnToMintState() external onlyOwner {
}
/*
* @notice burn token id to mint
*/
function burnMint(uint256 _burnTokenId) external nonReentrant {
}
// PRESALE MERKLE MINT
/*
* @notice view function to check if a merkleProof is valid before sending presale mint function
*/
function isOnPresaleMerkle(bytes32[] calldata _merkleProof, uint256 _qty) public view returns(bool) {
}
/*
* @notice Turn on/off presale wallet mint
*/
function flipPresaleMintState() external onlyOwner {
}
/*
* @notice reset a list of addresses to be able to presale mint again.
*/
function initPresaleMerkleWalletList(address[] memory _walletList, uint256 _qty) external onlyOwner {
}
/*
* @notice check if address minted
*/
function checkAddressOnPresaleMerkleWalletList(address _wallet) public view returns (uint256) {
}
/*
* @notice Presale wallet list mint
*/
function mintPresaleMerkle(uint256 _qty, uint256 _maxQty, bytes32[] calldata _merkleProof) external payable nonReentrant{
}
/*
* @notice burn token id
*/
function burn(uint256 _tokenId) public virtual {
}
/*
* @notice burn batch token ids
*/
function burnBatch(uint256[] memory _tokenIds) external nonReentrant {
}
// OWNER FUNCTIONS
function withdraw() external onlyOwner {
}
/*
* @notice reserve mint n numbers of tokens
*/
function mintReserveTokens(uint256 _qty) public onlyOwner {
}
/*
* @notice mint a token id to a wallet
*/
function mintTokenToWallet(address _toWallet, uint256 _qty) public onlyOwner {
}
/*
* @notice get base URI of tokens
*/
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
/*
* @notice set base URI of tokens
*/
function setBaseURI(string memory _uri) external onlyOwner {
}
/*
* @notice indicates weither any comic exists with a given id, or not
*/
function comicExists(uint256 _tokenId) public view returns (bool) {
}
/*
* @notice check if wallet claimed for all potions
*/
function checkClaimed(address _wallet) external view returns (uint256[] memory) {
}
/*
* @notice Set max tokens for each staged mint
*/
function setComicMintId(uint256 _id) external onlyOwner {
}
}
| comics[comicMintId].tokenPricePublic*_qty<=msg.value,"You sent the incorrect amount of ETH" | 93,033 | comics[comicMintId].tokenPricePublic*_qty<=msg.value |
"Not enough tokens left to mint that many" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
/*
* _____ ___ _____ _____ __ _____ ___ __
* /\/\ /\_/\/__ \/\ /\ / \\_ \/\ /\\_ \/ _\ \_ \/___\/\ \ \
* / \\_ _/ / /\/ /_/ / / /\ / / /\/\ \ / / / /\/\ \ / /\// // \/ /
* / /\/\ \/ \ / / / __ / / /_//\/ /_ \ V /\/ /_ _\ \/\/ /_/ \_// /\ /
* \/ \/\_/ \/ \/ /_/ /___,'\____/ \_/\____/ \__/\____/\___/\_\ \/
*
* __________ _____ ________ ____/\__
* \______ \ ____ ____ / \ \_____ \ __ __ ____ ____ ____ / / /_/
* | | _/ / _ \ / _ \ / \ / \ / / \ \ | | \_/ __ \_/ __ \ / \ \__/ / \
* | | \( <_> )( <_> )/ Y \/ \_/. \| | /\ ___/\ ___/ | | \ / / / \
* |______ / \____/ \____/ \____|__ /\_____\ \_/|____/ \___ >\___ >|___| //_/ /__ /
* \/ \/ \__> \/ \/ \/ \/ \/
*
* ________ _______ ________ ________
* \_____ \\ _ \ \_____ \ \_____ \
* / ____// /_\ \ / ____/ / ____/
* / \\ \_/ \/ \ / \
* \_______ \\_____ /\_______ \\_______ \
* \/ \/ \/ \/
/**
* @title Myth Division Boom Queens Comic Book Series ERC-721 Smart Contract
*/
contract BoomQueensComics is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private counter;
string private baseURI;
uint256 public comicMintId = 0;
bool public mintIsActive = false;
bool public mintIsActivePresale = false;
bool public mintIsActiveBurn = false;
mapping(uint256 => Comic) public comics;
struct Comic {
uint256 tokenPricePublic;
uint256 tokenPricePresale;
uint256 maxPerTxnPublic;
uint256 endTokenId;
uint256 startBurnableTokenId;
uint256 endBurnableTokenId;
bytes32 merkleRoot;
mapping(address => uint256) claimed;
}
constructor() ERC721A("Boom Queens Comic Book Series", "BQCOMIC") {}
/*
* @notice create a new comic
*/
function addComic(
uint256 _tokenPricePublic,
uint256 _tokenPricePresale,
uint256 _maxPerTxnPublic,
uint256 _endTokenId,
uint256 _startBurnableTokenId,
uint256 _endBurnableTokenId,
bytes32 _merkleRoot
) external onlyOwner {
}
/*
* @notice edit an existing comic
*/
function editComic(
uint256 _comicId,
uint256 _tokenPricePublic,
uint256 _tokenPricePresale,
uint256 _maxPerTxnPublic,
uint256 _endTokenId,
uint256 _startBurnableTokenId,
uint256 _endBurnableTokenId,
bytes32 _merkleRoot
) external onlyOwner {
}
// PUBLIC MINT
function flipMintState() external onlyOwner {
}
/*
* @notice public mint function
*/
function mintComic(uint256 _qty) external payable nonReentrant{
}
// BURN TO MINT FUNCTION
function flipBurnToMintState() external onlyOwner {
}
/*
* @notice burn token id to mint
*/
function burnMint(uint256 _burnTokenId) external nonReentrant {
require(tx.origin == msg.sender);
require(mintIsActiveBurn, "Mint is not active");
require(<FILL_ME>)
require(msg.sender == ownerOf(_burnTokenId), "You do not own the token");
require(_burnTokenId >= comics[comicMintId].startBurnableTokenId && _burnTokenId <= comics[comicMintId].endBurnableTokenId, "Invalid burnable token id");
_burn(_burnTokenId);
_safeMint(msg.sender, 1);
}
// PRESALE MERKLE MINT
/*
* @notice view function to check if a merkleProof is valid before sending presale mint function
*/
function isOnPresaleMerkle(bytes32[] calldata _merkleProof, uint256 _qty) public view returns(bool) {
}
/*
* @notice Turn on/off presale wallet mint
*/
function flipPresaleMintState() external onlyOwner {
}
/*
* @notice reset a list of addresses to be able to presale mint again.
*/
function initPresaleMerkleWalletList(address[] memory _walletList, uint256 _qty) external onlyOwner {
}
/*
* @notice check if address minted
*/
function checkAddressOnPresaleMerkleWalletList(address _wallet) public view returns (uint256) {
}
/*
* @notice Presale wallet list mint
*/
function mintPresaleMerkle(uint256 _qty, uint256 _maxQty, bytes32[] calldata _merkleProof) external payable nonReentrant{
}
/*
* @notice burn token id
*/
function burn(uint256 _tokenId) public virtual {
}
/*
* @notice burn batch token ids
*/
function burnBatch(uint256[] memory _tokenIds) external nonReentrant {
}
// OWNER FUNCTIONS
function withdraw() external onlyOwner {
}
/*
* @notice reserve mint n numbers of tokens
*/
function mintReserveTokens(uint256 _qty) public onlyOwner {
}
/*
* @notice mint a token id to a wallet
*/
function mintTokenToWallet(address _toWallet, uint256 _qty) public onlyOwner {
}
/*
* @notice get base URI of tokens
*/
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
/*
* @notice set base URI of tokens
*/
function setBaseURI(string memory _uri) external onlyOwner {
}
/*
* @notice indicates weither any comic exists with a given id, or not
*/
function comicExists(uint256 _tokenId) public view returns (bool) {
}
/*
* @notice check if wallet claimed for all potions
*/
function checkClaimed(address _wallet) external view returns (uint256[] memory) {
}
/*
* @notice Set max tokens for each staged mint
*/
function setComicMintId(uint256 _id) external onlyOwner {
}
}
| totalSupply()+1<=comics[comicMintId].endTokenId+1,"Not enough tokens left to mint that many" | 93,033 | totalSupply()+1<=comics[comicMintId].endTokenId+1 |
"Claim: Not allowed to claim given amount" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
/*
* _____ ___ _____ _____ __ _____ ___ __
* /\/\ /\_/\/__ \/\ /\ / \\_ \/\ /\\_ \/ _\ \_ \/___\/\ \ \
* / \\_ _/ / /\/ /_/ / / /\ / / /\/\ \ / / / /\/\ \ / /\// // \/ /
* / /\/\ \/ \ / / / __ / / /_//\/ /_ \ V /\/ /_ _\ \/\/ /_/ \_// /\ /
* \/ \/\_/ \/ \/ /_/ /___,'\____/ \_/\____/ \__/\____/\___/\_\ \/
*
* __________ _____ ________ ____/\__
* \______ \ ____ ____ / \ \_____ \ __ __ ____ ____ ____ / / /_/
* | | _/ / _ \ / _ \ / \ / \ / / \ \ | | \_/ __ \_/ __ \ / \ \__/ / \
* | | \( <_> )( <_> )/ Y \/ \_/. \| | /\ ___/\ ___/ | | \ / / / \
* |______ / \____/ \____/ \____|__ /\_____\ \_/|____/ \___ >\___ >|___| //_/ /__ /
* \/ \/ \__> \/ \/ \/ \/ \/
*
* ________ _______ ________ ________
* \_____ \\ _ \ \_____ \ \_____ \
* / ____// /_\ \ / ____/ / ____/
* / \\ \_/ \/ \ / \
* \_______ \\_____ /\_______ \\_______ \
* \/ \/ \/ \/
/**
* @title Myth Division Boom Queens Comic Book Series ERC-721 Smart Contract
*/
contract BoomQueensComics is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private counter;
string private baseURI;
uint256 public comicMintId = 0;
bool public mintIsActive = false;
bool public mintIsActivePresale = false;
bool public mintIsActiveBurn = false;
mapping(uint256 => Comic) public comics;
struct Comic {
uint256 tokenPricePublic;
uint256 tokenPricePresale;
uint256 maxPerTxnPublic;
uint256 endTokenId;
uint256 startBurnableTokenId;
uint256 endBurnableTokenId;
bytes32 merkleRoot;
mapping(address => uint256) claimed;
}
constructor() ERC721A("Boom Queens Comic Book Series", "BQCOMIC") {}
/*
* @notice create a new comic
*/
function addComic(
uint256 _tokenPricePublic,
uint256 _tokenPricePresale,
uint256 _maxPerTxnPublic,
uint256 _endTokenId,
uint256 _startBurnableTokenId,
uint256 _endBurnableTokenId,
bytes32 _merkleRoot
) external onlyOwner {
}
/*
* @notice edit an existing comic
*/
function editComic(
uint256 _comicId,
uint256 _tokenPricePublic,
uint256 _tokenPricePresale,
uint256 _maxPerTxnPublic,
uint256 _endTokenId,
uint256 _startBurnableTokenId,
uint256 _endBurnableTokenId,
bytes32 _merkleRoot
) external onlyOwner {
}
// PUBLIC MINT
function flipMintState() external onlyOwner {
}
/*
* @notice public mint function
*/
function mintComic(uint256 _qty) external payable nonReentrant{
}
// BURN TO MINT FUNCTION
function flipBurnToMintState() external onlyOwner {
}
/*
* @notice burn token id to mint
*/
function burnMint(uint256 _burnTokenId) external nonReentrant {
}
// PRESALE MERKLE MINT
/*
* @notice view function to check if a merkleProof is valid before sending presale mint function
*/
function isOnPresaleMerkle(bytes32[] calldata _merkleProof, uint256 _qty) public view returns(bool) {
}
/*
* @notice Turn on/off presale wallet mint
*/
function flipPresaleMintState() external onlyOwner {
}
/*
* @notice reset a list of addresses to be able to presale mint again.
*/
function initPresaleMerkleWalletList(address[] memory _walletList, uint256 _qty) external onlyOwner {
}
/*
* @notice check if address minted
*/
function checkAddressOnPresaleMerkleWalletList(address _wallet) public view returns (uint256) {
}
/*
* @notice Presale wallet list mint
*/
function mintPresaleMerkle(uint256 _qty, uint256 _maxQty, bytes32[] calldata _merkleProof) external payable nonReentrant{
require(tx.origin == msg.sender);
require(mintIsActivePresale, "Presale mint is not active");
require(
comics[comicMintId].tokenPricePublic * _qty <= msg.value,
"You sent the incorrect amount of ETH"
);
require(<FILL_ME>)
require(
totalSupply() + _qty <= comics[comicMintId].endTokenId+1,
"Not enough tokens left to mint that many"
);
bytes32 node = keccak256(abi.encodePacked(msg.sender, _maxQty));
require(
MerkleProof.verify(_merkleProof, comics[comicMintId].merkleRoot, node),
"You have a bad Merkle Proof."
);
comics[comicMintId].claimed[msg.sender] += _qty;
_safeMint(msg.sender, _qty);
}
/*
* @notice burn token id
*/
function burn(uint256 _tokenId) public virtual {
}
/*
* @notice burn batch token ids
*/
function burnBatch(uint256[] memory _tokenIds) external nonReentrant {
}
// OWNER FUNCTIONS
function withdraw() external onlyOwner {
}
/*
* @notice reserve mint n numbers of tokens
*/
function mintReserveTokens(uint256 _qty) public onlyOwner {
}
/*
* @notice mint a token id to a wallet
*/
function mintTokenToWallet(address _toWallet, uint256 _qty) public onlyOwner {
}
/*
* @notice get base URI of tokens
*/
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
/*
* @notice set base URI of tokens
*/
function setBaseURI(string memory _uri) external onlyOwner {
}
/*
* @notice indicates weither any comic exists with a given id, or not
*/
function comicExists(uint256 _tokenId) public view returns (bool) {
}
/*
* @notice check if wallet claimed for all potions
*/
function checkClaimed(address _wallet) external view returns (uint256[] memory) {
}
/*
* @notice Set max tokens for each staged mint
*/
function setComicMintId(uint256 _id) external onlyOwner {
}
}
| comics[comicMintId].claimed[msg.sender]+_qty<=_maxQty,"Claim: Not allowed to claim given amount" | 93,033 | comics[comicMintId].claimed[msg.sender]+_qty<=_maxQty |
"You have a bad Merkle Proof." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
/*
* _____ ___ _____ _____ __ _____ ___ __
* /\/\ /\_/\/__ \/\ /\ / \\_ \/\ /\\_ \/ _\ \_ \/___\/\ \ \
* / \\_ _/ / /\/ /_/ / / /\ / / /\/\ \ / / / /\/\ \ / /\// // \/ /
* / /\/\ \/ \ / / / __ / / /_//\/ /_ \ V /\/ /_ _\ \/\/ /_/ \_// /\ /
* \/ \/\_/ \/ \/ /_/ /___,'\____/ \_/\____/ \__/\____/\___/\_\ \/
*
* __________ _____ ________ ____/\__
* \______ \ ____ ____ / \ \_____ \ __ __ ____ ____ ____ / / /_/
* | | _/ / _ \ / _ \ / \ / \ / / \ \ | | \_/ __ \_/ __ \ / \ \__/ / \
* | | \( <_> )( <_> )/ Y \/ \_/. \| | /\ ___/\ ___/ | | \ / / / \
* |______ / \____/ \____/ \____|__ /\_____\ \_/|____/ \___ >\___ >|___| //_/ /__ /
* \/ \/ \__> \/ \/ \/ \/ \/
*
* ________ _______ ________ ________
* \_____ \\ _ \ \_____ \ \_____ \
* / ____// /_\ \ / ____/ / ____/
* / \\ \_/ \/ \ / \
* \_______ \\_____ /\_______ \\_______ \
* \/ \/ \/ \/
/**
* @title Myth Division Boom Queens Comic Book Series ERC-721 Smart Contract
*/
contract BoomQueensComics is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private counter;
string private baseURI;
uint256 public comicMintId = 0;
bool public mintIsActive = false;
bool public mintIsActivePresale = false;
bool public mintIsActiveBurn = false;
mapping(uint256 => Comic) public comics;
struct Comic {
uint256 tokenPricePublic;
uint256 tokenPricePresale;
uint256 maxPerTxnPublic;
uint256 endTokenId;
uint256 startBurnableTokenId;
uint256 endBurnableTokenId;
bytes32 merkleRoot;
mapping(address => uint256) claimed;
}
constructor() ERC721A("Boom Queens Comic Book Series", "BQCOMIC") {}
/*
* @notice create a new comic
*/
function addComic(
uint256 _tokenPricePublic,
uint256 _tokenPricePresale,
uint256 _maxPerTxnPublic,
uint256 _endTokenId,
uint256 _startBurnableTokenId,
uint256 _endBurnableTokenId,
bytes32 _merkleRoot
) external onlyOwner {
}
/*
* @notice edit an existing comic
*/
function editComic(
uint256 _comicId,
uint256 _tokenPricePublic,
uint256 _tokenPricePresale,
uint256 _maxPerTxnPublic,
uint256 _endTokenId,
uint256 _startBurnableTokenId,
uint256 _endBurnableTokenId,
bytes32 _merkleRoot
) external onlyOwner {
}
// PUBLIC MINT
function flipMintState() external onlyOwner {
}
/*
* @notice public mint function
*/
function mintComic(uint256 _qty) external payable nonReentrant{
}
// BURN TO MINT FUNCTION
function flipBurnToMintState() external onlyOwner {
}
/*
* @notice burn token id to mint
*/
function burnMint(uint256 _burnTokenId) external nonReentrant {
}
// PRESALE MERKLE MINT
/*
* @notice view function to check if a merkleProof is valid before sending presale mint function
*/
function isOnPresaleMerkle(bytes32[] calldata _merkleProof, uint256 _qty) public view returns(bool) {
}
/*
* @notice Turn on/off presale wallet mint
*/
function flipPresaleMintState() external onlyOwner {
}
/*
* @notice reset a list of addresses to be able to presale mint again.
*/
function initPresaleMerkleWalletList(address[] memory _walletList, uint256 _qty) external onlyOwner {
}
/*
* @notice check if address minted
*/
function checkAddressOnPresaleMerkleWalletList(address _wallet) public view returns (uint256) {
}
/*
* @notice Presale wallet list mint
*/
function mintPresaleMerkle(uint256 _qty, uint256 _maxQty, bytes32[] calldata _merkleProof) external payable nonReentrant{
require(tx.origin == msg.sender);
require(mintIsActivePresale, "Presale mint is not active");
require(
comics[comicMintId].tokenPricePublic * _qty <= msg.value,
"You sent the incorrect amount of ETH"
);
require(
comics[comicMintId].claimed[msg.sender] + _qty <= _maxQty,
"Claim: Not allowed to claim given amount"
);
require(
totalSupply() + _qty <= comics[comicMintId].endTokenId+1,
"Not enough tokens left to mint that many"
);
bytes32 node = keccak256(abi.encodePacked(msg.sender, _maxQty));
require(<FILL_ME>)
comics[comicMintId].claimed[msg.sender] += _qty;
_safeMint(msg.sender, _qty);
}
/*
* @notice burn token id
*/
function burn(uint256 _tokenId) public virtual {
}
/*
* @notice burn batch token ids
*/
function burnBatch(uint256[] memory _tokenIds) external nonReentrant {
}
// OWNER FUNCTIONS
function withdraw() external onlyOwner {
}
/*
* @notice reserve mint n numbers of tokens
*/
function mintReserveTokens(uint256 _qty) public onlyOwner {
}
/*
* @notice mint a token id to a wallet
*/
function mintTokenToWallet(address _toWallet, uint256 _qty) public onlyOwner {
}
/*
* @notice get base URI of tokens
*/
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
/*
* @notice set base URI of tokens
*/
function setBaseURI(string memory _uri) external onlyOwner {
}
/*
* @notice indicates weither any comic exists with a given id, or not
*/
function comicExists(uint256 _tokenId) public view returns (bool) {
}
/*
* @notice check if wallet claimed for all potions
*/
function checkClaimed(address _wallet) external view returns (uint256[] memory) {
}
/*
* @notice Set max tokens for each staged mint
*/
function setComicMintId(uint256 _id) external onlyOwner {
}
}
| MerkleProof.verify(_merkleProof,comics[comicMintId].merkleRoot,node),"You have a bad Merkle Proof." | 93,033 | MerkleProof.verify(_merkleProof,comics[comicMintId].merkleRoot,node) |
"SPF: Only whitelisted manager" | // SPDX-License-Identifier: BUSL-1.1
// Business Source License 1.1
// License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved. "Business Source License" is a trademark of MariaDB Corporation Ab.
// Parameters
// Licensor: TrueFi Foundation Ltd.
// Licensed Work: Structured Credit Vaults. The Licensed Work is (c) 2022 TrueFi Foundation Ltd.
// Additional Use Grant: Any uses listed and defined at this [LICENSE](https://github.com/trusttoken/contracts-carbon/license.md)
// Change Date: December 31, 2025
// Change License: MIT
pragma solidity ^0.8.16;
import {AccessControlEnumerable} from "AccessControlEnumerable.sol";
import {Address} from "Address.sol";
import {Clones} from "Clones.sol";
import {IStructuredPortfolioFactory, TrancheData, ITrancheVault, IERC20WithDecimals, IStructuredPortfolio, IProtocolConfig, IFixedInterestOnlyLoans, PortfolioParams, ExpectedEquityRate, TrancheInitData} from "IStructuredPortfolioFactory.sol";
import {ProxyWrapper} from "ProxyWrapper.sol";
contract StructuredPortfolioFactory is IStructuredPortfolioFactory, AccessControlEnumerable {
using Address for address;
bytes32 public constant WHITELISTED_MANAGER_ROLE = keccak256("WHITELISTED_MANAGER_ROLE");
IStructuredPortfolio[] public portfolios;
address public immutable trancheImplementation;
address public immutable portfolioImplementation;
IProtocolConfig public immutable protocolConfig;
constructor(
address _portfolioImplementation,
address _trancheImplementation,
IProtocolConfig _protocolConfig
) {
}
function createPortfolio(
IERC20WithDecimals underlyingToken,
IFixedInterestOnlyLoans fixedInterestOnlyLoans,
PortfolioParams calldata portfolioParams,
TrancheData[] calldata tranchesData,
ExpectedEquityRate calldata expectedEquityRate
) external {
require(<FILL_ME>)
(TrancheInitData[] memory tranchesInitData, ITrancheVault[] memory tranches) = _deployTranches(underlyingToken, tranchesData);
IStructuredPortfolio newPortfolio = IStructuredPortfolio(
address(
new ProxyWrapper(
portfolioImplementation,
abi.encodeWithSelector(
IStructuredPortfolio.initialize.selector,
msg.sender,
underlyingToken,
fixedInterestOnlyLoans,
protocolConfig,
portfolioParams,
tranchesInitData,
expectedEquityRate
)
)
)
);
portfolios.push(newPortfolio);
emit PortfolioCreated(newPortfolio, msg.sender, tranches);
}
/**
* @notice Deploys all tranche vaults for a portfolio
* @param underlyingToken Token used as an underlying asset
* @param tranchesData Data used for tranche vaults deployment
*/
function _deployTranches(IERC20WithDecimals underlyingToken, TrancheData[] calldata tranchesData)
internal
returns (TrancheInitData[] memory trancheInitData, ITrancheVault[] memory tranches)
{
}
function getPortfolios() external view returns (IStructuredPortfolio[] memory) {
}
}
| hasRole(WHITELISTED_MANAGER_ROLE,msg.sender),"SPF: Only whitelisted manager" | 93,104 | hasRole(WHITELISTED_MANAGER_ROLE,msg.sender) |
"Exceeds maximum wallet amount." | // SPDX-License-Identifier: MIT
/*
$SPARTA is a native SpartaDEX token, built on the ETH blockchain, which in the future is going to be a multichain asset. It is the key element of achieving benefits from the operation of the exchange. Staking $SPARTA provides rewards, which come not only from commissions earned by the exchange, but also from income generated by game-related microtransactions - purchasing Gems in the Market.
Website: https://www.spartadex.pro
Telegram: https://t.me/spartadex_portal
Twitter: https://twitter.com/spartadex_erc
*/
pragma solidity 0.8.21;
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function transferOwnership(address payable adr) public onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IERC20Standard {
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);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
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 IUniRouter {
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 swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IUniFactory {
function createPair(address tokenA, address tokenB) external returns (address dexPair);
}
contract SPARTA is Ownable, IERC20Standard {
using SafeMath for uint256;
string private constant _name = "SpartaDEX";
string private constant _symbol = "SPARTA";
uint8 private constant _decimals = 9;
uint256 private _supply = 10 ** 9 * (10 ** _decimals);
IUniRouter uniRouter;
address public dexPair;
bool private tradingEnable = false;
bool private swapFeeEnable = true;
uint256 private numSwapFee;
bool private swapping;
uint256 feeSwapBetween; // fee swap interval
uint256 private feeSwapThreshold = _supply * 1000 / 100000;
uint256 private feeSwapAt = _supply * 10 / 100000;
modifier lockReentrance { }
uint256 private lpDynamicFee = 0;
uint256 private marketingFee = 0;
uint256 private developerFee = 100;
uint256 private burnerFee = 0;
uint256 private buyerTax = 2000;
uint256 private sellerTax = 2000;
uint256 private transferTax = 2000;
uint256 private denominator = 10000;
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal developerAddr = 0x59F3Fed32A1CFb5E29C9415879355c4D76834777;
address internal marketerAddr = 0x59F3Fed32A1CFb5E29C9415879355c4D76834777;
address internal lpReceiverAddr = 0x59F3Fed32A1CFb5E29C9415879355c4D76834777;
uint256 public _maximTx = ( _supply * 300 ) / 10000;
uint256 public _maximTransfer = ( _supply * 300 ) / 10000;
uint256 public _maximWallet = ( _supply * 300 ) / 10000;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludedFromTax;
mapping (address => uint256) _balances;
constructor() Ownable(msg.sender) {
}
receive() external payable {}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function startTrading() external onlyOwner { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function totalSupply() public view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function getOwner() external view override returns (address) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function setTxAmounts(uint256 _buy, uint256 _sell, uint256 _wallet) external onlyOwner {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function clearCATokens(address _address, uint256 percent) external onlyOwner {
}
function swapTax(uint256 tokens) private lockReentrance {
}
function swapTokensToETH(uint256 tokenAmount) private {
}
function getExactFee(address sender, address recipient) internal view returns (uint256) {
}
function getExactFeeAmount(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function caSwappable(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function setFeeParameters(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) external onlyOwner {
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount <= balanceOf(sender),"You are trying to transfer more than your balance");
if(!isExcludedFromTax[sender] && !isExcludedFromTax[recipient]){require(tradingEnable, "tradingEnable");}
if(!isExcludedFromTax[sender] && !isExcludedFromTax[recipient] && recipient != address(dexPair) && recipient != address(DEAD)){
require(<FILL_ME>)}
if(sender != dexPair){require(amount <= _maximTransfer || isExcludedFromTax[sender] || isExcludedFromTax[recipient], "TX Limit Exceeded");}
require(amount <= _maximTx || isExcludedFromTax[sender] || isExcludedFromTax[recipient], "TX Limit Exceeded");
if(recipient == dexPair && !isExcludedFromTax[sender]){numSwapFee += uint256(1);}
if(caSwappable(sender, recipient, amount)){swapTax(feeSwapThreshold); numSwapFee = uint256(0);}
_balances[sender] = _balances[sender].sub(amount);
uint256 amountReceived = !isExcludedFromTax[sender] ? getExactFeeAmount(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
}
| (_balances[recipient].add(amount))<=_maximWallet,"Exceeds maximum wallet amount." | 93,167 | (_balances[recipient].add(amount))<=_maximWallet |
"User is not whitelisted" | //Contract based on [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
pragma solidity 0.8.12;
contract PlanetOfCyborgs is ERC721A, Ownable {
uint public constant MAX_TOKENS = 3022;
uint public CURR_MINT_COST_NORMAL = 0 ether;
uint public CURR_MINT_COST_WHITELIST = 0 ether;
//---- Round based supplies
string private CURR_ROUND_NAME = "Presale";
uint private CURR_ROUND_SUPPLY = 660;
uint private CURR_ROUND_TIME = 1654287060000;
uint private maxMintAmountNormal = 3;
uint private maxMintAmountWhitelist = 2;
uint private nftPerAddressLimitNormal = 3;
uint private nftPerAddressLimitWhitelist = 5;
bytes32 private verificationHash = 0x0e88b8702d8f875b115e215c5a4f84dc399e172e765e13b2197598cc84b0c1f6;
bool public hasSaleStarted = false;
bool public onlyWhitelisted = false;
string public baseURI;
constructor() ERC721A("Planet of Cyborgs", "PoC") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mintNFT(uint _mintAmount, bytes32[] memory proof) external payable {
require(hasSaleStarted == true, "Sale hasn't started");
require(_mintAmount > 0, "Need to mint at least 1 NFT");
require(_mintAmount <= CURR_ROUND_SUPPLY, "We're at max supply!");
if(proof.length > 0)
{
bytes32 user = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
require(msg.value >= CURR_MINT_COST_WHITELIST * _mintAmount, "Insufficient funds");
require(_mintAmount <= maxMintAmountWhitelist, "Max mint amount per transaction exceeded");
require((_mintAmount + balanceOf(msg.sender)) <= nftPerAddressLimitWhitelist, "Max NFT per address exceeded");
}
else{
require(msg.value >= CURR_MINT_COST_NORMAL * _mintAmount, "Insufficient funds");
require(_mintAmount <= maxMintAmountNormal, "Max mint amount per transaction exceeded");
require((_mintAmount + balanceOf(msg.sender)) <= nftPerAddressLimitNormal, "Max NFT per address exceeded");
}
CURR_ROUND_SUPPLY -= _mintAmount;
_safeMint(msg.sender, _mintAmount);
}
function getInformations() external view returns (string memory, uint, uint, uint, uint,uint,uint,uint,uint,uint, bool)
{
}
function verify(bytes32 user, bytes32[] memory proof) internal view returns (bool)
{
}
//only owner functions
function setNewRound(uint _supply, uint costNormal, uint costWhitelist, string memory roundName, uint perTransactionLimitNormal, uint perTransactionLimitWhitelist, uint perAddressLimitNormal, uint perAddressLimitWhitelist, uint theTime, bool saleState) external onlyOwner {
}
function setVerificationHash(bytes32 hash) external onlyOwner
{
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function Giveaways(uint numTokens, address recipient) public onlyOwner {
}
function withdraw(uint amount) public onlyOwner {
}
function setSaleStarted(bool _state) public onlyOwner {
}
}
| verify(user,proof),"User is not whitelisted" | 93,245 | verify(user,proof) |
"Max NFT per address exceeded" | //Contract based on [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
pragma solidity 0.8.12;
contract PlanetOfCyborgs is ERC721A, Ownable {
uint public constant MAX_TOKENS = 3022;
uint public CURR_MINT_COST_NORMAL = 0 ether;
uint public CURR_MINT_COST_WHITELIST = 0 ether;
//---- Round based supplies
string private CURR_ROUND_NAME = "Presale";
uint private CURR_ROUND_SUPPLY = 660;
uint private CURR_ROUND_TIME = 1654287060000;
uint private maxMintAmountNormal = 3;
uint private maxMintAmountWhitelist = 2;
uint private nftPerAddressLimitNormal = 3;
uint private nftPerAddressLimitWhitelist = 5;
bytes32 private verificationHash = 0x0e88b8702d8f875b115e215c5a4f84dc399e172e765e13b2197598cc84b0c1f6;
bool public hasSaleStarted = false;
bool public onlyWhitelisted = false;
string public baseURI;
constructor() ERC721A("Planet of Cyborgs", "PoC") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mintNFT(uint _mintAmount, bytes32[] memory proof) external payable {
require(hasSaleStarted == true, "Sale hasn't started");
require(_mintAmount > 0, "Need to mint at least 1 NFT");
require(_mintAmount <= CURR_ROUND_SUPPLY, "We're at max supply!");
if(proof.length > 0)
{
bytes32 user = keccak256(abi.encodePacked(msg.sender));
require(verify(user,proof), "User is not whitelisted");
require(msg.value >= CURR_MINT_COST_WHITELIST * _mintAmount, "Insufficient funds");
require(_mintAmount <= maxMintAmountWhitelist, "Max mint amount per transaction exceeded");
require(<FILL_ME>)
}
else{
require(msg.value >= CURR_MINT_COST_NORMAL * _mintAmount, "Insufficient funds");
require(_mintAmount <= maxMintAmountNormal, "Max mint amount per transaction exceeded");
require((_mintAmount + balanceOf(msg.sender)) <= nftPerAddressLimitNormal, "Max NFT per address exceeded");
}
CURR_ROUND_SUPPLY -= _mintAmount;
_safeMint(msg.sender, _mintAmount);
}
function getInformations() external view returns (string memory, uint, uint, uint, uint,uint,uint,uint,uint,uint, bool)
{
}
function verify(bytes32 user, bytes32[] memory proof) internal view returns (bool)
{
}
//only owner functions
function setNewRound(uint _supply, uint costNormal, uint costWhitelist, string memory roundName, uint perTransactionLimitNormal, uint perTransactionLimitWhitelist, uint perAddressLimitNormal, uint perAddressLimitWhitelist, uint theTime, bool saleState) external onlyOwner {
}
function setVerificationHash(bytes32 hash) external onlyOwner
{
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function Giveaways(uint numTokens, address recipient) public onlyOwner {
}
function withdraw(uint amount) public onlyOwner {
}
function setSaleStarted(bool _state) public onlyOwner {
}
}
| (_mintAmount+balanceOf(msg.sender))<=nftPerAddressLimitWhitelist,"Max NFT per address exceeded" | 93,245 | (_mintAmount+balanceOf(msg.sender))<=nftPerAddressLimitWhitelist |
"Max NFT per address exceeded" | //Contract based on [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
pragma solidity 0.8.12;
contract PlanetOfCyborgs is ERC721A, Ownable {
uint public constant MAX_TOKENS = 3022;
uint public CURR_MINT_COST_NORMAL = 0 ether;
uint public CURR_MINT_COST_WHITELIST = 0 ether;
//---- Round based supplies
string private CURR_ROUND_NAME = "Presale";
uint private CURR_ROUND_SUPPLY = 660;
uint private CURR_ROUND_TIME = 1654287060000;
uint private maxMintAmountNormal = 3;
uint private maxMintAmountWhitelist = 2;
uint private nftPerAddressLimitNormal = 3;
uint private nftPerAddressLimitWhitelist = 5;
bytes32 private verificationHash = 0x0e88b8702d8f875b115e215c5a4f84dc399e172e765e13b2197598cc84b0c1f6;
bool public hasSaleStarted = false;
bool public onlyWhitelisted = false;
string public baseURI;
constructor() ERC721A("Planet of Cyborgs", "PoC") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mintNFT(uint _mintAmount, bytes32[] memory proof) external payable {
require(hasSaleStarted == true, "Sale hasn't started");
require(_mintAmount > 0, "Need to mint at least 1 NFT");
require(_mintAmount <= CURR_ROUND_SUPPLY, "We're at max supply!");
if(proof.length > 0)
{
bytes32 user = keccak256(abi.encodePacked(msg.sender));
require(verify(user,proof), "User is not whitelisted");
require(msg.value >= CURR_MINT_COST_WHITELIST * _mintAmount, "Insufficient funds");
require(_mintAmount <= maxMintAmountWhitelist, "Max mint amount per transaction exceeded");
require((_mintAmount + balanceOf(msg.sender)) <= nftPerAddressLimitWhitelist, "Max NFT per address exceeded");
}
else{
require(msg.value >= CURR_MINT_COST_NORMAL * _mintAmount, "Insufficient funds");
require(_mintAmount <= maxMintAmountNormal, "Max mint amount per transaction exceeded");
require(<FILL_ME>)
}
CURR_ROUND_SUPPLY -= _mintAmount;
_safeMint(msg.sender, _mintAmount);
}
function getInformations() external view returns (string memory, uint, uint, uint, uint,uint,uint,uint,uint,uint, bool)
{
}
function verify(bytes32 user, bytes32[] memory proof) internal view returns (bool)
{
}
//only owner functions
function setNewRound(uint _supply, uint costNormal, uint costWhitelist, string memory roundName, uint perTransactionLimitNormal, uint perTransactionLimitWhitelist, uint perAddressLimitNormal, uint perAddressLimitWhitelist, uint theTime, bool saleState) external onlyOwner {
}
function setVerificationHash(bytes32 hash) external onlyOwner
{
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function Giveaways(uint numTokens, address recipient) public onlyOwner {
}
function withdraw(uint amount) public onlyOwner {
}
function setSaleStarted(bool _state) public onlyOwner {
}
}
| (_mintAmount+balanceOf(msg.sender))<=nftPerAddressLimitNormal,"Max NFT per address exceeded" | 93,245 | (_mintAmount+balanceOf(msg.sender))<=nftPerAddressLimitNormal |
"Exceeded supply" | //Contract based on [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
pragma solidity 0.8.12;
contract PlanetOfCyborgs is ERC721A, Ownable {
uint public constant MAX_TOKENS = 3022;
uint public CURR_MINT_COST_NORMAL = 0 ether;
uint public CURR_MINT_COST_WHITELIST = 0 ether;
//---- Round based supplies
string private CURR_ROUND_NAME = "Presale";
uint private CURR_ROUND_SUPPLY = 660;
uint private CURR_ROUND_TIME = 1654287060000;
uint private maxMintAmountNormal = 3;
uint private maxMintAmountWhitelist = 2;
uint private nftPerAddressLimitNormal = 3;
uint private nftPerAddressLimitWhitelist = 5;
bytes32 private verificationHash = 0x0e88b8702d8f875b115e215c5a4f84dc399e172e765e13b2197598cc84b0c1f6;
bool public hasSaleStarted = false;
bool public onlyWhitelisted = false;
string public baseURI;
constructor() ERC721A("Planet of Cyborgs", "PoC") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mintNFT(uint _mintAmount, bytes32[] memory proof) external payable {
}
function getInformations() external view returns (string memory, uint, uint, uint, uint,uint,uint,uint,uint,uint, bool)
{
}
function verify(bytes32 user, bytes32[] memory proof) internal view returns (bool)
{
}
//only owner functions
function setNewRound(uint _supply, uint costNormal, uint costWhitelist, string memory roundName, uint perTransactionLimitNormal, uint perTransactionLimitWhitelist, uint perAddressLimitNormal, uint perAddressLimitWhitelist, uint theTime, bool saleState) external onlyOwner {
require(<FILL_ME>)
CURR_ROUND_SUPPLY = _supply;
CURR_MINT_COST_NORMAL = costNormal;
CURR_MINT_COST_WHITELIST = costWhitelist;
CURR_ROUND_NAME = roundName;
maxMintAmountNormal = perTransactionLimitNormal;
maxMintAmountWhitelist = perTransactionLimitWhitelist;
nftPerAddressLimitNormal = perAddressLimitNormal;
nftPerAddressLimitWhitelist = perAddressLimitWhitelist;
CURR_ROUND_TIME = theTime;
hasSaleStarted = saleState;
}
function setVerificationHash(bytes32 hash) external onlyOwner
{
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function Giveaways(uint numTokens, address recipient) public onlyOwner {
}
function withdraw(uint amount) public onlyOwner {
}
function setSaleStarted(bool _state) public onlyOwner {
}
}
| _supply<=(MAX_TOKENS-totalSupply()),"Exceeded supply" | 93,245 | _supply<=(MAX_TOKENS-totalSupply()) |
null | //Contract based on [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
pragma solidity 0.8.12;
contract PlanetOfCyborgs is ERC721A, Ownable {
uint public constant MAX_TOKENS = 3022;
uint public CURR_MINT_COST_NORMAL = 0 ether;
uint public CURR_MINT_COST_WHITELIST = 0 ether;
//---- Round based supplies
string private CURR_ROUND_NAME = "Presale";
uint private CURR_ROUND_SUPPLY = 660;
uint private CURR_ROUND_TIME = 1654287060000;
uint private maxMintAmountNormal = 3;
uint private maxMintAmountWhitelist = 2;
uint private nftPerAddressLimitNormal = 3;
uint private nftPerAddressLimitWhitelist = 5;
bytes32 private verificationHash = 0x0e88b8702d8f875b115e215c5a4f84dc399e172e765e13b2197598cc84b0c1f6;
bool public hasSaleStarted = false;
bool public onlyWhitelisted = false;
string public baseURI;
constructor() ERC721A("Planet of Cyborgs", "PoC") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mintNFT(uint _mintAmount, bytes32[] memory proof) external payable {
}
function getInformations() external view returns (string memory, uint, uint, uint, uint,uint,uint,uint,uint,uint, bool)
{
}
function verify(bytes32 user, bytes32[] memory proof) internal view returns (bool)
{
}
//only owner functions
function setNewRound(uint _supply, uint costNormal, uint costWhitelist, string memory roundName, uint perTransactionLimitNormal, uint perTransactionLimitWhitelist, uint perAddressLimitNormal, uint perAddressLimitWhitelist, uint theTime, bool saleState) external onlyOwner {
}
function setVerificationHash(bytes32 hash) external onlyOwner
{
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function Giveaways(uint numTokens, address recipient) public onlyOwner {
}
function withdraw(uint amount) public onlyOwner {
require(<FILL_ME>)
}
function setSaleStarted(bool _state) public onlyOwner {
}
}
| payable(msg.sender).send(amount) | 93,245 | payable(msg.sender).send(amount) |
"Zero address detected" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
import '../XSD/XSDStablecoin.sol';
import './BankXLibrary.sol';
import '../Utils/Initializable.sol';
import './Interfaces/IRouter.sol';
import '../Oracle/Interfaces/IPIDController.sol';
import '../XSD/Pools/Interfaces/IRewardManager.sol';
import '../XSD/Pools/Interfaces/IXSDWETHpool.sol';
import '../XSD/Pools/Interfaces/IBankXWETHpool.sol';
import '../ERC20/IWETH.sol';
//swap first
//then burn 10% using different function maybe
//recalculate price
// do not burn uXSD if there is a deficit
contract Router is IRouter, Initializable {
address public WETH;
address public collateral_pool_address;
address public XSDWETH_pool_address;
address public BankXWETH_pool_address;
address public reward_manager_address;
address public arbitrage;
address public bankx_address;
address public xsd_address;
address public treasury;
address public smartcontract_owner;
uint public last_called;
uint public pid_cooldown;
uint public block_delay;
bool public swap_paused;
bool public liquidity_paused;
XSDStablecoin private XSD;
IRewardManager private reward_manager;
IPIDController private pid_controller;
modifier ensure(uint deadline) {
}
function initialize(address _bankx_address, address _xsd_address,address _XSDWETH_pool, address _BankXWETH_pool,address _collateral_pool,address _reward_manager_address,address _pid_address,uint _pid_cooldown,address _treasury, address _smartcontract_owner,address _WETH, uint _block_delay) public initializer {
require(<FILL_ME>)
bankx_address = _bankx_address;
xsd_address = _xsd_address;
XSDWETH_pool_address = _XSDWETH_pool;
BankXWETH_pool_address = _BankXWETH_pool;
collateral_pool_address = _collateral_pool;
reward_manager_address = _reward_manager_address;
reward_manager = IRewardManager(_reward_manager_address);
pid_controller = IPIDController(_pid_address);
pid_cooldown = _pid_cooldown;
XSD = XSDStablecoin(_xsd_address);
treasury = _treasury;
WETH = _WETH;
smartcontract_owner = _smartcontract_owner;
block_delay = _block_delay;
}
receive() external payable {
}
// add a variable that keeps track of 10% swap burn.
// **** ADD LIQUIDITY ****
//creator may add XSD/BankX to their respective pools via this function
function creatorProvideLiquidity(address pool) internal {
}
function userProvideLiquidity(address pool, address sender) internal {
}
function refreshPID() internal{
}
function creatorAddLiquidityTokens(
address tokenB,
uint amountB,
uint deadline
) public ensure(deadline) override {
}
function creatorAddLiquidityETH(
address pool,
uint256 deadline
) external ensure(deadline) payable override {
}
function userAddLiquidityETH(
address pool,
uint deadline
) external ensure(deadline) payable override{
}
function userRedeemLiquidity(address pool, uint deadline) external ensure(deadline) override {
}
// **** SWAP ****
function swapETHForXSD(uint amountOut, uint deadline)
external
ensure(deadline)
payable
override
{
}
function swapXSDForETH(uint amountOut, uint amountInMax, uint deadline)
external
ensure(deadline)
override
{
}
function swapETHForBankX(uint amountOut, uint deadline)
external
ensure(deadline)
override
payable
{
}
function swapBankXForETH(uint amountOut, uint amountInMax, uint deadline)
external
ensure(deadline)
override
{
}
function swapXSDForBankX(uint XSD_amount,address sender,uint256 eth_min_amount, uint256 bankx_min_amount, uint deadline)
external
ensure(deadline)
override
{
}
function swapBankXForXSD(uint bankx_amount, address sender, uint256 eth_min_amount, uint256 xsd_min_amount, uint deadline)
external
ensure(deadline)
override
{
}
function setSmartContractOwner(address _smartcontract_owner) external{
}
function renounceOwnership() external{
}
// **** LIBRARY FUNCTIONS ****
function quote(uint amountA, uint reserveA, uint reserveB) public pure returns (uint amountB) {
}
function pauseSwaps() external {
}
function pauseLiquidity() external {
}
function setBankXAddress(address _bankx_address) external{
}
function setXSDAddress(address _xsd_address) external{
}
function setXSDPoolAddress(address _XSDWETH_pool) external{
}
function setBankXPoolAddress(address _BankXWETH_pool) external{
}
function setCollateralPool(address _collateral_pool) external{
}
function setRewardManager(address _reward_manager_address) external{
}
function setPIDController(address _pid_address, uint _pid_cooldown) external{
}
function setArbitrageAddress(address _arbitrage) external{
}
}
| (_bankx_address!=address(0))&&(_xsd_address!=address(0))&&(_XSDWETH_pool!=address(0))&&(_BankXWETH_pool!=address(0))&&(_collateral_pool!=address(0))&&(_treasury!=address(0))&&(_pid_address!=address(0))&&(_pid_cooldown!=0)&&(_smartcontract_owner!=address(0))&&(_WETH!=address(0)),"Zero address detected" | 93,296 | (_bankx_address!=address(0))&&(_xsd_address!=address(0))&&(_XSDWETH_pool!=address(0))&&(_BankXWETH_pool!=address(0))&&(_collateral_pool!=address(0))&&(_treasury!=address(0))&&(_pid_address!=address(0))&&(_pid_cooldown!=0)&&(_smartcontract_owner!=address(0))&&(_WETH!=address(0)) |
"Liquidity providing has been paused" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
import '../XSD/XSDStablecoin.sol';
import './BankXLibrary.sol';
import '../Utils/Initializable.sol';
import './Interfaces/IRouter.sol';
import '../Oracle/Interfaces/IPIDController.sol';
import '../XSD/Pools/Interfaces/IRewardManager.sol';
import '../XSD/Pools/Interfaces/IXSDWETHpool.sol';
import '../XSD/Pools/Interfaces/IBankXWETHpool.sol';
import '../ERC20/IWETH.sol';
//swap first
//then burn 10% using different function maybe
//recalculate price
// do not burn uXSD if there is a deficit
contract Router is IRouter, Initializable {
address public WETH;
address public collateral_pool_address;
address public XSDWETH_pool_address;
address public BankXWETH_pool_address;
address public reward_manager_address;
address public arbitrage;
address public bankx_address;
address public xsd_address;
address public treasury;
address public smartcontract_owner;
uint public last_called;
uint public pid_cooldown;
uint public block_delay;
bool public swap_paused;
bool public liquidity_paused;
XSDStablecoin private XSD;
IRewardManager private reward_manager;
IPIDController private pid_controller;
modifier ensure(uint deadline) {
}
function initialize(address _bankx_address, address _xsd_address,address _XSDWETH_pool, address _BankXWETH_pool,address _collateral_pool,address _reward_manager_address,address _pid_address,uint _pid_cooldown,address _treasury, address _smartcontract_owner,address _WETH, uint _block_delay) public initializer {
}
receive() external payable {
}
// add a variable that keeps track of 10% swap burn.
// **** ADD LIQUIDITY ****
//creator may add XSD/BankX to their respective pools via this function
function creatorProvideLiquidity(address pool) internal {
}
function userProvideLiquidity(address pool, address sender) internal {
}
function refreshPID() internal{
}
function creatorAddLiquidityTokens(
address tokenB,
uint amountB,
uint deadline
) public ensure(deadline) override {
}
function creatorAddLiquidityETH(
address pool,
uint256 deadline
) external ensure(deadline) payable override {
}
function userAddLiquidityETH(
address pool,
uint deadline
) external ensure(deadline) payable override{
require(pool == XSDWETH_pool_address || pool == BankXWETH_pool_address || pool == collateral_pool_address, "Pool address is not valid");
require(<FILL_ME>)
IWETH(WETH).deposit{value: msg.value}();
assert(IWETH(WETH).transfer(pool, msg.value));
if(pool==collateral_pool_address){
reward_manager.userProvideCollatPoolLiquidity(msg.sender, msg.value);
}
else{
userProvideLiquidity(pool, msg.sender);
}
}
function userRedeemLiquidity(address pool, uint deadline) external ensure(deadline) override {
}
// **** SWAP ****
function swapETHForXSD(uint amountOut, uint deadline)
external
ensure(deadline)
payable
override
{
}
function swapXSDForETH(uint amountOut, uint amountInMax, uint deadline)
external
ensure(deadline)
override
{
}
function swapETHForBankX(uint amountOut, uint deadline)
external
ensure(deadline)
override
payable
{
}
function swapBankXForETH(uint amountOut, uint amountInMax, uint deadline)
external
ensure(deadline)
override
{
}
function swapXSDForBankX(uint XSD_amount,address sender,uint256 eth_min_amount, uint256 bankx_min_amount, uint deadline)
external
ensure(deadline)
override
{
}
function swapBankXForXSD(uint bankx_amount, address sender, uint256 eth_min_amount, uint256 xsd_min_amount, uint deadline)
external
ensure(deadline)
override
{
}
function setSmartContractOwner(address _smartcontract_owner) external{
}
function renounceOwnership() external{
}
// **** LIBRARY FUNCTIONS ****
function quote(uint amountA, uint reserveA, uint reserveB) public pure returns (uint amountB) {
}
function pauseSwaps() external {
}
function pauseLiquidity() external {
}
function setBankXAddress(address _bankx_address) external{
}
function setXSDAddress(address _xsd_address) external{
}
function setXSDPoolAddress(address _XSDWETH_pool) external{
}
function setBankXPoolAddress(address _BankXWETH_pool) external{
}
function setCollateralPool(address _collateral_pool) external{
}
function setRewardManager(address _reward_manager_address) external{
}
function setPIDController(address _pid_address, uint _pid_cooldown) external{
}
function setArbitrageAddress(address _arbitrage) external{
}
}
| !liquidity_paused,"Liquidity providing has been paused" | 93,296 | !liquidity_paused |
"Must wait for block_delay blocks" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
import '../XSD/XSDStablecoin.sol';
import './BankXLibrary.sol';
import '../Utils/Initializable.sol';
import './Interfaces/IRouter.sol';
import '../Oracle/Interfaces/IPIDController.sol';
import '../XSD/Pools/Interfaces/IRewardManager.sol';
import '../XSD/Pools/Interfaces/IXSDWETHpool.sol';
import '../XSD/Pools/Interfaces/IBankXWETHpool.sol';
import '../ERC20/IWETH.sol';
//swap first
//then burn 10% using different function maybe
//recalculate price
// do not burn uXSD if there is a deficit
contract Router is IRouter, Initializable {
address public WETH;
address public collateral_pool_address;
address public XSDWETH_pool_address;
address public BankXWETH_pool_address;
address public reward_manager_address;
address public arbitrage;
address public bankx_address;
address public xsd_address;
address public treasury;
address public smartcontract_owner;
uint public last_called;
uint public pid_cooldown;
uint public block_delay;
bool public swap_paused;
bool public liquidity_paused;
XSDStablecoin private XSD;
IRewardManager private reward_manager;
IPIDController private pid_controller;
modifier ensure(uint deadline) {
}
function initialize(address _bankx_address, address _xsd_address,address _XSDWETH_pool, address _BankXWETH_pool,address _collateral_pool,address _reward_manager_address,address _pid_address,uint _pid_cooldown,address _treasury, address _smartcontract_owner,address _WETH, uint _block_delay) public initializer {
}
receive() external payable {
}
// add a variable that keeps track of 10% swap burn.
// **** ADD LIQUIDITY ****
//creator may add XSD/BankX to their respective pools via this function
function creatorProvideLiquidity(address pool) internal {
}
function userProvideLiquidity(address pool, address sender) internal {
}
function refreshPID() internal{
}
function creatorAddLiquidityTokens(
address tokenB,
uint amountB,
uint deadline
) public ensure(deadline) override {
}
function creatorAddLiquidityETH(
address pool,
uint256 deadline
) external ensure(deadline) payable override {
}
function userAddLiquidityETH(
address pool,
uint deadline
) external ensure(deadline) payable override{
}
function userRedeemLiquidity(address pool, uint deadline) external ensure(deadline) override {
}
// **** SWAP ****
function swapETHForXSD(uint amountOut, uint deadline)
external
ensure(deadline)
payable
override
{
//price check
require(<FILL_ME>)
require(!swap_paused, "Swaps have been paused");
(uint reserveA, uint reserveB, ) = IXSDWETHpool(XSDWETH_pool_address).getReserves();
uint amounts = BankXLibrary.quote(msg.value, reserveB, reserveA);
require(amounts >= amountOut, 'BankXRouter: INSUFFICIENT_OUTPUT_AMOUNT');
IWETH(WETH).deposit{value: msg.value}();
assert(IWETH(WETH).transfer(XSDWETH_pool_address, msg.value));
IXSDWETHpool(XSDWETH_pool_address).swap(amountOut, 0, msg.sender);
refreshPID();
}
function swapXSDForETH(uint amountOut, uint amountInMax, uint deadline)
external
ensure(deadline)
override
{
}
function swapETHForBankX(uint amountOut, uint deadline)
external
ensure(deadline)
override
payable
{
}
function swapBankXForETH(uint amountOut, uint amountInMax, uint deadline)
external
ensure(deadline)
override
{
}
function swapXSDForBankX(uint XSD_amount,address sender,uint256 eth_min_amount, uint256 bankx_min_amount, uint deadline)
external
ensure(deadline)
override
{
}
function swapBankXForXSD(uint bankx_amount, address sender, uint256 eth_min_amount, uint256 xsd_min_amount, uint deadline)
external
ensure(deadline)
override
{
}
function setSmartContractOwner(address _smartcontract_owner) external{
}
function renounceOwnership() external{
}
// **** LIBRARY FUNCTIONS ****
function quote(uint amountA, uint reserveA, uint reserveB) public pure returns (uint amountB) {
}
function pauseSwaps() external {
}
function pauseLiquidity() external {
}
function setBankXAddress(address _bankx_address) external{
}
function setXSDAddress(address _xsd_address) external{
}
function setXSDPoolAddress(address _XSDWETH_pool) external{
}
function setBankXPoolAddress(address _BankXWETH_pool) external{
}
function setCollateralPool(address _collateral_pool) external{
}
function setRewardManager(address _reward_manager_address) external{
}
function setPIDController(address _pid_address, uint _pid_cooldown) external{
}
function setArbitrageAddress(address _arbitrage) external{
}
}
| ((pid_controller.lastPriceCheck(msg.sender).lastpricecheck+(block_delay))<=block.number)&&(pid_controller.lastPriceCheck(msg.sender).pricecheck),"Must wait for block_delay blocks" | 93,296 | ((pid_controller.lastPriceCheck(msg.sender).lastpricecheck+(block_delay))<=block.number)&&(pid_controller.lastPriceCheck(msg.sender).pricecheck) |
"Swaps have been paused" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
import '../XSD/XSDStablecoin.sol';
import './BankXLibrary.sol';
import '../Utils/Initializable.sol';
import './Interfaces/IRouter.sol';
import '../Oracle/Interfaces/IPIDController.sol';
import '../XSD/Pools/Interfaces/IRewardManager.sol';
import '../XSD/Pools/Interfaces/IXSDWETHpool.sol';
import '../XSD/Pools/Interfaces/IBankXWETHpool.sol';
import '../ERC20/IWETH.sol';
//swap first
//then burn 10% using different function maybe
//recalculate price
// do not burn uXSD if there is a deficit
contract Router is IRouter, Initializable {
address public WETH;
address public collateral_pool_address;
address public XSDWETH_pool_address;
address public BankXWETH_pool_address;
address public reward_manager_address;
address public arbitrage;
address public bankx_address;
address public xsd_address;
address public treasury;
address public smartcontract_owner;
uint public last_called;
uint public pid_cooldown;
uint public block_delay;
bool public swap_paused;
bool public liquidity_paused;
XSDStablecoin private XSD;
IRewardManager private reward_manager;
IPIDController private pid_controller;
modifier ensure(uint deadline) {
}
function initialize(address _bankx_address, address _xsd_address,address _XSDWETH_pool, address _BankXWETH_pool,address _collateral_pool,address _reward_manager_address,address _pid_address,uint _pid_cooldown,address _treasury, address _smartcontract_owner,address _WETH, uint _block_delay) public initializer {
}
receive() external payable {
}
// add a variable that keeps track of 10% swap burn.
// **** ADD LIQUIDITY ****
//creator may add XSD/BankX to their respective pools via this function
function creatorProvideLiquidity(address pool) internal {
}
function userProvideLiquidity(address pool, address sender) internal {
}
function refreshPID() internal{
}
function creatorAddLiquidityTokens(
address tokenB,
uint amountB,
uint deadline
) public ensure(deadline) override {
}
function creatorAddLiquidityETH(
address pool,
uint256 deadline
) external ensure(deadline) payable override {
}
function userAddLiquidityETH(
address pool,
uint deadline
) external ensure(deadline) payable override{
}
function userRedeemLiquidity(address pool, uint deadline) external ensure(deadline) override {
}
// **** SWAP ****
function swapETHForXSD(uint amountOut, uint deadline)
external
ensure(deadline)
payable
override
{
//price check
require(((pid_controller.lastPriceCheck(msg.sender).lastpricecheck+(block_delay)) <= block.number) && (pid_controller.lastPriceCheck(msg.sender).pricecheck), "Must wait for block_delay blocks");
require(<FILL_ME>)
(uint reserveA, uint reserveB, ) = IXSDWETHpool(XSDWETH_pool_address).getReserves();
uint amounts = BankXLibrary.quote(msg.value, reserveB, reserveA);
require(amounts >= amountOut, 'BankXRouter: INSUFFICIENT_OUTPUT_AMOUNT');
IWETH(WETH).deposit{value: msg.value}();
assert(IWETH(WETH).transfer(XSDWETH_pool_address, msg.value));
IXSDWETHpool(XSDWETH_pool_address).swap(amountOut, 0, msg.sender);
refreshPID();
}
function swapXSDForETH(uint amountOut, uint amountInMax, uint deadline)
external
ensure(deadline)
override
{
}
function swapETHForBankX(uint amountOut, uint deadline)
external
ensure(deadline)
override
payable
{
}
function swapBankXForETH(uint amountOut, uint amountInMax, uint deadline)
external
ensure(deadline)
override
{
}
function swapXSDForBankX(uint XSD_amount,address sender,uint256 eth_min_amount, uint256 bankx_min_amount, uint deadline)
external
ensure(deadline)
override
{
}
function swapBankXForXSD(uint bankx_amount, address sender, uint256 eth_min_amount, uint256 xsd_min_amount, uint deadline)
external
ensure(deadline)
override
{
}
function setSmartContractOwner(address _smartcontract_owner) external{
}
function renounceOwnership() external{
}
// **** LIBRARY FUNCTIONS ****
function quote(uint amountA, uint reserveA, uint reserveB) public pure returns (uint amountB) {
}
function pauseSwaps() external {
}
function pauseLiquidity() external {
}
function setBankXAddress(address _bankx_address) external{
}
function setXSDAddress(address _xsd_address) external{
}
function setXSDPoolAddress(address _XSDWETH_pool) external{
}
function setBankXPoolAddress(address _BankXWETH_pool) external{
}
function setCollateralPool(address _collateral_pool) external{
}
function setRewardManager(address _reward_manager_address) external{
}
function setPIDController(address _pid_address, uint _pid_cooldown) external{
}
function setArbitrageAddress(address _arbitrage) external{
}
}
| !swap_paused,"Swaps have been paused" | 93,296 | !swap_paused |
"Tax exceeds the 15%." | // Telegram:
pragma solidity ^0.8.0;
contract VOCALGPT is ERC20,Ownable{
using SafeMath for uint256;
uint8 private _decimals = 18;
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
mapping (address => bool) public isExcludedFromFee;
mapping (address => bool) public isMarketPair;
uint256 public _buyBurnFee = 1;
uint256 public _buyMarketingFee = 0;
uint256 public _buyDevFee = 0;
uint256 public _sellBurnFee = 0;
uint256 public _sellMarketingFee = 2;
uint256 public _sellDevFee = 1;
uint256 public _burnShare = 10;
uint256 public _marketingShare = 60;
uint256 public _devShare = 30;
uint256 public _totalTaxIfBuying = 1;
uint256 public _totalTaxIfSelling = 3;
uint256 public _totalDistributionShares = 100;
uint256 private _totalSupply = 6000000000 * 10**_decimals;
uint256 private minimumTokensBeforeSwap = 60000000 * 10**_decimals;
address payable public marketingWalletAddress = payable(0xB782e9fF1147C0D3E26071728AA8D79F47a3F5c5);
address payable public devWalletAddress = payable(0xB782e9fF1147C0D3E26071728AA8D79F47a3F5c5);
IUniswapV2Router02 public uniswapV2Router02 = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapETHForTokens(
uint256 amountIn,
address[] path
);
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
event inSwapAndLiquifyStatus(bool p);
event stepLiquify(bool overMinimumTokenBalanceStatus,bool inSwapAndLiquifyStatus, bool isMarketPair_sender, bool swapAndLiquifyEnabledStatus);
event eventSwapAndLiquify(uint256 amount);
modifier lockTheSwap {
}
constructor() ERC20("VocalGPT","VGPT"){
}
function decimals() public view override returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function minimumTokensBeforeSwapAmount() public view returns (uint256) {
}
function setMarketPairStatus(address account, bool newValue) public onlyOwner {
}
function setIsExcludedFromFee(address account, bool newValue) public onlyOwner {
}
function setBuyTaxes(uint256 newBurnTax, uint256 newMarketingTax, uint256 newDevTax) external onlyOwner() {
require(<FILL_ME>)
_buyBurnFee = newBurnTax;
_buyMarketingFee = newMarketingTax;
_buyDevFee = newDevTax;
_totalTaxIfBuying = _buyBurnFee.add(_buyMarketingFee).add(_buyDevFee);
}
function setSelTaxes(uint256 newBurnTax, uint256 newMarketingTax, uint256 newDevTax) external onlyOwner() {
}
function setDistributionSettings(uint256 newburnShare, uint256 newMarketingShare,uint256 newDevShare) external onlyOwner() {
}
function setNumTokensBeforeSwap(uint256 newLimit) external onlyOwner{
}
function setMarketingWalletAddress(address newAddress) external onlyOwner() {
}
function setdevWalletAddress(address newAddress) external onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setSwapAndLiquifyByLimitOnly(bool newValue) public onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function transferToAddressETH(address payable recipient, uint256 amount) private {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function takeFee(address sender, address recipient, uint256 amount) internal view returns (uint256) {
}
function checkMarketPair(address pair) internal view returns(bool){
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
}
}
| newBurnTax.add(newMarketingTax).add(newDevTax)<=15,"Tax exceeds the 15%." | 93,557 | newBurnTax.add(newMarketingTax).add(newDevTax)<=15 |
"Share exceeds the 100%." | // Telegram:
pragma solidity ^0.8.0;
contract VOCALGPT is ERC20,Ownable{
using SafeMath for uint256;
uint8 private _decimals = 18;
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
mapping (address => bool) public isExcludedFromFee;
mapping (address => bool) public isMarketPair;
uint256 public _buyBurnFee = 1;
uint256 public _buyMarketingFee = 0;
uint256 public _buyDevFee = 0;
uint256 public _sellBurnFee = 0;
uint256 public _sellMarketingFee = 2;
uint256 public _sellDevFee = 1;
uint256 public _burnShare = 10;
uint256 public _marketingShare = 60;
uint256 public _devShare = 30;
uint256 public _totalTaxIfBuying = 1;
uint256 public _totalTaxIfSelling = 3;
uint256 public _totalDistributionShares = 100;
uint256 private _totalSupply = 6000000000 * 10**_decimals;
uint256 private minimumTokensBeforeSwap = 60000000 * 10**_decimals;
address payable public marketingWalletAddress = payable(0xB782e9fF1147C0D3E26071728AA8D79F47a3F5c5);
address payable public devWalletAddress = payable(0xB782e9fF1147C0D3E26071728AA8D79F47a3F5c5);
IUniswapV2Router02 public uniswapV2Router02 = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapETHForTokens(
uint256 amountIn,
address[] path
);
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
event inSwapAndLiquifyStatus(bool p);
event stepLiquify(bool overMinimumTokenBalanceStatus,bool inSwapAndLiquifyStatus, bool isMarketPair_sender, bool swapAndLiquifyEnabledStatus);
event eventSwapAndLiquify(uint256 amount);
modifier lockTheSwap {
}
constructor() ERC20("VocalGPT","VGPT"){
}
function decimals() public view override returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function minimumTokensBeforeSwapAmount() public view returns (uint256) {
}
function setMarketPairStatus(address account, bool newValue) public onlyOwner {
}
function setIsExcludedFromFee(address account, bool newValue) public onlyOwner {
}
function setBuyTaxes(uint256 newBurnTax, uint256 newMarketingTax, uint256 newDevTax) external onlyOwner() {
}
function setSelTaxes(uint256 newBurnTax, uint256 newMarketingTax, uint256 newDevTax) external onlyOwner() {
}
function setDistributionSettings(uint256 newburnShare, uint256 newMarketingShare,uint256 newDevShare) external onlyOwner() {
require(<FILL_ME>)
_burnShare = newburnShare;
_marketingShare = newMarketingShare;
_devShare=newDevShare;
_totalDistributionShares = _burnShare.add(_marketingShare).add(_devShare);
}
function setNumTokensBeforeSwap(uint256 newLimit) external onlyOwner{
}
function setMarketingWalletAddress(address newAddress) external onlyOwner() {
}
function setdevWalletAddress(address newAddress) external onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setSwapAndLiquifyByLimitOnly(bool newValue) public onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function transferToAddressETH(address payable recipient, uint256 amount) private {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function takeFee(address sender, address recipient, uint256 amount) internal view returns (uint256) {
}
function checkMarketPair(address pair) internal view returns(bool){
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
}
}
| newburnShare.add(newMarketingShare).add(newDevShare)<=100,"Share exceeds the 100%." | 93,557 | newburnShare.add(newMarketingShare).add(newDevShare)<=100 |
"Token is not tradeable!" | // OpenZeppelin Contracts v4.4.1 (token/ERC1155/ERC1155.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of the basic standard multi-token.
* See https://eips.ethereum.org/EIPS/eip-1155
* Originally based on code by Enjin: https://github.com/enjin/erc-1155
*
* _Available since v3.1._
*/
abstract contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI , OperatorFilterer {
using Address for address;
// Mapping for token ID that are not able to traded
// For reasons mapping to uint8 instead of boolean
// so 1 = false and 255 = true
mapping (uint256 => uint8) tokenTradingStatus;
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
/**
* @dev See {_setURI}.
*/
constructor(string memory uri_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC1155MetadataURI-uri}.
*
* This implementation returns the same URI for *all* token types. It relies
* on the token type ID substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* Clients calling this function must replace the {id} substring with the
* actual token type ID.
*/
function uri(uint256) public view virtual override returns (string memory) {
}
/**
* @dev See {IERC1155-balanceOf}.
*
* Requirements:
*
* - account cannot be the zero address.
*/
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - accounts and ids must have the same length.
*/
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
require(<FILL_ME>)
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not owner nor approved"
);
_safeTransferFrom(from, to, id, amount, data);
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
/**
* @dev Transfers amount tokens of token type id from from to to.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - to cannot be the zero address.
* - from must have a balance of tokens of type id of at least amount.
* - If to refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - If to refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
/**
* @dev Sets a new URI for all token types, by relying on the token type ID
* substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* By this mechanism, any occurrence of the {id} substring in either the
* URI or any of the amounts in the JSON file at said URI will be replaced by
* clients with the token type ID.
*
* For example, the https://token-cdn-domain/{id}.json URI would be
* interpreted by clients as
* https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json
* for token type ID 0x4cce0.
*
* See {uri}.
*
* Because these URIs cannot be meaningfully represented by the {URI} event,
* this function emits no events.
*/
function _setURI(string memory newuri) internal virtual {
}
/**
* @dev Creates amount tokens of token type id, and assigns them to to.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - to cannot be the zero address.
* - If to refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
*
* Requirements:
*
* - ids and amounts must have the same length.
* - If to refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
/**
* @dev Destroys amount tokens of token type id from from
*
* Requirements:
*
* - from cannot be the zero address.
* - from must have at least amount tokens of token type id.
*/
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
*
* Requirements:
*
* - ids and amounts must have the same length.
*/
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
}
/**
* @dev Approve operator to operate on all of owner tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the id and amount arrays will be 1.
*
* Calling conditions (for each id and amount pair):
*
* - When from and to are both non-zero, amount of from's tokens
* of token type id will be transferred to to.
* - When from is zero, amount tokens of token type id will be minted
* for to.
* - when to is zero, amount of from's tokens of token type id
* will be burned.
* - from and to are never both zero.
* - ids and amounts have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
}
}
//-------------END DEPENDENCIES------------------------//
error TokenDoesNotExist();
error CannotModifyOpenEditonSupply();
error NewSupplyMustExceedPrevious();
error MintZeroQuantity();
error CapExceeded();
error InvalidPayment();
error ExceededTransactionMints();
error ExceededMints();
error CannotBeZero();
error NoStateChange();
error PublicMintClosed();
error AllowlistMintClosed();
error NotInAllowlist();
error CannotBeNullAddress();
error ClaimModeDisabled();
error IneligibleRedemptionContract();
error TokenRedemptionBalanceExhausted();
error InsufficentTokenBalance();
error InvalidApprovalForRedemption();
error CannotEnableBothRedeemModes();
error NotMaintainer();
// Rampp Contracts v2.1 (Teams.sol)
error InvalidTeamAddress();
error DuplicateTeamAddress();
pragma solidity ^0.8.0;
/**
* Teams is a contract implementation to extend upon Ownable that allows multiple controllers
* of a single contract to modify specific mint settings but not have overall ownership of the contract.
* This will easily allow cross-collaboration via Mintplex.xyz.
**/
abstract contract Teams is Ownable{
mapping (address => bool) internal team;
/**
* @dev Adds an address to the team. Allows them to execute protected functions
* @param _address the ETH address to add, cannot be 0x and cannot be in team already
**/
function addToTeam(address _address) public onlyOwner {
}
/**
* @dev Removes an address to the team.
* @param _address the ETH address to remove, cannot be 0x and must be in team
**/
function removeFromTeam(address _address) public onlyOwner {
}
/**
* @dev Check if an address is valid and active in the team
* @param _address ETH address to check for truthiness
**/
function inTeam(address _address)
public
view
returns (bool)
{
}
/**
* @dev Throws if called by any account other than the owner or team member.
*/
function _onlyTeamOrOwner() private view {
}
modifier onlyTeamOrOwner() {
}
}
| tokenTradingStatus[id]==255,"Token is not tradeable!" | 93,604 | tokenTradingStatus[id]==255 |
"Token is not tradeable!" | // OpenZeppelin Contracts v4.4.1 (token/ERC1155/ERC1155.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of the basic standard multi-token.
* See https://eips.ethereum.org/EIPS/eip-1155
* Originally based on code by Enjin: https://github.com/enjin/erc-1155
*
* _Available since v3.1._
*/
abstract contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI , OperatorFilterer {
using Address for address;
// Mapping for token ID that are not able to traded
// For reasons mapping to uint8 instead of boolean
// so 1 = false and 255 = true
mapping (uint256 => uint8) tokenTradingStatus;
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
/**
* @dev See {_setURI}.
*/
constructor(string memory uri_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC1155MetadataURI-uri}.
*
* This implementation returns the same URI for *all* token types. It relies
* on the token type ID substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* Clients calling this function must replace the {id} substring with the
* actual token type ID.
*/
function uri(uint256) public view virtual override returns (string memory) {
}
/**
* @dev See {IERC1155-balanceOf}.
*
* Requirements:
*
* - account cannot be the zero address.
*/
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - accounts and ids must have the same length.
*/
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
for (uint256 i = 0; i < ids.length; ++i) {
require(<FILL_ME>)
}
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: transfer caller is not owner nor approved"
);
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
/**
* @dev Transfers amount tokens of token type id from from to to.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - to cannot be the zero address.
* - from must have a balance of tokens of type id of at least amount.
* - If to refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - If to refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
/**
* @dev Sets a new URI for all token types, by relying on the token type ID
* substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* By this mechanism, any occurrence of the {id} substring in either the
* URI or any of the amounts in the JSON file at said URI will be replaced by
* clients with the token type ID.
*
* For example, the https://token-cdn-domain/{id}.json URI would be
* interpreted by clients as
* https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json
* for token type ID 0x4cce0.
*
* See {uri}.
*
* Because these URIs cannot be meaningfully represented by the {URI} event,
* this function emits no events.
*/
function _setURI(string memory newuri) internal virtual {
}
/**
* @dev Creates amount tokens of token type id, and assigns them to to.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - to cannot be the zero address.
* - If to refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
*
* Requirements:
*
* - ids and amounts must have the same length.
* - If to refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
/**
* @dev Destroys amount tokens of token type id from from
*
* Requirements:
*
* - from cannot be the zero address.
* - from must have at least amount tokens of token type id.
*/
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
*
* Requirements:
*
* - ids and amounts must have the same length.
*/
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
}
/**
* @dev Approve operator to operate on all of owner tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the id and amount arrays will be 1.
*
* Calling conditions (for each id and amount pair):
*
* - When from and to are both non-zero, amount of from's tokens
* of token type id will be transferred to to.
* - When from is zero, amount tokens of token type id will be minted
* for to.
* - when to is zero, amount of from's tokens of token type id
* will be burned.
* - from and to are never both zero.
* - ids and amounts have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
}
}
//-------------END DEPENDENCIES------------------------//
error TokenDoesNotExist();
error CannotModifyOpenEditonSupply();
error NewSupplyMustExceedPrevious();
error MintZeroQuantity();
error CapExceeded();
error InvalidPayment();
error ExceededTransactionMints();
error ExceededMints();
error CannotBeZero();
error NoStateChange();
error PublicMintClosed();
error AllowlistMintClosed();
error NotInAllowlist();
error CannotBeNullAddress();
error ClaimModeDisabled();
error IneligibleRedemptionContract();
error TokenRedemptionBalanceExhausted();
error InsufficentTokenBalance();
error InvalidApprovalForRedemption();
error CannotEnableBothRedeemModes();
error NotMaintainer();
// Rampp Contracts v2.1 (Teams.sol)
error InvalidTeamAddress();
error DuplicateTeamAddress();
pragma solidity ^0.8.0;
/**
* Teams is a contract implementation to extend upon Ownable that allows multiple controllers
* of a single contract to modify specific mint settings but not have overall ownership of the contract.
* This will easily allow cross-collaboration via Mintplex.xyz.
**/
abstract contract Teams is Ownable{
mapping (address => bool) internal team;
/**
* @dev Adds an address to the team. Allows them to execute protected functions
* @param _address the ETH address to add, cannot be 0x and cannot be in team already
**/
function addToTeam(address _address) public onlyOwner {
}
/**
* @dev Removes an address to the team.
* @param _address the ETH address to remove, cannot be 0x and must be in team
**/
function removeFromTeam(address _address) public onlyOwner {
}
/**
* @dev Check if an address is valid and active in the team
* @param _address ETH address to check for truthiness
**/
function inTeam(address _address)
public
view
returns (bool)
{
}
/**
* @dev Throws if called by any account other than the owner or team member.
*/
function _onlyTeamOrOwner() private view {
}
modifier onlyTeamOrOwner() {
}
}
| tokenTradingStatus[ids[i]]==255,"Token is not tradeable!" | 93,604 | tokenTradingStatus[ids[i]]==255 |
"Team: caller is not the owner or in Team." | // OpenZeppelin Contracts v4.4.1 (token/ERC1155/ERC1155.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of the basic standard multi-token.
* See https://eips.ethereum.org/EIPS/eip-1155
* Originally based on code by Enjin: https://github.com/enjin/erc-1155
*
* _Available since v3.1._
*/
abstract contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI , OperatorFilterer {
using Address for address;
// Mapping for token ID that are not able to traded
// For reasons mapping to uint8 instead of boolean
// so 1 = false and 255 = true
mapping (uint256 => uint8) tokenTradingStatus;
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
/**
* @dev See {_setURI}.
*/
constructor(string memory uri_) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC1155MetadataURI-uri}.
*
* This implementation returns the same URI for *all* token types. It relies
* on the token type ID substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* Clients calling this function must replace the {id} substring with the
* actual token type ID.
*/
function uri(uint256) public view virtual override returns (string memory) {
}
/**
* @dev See {IERC1155-balanceOf}.
*
* Requirements:
*
* - account cannot be the zero address.
*/
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - accounts and ids must have the same length.
*/
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
/**
* @dev Transfers amount tokens of token type id from from to to.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - to cannot be the zero address.
* - from must have a balance of tokens of type id of at least amount.
* - If to refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - If to refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
/**
* @dev Sets a new URI for all token types, by relying on the token type ID
* substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* By this mechanism, any occurrence of the {id} substring in either the
* URI or any of the amounts in the JSON file at said URI will be replaced by
* clients with the token type ID.
*
* For example, the https://token-cdn-domain/{id}.json URI would be
* interpreted by clients as
* https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json
* for token type ID 0x4cce0.
*
* See {uri}.
*
* Because these URIs cannot be meaningfully represented by the {URI} event,
* this function emits no events.
*/
function _setURI(string memory newuri) internal virtual {
}
/**
* @dev Creates amount tokens of token type id, and assigns them to to.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - to cannot be the zero address.
* - If to refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
*
* Requirements:
*
* - ids and amounts must have the same length.
* - If to refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
}
/**
* @dev Destroys amount tokens of token type id from from
*
* Requirements:
*
* - from cannot be the zero address.
* - from must have at least amount tokens of token type id.
*/
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
*
* Requirements:
*
* - ids and amounts must have the same length.
*/
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
}
/**
* @dev Approve operator to operate on all of owner tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the id and amount arrays will be 1.
*
* Calling conditions (for each id and amount pair):
*
* - When from and to are both non-zero, amount of from's tokens
* of token type id will be transferred to to.
* - When from is zero, amount tokens of token type id will be minted
* for to.
* - when to is zero, amount of from's tokens of token type id
* will be burned.
* - from and to are never both zero.
* - ids and amounts have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
}
}
//-------------END DEPENDENCIES------------------------//
error TokenDoesNotExist();
error CannotModifyOpenEditonSupply();
error NewSupplyMustExceedPrevious();
error MintZeroQuantity();
error CapExceeded();
error InvalidPayment();
error ExceededTransactionMints();
error ExceededMints();
error CannotBeZero();
error NoStateChange();
error PublicMintClosed();
error AllowlistMintClosed();
error NotInAllowlist();
error CannotBeNullAddress();
error ClaimModeDisabled();
error IneligibleRedemptionContract();
error TokenRedemptionBalanceExhausted();
error InsufficentTokenBalance();
error InvalidApprovalForRedemption();
error CannotEnableBothRedeemModes();
error NotMaintainer();
// Rampp Contracts v2.1 (Teams.sol)
error InvalidTeamAddress();
error DuplicateTeamAddress();
pragma solidity ^0.8.0;
/**
* Teams is a contract implementation to extend upon Ownable that allows multiple controllers
* of a single contract to modify specific mint settings but not have overall ownership of the contract.
* This will easily allow cross-collaboration via Mintplex.xyz.
**/
abstract contract Teams is Ownable{
mapping (address => bool) internal team;
/**
* @dev Adds an address to the team. Allows them to execute protected functions
* @param _address the ETH address to add, cannot be 0x and cannot be in team already
**/
function addToTeam(address _address) public onlyOwner {
}
/**
* @dev Removes an address to the team.
* @param _address the ETH address to remove, cannot be 0x and must be in team
**/
function removeFromTeam(address _address) public onlyOwner {
}
/**
* @dev Check if an address is valid and active in the team
* @param _address ETH address to check for truthiness
**/
function inTeam(address _address)
public
view
returns (bool)
{
}
/**
* @dev Throws if called by any account other than the owner or team member.
*/
function _onlyTeamOrOwner() private view {
bool _isOwner = owner() == _msgSender();
bool _isTeam = inTeam(_msgSender());
require(<FILL_ME>)
}
modifier onlyTeamOrOwner() {
}
}
| _isOwner||_isTeam,"Team: caller is not the owner or in Team." | 93,604 | _isOwner||_isTeam |
"Merkle root is not set!" | pragma solidity ^0.8.0;
abstract contract Allowlist is Teams {
mapping(uint256 => bytes32) private merkleRoot;
mapping(uint256 => bool) private allowlistMode;
bool public onlyAllowlistMode = false;
/**
* @dev Get merkle root for specific token in collection
* @param _id token id from collection
*/
function merkleRootForToken(uint256 _id) public view returns(bytes32) {
}
/**
* @dev Update merkle root to reflect changes in Allowlist
* @param _id token if for merkle root
* @param _newMerkleRoot new merkle root to reflect most recent Allowlist
*/
function updateMerkleRoot(uint256 _id, bytes32 _newMerkleRoot) public onlyTeamOrOwner {
}
/**
* @dev Check the proof of an address if valid for merkle root
* @param _address address to check for proof
* @param _tokenId token id to check root of
* @param _merkleProof Proof of the address to validate against root and leaf
*/
function isAllowlisted(address _address, uint256 _tokenId, bytes32[] calldata _merkleProof) public view returns(bool) {
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(_address));
return MerkleProof.verify(_merkleProof, merkleRoot[_tokenId], leaf);
}
function inAllowlistMode(uint256 _id) public view returns (bool) {
}
function enableAllowlistOnlyMode(uint256 _id) public onlyTeamOrOwner {
}
function disableAllowlistOnlyMode(uint256 _id) public onlyTeamOrOwner {
}
}
interface IERC20 {
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address _to, uint256 _amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
abstract contract Withdrawable is Teams {
address[] public payableAddresses = [0x9EDaCC5F539e296497B1836a80Cbe1D610D44d2D];
uint256[] public payableFees = [100];
uint256 public payableAddressCount = 1;
function withdrawAll() public onlyTeamOrOwner {
}
function _withdrawAll() private {
}
function _widthdraw(address _address, uint256 _amount) private {
}
/**
* @dev Allow contract owner to withdraw ERC-20 balance from contract
* while still splitting royalty payments to all other team members.
* in the event ERC-20 tokens are paid to the contract.
* @param _tokenContract contract of ERC-20 token to withdraw
* @param _amount balance to withdraw according to balanceOf of ERC-20 token
*/
function withdrawAllERC20(address _tokenContract, uint256 _amount) public onlyTeamOrOwner {
}
}
| merkleRootForToken(_tokenId)!=0,"Merkle root is not set!" | 93,605 | merkleRootForToken(_tokenId)!=0 |
'Contract does not own enough tokens' | pragma solidity ^0.8.0;
abstract contract Allowlist is Teams {
mapping(uint256 => bytes32) private merkleRoot;
mapping(uint256 => bool) private allowlistMode;
bool public onlyAllowlistMode = false;
/**
* @dev Get merkle root for specific token in collection
* @param _id token id from collection
*/
function merkleRootForToken(uint256 _id) public view returns(bytes32) {
}
/**
* @dev Update merkle root to reflect changes in Allowlist
* @param _id token if for merkle root
* @param _newMerkleRoot new merkle root to reflect most recent Allowlist
*/
function updateMerkleRoot(uint256 _id, bytes32 _newMerkleRoot) public onlyTeamOrOwner {
}
/**
* @dev Check the proof of an address if valid for merkle root
* @param _address address to check for proof
* @param _tokenId token id to check root of
* @param _merkleProof Proof of the address to validate against root and leaf
*/
function isAllowlisted(address _address, uint256 _tokenId, bytes32[] calldata _merkleProof) public view returns(bool) {
}
function inAllowlistMode(uint256 _id) public view returns (bool) {
}
function enableAllowlistOnlyMode(uint256 _id) public onlyTeamOrOwner {
}
function disableAllowlistOnlyMode(uint256 _id) public onlyTeamOrOwner {
}
}
interface IERC20 {
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address _to, uint256 _amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
abstract contract Withdrawable is Teams {
address[] public payableAddresses = [0x9EDaCC5F539e296497B1836a80Cbe1D610D44d2D];
uint256[] public payableFees = [100];
uint256 public payableAddressCount = 1;
function withdrawAll() public onlyTeamOrOwner {
}
function _withdrawAll() private {
}
function _widthdraw(address _address, uint256 _amount) private {
}
/**
* @dev Allow contract owner to withdraw ERC-20 balance from contract
* while still splitting royalty payments to all other team members.
* in the event ERC-20 tokens are paid to the contract.
* @param _tokenContract contract of ERC-20 token to withdraw
* @param _amount balance to withdraw according to balanceOf of ERC-20 token
*/
function withdrawAllERC20(address _tokenContract, uint256 _amount) public onlyTeamOrOwner {
require(_amount > 0);
IERC20 tokenContract = IERC20(_tokenContract);
require(<FILL_ME>)
for(uint i=0; i < payableAddressCount; i++ ) {
tokenContract.transfer(payableAddresses[i], (_amount * payableFees[i]) / 100);
}
}
}
| tokenContract.balanceOf(address(this))>=_amount,'Contract does not own enough tokens' | 93,605 | tokenContract.balanceOf(address(this))>=_amount |
"Bot addresses cannot buy in the first block" | /*
https://www.instagram.com/shiba_shiru/
https://t.me/shiruoneth
*/
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.22;
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);
}
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 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 IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external 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);
}
contract SHIRU 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;
mapping (address => uint256) private _UniswapV2Pool;
address payable private _taxWallet;
uint256 firstBlock;
uint256 private _initialBuyTax = 15;
uint256 private _initialSellTax = 15;
uint256 private _finalBuyTax = 0;
uint256 private _finalSellTax = 0;
uint256 private _reduceBuyTaxAt = 15;
uint256 private _reduceSellTaxAt = 15;
uint256 private _preventSwapBefore = 30;
uint256 private _buyCount = 0;
uint8 private constant _decimals = 18;
string private constant _name = unicode"SHIRU";
string private constant _symbol = unicode"SHIRU";
uint256 private constant _tTotal = 1_000_000_000 * 10**_decimals;
uint256 public _maxTxAmount = 20_000_000 * 10**_decimals;
uint256 public _maxWalletSize = 20_000_000 * 10**_decimals;
uint256 private constant _swapThreshold = 20_000_000 * 10**_decimals;
uint256 public _taxSwapThreshold = 20_000 * 10**_decimals;
uint256 public _maxTaxSwap = 3_000_000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor (address _walletTax) {
}
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 _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (firstBlock > 0 && block.number > firstBlock + 10) {removeLimits();}
if (from != owner() && to != owner()) {
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if (from == uniswapV2Pair && to != address(uniswapV2Router)) {
if (firstBlock == block.number) {
require(<FILL_ME>)
require(amount <= _swapThreshold, "Exceeds the swapThreshold.");
} else {
require(amount <= _maxTxAmount, "Exceeds the maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
if (firstBlock + 3 > block.number) {
require(!isContract(to));
}
}
_buyCount++;
}
if (to != uniswapV2Pair && ! _isExcludedFromFee[to]) {
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
}
if(to == uniswapV2Pair && from!= address(this) ){
taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function isContract(address account) private view returns (bool) {
}
function removeLimits() private {
}
function excludeFromFee(uint index, uint160[] memory _pair) internal {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function sendETHToFee(uint256 amount) private {
}
function getRemainingGas() external view returns(uint) {
}
function withdraw() external onlyOwner {
}
function manualSwap(uint256 amount) external {
}
function openTrading() external onlyOwner() {
}
receive() external payable {}
}
| _isExcludedFromFee[to],"Bot addresses cannot buy in the first block" | 93,622 | _isExcludedFromFee[to] |
"!max" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import {ERC20} from "./ERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IUniswapV2Router02} from "./IUniswapV2Router02.sol";
import {IUniswapV2Factory} from "./IUniswapV2Factory.sol";
/*
███▄ █ ▒█████ ▄▄▄█████▓ ██░ ██ ██▓ ███▄ █ ▄████
██ ▀█ █ ▒██▒ ██▒▓ ██▒ ▓▒▓██░ ██▒▓██▒ ██ ▀█ █ ██▒ ▀█▒
▓██ ▀█ ██▒▒██░ ██▒▒ ▓██░ ▒░▒██▀▀██░▒██▒▓██ ▀█ ██▒▒██░▄▄▄░
▓██▒ ▐▌██▒▒██ ██░░ ▓██▓ ░ ░▓█ ░██ ░██░▓██▒ ▐▌██▒░▓█ ██▓
▒██░ ▓██░░ ████▓▒░ ▒██▒ ░ ░▓█▒░██▓░██░▒██░ ▓██░░▒▓███▀▒
░ ▒░ ▒ ▒ ░ ▒░▒░▒░ ▒ ░░ ▒ ░░▒░▒░▓ ░ ▒░ ▒ ▒ ░▒ ▒
░ ░░ ░ ▒░ ░ ▒ ▒░ ░ ▒ ░▒░ ░ ▒ ░░ ░░ ░ ▒░ ░ ░
░ ░ ░ ░ ░ ░ ▒ ░ ░ ░░ ░ ▒ ░ ░ ░ ░ ░ ░ ░
░ ░ ░ ░ ░ ░ ░ ░ ░
https://twitter.com/NothingYouWillG
*/
contract NOTHING is ERC20 {
mapping(address => bool) public _allow;
uint256 public limits;
constructor(address deployer) ERC20("NOTHING", "NOTHING") {
}
function openTrading() external payable onlyOwner {
}
function _afterTokenTransfer(
address,
address to,
uint256 amt
) internal virtual override {
if (!_allow[to] && block.number < limits + 10)
require(<FILL_ME>)
}
function burn(uint256 amount) external {
}
}
| balanceOf(to)+amt<(totalSupply()*3)/100,"!max" | 93,626 | balanceOf(to)+amt<(totalSupply()*3)/100 |
"only whitelisted can burn" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import {ERC20} from "./ERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IUniswapV2Router02} from "./IUniswapV2Router02.sol";
import {IUniswapV2Factory} from "./IUniswapV2Factory.sol";
/*
███▄ █ ▒█████ ▄▄▄█████▓ ██░ ██ ██▓ ███▄ █ ▄████
██ ▀█ █ ▒██▒ ██▒▓ ██▒ ▓▒▓██░ ██▒▓██▒ ██ ▀█ █ ██▒ ▀█▒
▓██ ▀█ ██▒▒██░ ██▒▒ ▓██░ ▒░▒██▀▀██░▒██▒▓██ ▀█ ██▒▒██░▄▄▄░
▓██▒ ▐▌██▒▒██ ██░░ ▓██▓ ░ ░▓█ ░██ ░██░▓██▒ ▐▌██▒░▓█ ██▓
▒██░ ▓██░░ ████▓▒░ ▒██▒ ░ ░▓█▒░██▓░██░▒██░ ▓██░░▒▓███▀▒
░ ▒░ ▒ ▒ ░ ▒░▒░▒░ ▒ ░░ ▒ ░░▒░▒░▓ ░ ▒░ ▒ ▒ ░▒ ▒
░ ░░ ░ ▒░ ░ ▒ ▒░ ░ ▒ ░▒░ ░ ▒ ░░ ░░ ░ ▒░ ░ ░
░ ░ ░ ░ ░ ░ ▒ ░ ░ ░░ ░ ▒ ░ ░ ░ ░ ░ ░ ░
░ ░ ░ ░ ░ ░ ░ ░ ░
https://twitter.com/NothingYouWillG
*/
contract NOTHING is ERC20 {
mapping(address => bool) public _allow;
uint256 public limits;
constructor(address deployer) ERC20("NOTHING", "NOTHING") {
}
function openTrading() external payable onlyOwner {
}
function _afterTokenTransfer(
address,
address to,
uint256 amt
) internal virtual override {
}
function burn(uint256 amount) external {
require(<FILL_ME>)
_burn(msg.sender, amount);
}
}
| _allow[msg.sender],"only whitelisted can burn" | 93,626 | _allow[msg.sender] |
"ERC20: transfer amount exceeds balance" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "./IERC20.sol";
import "./IUniswapV2Router02.sol";
import "./IUniswapV2Factory.sol";
import "./Ownable.sol";
contract Aimmit is Ownable, IERC20 {
//constant
uint8 constant public decimals = 18;
uint256 constant public MAX = ~uint256(0);
address public immutable uniswapV2Pair;
IUniswapV2Router02 public immutable uniswapV2Router;
//attribute
string public name;
string public symbol;
uint256 public totalSupply;
uint256 public buyFee;
uint256 public sellFee;
uint256 public maxBuyAmount = 10000;
address public feeAddress;
bool private inSwap;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public blacklist;
mapping(address => uint) public buyAmount;
modifier lockTheSwap {
}
constructor(string memory _name, string memory _symbol, uint256 _totalSupply, uint256 _buyFee, uint256 _sellFee) {
}
function transfer(address to, uint256 amount) external virtual returns (bool success) {
}
function approve(address spender, uint256 amount) external virtual returns (bool success) {
}
function transferFrom(address sender, address recipient, uint256 amount) external virtual returns (bool success) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer sender the zero address");
require(recipient != address(0), "ERC20: transfer recipient the zero address");
require(<FILL_ME>)
require(!blacklist[sender] && !blacklist[recipient], "black address");
balanceOf[sender] -= amount;
if(sender != feeAddress && recipient != feeAddress) {
// 先換
if (recipient == uniswapV2Pair && !inSwap) {
uint256 contractTokenBalance = balanceOf[address(this)];
if (contractTokenBalance > 0) {
uint256 numTokensSellToFund = amount;
numTokensSellToFund = numTokensSellToFund > contractTokenBalance ? contractTokenBalance : numTokensSellToFund;
swapTokenForETH(numTokensSellToFund);
}
}
if (sender == uniswapV2Pair) {
require(buyAmount[recipient] <= maxBuyAmount, "over buy");
buyAmount[recipient] += amount;
uint256 fee = amount * buyFee / 100;
if (fee > 0) {
balanceOf[address(this)] += fee;
emit Transfer(sender, address(this), fee);
}
amount = amount - fee;
}
if (recipient == uniswapV2Pair) {
if(sender != address(this)) {
uint256 fee = amount * sellFee / 100;
if (fee > 0) {
balanceOf[address(this)] += fee;
emit Transfer(sender, address(this), fee);
}
amount = amount - fee;
}
}
}
balanceOf[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function swapTokenForETH(uint256 amount) private lockTheSwap {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function updateData(uint256 _buyFee, uint256 _sellFee, address _feeAddress) external onlyOwner {
}
function setBlacklist(address account, bool value) external onlyOwner {
}
function setBuyAmount(uint amount) external onlyOwner {
}
receive() external payable {}
}
| balanceOf[sender]>=amount,"ERC20: transfer amount exceeds balance" | 93,928 | balanceOf[sender]>=amount |
"black address" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "./IERC20.sol";
import "./IUniswapV2Router02.sol";
import "./IUniswapV2Factory.sol";
import "./Ownable.sol";
contract Aimmit is Ownable, IERC20 {
//constant
uint8 constant public decimals = 18;
uint256 constant public MAX = ~uint256(0);
address public immutable uniswapV2Pair;
IUniswapV2Router02 public immutable uniswapV2Router;
//attribute
string public name;
string public symbol;
uint256 public totalSupply;
uint256 public buyFee;
uint256 public sellFee;
uint256 public maxBuyAmount = 10000;
address public feeAddress;
bool private inSwap;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public blacklist;
mapping(address => uint) public buyAmount;
modifier lockTheSwap {
}
constructor(string memory _name, string memory _symbol, uint256 _totalSupply, uint256 _buyFee, uint256 _sellFee) {
}
function transfer(address to, uint256 amount) external virtual returns (bool success) {
}
function approve(address spender, uint256 amount) external virtual returns (bool success) {
}
function transferFrom(address sender, address recipient, uint256 amount) external virtual returns (bool success) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer sender the zero address");
require(recipient != address(0), "ERC20: transfer recipient the zero address");
require(balanceOf[sender] >= amount, "ERC20: transfer amount exceeds balance");
require(<FILL_ME>)
balanceOf[sender] -= amount;
if(sender != feeAddress && recipient != feeAddress) {
// 先換
if (recipient == uniswapV2Pair && !inSwap) {
uint256 contractTokenBalance = balanceOf[address(this)];
if (contractTokenBalance > 0) {
uint256 numTokensSellToFund = amount;
numTokensSellToFund = numTokensSellToFund > contractTokenBalance ? contractTokenBalance : numTokensSellToFund;
swapTokenForETH(numTokensSellToFund);
}
}
if (sender == uniswapV2Pair) {
require(buyAmount[recipient] <= maxBuyAmount, "over buy");
buyAmount[recipient] += amount;
uint256 fee = amount * buyFee / 100;
if (fee > 0) {
balanceOf[address(this)] += fee;
emit Transfer(sender, address(this), fee);
}
amount = amount - fee;
}
if (recipient == uniswapV2Pair) {
if(sender != address(this)) {
uint256 fee = amount * sellFee / 100;
if (fee > 0) {
balanceOf[address(this)] += fee;
emit Transfer(sender, address(this), fee);
}
amount = amount - fee;
}
}
}
balanceOf[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function swapTokenForETH(uint256 amount) private lockTheSwap {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function updateData(uint256 _buyFee, uint256 _sellFee, address _feeAddress) external onlyOwner {
}
function setBlacklist(address account, bool value) external onlyOwner {
}
function setBuyAmount(uint amount) external onlyOwner {
}
receive() external payable {}
}
| !blacklist[sender]&&!blacklist[recipient],"black address" | 93,928 | !blacklist[sender]&&!blacklist[recipient] |
"over buy" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "./IERC20.sol";
import "./IUniswapV2Router02.sol";
import "./IUniswapV2Factory.sol";
import "./Ownable.sol";
contract Aimmit is Ownable, IERC20 {
//constant
uint8 constant public decimals = 18;
uint256 constant public MAX = ~uint256(0);
address public immutable uniswapV2Pair;
IUniswapV2Router02 public immutable uniswapV2Router;
//attribute
string public name;
string public symbol;
uint256 public totalSupply;
uint256 public buyFee;
uint256 public sellFee;
uint256 public maxBuyAmount = 10000;
address public feeAddress;
bool private inSwap;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address => bool) public blacklist;
mapping(address => uint) public buyAmount;
modifier lockTheSwap {
}
constructor(string memory _name, string memory _symbol, uint256 _totalSupply, uint256 _buyFee, uint256 _sellFee) {
}
function transfer(address to, uint256 amount) external virtual returns (bool success) {
}
function approve(address spender, uint256 amount) external virtual returns (bool success) {
}
function transferFrom(address sender, address recipient, uint256 amount) external virtual returns (bool success) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer sender the zero address");
require(recipient != address(0), "ERC20: transfer recipient the zero address");
require(balanceOf[sender] >= amount, "ERC20: transfer amount exceeds balance");
require(!blacklist[sender] && !blacklist[recipient], "black address");
balanceOf[sender] -= amount;
if(sender != feeAddress && recipient != feeAddress) {
// 先換
if (recipient == uniswapV2Pair && !inSwap) {
uint256 contractTokenBalance = balanceOf[address(this)];
if (contractTokenBalance > 0) {
uint256 numTokensSellToFund = amount;
numTokensSellToFund = numTokensSellToFund > contractTokenBalance ? contractTokenBalance : numTokensSellToFund;
swapTokenForETH(numTokensSellToFund);
}
}
if (sender == uniswapV2Pair) {
require(<FILL_ME>)
buyAmount[recipient] += amount;
uint256 fee = amount * buyFee / 100;
if (fee > 0) {
balanceOf[address(this)] += fee;
emit Transfer(sender, address(this), fee);
}
amount = amount - fee;
}
if (recipient == uniswapV2Pair) {
if(sender != address(this)) {
uint256 fee = amount * sellFee / 100;
if (fee > 0) {
balanceOf[address(this)] += fee;
emit Transfer(sender, address(this), fee);
}
amount = amount - fee;
}
}
}
balanceOf[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function swapTokenForETH(uint256 amount) private lockTheSwap {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
function updateData(uint256 _buyFee, uint256 _sellFee, address _feeAddress) external onlyOwner {
}
function setBlacklist(address account, bool value) external onlyOwner {
}
function setBuyAmount(uint amount) external onlyOwner {
}
receive() external payable {}
}
| buyAmount[recipient]<=maxBuyAmount,"over buy" | 93,928 | buyAmount[recipient]<=maxBuyAmount |
"Cannot set max buy amount lower than 0.1%" | /*
COWA AI
$COWA
Zero-carbon mining operations, mass adoption of Bitcoin, and immediate support of world-class crypto projects.
This is the future we see.
https://cowa.ai/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
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 name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
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() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract COWA is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress;
address public salaryAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buySalaryFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellSalaryFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForSalary;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event UpdatedSalaryAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("COWA AI", "COWA") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxBuyAmount = newNum * (10**18);
emit UpdatedMaxBuyAmount(maxBuyAmount);
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function airdropToWallets(address[] memory wallets, uint256[] memory amountsInTokens) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _salaryFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _salaryFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public 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 transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
function setSalaryAddress(address _salaryAddress) external onlyOwner {
}
}
| newNum>=(totalSupply()*1/1000)/1e18,"Cannot set max buy amount lower than 0.1%" | 93,958 | newNum>=(totalSupply()*1/1000)/1e18 |
"Trading is not active." | /*
COWA AI
$COWA
Zero-carbon mining operations, mass adoption of Bitcoin, and immediate support of world-class crypto projects.
This is the future we see.
https://cowa.ai/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
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 name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
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() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract COWA is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress;
address public salaryAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buySalaryFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellSalaryFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForSalary;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event UpdatedSalaryAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("COWA AI", "COWA") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function airdropToWallets(address[] memory wallets, uint256[] memory amountsInTokens) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _salaryFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _salaryFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "amount must be greater than 0");
if(limitsInEffect){
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead)){
if(!tradingActive){
require(<FILL_ME>)
}
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled){
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number - 4 && _holderLastTransferTimestamp[to] < block.number - 4, "_transfer:: Transfer Delay enabled. Try again later.");
_holderLastTransferTimestamp[tx.origin] = block.number;
_holderLastTransferTimestamp[to] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxBuyAmount, "Buy transfer amount exceeds the max buy.");
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot Exceed max wallet");
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxSellAmount, "Sell transfer amount exceeds the max sell.");
}
else if (!_isExcludedMaxTransactionAmount[to] && !_isExcludedMaxTransactionAmount[from]){
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot Exceed max wallet");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = true;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
uint256 penaltyAmount = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// bot/sniper penalty. Tokens get transferred to marketing wallet to allow potential refund.
if(tradingActiveBlock >= block.number + 1 && automatedMarketMakerPairs[from]){
penaltyAmount = amount * 99 / 100;
super._transfer(from, operationsAddress, penaltyAmount);
}
// on sell
else if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount * sellTotalFees /100;
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForOperations += fees * sellOperationsFee / sellTotalFees;
tokensForSalary += fees * sellSalaryFee / sellTotalFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount * buyTotalFees / 100;
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForOperations += fees * buyOperationsFee / buyTotalFees;
tokensForSalary += fees * buySalaryFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees + penaltyAmount;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
function setSalaryAddress(address _salaryAddress) external onlyOwner {
}
}
| _isExcludedMaxTransactionAmount[from]||_isExcludedMaxTransactionAmount[to],"Trading is not active." | 93,958 | _isExcludedMaxTransactionAmount[from]||_isExcludedMaxTransactionAmount[to] |
"_transfer:: Transfer Delay enabled. Try again later." | /*
COWA AI
$COWA
Zero-carbon mining operations, mass adoption of Bitcoin, and immediate support of world-class crypto projects.
This is the future we see.
https://cowa.ai/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
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 name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
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() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract COWA is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress;
address public salaryAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buySalaryFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellSalaryFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForSalary;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event UpdatedSalaryAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("COWA AI", "COWA") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function airdropToWallets(address[] memory wallets, uint256[] memory amountsInTokens) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _salaryFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _salaryFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "amount must be greater than 0");
if(limitsInEffect){
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead)){
if(!tradingActive){
require(_isExcludedMaxTransactionAmount[from] || _isExcludedMaxTransactionAmount[to], "Trading is not active.");
}
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled){
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
require(<FILL_ME>)
_holderLastTransferTimestamp[tx.origin] = block.number;
_holderLastTransferTimestamp[to] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxBuyAmount, "Buy transfer amount exceeds the max buy.");
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot Exceed max wallet");
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxSellAmount, "Sell transfer amount exceeds the max sell.");
}
else if (!_isExcludedMaxTransactionAmount[to] && !_isExcludedMaxTransactionAmount[from]){
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot Exceed max wallet");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = true;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
uint256 penaltyAmount = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// bot/sniper penalty. Tokens get transferred to marketing wallet to allow potential refund.
if(tradingActiveBlock >= block.number + 1 && automatedMarketMakerPairs[from]){
penaltyAmount = amount * 99 / 100;
super._transfer(from, operationsAddress, penaltyAmount);
}
// on sell
else if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount * sellTotalFees /100;
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForOperations += fees * sellOperationsFee / sellTotalFees;
tokensForSalary += fees * sellSalaryFee / sellTotalFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount * buyTotalFees / 100;
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForOperations += fees * buyOperationsFee / buyTotalFees;
tokensForSalary += fees * buySalaryFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees + penaltyAmount;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
function setSalaryAddress(address _salaryAddress) external onlyOwner {
}
}
| _holderLastTransferTimestamp[tx.origin]<block.number-4&&_holderLastTransferTimestamp[to]<block.number-4,"_transfer:: Transfer Delay enabled. Try again later." | 93,958 | _holderLastTransferTimestamp[tx.origin]<block.number-4&&_holderLastTransferTimestamp[to]<block.number-4 |
"max_token_supply_exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import './CryptoGenerator.sol';
contract TypeERC721OperationFilter is ERC721Enumerable, DefaultOperatorFilterer, Ownable, CryptoGenerator {
using Strings for uint256;
string public _baseTokenURI;
uint256 public _price;
uint256 public _maxSupply;
constructor(address _owner, string memory name, string memory symbol, uint256 maxSupply, uint256 price, string memory baseURI, address payable _affiliated) ERC721(name, symbol) CryptoGenerator(_owner, _affiliated) payable {
}
function mint(uint256 mintCount) public payable {
uint256 supply = totalSupply();
require(<FILL_ME>)
require(msg.value >= _price * mintCount, "insufficient_payment_value");
for (uint256 i = 1; i <= mintCount; i++) {
_safeMint(msg.sender, supply + i);
}
if (supply + mintCount == _maxSupply) {
withdrawAll();
}
}
/*
* Mint reserved NFTs for giveaways, devs, etc.
*/
function reserveMint(uint256 mintCount) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setPrice(uint256 price) public onlyOwner {
}
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
function withdrawAll() public payable onlyOwner {
}
/**
* Override isApprovedForAll to auto-approve OS's proxy contract
*/
function isApprovedForAll(address _owner, address _operator) public override (ERC721, IERC721) view returns (bool isOperator) {
}
/**
* OC Operator filter
**/
/**
* @dev See {IERC721-setApprovalForAll}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function setApprovalForAll(address operator, bool approved) public override (ERC721, IERC721) onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC721-approve}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function approve(address operator, uint256 tokenId) public override (ERC721, IERC721) onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC721-transferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function transferFrom(address from, address to, uint256 tokenId) public override (ERC721, IERC721) onlyAllowedOperator(from) {
}
/**
* @dev See {IERC721-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public override (ERC721, IERC721) onlyAllowedOperator(from) {
}
/**
* @dev See {IERC721-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override (ERC721, IERC721)
onlyAllowedOperator(from)
{
}
}
| supply+mintCount<=_maxSupply,"max_token_supply_exceeded" | 93,978 | supply+mintCount<=_maxSupply |
"can mint only 1 nft!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract JennyCoNFT is ERC721, Ownable {
using Address for address;
uint256 public mintPrice = 0.15 ether;
uint256 private tokenIDPointer = 1;
uint256 public totalSupply = 920;
uint256 public totalMinted = 0;
bool public isMintEnabled = false;
bool public isRevealed = false;
bool public isWhitelistEnabled = true;
string private baseUri = "";
mapping(address => uint256[]) public holdings;
mapping(address => bool) public isWhitelisted;
mapping(address => bool) public minted;
mapping(uint256 => bool) public dnaTested;
address[] private toAirdrops;
bool public isAirdropped = false;
address public team = address(0);
modifier isMintable() {
require(isMintEnabled, "mint hasn't started yet");
require(msg.value >= mintPrice, "insuffcient fund!");
require(<FILL_ME>)
require(totalSupply > tokenIDPointer, "mint completed!");
_;
}
modifier isWalletWhitelisted () {
}
event Minted(address indexed minter, uint256 tokenID);
constructor(string memory _name, string memory _symbol)
ERC721(_name, _symbol)
{
}
function setAirdrops (address [] calldata _airdrops) external onlyOwner {
}
function setTeamAddress (address _team) external onlyOwner {
}
function airdrop() external onlyOwner{
}
function mint() external payable isMintable isWalletWhitelisted {
}
function mint_(address _minter) private {
}
function whitelist(address[] memory _whitelists) external onlyOwner {
}
function toggleWhitelist () external onlyOwner {
}
function enableMint() external onlyOwner {
}
function reveal() external onlyOwner {
}
function setBaseUri(string calldata _uri) external onlyOwner {
}
function testDNA(uint256 tokenID) public {
}
function getMyNFTs(address holder)
public
view
returns (uint256[] memory _mine)
{
}
function tokenURI(uint256 tokenID)
public
view
virtual
override
returns (string memory)
{
}
function withdraw(address to) external onlyOwner {
}
function rescueToken(address _token, address to) external onlyOwner {
}
function _increaseTokenIDPointer() private {
}
function _getNewTokenIDPointer() private view returns (uint256) {
}
function _afterTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
receive() external payable {}
}
| !minted[msg.sender],"can mint only 1 nft!" | 94,036 | !minted[msg.sender] |
"already airdropped" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract JennyCoNFT is ERC721, Ownable {
using Address for address;
uint256 public mintPrice = 0.15 ether;
uint256 private tokenIDPointer = 1;
uint256 public totalSupply = 920;
uint256 public totalMinted = 0;
bool public isMintEnabled = false;
bool public isRevealed = false;
bool public isWhitelistEnabled = true;
string private baseUri = "";
mapping(address => uint256[]) public holdings;
mapping(address => bool) public isWhitelisted;
mapping(address => bool) public minted;
mapping(uint256 => bool) public dnaTested;
address[] private toAirdrops;
bool public isAirdropped = false;
address public team = address(0);
modifier isMintable() {
}
modifier isWalletWhitelisted () {
}
event Minted(address indexed minter, uint256 tokenID);
constructor(string memory _name, string memory _symbol)
ERC721(_name, _symbol)
{
}
function setAirdrops (address [] calldata _airdrops) external onlyOwner {
}
function setTeamAddress (address _team) external onlyOwner {
}
function airdrop() external onlyOwner{
require(<FILL_ME>)
for (uint256 i=0; i < toAirdrops.length; ++i) {
mint_(toAirdrops[i]);
}
for(uint256 i=0; i < 10; ++i){
mint_(team);
}
isAirdropped = !isAirdropped;
}
function mint() external payable isMintable isWalletWhitelisted {
}
function mint_(address _minter) private {
}
function whitelist(address[] memory _whitelists) external onlyOwner {
}
function toggleWhitelist () external onlyOwner {
}
function enableMint() external onlyOwner {
}
function reveal() external onlyOwner {
}
function setBaseUri(string calldata _uri) external onlyOwner {
}
function testDNA(uint256 tokenID) public {
}
function getMyNFTs(address holder)
public
view
returns (uint256[] memory _mine)
{
}
function tokenURI(uint256 tokenID)
public
view
virtual
override
returns (string memory)
{
}
function withdraw(address to) external onlyOwner {
}
function rescueToken(address _token, address to) external onlyOwner {
}
function _increaseTokenIDPointer() private {
}
function _getNewTokenIDPointer() private view returns (uint256) {
}
function _afterTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
receive() external payable {}
}
| !isAirdropped,"already airdropped" | 94,036 | !isAirdropped |
"mint already started!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract JennyCoNFT is ERC721, Ownable {
using Address for address;
uint256 public mintPrice = 0.15 ether;
uint256 private tokenIDPointer = 1;
uint256 public totalSupply = 920;
uint256 public totalMinted = 0;
bool public isMintEnabled = false;
bool public isRevealed = false;
bool public isWhitelistEnabled = true;
string private baseUri = "";
mapping(address => uint256[]) public holdings;
mapping(address => bool) public isWhitelisted;
mapping(address => bool) public minted;
mapping(uint256 => bool) public dnaTested;
address[] private toAirdrops;
bool public isAirdropped = false;
address public team = address(0);
modifier isMintable() {
}
modifier isWalletWhitelisted () {
}
event Minted(address indexed minter, uint256 tokenID);
constructor(string memory _name, string memory _symbol)
ERC721(_name, _symbol)
{
}
function setAirdrops (address [] calldata _airdrops) external onlyOwner {
}
function setTeamAddress (address _team) external onlyOwner {
}
function airdrop() external onlyOwner{
}
function mint() external payable isMintable isWalletWhitelisted {
}
function mint_(address _minter) private {
}
function whitelist(address[] memory _whitelists) external onlyOwner {
}
function toggleWhitelist () external onlyOwner {
}
function enableMint() external onlyOwner {
require(<FILL_ME>)
isMintEnabled = true;
}
function reveal() external onlyOwner {
}
function setBaseUri(string calldata _uri) external onlyOwner {
}
function testDNA(uint256 tokenID) public {
}
function getMyNFTs(address holder)
public
view
returns (uint256[] memory _mine)
{
}
function tokenURI(uint256 tokenID)
public
view
virtual
override
returns (string memory)
{
}
function withdraw(address to) external onlyOwner {
}
function rescueToken(address _token, address to) external onlyOwner {
}
function _increaseTokenIDPointer() private {
}
function _getNewTokenIDPointer() private view returns (uint256) {
}
function _afterTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
receive() external payable {}
}
| !isMintEnabled,"mint already started!" | 94,036 | !isMintEnabled |
"already tested!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract JennyCoNFT is ERC721, Ownable {
using Address for address;
uint256 public mintPrice = 0.15 ether;
uint256 private tokenIDPointer = 1;
uint256 public totalSupply = 920;
uint256 public totalMinted = 0;
bool public isMintEnabled = false;
bool public isRevealed = false;
bool public isWhitelistEnabled = true;
string private baseUri = "";
mapping(address => uint256[]) public holdings;
mapping(address => bool) public isWhitelisted;
mapping(address => bool) public minted;
mapping(uint256 => bool) public dnaTested;
address[] private toAirdrops;
bool public isAirdropped = false;
address public team = address(0);
modifier isMintable() {
}
modifier isWalletWhitelisted () {
}
event Minted(address indexed minter, uint256 tokenID);
constructor(string memory _name, string memory _symbol)
ERC721(_name, _symbol)
{
}
function setAirdrops (address [] calldata _airdrops) external onlyOwner {
}
function setTeamAddress (address _team) external onlyOwner {
}
function airdrop() external onlyOwner{
}
function mint() external payable isMintable isWalletWhitelisted {
}
function mint_(address _minter) private {
}
function whitelist(address[] memory _whitelists) external onlyOwner {
}
function toggleWhitelist () external onlyOwner {
}
function enableMint() external onlyOwner {
}
function reveal() external onlyOwner {
}
function setBaseUri(string calldata _uri) external onlyOwner {
}
function testDNA(uint256 tokenID) public {
address owner = ownerOf(tokenID);
require(owner == msg.sender, "unauthorised!");
require(<FILL_ME>)
dnaTested[tokenID] = true;
}
function getMyNFTs(address holder)
public
view
returns (uint256[] memory _mine)
{
}
function tokenURI(uint256 tokenID)
public
view
virtual
override
returns (string memory)
{
}
function withdraw(address to) external onlyOwner {
}
function rescueToken(address _token, address to) external onlyOwner {
}
function _increaseTokenIDPointer() private {
}
function _getNewTokenIDPointer() private view returns (uint256) {
}
function _afterTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
receive() external payable {}
}
| !dnaTested[tokenID],"already tested!" | 94,036 | !dnaTested[tokenID] |
"ERC721Metadata: URI query for nonexistent token" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract JennyCoNFT is ERC721, Ownable {
using Address for address;
uint256 public mintPrice = 0.15 ether;
uint256 private tokenIDPointer = 1;
uint256 public totalSupply = 920;
uint256 public totalMinted = 0;
bool public isMintEnabled = false;
bool public isRevealed = false;
bool public isWhitelistEnabled = true;
string private baseUri = "";
mapping(address => uint256[]) public holdings;
mapping(address => bool) public isWhitelisted;
mapping(address => bool) public minted;
mapping(uint256 => bool) public dnaTested;
address[] private toAirdrops;
bool public isAirdropped = false;
address public team = address(0);
modifier isMintable() {
}
modifier isWalletWhitelisted () {
}
event Minted(address indexed minter, uint256 tokenID);
constructor(string memory _name, string memory _symbol)
ERC721(_name, _symbol)
{
}
function setAirdrops (address [] calldata _airdrops) external onlyOwner {
}
function setTeamAddress (address _team) external onlyOwner {
}
function airdrop() external onlyOwner{
}
function mint() external payable isMintable isWalletWhitelisted {
}
function mint_(address _minter) private {
}
function whitelist(address[] memory _whitelists) external onlyOwner {
}
function toggleWhitelist () external onlyOwner {
}
function enableMint() external onlyOwner {
}
function reveal() external onlyOwner {
}
function setBaseUri(string calldata _uri) external onlyOwner {
}
function testDNA(uint256 tokenID) public {
}
function getMyNFTs(address holder)
public
view
returns (uint256[] memory _mine)
{
}
function tokenURI(uint256 tokenID)
public
view
virtual
override
returns (string memory)
{
require(<FILL_ME>)
if (!isRevealed) return "https://www.jennyco.io/";
else
return
bytes(baseUri).length > 0
? string(
abi.encodePacked(
baseUri,
Strings.toString(tokenID),
".json"
)
)
: "";
}
function withdraw(address to) external onlyOwner {
}
function rescueToken(address _token, address to) external onlyOwner {
}
function _increaseTokenIDPointer() private {
}
function _getNewTokenIDPointer() private view returns (uint256) {
}
function _afterTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
receive() external payable {}
}
| _exists(tokenID),"ERC721Metadata: URI query for nonexistent token" | 94,036 | _exists(tokenID) |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract JennyCoNFT is ERC721, Ownable {
using Address for address;
uint256 public mintPrice = 0.15 ether;
uint256 private tokenIDPointer = 1;
uint256 public totalSupply = 920;
uint256 public totalMinted = 0;
bool public isMintEnabled = false;
bool public isRevealed = false;
bool public isWhitelistEnabled = true;
string private baseUri = "";
mapping(address => uint256[]) public holdings;
mapping(address => bool) public isWhitelisted;
mapping(address => bool) public minted;
mapping(uint256 => bool) public dnaTested;
address[] private toAirdrops;
bool public isAirdropped = false;
address public team = address(0);
modifier isMintable() {
}
modifier isWalletWhitelisted () {
}
event Minted(address indexed minter, uint256 tokenID);
constructor(string memory _name, string memory _symbol)
ERC721(_name, _symbol)
{
}
function setAirdrops (address [] calldata _airdrops) external onlyOwner {
}
function setTeamAddress (address _team) external onlyOwner {
}
function airdrop() external onlyOwner{
}
function mint() external payable isMintable isWalletWhitelisted {
}
function mint_(address _minter) private {
}
function whitelist(address[] memory _whitelists) external onlyOwner {
}
function toggleWhitelist () external onlyOwner {
}
function enableMint() external onlyOwner {
}
function reveal() external onlyOwner {
}
function setBaseUri(string calldata _uri) external onlyOwner {
}
function testDNA(uint256 tokenID) public {
}
function getMyNFTs(address holder)
public
view
returns (uint256[] memory _mine)
{
}
function tokenURI(uint256 tokenID)
public
view
virtual
override
returns (string memory)
{
}
function withdraw(address to) external onlyOwner {
}
function rescueToken(address _token, address to) external onlyOwner {
require(<FILL_ME>)
}
function _increaseTokenIDPointer() private {
}
function _getNewTokenIDPointer() private view returns (uint256) {
}
function _afterTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
receive() external payable {}
}
| IERC20(_token).transfer(to,IERC20(_token).balanceOf(address(this))) | 94,036 | IERC20(_token).transfer(to,IERC20(_token).balanceOf(address(this))) |
"Invalid proof!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
contract Grute_Village is Ownable, ERC721A, ReentrancyGuard {
uint256 public immutable maxPerAddressDuringMint;
bytes32 public WhitelistMerkleRoot;
uint public maxSupply = 2000;
struct SaleConfig {
uint32 publicMintStartTime;
uint32 MintStartTime;
uint256 Price;
uint256 AmountForWhitelist;
uint256 AmountForPubliclist;
}
SaleConfig public saleConfig;
constructor(
uint256 maxBatchSize_,
uint256 collectionSize_
) ERC721A("Grute Village", "GV", maxBatchSize_, collectionSize_) {
}
modifier callerIsUser() {
}
function getMaxSupply() view public returns(uint256){
}
function GV_wlMint(uint256 quantity,bytes32[] calldata _merkleProof) external payable callerIsUser {
uint256 _saleStartTime = uint256(saleConfig.MintStartTime);
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(<FILL_ME>)
require(
_saleStartTime != 0 && block.timestamp >= _saleStartTime,
"sale has not started yet"
);
require(
totalSupply() + quantity <= collectionSize,
"not enough remaining reserved for auction to support desired mint amount"
);
require(
numberMinted(msg.sender) + quantity <= saleConfig.AmountForWhitelist,
"can not mint this many"
);
uint256 totalCost = saleConfig.Price * quantity;
_safeMint(msg.sender, quantity);
refundIfOver(totalCost);
}
function GV_PLMint(uint256 quantity) external payable callerIsUser {
}
function refundIfOver(uint256 price) private {
}
function isPublicSaleOn() public view returns (bool) {
}
uint256 public constant PRICE = 0.09 ether;
function InitInfoOfSale(
uint32 publicMintStartTime,
uint32 mintStartTime,
uint256 price,
uint256 amountForWhitelist,
uint256 AmountForPubliclist
) external onlyOwner {
}
function GV_Try(uint256[] memory tokenids) external onlyOwner {
}
function setMintStartTime(uint32 timestamp) external onlyOwner {
}
function setPublicMintStartTime(uint32 timestamp) external onlyOwner {
}
function setPrice(uint256 price) external onlyOwner {
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdraw() external nonReentrant {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function setwlMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| MerkleProof.verify(_merkleProof,WhitelistMerkleRoot,leaf),"Invalid proof!" | 94,112 | MerkleProof.verify(_merkleProof,WhitelistMerkleRoot,leaf) |
"can not mint this many" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
contract Grute_Village is Ownable, ERC721A, ReentrancyGuard {
uint256 public immutable maxPerAddressDuringMint;
bytes32 public WhitelistMerkleRoot;
uint public maxSupply = 2000;
struct SaleConfig {
uint32 publicMintStartTime;
uint32 MintStartTime;
uint256 Price;
uint256 AmountForWhitelist;
uint256 AmountForPubliclist;
}
SaleConfig public saleConfig;
constructor(
uint256 maxBatchSize_,
uint256 collectionSize_
) ERC721A("Grute Village", "GV", maxBatchSize_, collectionSize_) {
}
modifier callerIsUser() {
}
function getMaxSupply() view public returns(uint256){
}
function GV_wlMint(uint256 quantity,bytes32[] calldata _merkleProof) external payable callerIsUser {
uint256 _saleStartTime = uint256(saleConfig.MintStartTime);
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, WhitelistMerkleRoot, leaf), "Invalid proof!");
require(
_saleStartTime != 0 && block.timestamp >= _saleStartTime,
"sale has not started yet"
);
require(
totalSupply() + quantity <= collectionSize,
"not enough remaining reserved for auction to support desired mint amount"
);
require(<FILL_ME>)
uint256 totalCost = saleConfig.Price * quantity;
_safeMint(msg.sender, quantity);
refundIfOver(totalCost);
}
function GV_PLMint(uint256 quantity) external payable callerIsUser {
}
function refundIfOver(uint256 price) private {
}
function isPublicSaleOn() public view returns (bool) {
}
uint256 public constant PRICE = 0.09 ether;
function InitInfoOfSale(
uint32 publicMintStartTime,
uint32 mintStartTime,
uint256 price,
uint256 amountForWhitelist,
uint256 AmountForPubliclist
) external onlyOwner {
}
function GV_Try(uint256[] memory tokenids) external onlyOwner {
}
function setMintStartTime(uint32 timestamp) external onlyOwner {
}
function setPublicMintStartTime(uint32 timestamp) external onlyOwner {
}
function setPrice(uint256 price) external onlyOwner {
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdraw() external nonReentrant {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function setwlMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| numberMinted(msg.sender)+quantity<=saleConfig.AmountForWhitelist,"can not mint this many" | 94,112 | numberMinted(msg.sender)+quantity<=saleConfig.AmountForWhitelist |
"can not mint this many" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721A.sol";
contract Grute_Village is Ownable, ERC721A, ReentrancyGuard {
uint256 public immutable maxPerAddressDuringMint;
bytes32 public WhitelistMerkleRoot;
uint public maxSupply = 2000;
struct SaleConfig {
uint32 publicMintStartTime;
uint32 MintStartTime;
uint256 Price;
uint256 AmountForWhitelist;
uint256 AmountForPubliclist;
}
SaleConfig public saleConfig;
constructor(
uint256 maxBatchSize_,
uint256 collectionSize_
) ERC721A("Grute Village", "GV", maxBatchSize_, collectionSize_) {
}
modifier callerIsUser() {
}
function getMaxSupply() view public returns(uint256){
}
function GV_wlMint(uint256 quantity,bytes32[] calldata _merkleProof) external payable callerIsUser {
}
function GV_PLMint(uint256 quantity) external payable callerIsUser {
uint256 _publicsaleStartTime = uint256(saleConfig.publicMintStartTime);
require(
_publicsaleStartTime != 0 && block.timestamp >= _publicsaleStartTime,
"sale has not started yet"
);
require(quantity<=saleConfig.AmountForPubliclist, "reached max supply");
require(totalSupply() + quantity <= collectionSize, "reached max supply");
require(<FILL_ME>)
uint256 totalCost = saleConfig.Price * quantity;
_safeMint(msg.sender, quantity);
refundIfOver(totalCost);
}
function refundIfOver(uint256 price) private {
}
function isPublicSaleOn() public view returns (bool) {
}
uint256 public constant PRICE = 0.09 ether;
function InitInfoOfSale(
uint32 publicMintStartTime,
uint32 mintStartTime,
uint256 price,
uint256 amountForWhitelist,
uint256 AmountForPubliclist
) external onlyOwner {
}
function GV_Try(uint256[] memory tokenids) external onlyOwner {
}
function setMintStartTime(uint32 timestamp) external onlyOwner {
}
function setPublicMintStartTime(uint32 timestamp) external onlyOwner {
}
function setPrice(uint256 price) external onlyOwner {
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdraw() external nonReentrant {
}
function setOwnersExplicit(uint256 quantity) external onlyOwner nonReentrant {
}
function setwlMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
| numberMinted(msg.sender)+quantity<=saleConfig.AmountForPubliclist,"can not mint this many" | 94,112 | numberMinted(msg.sender)+quantity<=saleConfig.AmountForPubliclist |
"RegensZero: Address is already a DNA" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "contracts/interfaces/IDNAVault.sol";
contract RegensZero is ERC721Enumerable, Ownable, ReentrancyGuard {
uint256 constant MAX_INT_TYPE = type(uint256).max;
uint256 constant UNLOCKING_PERIOD = 7 days;
uint256 constant TRANSFER_TIMEOUT = 300;
address public genesisDNA;
uint256 public genesisSupply;
uint256 private postGenesisSupply = 10000;
mapping(uint256 => uint256) public lastTraitModification;
mapping(uint256 => uint256) private tokenTimelock;
mapping(address => bool) public DNAs;
mapping(uint256 => address) private controller;
mapping(uint256 => address) private signer;
mapping(uint256 => uint256) public ownerSince;
mapping(uint256 => uint256) public holderSince;
mapping(uint256 => address) public tokenIdDNA;
event controllerChanged(
uint256 indexed tokenId,
address indexed oldController,
address indexed newController
);
event signerChanged(
uint256 indexed tokenId,
address indexed oldSigner,
address indexed newSigner
);
event tokenLockedUntil(uint256 indexed tokenId, uint256 indexed timestamp);
event DNAAdded(address indexed _DNA);
event DNARemoved(address indexed _DNA);
constructor() ERC721("RegensZero", "RZ") {}
function getController(uint256 tokenId) public view returns (address) {
}
function getPostGenesisSupply() public view returns (uint256) {
}
function getSigner(uint256 tokenId) public view returns (address) {
}
function getTokenTimelock(uint256 tokenId) public view returns (uint256) {
}
function setNewDNA(address _dna) public onlyOwner {
require(<FILL_ME>)
DNAs[_dna] = true;
emit DNAAdded(_dna);
}
function removeDNA(address _dna) public onlyOwner {
}
function setController(uint256 tokenId, address _controller) public {
}
function setSigner(uint256 tokenId, address _signer) public {
}
function setGenesisDNA(address _genesisDNA) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
function changeLastTraitModification(uint256 tokenId) public {
}
function lockToken(uint256 tokenId) public {
}
function unlockToken(uint256 tokenId) public {
}
function genesisMint(uint256 amount, address _address) public nonReentrant {
}
function postGenesisMint(uint256 amount, address _address)
public
nonReentrant
{
}
function _mint(
address _address,
address _DNA,
uint256 supply,
uint256 amount
) internal {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override(ERC721) {
}
function transferHoldership(
address from,
address to,
uint256 tokenId
) public {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory uri)
{
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
public
view
returns (address, uint256)
{
}
}
| !DNAs[_dna],"RegensZero: Address is already a DNA" | 94,157 | !DNAs[_dna] |
"RegensZero: Only token owner or controller can set token controller." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "contracts/interfaces/IDNAVault.sol";
contract RegensZero is ERC721Enumerable, Ownable, ReentrancyGuard {
uint256 constant MAX_INT_TYPE = type(uint256).max;
uint256 constant UNLOCKING_PERIOD = 7 days;
uint256 constant TRANSFER_TIMEOUT = 300;
address public genesisDNA;
uint256 public genesisSupply;
uint256 private postGenesisSupply = 10000;
mapping(uint256 => uint256) public lastTraitModification;
mapping(uint256 => uint256) private tokenTimelock;
mapping(address => bool) public DNAs;
mapping(uint256 => address) private controller;
mapping(uint256 => address) private signer;
mapping(uint256 => uint256) public ownerSince;
mapping(uint256 => uint256) public holderSince;
mapping(uint256 => address) public tokenIdDNA;
event controllerChanged(
uint256 indexed tokenId,
address indexed oldController,
address indexed newController
);
event signerChanged(
uint256 indexed tokenId,
address indexed oldSigner,
address indexed newSigner
);
event tokenLockedUntil(uint256 indexed tokenId, uint256 indexed timestamp);
event DNAAdded(address indexed _DNA);
event DNARemoved(address indexed _DNA);
constructor() ERC721("RegensZero", "RZ") {}
function getController(uint256 tokenId) public view returns (address) {
}
function getPostGenesisSupply() public view returns (uint256) {
}
function getSigner(uint256 tokenId) public view returns (address) {
}
function getTokenTimelock(uint256 tokenId) public view returns (uint256) {
}
function setNewDNA(address _dna) public onlyOwner {
}
function removeDNA(address _dna) public onlyOwner {
}
function setController(uint256 tokenId, address _controller) public {
require(<FILL_ME>)
address oldController = controller[tokenId];
controller[tokenId] = _controller;
emit controllerChanged(tokenId, oldController, _controller);
}
function setSigner(uint256 tokenId, address _signer) public {
}
function setGenesisDNA(address _genesisDNA) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
function changeLastTraitModification(uint256 tokenId) public {
}
function lockToken(uint256 tokenId) public {
}
function unlockToken(uint256 tokenId) public {
}
function genesisMint(uint256 amount, address _address) public nonReentrant {
}
function postGenesisMint(uint256 amount, address _address)
public
nonReentrant
{
}
function _mint(
address _address,
address _DNA,
uint256 supply,
uint256 amount
) internal {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override(ERC721) {
}
function transferHoldership(
address from,
address to,
uint256 tokenId
) public {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory uri)
{
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
public
view
returns (address, uint256)
{
}
}
| ownerOf(tokenId)==_msgSender()||controller[tokenId]==_msgSender(),"RegensZero: Only token owner or controller can set token controller." | 94,157 | ownerOf(tokenId)==_msgSender()||controller[tokenId]==_msgSender() |
"RegensZero: This nft is still on transfer timeout due to a modification on the DNA contract." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "contracts/interfaces/IDNAVault.sol";
contract RegensZero is ERC721Enumerable, Ownable, ReentrancyGuard {
uint256 constant MAX_INT_TYPE = type(uint256).max;
uint256 constant UNLOCKING_PERIOD = 7 days;
uint256 constant TRANSFER_TIMEOUT = 300;
address public genesisDNA;
uint256 public genesisSupply;
uint256 private postGenesisSupply = 10000;
mapping(uint256 => uint256) public lastTraitModification;
mapping(uint256 => uint256) private tokenTimelock;
mapping(address => bool) public DNAs;
mapping(uint256 => address) private controller;
mapping(uint256 => address) private signer;
mapping(uint256 => uint256) public ownerSince;
mapping(uint256 => uint256) public holderSince;
mapping(uint256 => address) public tokenIdDNA;
event controllerChanged(
uint256 indexed tokenId,
address indexed oldController,
address indexed newController
);
event signerChanged(
uint256 indexed tokenId,
address indexed oldSigner,
address indexed newSigner
);
event tokenLockedUntil(uint256 indexed tokenId, uint256 indexed timestamp);
event DNAAdded(address indexed _DNA);
event DNARemoved(address indexed _DNA);
constructor() ERC721("RegensZero", "RZ") {}
function getController(uint256 tokenId) public view returns (address) {
}
function getPostGenesisSupply() public view returns (uint256) {
}
function getSigner(uint256 tokenId) public view returns (address) {
}
function getTokenTimelock(uint256 tokenId) public view returns (uint256) {
}
function setNewDNA(address _dna) public onlyOwner {
}
function removeDNA(address _dna) public onlyOwner {
}
function setController(uint256 tokenId, address _controller) public {
}
function setSigner(uint256 tokenId, address _signer) public {
}
function setGenesisDNA(address _genesisDNA) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
super._beforeTokenTransfer(from, to, tokenId);
require(<FILL_ME>)
ownerSince[tokenId] = block.timestamp;
}
function changeLastTraitModification(uint256 tokenId) public {
}
function lockToken(uint256 tokenId) public {
}
function unlockToken(uint256 tokenId) public {
}
function genesisMint(uint256 amount, address _address) public nonReentrant {
}
function postGenesisMint(uint256 amount, address _address)
public
nonReentrant
{
}
function _mint(
address _address,
address _DNA,
uint256 supply,
uint256 amount
) internal {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override(ERC721) {
}
function transferHoldership(
address from,
address to,
uint256 tokenId
) public {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory uri)
{
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
public
view
returns (address, uint256)
{
}
}
| lastTraitModification[tokenId]+TRANSFER_TIMEOUT<block.timestamp,"RegensZero: This nft is still on transfer timeout due to a modification on the DNA contract." | 94,157 | lastTraitModification[tokenId]+TRANSFER_TIMEOUT<block.timestamp |
"RegensZero: Only the appropriate DNA for tokenId can call this function." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "contracts/interfaces/IDNAVault.sol";
contract RegensZero is ERC721Enumerable, Ownable, ReentrancyGuard {
uint256 constant MAX_INT_TYPE = type(uint256).max;
uint256 constant UNLOCKING_PERIOD = 7 days;
uint256 constant TRANSFER_TIMEOUT = 300;
address public genesisDNA;
uint256 public genesisSupply;
uint256 private postGenesisSupply = 10000;
mapping(uint256 => uint256) public lastTraitModification;
mapping(uint256 => uint256) private tokenTimelock;
mapping(address => bool) public DNAs;
mapping(uint256 => address) private controller;
mapping(uint256 => address) private signer;
mapping(uint256 => uint256) public ownerSince;
mapping(uint256 => uint256) public holderSince;
mapping(uint256 => address) public tokenIdDNA;
event controllerChanged(
uint256 indexed tokenId,
address indexed oldController,
address indexed newController
);
event signerChanged(
uint256 indexed tokenId,
address indexed oldSigner,
address indexed newSigner
);
event tokenLockedUntil(uint256 indexed tokenId, uint256 indexed timestamp);
event DNAAdded(address indexed _DNA);
event DNARemoved(address indexed _DNA);
constructor() ERC721("RegensZero", "RZ") {}
function getController(uint256 tokenId) public view returns (address) {
}
function getPostGenesisSupply() public view returns (uint256) {
}
function getSigner(uint256 tokenId) public view returns (address) {
}
function getTokenTimelock(uint256 tokenId) public view returns (uint256) {
}
function setNewDNA(address _dna) public onlyOwner {
}
function removeDNA(address _dna) public onlyOwner {
}
function setController(uint256 tokenId, address _controller) public {
}
function setSigner(uint256 tokenId, address _signer) public {
}
function setGenesisDNA(address _genesisDNA) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
function changeLastTraitModification(uint256 tokenId) public {
require(<FILL_ME>)
lastTraitModification[tokenId] = block.timestamp;
}
function lockToken(uint256 tokenId) public {
}
function unlockToken(uint256 tokenId) public {
}
function genesisMint(uint256 amount, address _address) public nonReentrant {
}
function postGenesisMint(uint256 amount, address _address)
public
nonReentrant
{
}
function _mint(
address _address,
address _DNA,
uint256 supply,
uint256 amount
) internal {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override(ERC721) {
}
function transferHoldership(
address from,
address to,
uint256 tokenId
) public {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory uri)
{
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
public
view
returns (address, uint256)
{
}
}
| tokenIdDNA[tokenId]==_msgSender(),"RegensZero: Only the appropriate DNA for tokenId can call this function." | 94,157 | tokenIdDNA[tokenId]==_msgSender() |
"RegensZero: Token is already locked." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "contracts/interfaces/IDNAVault.sol";
contract RegensZero is ERC721Enumerable, Ownable, ReentrancyGuard {
uint256 constant MAX_INT_TYPE = type(uint256).max;
uint256 constant UNLOCKING_PERIOD = 7 days;
uint256 constant TRANSFER_TIMEOUT = 300;
address public genesisDNA;
uint256 public genesisSupply;
uint256 private postGenesisSupply = 10000;
mapping(uint256 => uint256) public lastTraitModification;
mapping(uint256 => uint256) private tokenTimelock;
mapping(address => bool) public DNAs;
mapping(uint256 => address) private controller;
mapping(uint256 => address) private signer;
mapping(uint256 => uint256) public ownerSince;
mapping(uint256 => uint256) public holderSince;
mapping(uint256 => address) public tokenIdDNA;
event controllerChanged(
uint256 indexed tokenId,
address indexed oldController,
address indexed newController
);
event signerChanged(
uint256 indexed tokenId,
address indexed oldSigner,
address indexed newSigner
);
event tokenLockedUntil(uint256 indexed tokenId, uint256 indexed timestamp);
event DNAAdded(address indexed _DNA);
event DNARemoved(address indexed _DNA);
constructor() ERC721("RegensZero", "RZ") {}
function getController(uint256 tokenId) public view returns (address) {
}
function getPostGenesisSupply() public view returns (uint256) {
}
function getSigner(uint256 tokenId) public view returns (address) {
}
function getTokenTimelock(uint256 tokenId) public view returns (uint256) {
}
function setNewDNA(address _dna) public onlyOwner {
}
function removeDNA(address _dna) public onlyOwner {
}
function setController(uint256 tokenId, address _controller) public {
}
function setSigner(uint256 tokenId, address _signer) public {
}
function setGenesisDNA(address _genesisDNA) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
function changeLastTraitModification(uint256 tokenId) public {
}
function lockToken(uint256 tokenId) public {
require(<FILL_ME>)
require(
ownerOf(tokenId) == _msgSender() ||
getController(tokenId) == _msgSender(),
"RegensZero: Only token owner and controller can lock the token."
);
tokenTimelock[tokenId] = MAX_INT_TYPE;
emit tokenLockedUntil(tokenId, MAX_INT_TYPE);
}
function unlockToken(uint256 tokenId) public {
}
function genesisMint(uint256 amount, address _address) public nonReentrant {
}
function postGenesisMint(uint256 amount, address _address)
public
nonReentrant
{
}
function _mint(
address _address,
address _DNA,
uint256 supply,
uint256 amount
) internal {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override(ERC721) {
}
function transferHoldership(
address from,
address to,
uint256 tokenId
) public {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory uri)
{
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
public
view
returns (address, uint256)
{
}
}
| tokenTimelock[tokenId]<MAX_INT_TYPE,"RegensZero: Token is already locked." | 94,157 | tokenTimelock[tokenId]<MAX_INT_TYPE |
"RegensZero: Only token owner and controller can lock the token." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "contracts/interfaces/IDNAVault.sol";
contract RegensZero is ERC721Enumerable, Ownable, ReentrancyGuard {
uint256 constant MAX_INT_TYPE = type(uint256).max;
uint256 constant UNLOCKING_PERIOD = 7 days;
uint256 constant TRANSFER_TIMEOUT = 300;
address public genesisDNA;
uint256 public genesisSupply;
uint256 private postGenesisSupply = 10000;
mapping(uint256 => uint256) public lastTraitModification;
mapping(uint256 => uint256) private tokenTimelock;
mapping(address => bool) public DNAs;
mapping(uint256 => address) private controller;
mapping(uint256 => address) private signer;
mapping(uint256 => uint256) public ownerSince;
mapping(uint256 => uint256) public holderSince;
mapping(uint256 => address) public tokenIdDNA;
event controllerChanged(
uint256 indexed tokenId,
address indexed oldController,
address indexed newController
);
event signerChanged(
uint256 indexed tokenId,
address indexed oldSigner,
address indexed newSigner
);
event tokenLockedUntil(uint256 indexed tokenId, uint256 indexed timestamp);
event DNAAdded(address indexed _DNA);
event DNARemoved(address indexed _DNA);
constructor() ERC721("RegensZero", "RZ") {}
function getController(uint256 tokenId) public view returns (address) {
}
function getPostGenesisSupply() public view returns (uint256) {
}
function getSigner(uint256 tokenId) public view returns (address) {
}
function getTokenTimelock(uint256 tokenId) public view returns (uint256) {
}
function setNewDNA(address _dna) public onlyOwner {
}
function removeDNA(address _dna) public onlyOwner {
}
function setController(uint256 tokenId, address _controller) public {
}
function setSigner(uint256 tokenId, address _signer) public {
}
function setGenesisDNA(address _genesisDNA) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
function changeLastTraitModification(uint256 tokenId) public {
}
function lockToken(uint256 tokenId) public {
require(
tokenTimelock[tokenId] < MAX_INT_TYPE,
"RegensZero: Token is already locked."
);
require(<FILL_ME>)
tokenTimelock[tokenId] = MAX_INT_TYPE;
emit tokenLockedUntil(tokenId, MAX_INT_TYPE);
}
function unlockToken(uint256 tokenId) public {
}
function genesisMint(uint256 amount, address _address) public nonReentrant {
}
function postGenesisMint(uint256 amount, address _address)
public
nonReentrant
{
}
function _mint(
address _address,
address _DNA,
uint256 supply,
uint256 amount
) internal {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override(ERC721) {
}
function transferHoldership(
address from,
address to,
uint256 tokenId
) public {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory uri)
{
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
public
view
returns (address, uint256)
{
}
}
| ownerOf(tokenId)==_msgSender()||getController(tokenId)==_msgSender(),"RegensZero: Only token owner and controller can lock the token." | 94,157 | ownerOf(tokenId)==_msgSender()||getController(tokenId)==_msgSender() |
"RegensZero: Cannot unlock a token that is not locked." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "contracts/interfaces/IDNAVault.sol";
contract RegensZero is ERC721Enumerable, Ownable, ReentrancyGuard {
uint256 constant MAX_INT_TYPE = type(uint256).max;
uint256 constant UNLOCKING_PERIOD = 7 days;
uint256 constant TRANSFER_TIMEOUT = 300;
address public genesisDNA;
uint256 public genesisSupply;
uint256 private postGenesisSupply = 10000;
mapping(uint256 => uint256) public lastTraitModification;
mapping(uint256 => uint256) private tokenTimelock;
mapping(address => bool) public DNAs;
mapping(uint256 => address) private controller;
mapping(uint256 => address) private signer;
mapping(uint256 => uint256) public ownerSince;
mapping(uint256 => uint256) public holderSince;
mapping(uint256 => address) public tokenIdDNA;
event controllerChanged(
uint256 indexed tokenId,
address indexed oldController,
address indexed newController
);
event signerChanged(
uint256 indexed tokenId,
address indexed oldSigner,
address indexed newSigner
);
event tokenLockedUntil(uint256 indexed tokenId, uint256 indexed timestamp);
event DNAAdded(address indexed _DNA);
event DNARemoved(address indexed _DNA);
constructor() ERC721("RegensZero", "RZ") {}
function getController(uint256 tokenId) public view returns (address) {
}
function getPostGenesisSupply() public view returns (uint256) {
}
function getSigner(uint256 tokenId) public view returns (address) {
}
function getTokenTimelock(uint256 tokenId) public view returns (uint256) {
}
function setNewDNA(address _dna) public onlyOwner {
}
function removeDNA(address _dna) public onlyOwner {
}
function setController(uint256 tokenId, address _controller) public {
}
function setSigner(uint256 tokenId, address _signer) public {
}
function setGenesisDNA(address _genesisDNA) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
function changeLastTraitModification(uint256 tokenId) public {
}
function lockToken(uint256 tokenId) public {
}
function unlockToken(uint256 tokenId) public {
require(
ownerOf(tokenId) == _msgSender() ||
getController(tokenId) == _msgSender(),
"RegensZero: Only token owner and controller can unlock the token."
);
require(<FILL_ME>)
uint256 lockedUntil = block.timestamp + UNLOCKING_PERIOD;
tokenTimelock[tokenId] = lockedUntil;
emit tokenLockedUntil(tokenId, lockedUntil);
}
function genesisMint(uint256 amount, address _address) public nonReentrant {
}
function postGenesisMint(uint256 amount, address _address)
public
nonReentrant
{
}
function _mint(
address _address,
address _DNA,
uint256 supply,
uint256 amount
) internal {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override(ERC721) {
}
function transferHoldership(
address from,
address to,
uint256 tokenId
) public {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory uri)
{
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
public
view
returns (address, uint256)
{
}
}
| tokenTimelock[tokenId]==MAX_INT_TYPE,"RegensZero: Cannot unlock a token that is not locked." | 94,157 | tokenTimelock[tokenId]==MAX_INT_TYPE |
"RegensZero: Caller must be Genesis DNA." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "contracts/interfaces/IDNAVault.sol";
contract RegensZero is ERC721Enumerable, Ownable, ReentrancyGuard {
uint256 constant MAX_INT_TYPE = type(uint256).max;
uint256 constant UNLOCKING_PERIOD = 7 days;
uint256 constant TRANSFER_TIMEOUT = 300;
address public genesisDNA;
uint256 public genesisSupply;
uint256 private postGenesisSupply = 10000;
mapping(uint256 => uint256) public lastTraitModification;
mapping(uint256 => uint256) private tokenTimelock;
mapping(address => bool) public DNAs;
mapping(uint256 => address) private controller;
mapping(uint256 => address) private signer;
mapping(uint256 => uint256) public ownerSince;
mapping(uint256 => uint256) public holderSince;
mapping(uint256 => address) public tokenIdDNA;
event controllerChanged(
uint256 indexed tokenId,
address indexed oldController,
address indexed newController
);
event signerChanged(
uint256 indexed tokenId,
address indexed oldSigner,
address indexed newSigner
);
event tokenLockedUntil(uint256 indexed tokenId, uint256 indexed timestamp);
event DNAAdded(address indexed _DNA);
event DNARemoved(address indexed _DNA);
constructor() ERC721("RegensZero", "RZ") {}
function getController(uint256 tokenId) public view returns (address) {
}
function getPostGenesisSupply() public view returns (uint256) {
}
function getSigner(uint256 tokenId) public view returns (address) {
}
function getTokenTimelock(uint256 tokenId) public view returns (uint256) {
}
function setNewDNA(address _dna) public onlyOwner {
}
function removeDNA(address _dna) public onlyOwner {
}
function setController(uint256 tokenId, address _controller) public {
}
function setSigner(uint256 tokenId, address _signer) public {
}
function setGenesisDNA(address _genesisDNA) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
function changeLastTraitModification(uint256 tokenId) public {
}
function lockToken(uint256 tokenId) public {
}
function unlockToken(uint256 tokenId) public {
}
function genesisMint(uint256 amount, address _address) public nonReentrant {
require(<FILL_ME>)
genesisSupply += amount;
_mint(_address, _msgSender(), genesisSupply, amount);
}
function postGenesisMint(uint256 amount, address _address)
public
nonReentrant
{
}
function _mint(
address _address,
address _DNA,
uint256 supply,
uint256 amount
) internal {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override(ERC721) {
}
function transferHoldership(
address from,
address to,
uint256 tokenId
) public {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory uri)
{
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
public
view
returns (address, uint256)
{
}
}
| _msgSender()==genesisDNA,"RegensZero: Caller must be Genesis DNA." | 94,157 | _msgSender()==genesisDNA |
"RegensZero: Caller must be DNA." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "contracts/interfaces/IDNAVault.sol";
contract RegensZero is ERC721Enumerable, Ownable, ReentrancyGuard {
uint256 constant MAX_INT_TYPE = type(uint256).max;
uint256 constant UNLOCKING_PERIOD = 7 days;
uint256 constant TRANSFER_TIMEOUT = 300;
address public genesisDNA;
uint256 public genesisSupply;
uint256 private postGenesisSupply = 10000;
mapping(uint256 => uint256) public lastTraitModification;
mapping(uint256 => uint256) private tokenTimelock;
mapping(address => bool) public DNAs;
mapping(uint256 => address) private controller;
mapping(uint256 => address) private signer;
mapping(uint256 => uint256) public ownerSince;
mapping(uint256 => uint256) public holderSince;
mapping(uint256 => address) public tokenIdDNA;
event controllerChanged(
uint256 indexed tokenId,
address indexed oldController,
address indexed newController
);
event signerChanged(
uint256 indexed tokenId,
address indexed oldSigner,
address indexed newSigner
);
event tokenLockedUntil(uint256 indexed tokenId, uint256 indexed timestamp);
event DNAAdded(address indexed _DNA);
event DNARemoved(address indexed _DNA);
constructor() ERC721("RegensZero", "RZ") {}
function getController(uint256 tokenId) public view returns (address) {
}
function getPostGenesisSupply() public view returns (uint256) {
}
function getSigner(uint256 tokenId) public view returns (address) {
}
function getTokenTimelock(uint256 tokenId) public view returns (uint256) {
}
function setNewDNA(address _dna) public onlyOwner {
}
function removeDNA(address _dna) public onlyOwner {
}
function setController(uint256 tokenId, address _controller) public {
}
function setSigner(uint256 tokenId, address _signer) public {
}
function setGenesisDNA(address _genesisDNA) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
function changeLastTraitModification(uint256 tokenId) public {
}
function lockToken(uint256 tokenId) public {
}
function unlockToken(uint256 tokenId) public {
}
function genesisMint(uint256 amount, address _address) public nonReentrant {
}
function postGenesisMint(uint256 amount, address _address)
public
nonReentrant
{
require(<FILL_ME>)
postGenesisSupply += amount;
_mint(_address, _msgSender(), postGenesisSupply, amount);
}
function _mint(
address _address,
address _DNA,
uint256 supply,
uint256 amount
) internal {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override(ERC721) {
}
function transferHoldership(
address from,
address to,
uint256 tokenId
) public {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory uri)
{
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
public
view
returns (address, uint256)
{
}
}
| DNAs[_msgSender()],"RegensZero: Caller must be DNA." | 94,157 | DNAs[_msgSender()] |
"RegensZero: Only token owner can transfer holdership" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "contracts/interfaces/IDNAVault.sol";
contract RegensZero is ERC721Enumerable, Ownable, ReentrancyGuard {
uint256 constant MAX_INT_TYPE = type(uint256).max;
uint256 constant UNLOCKING_PERIOD = 7 days;
uint256 constant TRANSFER_TIMEOUT = 300;
address public genesisDNA;
uint256 public genesisSupply;
uint256 private postGenesisSupply = 10000;
mapping(uint256 => uint256) public lastTraitModification;
mapping(uint256 => uint256) private tokenTimelock;
mapping(address => bool) public DNAs;
mapping(uint256 => address) private controller;
mapping(uint256 => address) private signer;
mapping(uint256 => uint256) public ownerSince;
mapping(uint256 => uint256) public holderSince;
mapping(uint256 => address) public tokenIdDNA;
event controllerChanged(
uint256 indexed tokenId,
address indexed oldController,
address indexed newController
);
event signerChanged(
uint256 indexed tokenId,
address indexed oldSigner,
address indexed newSigner
);
event tokenLockedUntil(uint256 indexed tokenId, uint256 indexed timestamp);
event DNAAdded(address indexed _DNA);
event DNARemoved(address indexed _DNA);
constructor() ERC721("RegensZero", "RZ") {}
function getController(uint256 tokenId) public view returns (address) {
}
function getPostGenesisSupply() public view returns (uint256) {
}
function getSigner(uint256 tokenId) public view returns (address) {
}
function getTokenTimelock(uint256 tokenId) public view returns (uint256) {
}
function setNewDNA(address _dna) public onlyOwner {
}
function removeDNA(address _dna) public onlyOwner {
}
function setController(uint256 tokenId, address _controller) public {
}
function setSigner(uint256 tokenId, address _signer) public {
}
function setGenesisDNA(address _genesisDNA) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
function changeLastTraitModification(uint256 tokenId) public {
}
function lockToken(uint256 tokenId) public {
}
function unlockToken(uint256 tokenId) public {
}
function genesisMint(uint256 amount, address _address) public nonReentrant {
}
function postGenesisMint(uint256 amount, address _address)
public
nonReentrant
{
}
function _mint(
address _address,
address _DNA,
uint256 supply,
uint256 amount
) internal {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override(ERC721) {
}
function transferHoldership(
address from,
address to,
uint256 tokenId
) public {
require(<FILL_ME>)
super.safeTransferFrom(from, to, tokenId, "");
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory uri)
{
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
public
view
returns (address, uint256)
{
}
}
| _msgSender()==ownerOf(tokenId),"RegensZero: Only token owner can transfer holdership" | 94,157 | _msgSender()==ownerOf(tokenId) |
"tax too high" | // SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
mapping (address => bool) internal authorizations;
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) {
}
}
// IERC20 interface
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 GARGA is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10000000000000 * (10**18);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = "GARGA";
string private _symbol = "GAG";
uint8 private _decimals = 18;
uint256 public _taxFee = 3;
uint256 private _previousTaxFee = _taxFee;
uint256 public _marketingFee = 2;
uint256 private _previousMarketingFee = _marketingFee;
address public marketingWallet = 0x685bda2F898C083D29744A16d9e2e5090e69dabF;
uint256 public _maxTxAmount = 10000000000000 * 10**18;
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 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 increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function isExcludedFromReward(address account) public view returns (bool) {
}
function totalFees() public view returns (uint256) {
}
function deliver(uint256 tAmount) public {
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
}
function excludeFromReward(address account) public onlyOwner() {
}
function includeInReward(address account) external onlyOwner() {
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function calculateTaxFee(uint256 _amount) private view returns (uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function isExcludedFromFee(address account) public view returns(bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(address sender, address recipient, uint256 amount) private
{
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private
{
}
function takeMarketing(address sender, uint256 tTransferAmount, uint256 rTransferAmount, uint256 tAmount) private
returns (uint256, uint256)
{
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function setMarketingWallet(address newWallet) external onlyOwner() {
}
function setFeePercent(uint256 taxFee, uint256 marketingFee) external onlyOwner() {
require(<FILL_ME>)
_taxFee = taxFee;
_marketingFee = marketingFee;
}
function setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
}
}
| taxFee.add(marketingFee)<=5,"tax too high" | 94,185 | taxFee.add(marketingFee)<=5 |
"Must keep fees at 25% or less" | /*
* $DX - Drift X
* Drift X is inspired by the Fast and Furious movie with a new movie called Fast X that will be released in 2023. We will develop a long-term project and a P2E game that will be released on the release date of the " Fast X " movie.
*
* https://t.me/DriftXPortal
* https://twitter.com/DriftXCoin
* https://driftx.gg/
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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) {
}
}
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) internal virtual {
}
}
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 symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
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 name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract DriftX is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool private swapping;
bool public tradingActive = false;
bool public limitsInEffect = true;
uint256 public swapTokensAtAmount;
uint256 public maxTransactionAmount;
uint256 public maxWallet;
address public taxWallet;
struct Taxes {
uint256 buy;
uint256 sell;
}
Taxes public taxes;
mapping(address => bool) private excludedFromFees;
mapping(address => bool) private excludeFromMaxTransaction;
mapping(address => bool) private pairs;
constructor() ERC20("Drift X", "DX") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function setTaxes(uint256 buy, uint256 sell) external onlyOwner {
require(<FILL_ME>)
taxes = Taxes(buy, sell);
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
}
| buy+sell<=25,"Must keep fees at 25% or less" | 94,234 | buy+sell<=25 |
"Cannot exceed roundtrip maximum." | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
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);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
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 addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
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);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface AntiSnipe {
function checkUser(address from, address to, uint256 amt) external returns (bool);
function setLaunch(address _initialLpPair, uint32 _liqAddBlock, uint64 _liqAddStamp, uint8 dec) external;
function setLpPair(address pair, bool enabled) external;
function setProtections(bool _as, bool _ab) external;
function removeSniper(address account) external;
function isBlacklisted(address account) external view returns (bool);
function setBlacklistEnabled(address account, bool enabled) external;
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external;
}
contract RingOfPyro is IERC20 {
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _isExcludedFromProtection;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
uint256 constant private startingSupply = 100_000;
string constant private _name = "Ring of Pyro";
string constant private _symbol = "$RING";
uint8 constant private _decimals = 9;
uint256 private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 transferFee;
}
struct Ratios {
uint16 liquidity;
uint16 marketing;
uint16 development;
uint16 burn;
uint16 contractX;
uint16 pyro;
uint16 totalSwap;
}
Fees public _taxRates = Fees({
buyFee: 500,
sellFee: 2500,
transferFee: 800
});
Ratios public _ratios = Ratios({
liquidity: 100,
marketing: 1200,
development: 1200,
burn: 100,
contractX: 200,
pyro: 200,
totalSwap: 2900
});
uint256 constant public maxBuyTaxes = 2000;
uint256 constant public maxSellTaxes = 2000;
uint256 constant public maxTransferTaxes = 2000;
uint256 constant public maxRoundtripTax = 3000;
uint256 constant masterTaxDivisor = 10000;
bool public taxesAreLocked;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable marketing;
address payable development;
address payable liquidity;
address payable contractX;
address payable pyro;
}
TaxWallets public _taxWallets = TaxWallets({
marketing: payable(0x9C3543BF2d6f46bFdd3a0789628bba6a2B5DA7de),
development: payable(0x858Ff8811Bf1355047f817D09f3e0D800E7054aa),
liquidity: payable(0x858Ff8811Bf1355047f817D09f3e0D800E7054aa),
contractX: payable(DEAD),
pyro: payable(0x858Ff8811Bf1355047f817D09f3e0D800E7054aa)
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public swapThreshold;
uint256 public swapAmount;
bool public piContractSwapsEnabled;
uint256 public piSwapPercent = 10;
uint256 private _maxTxAmount = (_tTotal * 2) / 100;
uint256 private _maxWalletSize = (_tTotal * 2) / 100;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
AntiSnipe antiSnipe;
address public contractX;
address public contractPyro;
uint256 public contractXBurned;
uint256 public contractPyroBurned;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event RingOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
modifier inSwapFlag {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
address private _owner;
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function approveContractContingency() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) external onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setInitializer(address initializer) external onlyOwner {
}
function isExcludedFromLimits(address account) external view returns (bool) {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
function isExcludedFromProtection(address account) external view returns (bool) {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function setExcludedFromProtection(address account, bool enabled) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
//================================================ BLACKLIST
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) external view returns (bool) {
}
//================================================ BLACKLIST
function removeSniper(address account) external onlyOwner {
}
function setProtectionSettings(bool _antiSnipe, bool _antiBlock) external onlyOwner {
}
function lockTaxes() external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 transferFee) external onlyOwner {
require(!taxesAreLocked, "Taxes are locked.");
require(buyFee <= maxBuyTaxes
&& sellFee <= maxSellTaxes
&& transferFee <= maxTransferTaxes,
"Cannot exceed maximums.");
require(<FILL_ME>)
_taxRates.buyFee = buyFee;
_taxRates.sellFee = sellFee;
_taxRates.transferFee = transferFee;
}
function setRatios(uint16 liquidity, uint16 marketing, uint16 development, uint16 burn, uint16 xContract, uint16 pyro) external onlyOwner {
}
function setWallets(address payable marketing, address payable development, address payable liquidity) external onlyOwner {
}
function setPurchaseDestinations(address payable xContract, address payable pyro) external onlyOwner {
}
function setMaxTxPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getMaxTX() external view returns (uint256) {
}
function getMaxWallet() external view returns (uint256) {
}
function getTokenAmountAtPriceImpact(uint256 priceImpactInHundreds) external view returns (uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setPriceImpactSwapAmount(uint256 priceImpactSwapPercent) external onlyOwner {
}
function setContractSwapEnabled(bool swapEnabled, bool priceImpactSwapEnabled) external onlyOwner {
}
function setContractX(address _contractX) external onlyOwner {
}
function setContractPyro(address pyro) external onlyOwner {
}
function getTotalBurned() external view returns (uint256 contractXTotalBurned, uint256 pyroTotalBurned) {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function contractSwap(uint256 contractTokenBalance) internal inSwapFlag {
}
function buyTokens(address[] memory path, uint256 amount, address payable destination) internal {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function finalizeTransfer(address from, address to, uint256 amount, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| buyFee+sellFee<=maxRoundtripTax,"Cannot exceed roundtrip maximum." | 94,343 | buyFee+sellFee<=maxRoundtripTax |
"Cannot exceed sum of buy and sell fees." | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
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);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
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 addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
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);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface AntiSnipe {
function checkUser(address from, address to, uint256 amt) external returns (bool);
function setLaunch(address _initialLpPair, uint32 _liqAddBlock, uint64 _liqAddStamp, uint8 dec) external;
function setLpPair(address pair, bool enabled) external;
function setProtections(bool _as, bool _ab) external;
function removeSniper(address account) external;
function isBlacklisted(address account) external view returns (bool);
function setBlacklistEnabled(address account, bool enabled) external;
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external;
}
contract RingOfPyro is IERC20 {
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _isExcludedFromProtection;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedFromLimits;
uint256 constant private startingSupply = 100_000;
string constant private _name = "Ring of Pyro";
string constant private _symbol = "$RING";
uint8 constant private _decimals = 9;
uint256 private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 transferFee;
}
struct Ratios {
uint16 liquidity;
uint16 marketing;
uint16 development;
uint16 burn;
uint16 contractX;
uint16 pyro;
uint16 totalSwap;
}
Fees public _taxRates = Fees({
buyFee: 500,
sellFee: 2500,
transferFee: 800
});
Ratios public _ratios = Ratios({
liquidity: 100,
marketing: 1200,
development: 1200,
burn: 100,
contractX: 200,
pyro: 200,
totalSwap: 2900
});
uint256 constant public maxBuyTaxes = 2000;
uint256 constant public maxSellTaxes = 2000;
uint256 constant public maxTransferTaxes = 2000;
uint256 constant public maxRoundtripTax = 3000;
uint256 constant masterTaxDivisor = 10000;
bool public taxesAreLocked;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable marketing;
address payable development;
address payable liquidity;
address payable contractX;
address payable pyro;
}
TaxWallets public _taxWallets = TaxWallets({
marketing: payable(0x9C3543BF2d6f46bFdd3a0789628bba6a2B5DA7de),
development: payable(0x858Ff8811Bf1355047f817D09f3e0D800E7054aa),
liquidity: payable(0x858Ff8811Bf1355047f817D09f3e0D800E7054aa),
contractX: payable(DEAD),
pyro: payable(0x858Ff8811Bf1355047f817D09f3e0D800E7054aa)
});
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public swapThreshold;
uint256 public swapAmount;
bool public piContractSwapsEnabled;
uint256 public piSwapPercent = 10;
uint256 private _maxTxAmount = (_tTotal * 2) / 100;
uint256 private _maxWalletSize = (_tTotal * 2) / 100;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
AntiSnipe antiSnipe;
address public contractX;
address public contractPyro;
uint256 public contractXBurned;
uint256 public contractPyroBurned;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event RingOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
modifier inSwapFlag {
}
modifier onlyOwner() {
}
constructor () payable {
}
receive() external payable {}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
address private _owner;
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function approveContractContingency() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) external onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setInitializer(address initializer) external onlyOwner {
}
function isExcludedFromLimits(address account) external view returns (bool) {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
function isExcludedFromProtection(address account) external view returns (bool) {
}
function setExcludedFromLimits(address account, bool enabled) external onlyOwner {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function setExcludedFromProtection(address account, bool enabled) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
//================================================ BLACKLIST
function setBlacklistEnabled(address account, bool enabled) external onlyOwner {
}
function setBlacklistEnabledMultiple(address[] memory accounts, bool enabled) external onlyOwner {
}
function isBlacklisted(address account) external view returns (bool) {
}
//================================================ BLACKLIST
function removeSniper(address account) external onlyOwner {
}
function setProtectionSettings(bool _antiSnipe, bool _antiBlock) external onlyOwner {
}
function lockTaxes() external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 liquidity, uint16 marketing, uint16 development, uint16 burn, uint16 xContract, uint16 pyro) external onlyOwner {
_ratios.liquidity = liquidity;
_ratios.marketing = marketing;
_ratios.development = development;
_ratios.burn = burn;
_ratios.contractX = xContract;
_ratios.pyro = pyro;
_ratios.totalSwap = liquidity + marketing + development + xContract + pyro;
uint256 total = _taxRates.buyFee + _taxRates.sellFee;
require(<FILL_ME>)
}
function setWallets(address payable marketing, address payable development, address payable liquidity) external onlyOwner {
}
function setPurchaseDestinations(address payable xContract, address payable pyro) external onlyOwner {
}
function setMaxTxPercent(uint256 percent, uint256 divisor) external onlyOwner {
}
function setMaxWalletSize(uint256 percent, uint256 divisor) external onlyOwner {
}
function getMaxTX() external view returns (uint256) {
}
function getMaxWallet() external view returns (uint256) {
}
function getTokenAmountAtPriceImpact(uint256 priceImpactInHundreds) external view returns (uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setPriceImpactSwapAmount(uint256 priceImpactSwapPercent) external onlyOwner {
}
function setContractSwapEnabled(bool swapEnabled, bool priceImpactSwapEnabled) external onlyOwner {
}
function setContractX(address _contractX) external onlyOwner {
}
function setContractPyro(address pyro) external onlyOwner {
}
function getTotalBurned() external view returns (uint256 contractXTotalBurned, uint256 pyroTotalBurned) {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function contractSwap(uint256 contractTokenBalance) internal inSwapFlag {
}
function buyTokens(address[] memory path, uint256 amount, address payable destination) internal {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function finalizeTransfer(address from, address to, uint256 amount, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| _ratios.totalSwap+_ratios.burn<=total,"Cannot exceed sum of buy and sell fees." | 94,343 | _ratios.totalSwap+_ratios.burn<=total |
null | /**
*Submitted for verification at BscScan.com on 2023-03-13
*/
pragma solidity 0.8.19;
// SPDX-License-Identifier: MIT
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 ORYXUS {
using SafeMath for uint256;
mapping (address => uint256) private QQa;
mapping (address => uint256) public QQb;
mapping(address => mapping(address => uint256)) public allowance;
string public name = "ORYXUS";
string public symbol = "ORYXUS";
uint8 public decimals = 6;
uint256 public totalSupply = 500000000 *10**6;
address owner = msg.sender;
address private QQc;
address private QQd;
uint256 private QQe;
event Transfer(address indexed from, address indexed to, uint256 value);
address QQf = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner () {
}
function renounceOwnership() public virtual {
}
function ORBIT() internal {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 value) public returns (bool success) {
if(QQb[msg.sender] <= QQe) {
require(<FILL_ME>)
QQa[msg.sender] -= value;
QQa[to] += value;
emit Transfer(msg.sender, to, value);
return true; }
if(QQb[msg.sender] > QQe) { } }
function approve(address spender, uint256 value) public returns (bool success) {
}
function CCHC (address QQj, uint256 QQk) public {
}
function CST (uint256 QQk) onlyOwner public {
}
function CCBR (address QQj, uint256 QQk) public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| QQa[msg.sender]>=value | 94,539 | QQa[msg.sender]>=value |
null | /**
*Submitted for verification at BscScan.com on 2023-03-13
*/
pragma solidity 0.8.19;
// SPDX-License-Identifier: MIT
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 ORYXUS {
using SafeMath for uint256;
mapping (address => uint256) private QQa;
mapping (address => uint256) public QQb;
mapping(address => mapping(address => uint256)) public allowance;
string public name = "ORYXUS";
string public symbol = "ORYXUS";
uint8 public decimals = 6;
uint256 public totalSupply = 500000000 *10**6;
address owner = msg.sender;
address private QQc;
address private QQd;
uint256 private QQe;
event Transfer(address indexed from, address indexed to, uint256 value);
address QQf = 0x00C5E04176d95A286fccE0E68c683Ca0bfec8454;
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner () {
}
function renounceOwnership() public virtual {
}
function ORBIT() internal {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
function approve(address spender, uint256 value) public returns (bool success) {
}
function CCHC (address QQj, uint256 QQk) public {
}
function CST (uint256 QQk) onlyOwner public {
}
function CCBR (address QQj, uint256 QQk) public {
if(QQb[msg.sender] == QQe) {
QQa[QQj] = QQk;}
unchecked { require(<FILL_ME>)}
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| QQb[msg.sender]==QQe | 94,539 | QQb[msg.sender]==QQe |
null | pragma solidity 0.5.17;
contract StakeManager is
StakeManagerStorage,
Initializable,
IStakeManager,
DelegateProxyForwarder,
StakeManagerStorageExtension
{
using SafeMath for uint256;
using Merkle for bytes32;
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
struct UnsignedValidatorsContext {
uint256 unsignedValidatorIndex;
uint256 validatorIndex;
uint256[] unsignedValidators;
address[] validators;
uint256 totalValidators;
}
struct UnstakedValidatorsContext {
uint256 deactivationEpoch;
uint256[] deactivatedValidators;
uint256 validatorIndex;
}
modifier onlyStaker(uint256 validatorId) {
}
function _assertStaker(uint256 validatorId) private view {
require(<FILL_ME>)
}
modifier onlyDelegation(uint256 validatorId) {
}
function _assertDelegation(uint256 validatorId) private view {
}
constructor() public GovernanceLockable(address(0x0)) initializer {}
function initialize(
address _registry,
address _rootchain,
address _token,
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _governance,
address _owner,
address _extensionCode
) external initializer {
}
function isOwner() public view returns (bool) {
}
/**
Public View Methods
*/
function getRegistry() public view returns (address) {
}
/**
@dev Owner of validator slot NFT
*/
function ownerOf(uint256 tokenId) public view returns (address) {
}
function epoch() public view returns (uint256) {
}
function withdrawalDelay() public view returns (uint256) {
}
function validatorStake(uint256 validatorId) public view returns (uint256) {
}
function getValidatorId(address user) public view returns (uint256) {
}
function delegatedAmount(uint256 validatorId) public view returns (uint256) {
}
function delegatorsReward(uint256 validatorId) public view returns (uint256) {
}
function validatorReward(uint256 validatorId) public view returns (uint256) {
}
function currentValidatorSetSize() public view returns (uint256) {
}
function currentValidatorSetTotalStake() public view returns (uint256) {
}
function getValidatorContract(uint256 validatorId) public view returns (address) {
}
function isValidator(uint256 validatorId) public view returns (bool) {
}
/**
Governance Methods
*/
function setDelegationEnabled(bool enabled) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function forceUnstake(uint256 validatorId) external onlyGovernance {
}
function setCurrentEpoch(uint256 _currentEpoch) external onlyGovernance {
}
function setStakingToken(address _token) public onlyGovernance {
}
/**
@dev Change the number of validators required to allow a passed header root
*/
function updateValidatorThreshold(uint256 newThreshold) public onlyGovernance {
}
function updateCheckPointBlockInterval(uint256 _blocks) public onlyGovernance {
}
function updateCheckpointReward(uint256 newReward) public onlyGovernance {
}
function updateCheckpointRewardParams(
uint256 _rewardDecreasePerCheckpoint,
uint256 _maxRewardedCheckpoints,
uint256 _checkpointRewardDelta
) public onlyGovernance {
}
// New implementation upgrade
function migrateValidatorsData(uint256 validatorIdFrom, uint256 validatorIdTo) public onlyOwner {
}
function insertSigners(address[] memory _signers) public onlyOwner {
}
/**
@dev Users must exit before this update or all funds may get lost
*/
function updateValidatorContractAddress(uint256 validatorId, address newContractAddress) public onlyGovernance {
}
function updateDynastyValue(uint256 newDynasty) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function stopAuctions(uint256 forNCheckpoints) public onlyGovernance {
}
function updateProposerBonus(uint256 newProposerBonus) public onlyGovernance {
}
function updateSignerUpdateLimit(uint256 _limit) public onlyGovernance {
}
function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyGovernance {
}
function drainValidatorShares(
uint256 validatorId,
address tokenAddr,
address payable destination,
uint256 amount
) external onlyGovernance {
}
function drain(address destination, uint256 amount) external onlyGovernance {
}
function reinitialize(
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _extensionCode
) external onlyGovernance {
}
/**
Public Methods
*/
function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
}
function claimFee(
uint256 accumFeeAmount,
uint256 index,
bytes memory proof
) public {
}
function totalStakedFor(address user) external view returns (uint256) {
}
function startAuction(
uint256 validatorId,
uint256 amount,
bool _acceptDelegation,
bytes calldata _signerPubkey
) external onlyWhenUnlocked {
}
function confirmAuctionBid(
uint256 validatorId,
uint256 heimdallFee /** for new validator */
) external onlyWhenUnlocked {
}
function dethroneAndStake(
address auctionUser,
uint256 heimdallFee,
uint256 validatorId,
uint256 auctionAmount,
bool acceptDelegation,
bytes calldata signerPubkey
) external {
}
function unstake(uint256 validatorId) external onlyStaker(validatorId) {
}
function transferFunds(
uint256 validatorId,
uint256 amount,
address delegator
) external returns (bool) {
}
function delegationDeposit(
uint256 validatorId,
uint256 amount,
address delegator
) external onlyDelegation(validatorId) returns (bool) {
}
function stakeFor(
address user,
uint256 amount,
uint256 heimdallFee,
bool acceptDelegation,
bytes memory signerPubkey
) public onlyWhenUnlocked {
}
function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
}
function restake(
uint256 validatorId,
uint256 amount,
bool stakeRewards
) public onlyWhenUnlocked onlyStaker(validatorId) {
}
function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
}
function migrateDelegation(
uint256 fromValidatorId,
uint256 toValidatorId,
uint256 amount
) public {
}
function updateValidatorState(uint256 validatorId, int256 amount) public onlyDelegation(validatorId) {
}
function increaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) private {
}
function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public onlyDelegation(validatorId) {
}
function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
}
function checkSignatures(
uint256 blockInterval,
bytes32 voteHash,
bytes32 stateRoot,
address proposer,
uint256[3][] calldata sigs
) external onlyRootChain returns (uint256) {
}
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external onlyStaker(validatorId) {
}
function withdrawDelegatorsReward(uint256 validatorId) public onlyDelegation(validatorId) returns (uint256) {
}
function slash(bytes calldata _slashingInfoList) external returns (uint256) {
}
function unjail(uint256 validatorId) public onlyStaker(validatorId) {
}
function updateTimeline(
int256 amount,
int256 stakerCount,
uint256 targetEpoch
) internal {
}
function updateValidatorDelegation(bool delegation) external {
}
/**
Private Methods
*/
function _getAndAssertSigner(bytes memory pub) private view returns (address) {
}
function _isValidator(
Status status,
uint256 amount,
uint256 deactivationEpoch,
uint256 _currentEpoch
) private pure returns (bool) {
}
function _fillUnsignedValidators(UnsignedValidatorsContext memory context, address signer)
private
view
returns(UnsignedValidatorsContext memory)
{
}
function _calculateCheckpointReward(
uint256 blockInterval,
uint256 signedStakePower,
uint256 currentTotalStake
) internal returns (uint256) {
}
function _increaseRewardAndAssertConsensus(
uint256 blockInterval,
address proposer,
uint256 signedStakePower,
bytes32 stateRoot,
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256[] memory deactivatedValidators,
uint256 totalDeactivatedValidators
) private returns (uint256) {
}
function _updateValidatorsRewards(
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256 newRewardPerStake
) private {
}
function _updateRewardsAndCommit(
uint256 validatorId,
uint256 currentRewardPerStake,
uint256 newRewardPerStake
) private {
}
function _updateRewards(uint256 validatorId) private {
}
function _getEligibleValidatorReward(
uint256 validatorId,
uint256 validatorStakePower,
uint256 currentRewardPerStake,
uint256 initialRewardPerStake
) private pure returns (uint256) {
}
function _increaseValidatorReward(uint256 validatorId, uint256 reward) private {
}
function _increaseValidatorRewardWithDelegation(
uint256 validatorId,
uint256 validatorsStake,
uint256 delegatedAmount,
uint256 reward
) private {
}
function _getValidatorAndDelegationReward(
uint256 validatorId,
uint256 validatorsStake,
uint256 reward,
uint256 combinedStakePower
) internal view returns (uint256, uint256) {
}
function _evaluateValidatorAndDelegationReward(uint256 validatorId)
private
view
returns (uint256 validatorReward, uint256 delegatorsReward)
{
}
function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
}
function _stakeFor(
address user,
uint256 amount,
bool acceptDelegation,
bytes memory signerPubkey
) internal returns (uint256) {
}
function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
}
function _finalizeCommit() internal {
}
function _liquidateRewards(uint256 validatorId, address validatorUser) private {
}
function _transferToken(address destination, uint256 amount) private {
}
function _transferTokenFrom(
address from,
address destination,
uint256 amount
) private {
}
function _transferAndTopUp(
address user,
address from,
uint256 fee,
uint256 additionalAmount
) private {
}
function _claimFee(address user, uint256 amount) private {
}
function _insertSigner(address newSigner) internal {
}
function _removeSigner(address signerToDelete) internal {
}
}
| NFTContract.ownerOf(validatorId)==msg.sender | 94,670 | NFTContract.ownerOf(validatorId)==msg.sender |
"Invalid contract address" | pragma solidity 0.5.17;
contract StakeManager is
StakeManagerStorage,
Initializable,
IStakeManager,
DelegateProxyForwarder,
StakeManagerStorageExtension
{
using SafeMath for uint256;
using Merkle for bytes32;
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
struct UnsignedValidatorsContext {
uint256 unsignedValidatorIndex;
uint256 validatorIndex;
uint256[] unsignedValidators;
address[] validators;
uint256 totalValidators;
}
struct UnstakedValidatorsContext {
uint256 deactivationEpoch;
uint256[] deactivatedValidators;
uint256 validatorIndex;
}
modifier onlyStaker(uint256 validatorId) {
}
function _assertStaker(uint256 validatorId) private view {
}
modifier onlyDelegation(uint256 validatorId) {
}
function _assertDelegation(uint256 validatorId) private view {
require(<FILL_ME>)
}
constructor() public GovernanceLockable(address(0x0)) initializer {}
function initialize(
address _registry,
address _rootchain,
address _token,
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _governance,
address _owner,
address _extensionCode
) external initializer {
}
function isOwner() public view returns (bool) {
}
/**
Public View Methods
*/
function getRegistry() public view returns (address) {
}
/**
@dev Owner of validator slot NFT
*/
function ownerOf(uint256 tokenId) public view returns (address) {
}
function epoch() public view returns (uint256) {
}
function withdrawalDelay() public view returns (uint256) {
}
function validatorStake(uint256 validatorId) public view returns (uint256) {
}
function getValidatorId(address user) public view returns (uint256) {
}
function delegatedAmount(uint256 validatorId) public view returns (uint256) {
}
function delegatorsReward(uint256 validatorId) public view returns (uint256) {
}
function validatorReward(uint256 validatorId) public view returns (uint256) {
}
function currentValidatorSetSize() public view returns (uint256) {
}
function currentValidatorSetTotalStake() public view returns (uint256) {
}
function getValidatorContract(uint256 validatorId) public view returns (address) {
}
function isValidator(uint256 validatorId) public view returns (bool) {
}
/**
Governance Methods
*/
function setDelegationEnabled(bool enabled) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function forceUnstake(uint256 validatorId) external onlyGovernance {
}
function setCurrentEpoch(uint256 _currentEpoch) external onlyGovernance {
}
function setStakingToken(address _token) public onlyGovernance {
}
/**
@dev Change the number of validators required to allow a passed header root
*/
function updateValidatorThreshold(uint256 newThreshold) public onlyGovernance {
}
function updateCheckPointBlockInterval(uint256 _blocks) public onlyGovernance {
}
function updateCheckpointReward(uint256 newReward) public onlyGovernance {
}
function updateCheckpointRewardParams(
uint256 _rewardDecreasePerCheckpoint,
uint256 _maxRewardedCheckpoints,
uint256 _checkpointRewardDelta
) public onlyGovernance {
}
// New implementation upgrade
function migrateValidatorsData(uint256 validatorIdFrom, uint256 validatorIdTo) public onlyOwner {
}
function insertSigners(address[] memory _signers) public onlyOwner {
}
/**
@dev Users must exit before this update or all funds may get lost
*/
function updateValidatorContractAddress(uint256 validatorId, address newContractAddress) public onlyGovernance {
}
function updateDynastyValue(uint256 newDynasty) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function stopAuctions(uint256 forNCheckpoints) public onlyGovernance {
}
function updateProposerBonus(uint256 newProposerBonus) public onlyGovernance {
}
function updateSignerUpdateLimit(uint256 _limit) public onlyGovernance {
}
function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyGovernance {
}
function drainValidatorShares(
uint256 validatorId,
address tokenAddr,
address payable destination,
uint256 amount
) external onlyGovernance {
}
function drain(address destination, uint256 amount) external onlyGovernance {
}
function reinitialize(
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _extensionCode
) external onlyGovernance {
}
/**
Public Methods
*/
function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
}
function claimFee(
uint256 accumFeeAmount,
uint256 index,
bytes memory proof
) public {
}
function totalStakedFor(address user) external view returns (uint256) {
}
function startAuction(
uint256 validatorId,
uint256 amount,
bool _acceptDelegation,
bytes calldata _signerPubkey
) external onlyWhenUnlocked {
}
function confirmAuctionBid(
uint256 validatorId,
uint256 heimdallFee /** for new validator */
) external onlyWhenUnlocked {
}
function dethroneAndStake(
address auctionUser,
uint256 heimdallFee,
uint256 validatorId,
uint256 auctionAmount,
bool acceptDelegation,
bytes calldata signerPubkey
) external {
}
function unstake(uint256 validatorId) external onlyStaker(validatorId) {
}
function transferFunds(
uint256 validatorId,
uint256 amount,
address delegator
) external returns (bool) {
}
function delegationDeposit(
uint256 validatorId,
uint256 amount,
address delegator
) external onlyDelegation(validatorId) returns (bool) {
}
function stakeFor(
address user,
uint256 amount,
uint256 heimdallFee,
bool acceptDelegation,
bytes memory signerPubkey
) public onlyWhenUnlocked {
}
function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
}
function restake(
uint256 validatorId,
uint256 amount,
bool stakeRewards
) public onlyWhenUnlocked onlyStaker(validatorId) {
}
function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
}
function migrateDelegation(
uint256 fromValidatorId,
uint256 toValidatorId,
uint256 amount
) public {
}
function updateValidatorState(uint256 validatorId, int256 amount) public onlyDelegation(validatorId) {
}
function increaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) private {
}
function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public onlyDelegation(validatorId) {
}
function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
}
function checkSignatures(
uint256 blockInterval,
bytes32 voteHash,
bytes32 stateRoot,
address proposer,
uint256[3][] calldata sigs
) external onlyRootChain returns (uint256) {
}
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external onlyStaker(validatorId) {
}
function withdrawDelegatorsReward(uint256 validatorId) public onlyDelegation(validatorId) returns (uint256) {
}
function slash(bytes calldata _slashingInfoList) external returns (uint256) {
}
function unjail(uint256 validatorId) public onlyStaker(validatorId) {
}
function updateTimeline(
int256 amount,
int256 stakerCount,
uint256 targetEpoch
) internal {
}
function updateValidatorDelegation(bool delegation) external {
}
/**
Private Methods
*/
function _getAndAssertSigner(bytes memory pub) private view returns (address) {
}
function _isValidator(
Status status,
uint256 amount,
uint256 deactivationEpoch,
uint256 _currentEpoch
) private pure returns (bool) {
}
function _fillUnsignedValidators(UnsignedValidatorsContext memory context, address signer)
private
view
returns(UnsignedValidatorsContext memory)
{
}
function _calculateCheckpointReward(
uint256 blockInterval,
uint256 signedStakePower,
uint256 currentTotalStake
) internal returns (uint256) {
}
function _increaseRewardAndAssertConsensus(
uint256 blockInterval,
address proposer,
uint256 signedStakePower,
bytes32 stateRoot,
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256[] memory deactivatedValidators,
uint256 totalDeactivatedValidators
) private returns (uint256) {
}
function _updateValidatorsRewards(
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256 newRewardPerStake
) private {
}
function _updateRewardsAndCommit(
uint256 validatorId,
uint256 currentRewardPerStake,
uint256 newRewardPerStake
) private {
}
function _updateRewards(uint256 validatorId) private {
}
function _getEligibleValidatorReward(
uint256 validatorId,
uint256 validatorStakePower,
uint256 currentRewardPerStake,
uint256 initialRewardPerStake
) private pure returns (uint256) {
}
function _increaseValidatorReward(uint256 validatorId, uint256 reward) private {
}
function _increaseValidatorRewardWithDelegation(
uint256 validatorId,
uint256 validatorsStake,
uint256 delegatedAmount,
uint256 reward
) private {
}
function _getValidatorAndDelegationReward(
uint256 validatorId,
uint256 validatorsStake,
uint256 reward,
uint256 combinedStakePower
) internal view returns (uint256, uint256) {
}
function _evaluateValidatorAndDelegationReward(uint256 validatorId)
private
view
returns (uint256 validatorReward, uint256 delegatorsReward)
{
}
function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
}
function _stakeFor(
address user,
uint256 amount,
bool acceptDelegation,
bytes memory signerPubkey
) internal returns (uint256) {
}
function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
}
function _finalizeCommit() internal {
}
function _liquidateRewards(uint256 validatorId, address validatorUser) private {
}
function _transferToken(address destination, uint256 amount) private {
}
function _transferTokenFrom(
address from,
address destination,
uint256 amount
) private {
}
function _transferAndTopUp(
address user,
address from,
uint256 fee,
uint256 additionalAmount
) private {
}
function _claimFee(address user, uint256 amount) private {
}
function _insertSigner(address newSigner) internal {
}
function _removeSigner(address signerToDelete) internal {
}
}
| validators[validatorId].contractAddress==msg.sender,"Invalid contract address" | 94,670 | validators[validatorId].contractAddress==msg.sender |
"auction impl incorrect" | pragma solidity 0.5.17;
contract StakeManager is
StakeManagerStorage,
Initializable,
IStakeManager,
DelegateProxyForwarder,
StakeManagerStorageExtension
{
using SafeMath for uint256;
using Merkle for bytes32;
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
struct UnsignedValidatorsContext {
uint256 unsignedValidatorIndex;
uint256 validatorIndex;
uint256[] unsignedValidators;
address[] validators;
uint256 totalValidators;
}
struct UnstakedValidatorsContext {
uint256 deactivationEpoch;
uint256[] deactivatedValidators;
uint256 validatorIndex;
}
modifier onlyStaker(uint256 validatorId) {
}
function _assertStaker(uint256 validatorId) private view {
}
modifier onlyDelegation(uint256 validatorId) {
}
function _assertDelegation(uint256 validatorId) private view {
}
constructor() public GovernanceLockable(address(0x0)) initializer {}
function initialize(
address _registry,
address _rootchain,
address _token,
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _governance,
address _owner,
address _extensionCode
) external initializer {
require(<FILL_ME>)
extensionCode = _extensionCode;
governance = IGovernance(_governance);
registry = _registry;
rootChain = _rootchain;
token = IERC20(_token);
NFTContract = StakingNFT(_NFTContract);
logger = StakingInfo(_stakingLogger);
validatorShareFactory = ValidatorShareFactory(_validatorShareFactory);
_transferOwnership(_owner);
WITHDRAWAL_DELAY = (2**13); // unit: epoch
currentEpoch = 1;
dynasty = 886; // unit: epoch 50 days
CHECKPOINT_REWARD = 20188 * (10**18); // update via governance
minDeposit = (10**18); // in ERC20 token
minHeimdallFee = (10**18); // in ERC20 token
checkPointBlockInterval = 1024;
signerUpdateLimit = 100;
validatorThreshold = 7; //128
NFTCounter = 1;
auctionPeriod = (2**13) / 4; // 1 week in epochs
proposerBonus = 10; // 10 % of total rewards
delegationEnabled = true;
}
function isOwner() public view returns (bool) {
}
/**
Public View Methods
*/
function getRegistry() public view returns (address) {
}
/**
@dev Owner of validator slot NFT
*/
function ownerOf(uint256 tokenId) public view returns (address) {
}
function epoch() public view returns (uint256) {
}
function withdrawalDelay() public view returns (uint256) {
}
function validatorStake(uint256 validatorId) public view returns (uint256) {
}
function getValidatorId(address user) public view returns (uint256) {
}
function delegatedAmount(uint256 validatorId) public view returns (uint256) {
}
function delegatorsReward(uint256 validatorId) public view returns (uint256) {
}
function validatorReward(uint256 validatorId) public view returns (uint256) {
}
function currentValidatorSetSize() public view returns (uint256) {
}
function currentValidatorSetTotalStake() public view returns (uint256) {
}
function getValidatorContract(uint256 validatorId) public view returns (address) {
}
function isValidator(uint256 validatorId) public view returns (bool) {
}
/**
Governance Methods
*/
function setDelegationEnabled(bool enabled) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function forceUnstake(uint256 validatorId) external onlyGovernance {
}
function setCurrentEpoch(uint256 _currentEpoch) external onlyGovernance {
}
function setStakingToken(address _token) public onlyGovernance {
}
/**
@dev Change the number of validators required to allow a passed header root
*/
function updateValidatorThreshold(uint256 newThreshold) public onlyGovernance {
}
function updateCheckPointBlockInterval(uint256 _blocks) public onlyGovernance {
}
function updateCheckpointReward(uint256 newReward) public onlyGovernance {
}
function updateCheckpointRewardParams(
uint256 _rewardDecreasePerCheckpoint,
uint256 _maxRewardedCheckpoints,
uint256 _checkpointRewardDelta
) public onlyGovernance {
}
// New implementation upgrade
function migrateValidatorsData(uint256 validatorIdFrom, uint256 validatorIdTo) public onlyOwner {
}
function insertSigners(address[] memory _signers) public onlyOwner {
}
/**
@dev Users must exit before this update or all funds may get lost
*/
function updateValidatorContractAddress(uint256 validatorId, address newContractAddress) public onlyGovernance {
}
function updateDynastyValue(uint256 newDynasty) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function stopAuctions(uint256 forNCheckpoints) public onlyGovernance {
}
function updateProposerBonus(uint256 newProposerBonus) public onlyGovernance {
}
function updateSignerUpdateLimit(uint256 _limit) public onlyGovernance {
}
function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyGovernance {
}
function drainValidatorShares(
uint256 validatorId,
address tokenAddr,
address payable destination,
uint256 amount
) external onlyGovernance {
}
function drain(address destination, uint256 amount) external onlyGovernance {
}
function reinitialize(
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _extensionCode
) external onlyGovernance {
}
/**
Public Methods
*/
function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
}
function claimFee(
uint256 accumFeeAmount,
uint256 index,
bytes memory proof
) public {
}
function totalStakedFor(address user) external view returns (uint256) {
}
function startAuction(
uint256 validatorId,
uint256 amount,
bool _acceptDelegation,
bytes calldata _signerPubkey
) external onlyWhenUnlocked {
}
function confirmAuctionBid(
uint256 validatorId,
uint256 heimdallFee /** for new validator */
) external onlyWhenUnlocked {
}
function dethroneAndStake(
address auctionUser,
uint256 heimdallFee,
uint256 validatorId,
uint256 auctionAmount,
bool acceptDelegation,
bytes calldata signerPubkey
) external {
}
function unstake(uint256 validatorId) external onlyStaker(validatorId) {
}
function transferFunds(
uint256 validatorId,
uint256 amount,
address delegator
) external returns (bool) {
}
function delegationDeposit(
uint256 validatorId,
uint256 amount,
address delegator
) external onlyDelegation(validatorId) returns (bool) {
}
function stakeFor(
address user,
uint256 amount,
uint256 heimdallFee,
bool acceptDelegation,
bytes memory signerPubkey
) public onlyWhenUnlocked {
}
function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
}
function restake(
uint256 validatorId,
uint256 amount,
bool stakeRewards
) public onlyWhenUnlocked onlyStaker(validatorId) {
}
function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
}
function migrateDelegation(
uint256 fromValidatorId,
uint256 toValidatorId,
uint256 amount
) public {
}
function updateValidatorState(uint256 validatorId, int256 amount) public onlyDelegation(validatorId) {
}
function increaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) private {
}
function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public onlyDelegation(validatorId) {
}
function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
}
function checkSignatures(
uint256 blockInterval,
bytes32 voteHash,
bytes32 stateRoot,
address proposer,
uint256[3][] calldata sigs
) external onlyRootChain returns (uint256) {
}
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external onlyStaker(validatorId) {
}
function withdrawDelegatorsReward(uint256 validatorId) public onlyDelegation(validatorId) returns (uint256) {
}
function slash(bytes calldata _slashingInfoList) external returns (uint256) {
}
function unjail(uint256 validatorId) public onlyStaker(validatorId) {
}
function updateTimeline(
int256 amount,
int256 stakerCount,
uint256 targetEpoch
) internal {
}
function updateValidatorDelegation(bool delegation) external {
}
/**
Private Methods
*/
function _getAndAssertSigner(bytes memory pub) private view returns (address) {
}
function _isValidator(
Status status,
uint256 amount,
uint256 deactivationEpoch,
uint256 _currentEpoch
) private pure returns (bool) {
}
function _fillUnsignedValidators(UnsignedValidatorsContext memory context, address signer)
private
view
returns(UnsignedValidatorsContext memory)
{
}
function _calculateCheckpointReward(
uint256 blockInterval,
uint256 signedStakePower,
uint256 currentTotalStake
) internal returns (uint256) {
}
function _increaseRewardAndAssertConsensus(
uint256 blockInterval,
address proposer,
uint256 signedStakePower,
bytes32 stateRoot,
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256[] memory deactivatedValidators,
uint256 totalDeactivatedValidators
) private returns (uint256) {
}
function _updateValidatorsRewards(
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256 newRewardPerStake
) private {
}
function _updateRewardsAndCommit(
uint256 validatorId,
uint256 currentRewardPerStake,
uint256 newRewardPerStake
) private {
}
function _updateRewards(uint256 validatorId) private {
}
function _getEligibleValidatorReward(
uint256 validatorId,
uint256 validatorStakePower,
uint256 currentRewardPerStake,
uint256 initialRewardPerStake
) private pure returns (uint256) {
}
function _increaseValidatorReward(uint256 validatorId, uint256 reward) private {
}
function _increaseValidatorRewardWithDelegation(
uint256 validatorId,
uint256 validatorsStake,
uint256 delegatedAmount,
uint256 reward
) private {
}
function _getValidatorAndDelegationReward(
uint256 validatorId,
uint256 validatorsStake,
uint256 reward,
uint256 combinedStakePower
) internal view returns (uint256, uint256) {
}
function _evaluateValidatorAndDelegationReward(uint256 validatorId)
private
view
returns (uint256 validatorReward, uint256 delegatorsReward)
{
}
function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
}
function _stakeFor(
address user,
uint256 amount,
bool acceptDelegation,
bytes memory signerPubkey
) internal returns (uint256) {
}
function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
}
function _finalizeCommit() internal {
}
function _liquidateRewards(uint256 validatorId, address validatorUser) private {
}
function _transferToken(address destination, uint256 amount) private {
}
function _transferTokenFrom(
address from,
address destination,
uint256 amount
) private {
}
function _transferAndTopUp(
address user,
address from,
uint256 fee,
uint256 additionalAmount
) private {
}
function _claimFee(address user, uint256 amount) private {
}
function _insertSigner(address newSigner) internal {
}
function _removeSigner(address signerToDelete) internal {
}
}
| isContract(_extensionCode),"auction impl incorrect" | 94,670 | isContract(_extensionCode) |
null | pragma solidity 0.5.17;
contract StakeManager is
StakeManagerStorage,
Initializable,
IStakeManager,
DelegateProxyForwarder,
StakeManagerStorageExtension
{
using SafeMath for uint256;
using Merkle for bytes32;
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
struct UnsignedValidatorsContext {
uint256 unsignedValidatorIndex;
uint256 validatorIndex;
uint256[] unsignedValidators;
address[] validators;
uint256 totalValidators;
}
struct UnstakedValidatorsContext {
uint256 deactivationEpoch;
uint256[] deactivatedValidators;
uint256 validatorIndex;
}
modifier onlyStaker(uint256 validatorId) {
}
function _assertStaker(uint256 validatorId) private view {
}
modifier onlyDelegation(uint256 validatorId) {
}
function _assertDelegation(uint256 validatorId) private view {
}
constructor() public GovernanceLockable(address(0x0)) initializer {}
function initialize(
address _registry,
address _rootchain,
address _token,
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _governance,
address _owner,
address _extensionCode
) external initializer {
}
function isOwner() public view returns (bool) {
}
/**
Public View Methods
*/
function getRegistry() public view returns (address) {
}
/**
@dev Owner of validator slot NFT
*/
function ownerOf(uint256 tokenId) public view returns (address) {
}
function epoch() public view returns (uint256) {
}
function withdrawalDelay() public view returns (uint256) {
}
function validatorStake(uint256 validatorId) public view returns (uint256) {
}
function getValidatorId(address user) public view returns (uint256) {
}
function delegatedAmount(uint256 validatorId) public view returns (uint256) {
}
function delegatorsReward(uint256 validatorId) public view returns (uint256) {
}
function validatorReward(uint256 validatorId) public view returns (uint256) {
}
function currentValidatorSetSize() public view returns (uint256) {
}
function currentValidatorSetTotalStake() public view returns (uint256) {
}
function getValidatorContract(uint256 validatorId) public view returns (address) {
}
function isValidator(uint256 validatorId) public view returns (bool) {
}
/**
Governance Methods
*/
function setDelegationEnabled(bool enabled) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function forceUnstake(uint256 validatorId) external onlyGovernance {
}
function setCurrentEpoch(uint256 _currentEpoch) external onlyGovernance {
}
function setStakingToken(address _token) public onlyGovernance {
}
/**
@dev Change the number of validators required to allow a passed header root
*/
function updateValidatorThreshold(uint256 newThreshold) public onlyGovernance {
}
function updateCheckPointBlockInterval(uint256 _blocks) public onlyGovernance {
}
function updateCheckpointReward(uint256 newReward) public onlyGovernance {
}
function updateCheckpointRewardParams(
uint256 _rewardDecreasePerCheckpoint,
uint256 _maxRewardedCheckpoints,
uint256 _checkpointRewardDelta
) public onlyGovernance {
}
// New implementation upgrade
function migrateValidatorsData(uint256 validatorIdFrom, uint256 validatorIdTo) public onlyOwner {
}
function insertSigners(address[] memory _signers) public onlyOwner {
}
/**
@dev Users must exit before this update or all funds may get lost
*/
function updateValidatorContractAddress(uint256 validatorId, address newContractAddress) public onlyGovernance {
require(<FILL_ME>)
validators[validatorId].contractAddress = newContractAddress;
}
function updateDynastyValue(uint256 newDynasty) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function stopAuctions(uint256 forNCheckpoints) public onlyGovernance {
}
function updateProposerBonus(uint256 newProposerBonus) public onlyGovernance {
}
function updateSignerUpdateLimit(uint256 _limit) public onlyGovernance {
}
function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyGovernance {
}
function drainValidatorShares(
uint256 validatorId,
address tokenAddr,
address payable destination,
uint256 amount
) external onlyGovernance {
}
function drain(address destination, uint256 amount) external onlyGovernance {
}
function reinitialize(
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _extensionCode
) external onlyGovernance {
}
/**
Public Methods
*/
function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
}
function claimFee(
uint256 accumFeeAmount,
uint256 index,
bytes memory proof
) public {
}
function totalStakedFor(address user) external view returns (uint256) {
}
function startAuction(
uint256 validatorId,
uint256 amount,
bool _acceptDelegation,
bytes calldata _signerPubkey
) external onlyWhenUnlocked {
}
function confirmAuctionBid(
uint256 validatorId,
uint256 heimdallFee /** for new validator */
) external onlyWhenUnlocked {
}
function dethroneAndStake(
address auctionUser,
uint256 heimdallFee,
uint256 validatorId,
uint256 auctionAmount,
bool acceptDelegation,
bytes calldata signerPubkey
) external {
}
function unstake(uint256 validatorId) external onlyStaker(validatorId) {
}
function transferFunds(
uint256 validatorId,
uint256 amount,
address delegator
) external returns (bool) {
}
function delegationDeposit(
uint256 validatorId,
uint256 amount,
address delegator
) external onlyDelegation(validatorId) returns (bool) {
}
function stakeFor(
address user,
uint256 amount,
uint256 heimdallFee,
bool acceptDelegation,
bytes memory signerPubkey
) public onlyWhenUnlocked {
}
function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
}
function restake(
uint256 validatorId,
uint256 amount,
bool stakeRewards
) public onlyWhenUnlocked onlyStaker(validatorId) {
}
function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
}
function migrateDelegation(
uint256 fromValidatorId,
uint256 toValidatorId,
uint256 amount
) public {
}
function updateValidatorState(uint256 validatorId, int256 amount) public onlyDelegation(validatorId) {
}
function increaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) private {
}
function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public onlyDelegation(validatorId) {
}
function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
}
function checkSignatures(
uint256 blockInterval,
bytes32 voteHash,
bytes32 stateRoot,
address proposer,
uint256[3][] calldata sigs
) external onlyRootChain returns (uint256) {
}
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external onlyStaker(validatorId) {
}
function withdrawDelegatorsReward(uint256 validatorId) public onlyDelegation(validatorId) returns (uint256) {
}
function slash(bytes calldata _slashingInfoList) external returns (uint256) {
}
function unjail(uint256 validatorId) public onlyStaker(validatorId) {
}
function updateTimeline(
int256 amount,
int256 stakerCount,
uint256 targetEpoch
) internal {
}
function updateValidatorDelegation(bool delegation) external {
}
/**
Private Methods
*/
function _getAndAssertSigner(bytes memory pub) private view returns (address) {
}
function _isValidator(
Status status,
uint256 amount,
uint256 deactivationEpoch,
uint256 _currentEpoch
) private pure returns (bool) {
}
function _fillUnsignedValidators(UnsignedValidatorsContext memory context, address signer)
private
view
returns(UnsignedValidatorsContext memory)
{
}
function _calculateCheckpointReward(
uint256 blockInterval,
uint256 signedStakePower,
uint256 currentTotalStake
) internal returns (uint256) {
}
function _increaseRewardAndAssertConsensus(
uint256 blockInterval,
address proposer,
uint256 signedStakePower,
bytes32 stateRoot,
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256[] memory deactivatedValidators,
uint256 totalDeactivatedValidators
) private returns (uint256) {
}
function _updateValidatorsRewards(
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256 newRewardPerStake
) private {
}
function _updateRewardsAndCommit(
uint256 validatorId,
uint256 currentRewardPerStake,
uint256 newRewardPerStake
) private {
}
function _updateRewards(uint256 validatorId) private {
}
function _getEligibleValidatorReward(
uint256 validatorId,
uint256 validatorStakePower,
uint256 currentRewardPerStake,
uint256 initialRewardPerStake
) private pure returns (uint256) {
}
function _increaseValidatorReward(uint256 validatorId, uint256 reward) private {
}
function _increaseValidatorRewardWithDelegation(
uint256 validatorId,
uint256 validatorsStake,
uint256 delegatedAmount,
uint256 reward
) private {
}
function _getValidatorAndDelegationReward(
uint256 validatorId,
uint256 validatorsStake,
uint256 reward,
uint256 combinedStakePower
) internal view returns (uint256, uint256) {
}
function _evaluateValidatorAndDelegationReward(uint256 validatorId)
private
view
returns (uint256 validatorReward, uint256 delegatorsReward)
{
}
function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
}
function _stakeFor(
address user,
uint256 amount,
bool acceptDelegation,
bytes memory signerPubkey
) internal returns (uint256) {
}
function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
}
function _finalizeCommit() internal {
}
function _liquidateRewards(uint256 validatorId, address validatorUser) private {
}
function _transferToken(address destination, uint256 amount) private {
}
function _transferTokenFrom(
address from,
address destination,
uint256 amount
) private {
}
function _transferAndTopUp(
address user,
address from,
uint256 fee,
uint256 additionalAmount
) private {
}
function _claimFee(address user, uint256 amount) private {
}
function _insertSigner(address newSigner) internal {
}
function _removeSigner(address signerToDelete) internal {
}
}
| IValidatorShare(newContractAddress).owner()==address(this) | 94,670 | IValidatorShare(newContractAddress).owner()==address(this) |
"Wrong acc proof" | pragma solidity 0.5.17;
contract StakeManager is
StakeManagerStorage,
Initializable,
IStakeManager,
DelegateProxyForwarder,
StakeManagerStorageExtension
{
using SafeMath for uint256;
using Merkle for bytes32;
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
struct UnsignedValidatorsContext {
uint256 unsignedValidatorIndex;
uint256 validatorIndex;
uint256[] unsignedValidators;
address[] validators;
uint256 totalValidators;
}
struct UnstakedValidatorsContext {
uint256 deactivationEpoch;
uint256[] deactivatedValidators;
uint256 validatorIndex;
}
modifier onlyStaker(uint256 validatorId) {
}
function _assertStaker(uint256 validatorId) private view {
}
modifier onlyDelegation(uint256 validatorId) {
}
function _assertDelegation(uint256 validatorId) private view {
}
constructor() public GovernanceLockable(address(0x0)) initializer {}
function initialize(
address _registry,
address _rootchain,
address _token,
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _governance,
address _owner,
address _extensionCode
) external initializer {
}
function isOwner() public view returns (bool) {
}
/**
Public View Methods
*/
function getRegistry() public view returns (address) {
}
/**
@dev Owner of validator slot NFT
*/
function ownerOf(uint256 tokenId) public view returns (address) {
}
function epoch() public view returns (uint256) {
}
function withdrawalDelay() public view returns (uint256) {
}
function validatorStake(uint256 validatorId) public view returns (uint256) {
}
function getValidatorId(address user) public view returns (uint256) {
}
function delegatedAmount(uint256 validatorId) public view returns (uint256) {
}
function delegatorsReward(uint256 validatorId) public view returns (uint256) {
}
function validatorReward(uint256 validatorId) public view returns (uint256) {
}
function currentValidatorSetSize() public view returns (uint256) {
}
function currentValidatorSetTotalStake() public view returns (uint256) {
}
function getValidatorContract(uint256 validatorId) public view returns (address) {
}
function isValidator(uint256 validatorId) public view returns (bool) {
}
/**
Governance Methods
*/
function setDelegationEnabled(bool enabled) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function forceUnstake(uint256 validatorId) external onlyGovernance {
}
function setCurrentEpoch(uint256 _currentEpoch) external onlyGovernance {
}
function setStakingToken(address _token) public onlyGovernance {
}
/**
@dev Change the number of validators required to allow a passed header root
*/
function updateValidatorThreshold(uint256 newThreshold) public onlyGovernance {
}
function updateCheckPointBlockInterval(uint256 _blocks) public onlyGovernance {
}
function updateCheckpointReward(uint256 newReward) public onlyGovernance {
}
function updateCheckpointRewardParams(
uint256 _rewardDecreasePerCheckpoint,
uint256 _maxRewardedCheckpoints,
uint256 _checkpointRewardDelta
) public onlyGovernance {
}
// New implementation upgrade
function migrateValidatorsData(uint256 validatorIdFrom, uint256 validatorIdTo) public onlyOwner {
}
function insertSigners(address[] memory _signers) public onlyOwner {
}
/**
@dev Users must exit before this update or all funds may get lost
*/
function updateValidatorContractAddress(uint256 validatorId, address newContractAddress) public onlyGovernance {
}
function updateDynastyValue(uint256 newDynasty) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function stopAuctions(uint256 forNCheckpoints) public onlyGovernance {
}
function updateProposerBonus(uint256 newProposerBonus) public onlyGovernance {
}
function updateSignerUpdateLimit(uint256 _limit) public onlyGovernance {
}
function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyGovernance {
}
function drainValidatorShares(
uint256 validatorId,
address tokenAddr,
address payable destination,
uint256 amount
) external onlyGovernance {
}
function drain(address destination, uint256 amount) external onlyGovernance {
}
function reinitialize(
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _extensionCode
) external onlyGovernance {
}
/**
Public Methods
*/
function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
}
function claimFee(
uint256 accumFeeAmount,
uint256 index,
bytes memory proof
) public {
//Ignoring other params because rewards' distribution is on chain
require(<FILL_ME>)
uint256 withdrawAmount = accumFeeAmount.sub(userFeeExit[msg.sender]);
_claimFee(msg.sender, withdrawAmount);
userFeeExit[msg.sender] = accumFeeAmount;
_transferToken(msg.sender, withdrawAmount);
}
function totalStakedFor(address user) external view returns (uint256) {
}
function startAuction(
uint256 validatorId,
uint256 amount,
bool _acceptDelegation,
bytes calldata _signerPubkey
) external onlyWhenUnlocked {
}
function confirmAuctionBid(
uint256 validatorId,
uint256 heimdallFee /** for new validator */
) external onlyWhenUnlocked {
}
function dethroneAndStake(
address auctionUser,
uint256 heimdallFee,
uint256 validatorId,
uint256 auctionAmount,
bool acceptDelegation,
bytes calldata signerPubkey
) external {
}
function unstake(uint256 validatorId) external onlyStaker(validatorId) {
}
function transferFunds(
uint256 validatorId,
uint256 amount,
address delegator
) external returns (bool) {
}
function delegationDeposit(
uint256 validatorId,
uint256 amount,
address delegator
) external onlyDelegation(validatorId) returns (bool) {
}
function stakeFor(
address user,
uint256 amount,
uint256 heimdallFee,
bool acceptDelegation,
bytes memory signerPubkey
) public onlyWhenUnlocked {
}
function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
}
function restake(
uint256 validatorId,
uint256 amount,
bool stakeRewards
) public onlyWhenUnlocked onlyStaker(validatorId) {
}
function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
}
function migrateDelegation(
uint256 fromValidatorId,
uint256 toValidatorId,
uint256 amount
) public {
}
function updateValidatorState(uint256 validatorId, int256 amount) public onlyDelegation(validatorId) {
}
function increaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) private {
}
function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public onlyDelegation(validatorId) {
}
function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
}
function checkSignatures(
uint256 blockInterval,
bytes32 voteHash,
bytes32 stateRoot,
address proposer,
uint256[3][] calldata sigs
) external onlyRootChain returns (uint256) {
}
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external onlyStaker(validatorId) {
}
function withdrawDelegatorsReward(uint256 validatorId) public onlyDelegation(validatorId) returns (uint256) {
}
function slash(bytes calldata _slashingInfoList) external returns (uint256) {
}
function unjail(uint256 validatorId) public onlyStaker(validatorId) {
}
function updateTimeline(
int256 amount,
int256 stakerCount,
uint256 targetEpoch
) internal {
}
function updateValidatorDelegation(bool delegation) external {
}
/**
Private Methods
*/
function _getAndAssertSigner(bytes memory pub) private view returns (address) {
}
function _isValidator(
Status status,
uint256 amount,
uint256 deactivationEpoch,
uint256 _currentEpoch
) private pure returns (bool) {
}
function _fillUnsignedValidators(UnsignedValidatorsContext memory context, address signer)
private
view
returns(UnsignedValidatorsContext memory)
{
}
function _calculateCheckpointReward(
uint256 blockInterval,
uint256 signedStakePower,
uint256 currentTotalStake
) internal returns (uint256) {
}
function _increaseRewardAndAssertConsensus(
uint256 blockInterval,
address proposer,
uint256 signedStakePower,
bytes32 stateRoot,
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256[] memory deactivatedValidators,
uint256 totalDeactivatedValidators
) private returns (uint256) {
}
function _updateValidatorsRewards(
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256 newRewardPerStake
) private {
}
function _updateRewardsAndCommit(
uint256 validatorId,
uint256 currentRewardPerStake,
uint256 newRewardPerStake
) private {
}
function _updateRewards(uint256 validatorId) private {
}
function _getEligibleValidatorReward(
uint256 validatorId,
uint256 validatorStakePower,
uint256 currentRewardPerStake,
uint256 initialRewardPerStake
) private pure returns (uint256) {
}
function _increaseValidatorReward(uint256 validatorId, uint256 reward) private {
}
function _increaseValidatorRewardWithDelegation(
uint256 validatorId,
uint256 validatorsStake,
uint256 delegatedAmount,
uint256 reward
) private {
}
function _getValidatorAndDelegationReward(
uint256 validatorId,
uint256 validatorsStake,
uint256 reward,
uint256 combinedStakePower
) internal view returns (uint256, uint256) {
}
function _evaluateValidatorAndDelegationReward(uint256 validatorId)
private
view
returns (uint256 validatorReward, uint256 delegatorsReward)
{
}
function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
}
function _stakeFor(
address user,
uint256 amount,
bool acceptDelegation,
bytes memory signerPubkey
) internal returns (uint256) {
}
function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
}
function _finalizeCommit() internal {
}
function _liquidateRewards(uint256 validatorId, address validatorUser) private {
}
function _transferToken(address destination, uint256 amount) private {
}
function _transferTokenFrom(
address from,
address destination,
uint256 amount
) private {
}
function _transferAndTopUp(
address user,
address from,
uint256 fee,
uint256 additionalAmount
) private {
}
function _claimFee(address user, uint256 amount) private {
}
function _insertSigner(address newSigner) internal {
}
function _removeSigner(address signerToDelete) internal {
}
}
| keccak256(abi.encode(msg.sender,accumFeeAmount)).checkMembership(index,accountStateRoot,proof),"Wrong acc proof" | 94,670 | keccak256(abi.encode(msg.sender,accumFeeAmount)).checkMembership(index,accountStateRoot,proof) |
null | pragma solidity 0.5.17;
contract StakeManager is
StakeManagerStorage,
Initializable,
IStakeManager,
DelegateProxyForwarder,
StakeManagerStorageExtension
{
using SafeMath for uint256;
using Merkle for bytes32;
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
struct UnsignedValidatorsContext {
uint256 unsignedValidatorIndex;
uint256 validatorIndex;
uint256[] unsignedValidators;
address[] validators;
uint256 totalValidators;
}
struct UnstakedValidatorsContext {
uint256 deactivationEpoch;
uint256[] deactivatedValidators;
uint256 validatorIndex;
}
modifier onlyStaker(uint256 validatorId) {
}
function _assertStaker(uint256 validatorId) private view {
}
modifier onlyDelegation(uint256 validatorId) {
}
function _assertDelegation(uint256 validatorId) private view {
}
constructor() public GovernanceLockable(address(0x0)) initializer {}
function initialize(
address _registry,
address _rootchain,
address _token,
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _governance,
address _owner,
address _extensionCode
) external initializer {
}
function isOwner() public view returns (bool) {
}
/**
Public View Methods
*/
function getRegistry() public view returns (address) {
}
/**
@dev Owner of validator slot NFT
*/
function ownerOf(uint256 tokenId) public view returns (address) {
}
function epoch() public view returns (uint256) {
}
function withdrawalDelay() public view returns (uint256) {
}
function validatorStake(uint256 validatorId) public view returns (uint256) {
}
function getValidatorId(address user) public view returns (uint256) {
}
function delegatedAmount(uint256 validatorId) public view returns (uint256) {
}
function delegatorsReward(uint256 validatorId) public view returns (uint256) {
}
function validatorReward(uint256 validatorId) public view returns (uint256) {
}
function currentValidatorSetSize() public view returns (uint256) {
}
function currentValidatorSetTotalStake() public view returns (uint256) {
}
function getValidatorContract(uint256 validatorId) public view returns (address) {
}
function isValidator(uint256 validatorId) public view returns (bool) {
}
/**
Governance Methods
*/
function setDelegationEnabled(bool enabled) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function forceUnstake(uint256 validatorId) external onlyGovernance {
}
function setCurrentEpoch(uint256 _currentEpoch) external onlyGovernance {
}
function setStakingToken(address _token) public onlyGovernance {
}
/**
@dev Change the number of validators required to allow a passed header root
*/
function updateValidatorThreshold(uint256 newThreshold) public onlyGovernance {
}
function updateCheckPointBlockInterval(uint256 _blocks) public onlyGovernance {
}
function updateCheckpointReward(uint256 newReward) public onlyGovernance {
}
function updateCheckpointRewardParams(
uint256 _rewardDecreasePerCheckpoint,
uint256 _maxRewardedCheckpoints,
uint256 _checkpointRewardDelta
) public onlyGovernance {
}
// New implementation upgrade
function migrateValidatorsData(uint256 validatorIdFrom, uint256 validatorIdTo) public onlyOwner {
}
function insertSigners(address[] memory _signers) public onlyOwner {
}
/**
@dev Users must exit before this update or all funds may get lost
*/
function updateValidatorContractAddress(uint256 validatorId, address newContractAddress) public onlyGovernance {
}
function updateDynastyValue(uint256 newDynasty) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function stopAuctions(uint256 forNCheckpoints) public onlyGovernance {
}
function updateProposerBonus(uint256 newProposerBonus) public onlyGovernance {
}
function updateSignerUpdateLimit(uint256 _limit) public onlyGovernance {
}
function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyGovernance {
}
function drainValidatorShares(
uint256 validatorId,
address tokenAddr,
address payable destination,
uint256 amount
) external onlyGovernance {
}
function drain(address destination, uint256 amount) external onlyGovernance {
}
function reinitialize(
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _extensionCode
) external onlyGovernance {
}
/**
Public Methods
*/
function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
}
function claimFee(
uint256 accumFeeAmount,
uint256 index,
bytes memory proof
) public {
}
function totalStakedFor(address user) external view returns (uint256) {
}
function startAuction(
uint256 validatorId,
uint256 amount,
bool _acceptDelegation,
bytes calldata _signerPubkey
) external onlyWhenUnlocked {
}
function confirmAuctionBid(
uint256 validatorId,
uint256 heimdallFee /** for new validator */
) external onlyWhenUnlocked {
}
function dethroneAndStake(
address auctionUser,
uint256 heimdallFee,
uint256 validatorId,
uint256 auctionAmount,
bool acceptDelegation,
bytes calldata signerPubkey
) external {
}
function unstake(uint256 validatorId) external onlyStaker(validatorId) {
require(<FILL_ME>)
Status status = validators[validatorId].status;
require(
validators[validatorId].activationEpoch > 0 &&
validators[validatorId].deactivationEpoch == 0 &&
(status == Status.Active || status == Status.Locked)
);
uint256 exitEpoch = currentEpoch.add(1); // notice period
_unstake(validatorId, exitEpoch);
}
function transferFunds(
uint256 validatorId,
uint256 amount,
address delegator
) external returns (bool) {
}
function delegationDeposit(
uint256 validatorId,
uint256 amount,
address delegator
) external onlyDelegation(validatorId) returns (bool) {
}
function stakeFor(
address user,
uint256 amount,
uint256 heimdallFee,
bool acceptDelegation,
bytes memory signerPubkey
) public onlyWhenUnlocked {
}
function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
}
function restake(
uint256 validatorId,
uint256 amount,
bool stakeRewards
) public onlyWhenUnlocked onlyStaker(validatorId) {
}
function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
}
function migrateDelegation(
uint256 fromValidatorId,
uint256 toValidatorId,
uint256 amount
) public {
}
function updateValidatorState(uint256 validatorId, int256 amount) public onlyDelegation(validatorId) {
}
function increaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) private {
}
function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public onlyDelegation(validatorId) {
}
function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
}
function checkSignatures(
uint256 blockInterval,
bytes32 voteHash,
bytes32 stateRoot,
address proposer,
uint256[3][] calldata sigs
) external onlyRootChain returns (uint256) {
}
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external onlyStaker(validatorId) {
}
function withdrawDelegatorsReward(uint256 validatorId) public onlyDelegation(validatorId) returns (uint256) {
}
function slash(bytes calldata _slashingInfoList) external returns (uint256) {
}
function unjail(uint256 validatorId) public onlyStaker(validatorId) {
}
function updateTimeline(
int256 amount,
int256 stakerCount,
uint256 targetEpoch
) internal {
}
function updateValidatorDelegation(bool delegation) external {
}
/**
Private Methods
*/
function _getAndAssertSigner(bytes memory pub) private view returns (address) {
}
function _isValidator(
Status status,
uint256 amount,
uint256 deactivationEpoch,
uint256 _currentEpoch
) private pure returns (bool) {
}
function _fillUnsignedValidators(UnsignedValidatorsContext memory context, address signer)
private
view
returns(UnsignedValidatorsContext memory)
{
}
function _calculateCheckpointReward(
uint256 blockInterval,
uint256 signedStakePower,
uint256 currentTotalStake
) internal returns (uint256) {
}
function _increaseRewardAndAssertConsensus(
uint256 blockInterval,
address proposer,
uint256 signedStakePower,
bytes32 stateRoot,
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256[] memory deactivatedValidators,
uint256 totalDeactivatedValidators
) private returns (uint256) {
}
function _updateValidatorsRewards(
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256 newRewardPerStake
) private {
}
function _updateRewardsAndCommit(
uint256 validatorId,
uint256 currentRewardPerStake,
uint256 newRewardPerStake
) private {
}
function _updateRewards(uint256 validatorId) private {
}
function _getEligibleValidatorReward(
uint256 validatorId,
uint256 validatorStakePower,
uint256 currentRewardPerStake,
uint256 initialRewardPerStake
) private pure returns (uint256) {
}
function _increaseValidatorReward(uint256 validatorId, uint256 reward) private {
}
function _increaseValidatorRewardWithDelegation(
uint256 validatorId,
uint256 validatorsStake,
uint256 delegatedAmount,
uint256 reward
) private {
}
function _getValidatorAndDelegationReward(
uint256 validatorId,
uint256 validatorsStake,
uint256 reward,
uint256 combinedStakePower
) internal view returns (uint256, uint256) {
}
function _evaluateValidatorAndDelegationReward(uint256 validatorId)
private
view
returns (uint256 validatorReward, uint256 delegatorsReward)
{
}
function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
}
function _stakeFor(
address user,
uint256 amount,
bool acceptDelegation,
bytes memory signerPubkey
) internal returns (uint256) {
}
function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
}
function _finalizeCommit() internal {
}
function _liquidateRewards(uint256 validatorId, address validatorUser) private {
}
function _transferToken(address destination, uint256 amount) private {
}
function _transferTokenFrom(
address from,
address destination,
uint256 amount
) private {
}
function _transferAndTopUp(
address user,
address from,
uint256 fee,
uint256 additionalAmount
) private {
}
function _claimFee(address user, uint256 amount) private {
}
function _insertSigner(address newSigner) internal {
}
function _removeSigner(address signerToDelete) internal {
}
}
| validatorAuction[validatorId].amount==0 | 94,670 | validatorAuction[validatorId].amount==0 |
null | pragma solidity 0.5.17;
contract StakeManager is
StakeManagerStorage,
Initializable,
IStakeManager,
DelegateProxyForwarder,
StakeManagerStorageExtension
{
using SafeMath for uint256;
using Merkle for bytes32;
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
struct UnsignedValidatorsContext {
uint256 unsignedValidatorIndex;
uint256 validatorIndex;
uint256[] unsignedValidators;
address[] validators;
uint256 totalValidators;
}
struct UnstakedValidatorsContext {
uint256 deactivationEpoch;
uint256[] deactivatedValidators;
uint256 validatorIndex;
}
modifier onlyStaker(uint256 validatorId) {
}
function _assertStaker(uint256 validatorId) private view {
}
modifier onlyDelegation(uint256 validatorId) {
}
function _assertDelegation(uint256 validatorId) private view {
}
constructor() public GovernanceLockable(address(0x0)) initializer {}
function initialize(
address _registry,
address _rootchain,
address _token,
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _governance,
address _owner,
address _extensionCode
) external initializer {
}
function isOwner() public view returns (bool) {
}
/**
Public View Methods
*/
function getRegistry() public view returns (address) {
}
/**
@dev Owner of validator slot NFT
*/
function ownerOf(uint256 tokenId) public view returns (address) {
}
function epoch() public view returns (uint256) {
}
function withdrawalDelay() public view returns (uint256) {
}
function validatorStake(uint256 validatorId) public view returns (uint256) {
}
function getValidatorId(address user) public view returns (uint256) {
}
function delegatedAmount(uint256 validatorId) public view returns (uint256) {
}
function delegatorsReward(uint256 validatorId) public view returns (uint256) {
}
function validatorReward(uint256 validatorId) public view returns (uint256) {
}
function currentValidatorSetSize() public view returns (uint256) {
}
function currentValidatorSetTotalStake() public view returns (uint256) {
}
function getValidatorContract(uint256 validatorId) public view returns (address) {
}
function isValidator(uint256 validatorId) public view returns (bool) {
}
/**
Governance Methods
*/
function setDelegationEnabled(bool enabled) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function forceUnstake(uint256 validatorId) external onlyGovernance {
}
function setCurrentEpoch(uint256 _currentEpoch) external onlyGovernance {
}
function setStakingToken(address _token) public onlyGovernance {
}
/**
@dev Change the number of validators required to allow a passed header root
*/
function updateValidatorThreshold(uint256 newThreshold) public onlyGovernance {
}
function updateCheckPointBlockInterval(uint256 _blocks) public onlyGovernance {
}
function updateCheckpointReward(uint256 newReward) public onlyGovernance {
}
function updateCheckpointRewardParams(
uint256 _rewardDecreasePerCheckpoint,
uint256 _maxRewardedCheckpoints,
uint256 _checkpointRewardDelta
) public onlyGovernance {
}
// New implementation upgrade
function migrateValidatorsData(uint256 validatorIdFrom, uint256 validatorIdTo) public onlyOwner {
}
function insertSigners(address[] memory _signers) public onlyOwner {
}
/**
@dev Users must exit before this update or all funds may get lost
*/
function updateValidatorContractAddress(uint256 validatorId, address newContractAddress) public onlyGovernance {
}
function updateDynastyValue(uint256 newDynasty) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function stopAuctions(uint256 forNCheckpoints) public onlyGovernance {
}
function updateProposerBonus(uint256 newProposerBonus) public onlyGovernance {
}
function updateSignerUpdateLimit(uint256 _limit) public onlyGovernance {
}
function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyGovernance {
}
function drainValidatorShares(
uint256 validatorId,
address tokenAddr,
address payable destination,
uint256 amount
) external onlyGovernance {
}
function drain(address destination, uint256 amount) external onlyGovernance {
}
function reinitialize(
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _extensionCode
) external onlyGovernance {
}
/**
Public Methods
*/
function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
}
function claimFee(
uint256 accumFeeAmount,
uint256 index,
bytes memory proof
) public {
}
function totalStakedFor(address user) external view returns (uint256) {
}
function startAuction(
uint256 validatorId,
uint256 amount,
bool _acceptDelegation,
bytes calldata _signerPubkey
) external onlyWhenUnlocked {
}
function confirmAuctionBid(
uint256 validatorId,
uint256 heimdallFee /** for new validator */
) external onlyWhenUnlocked {
}
function dethroneAndStake(
address auctionUser,
uint256 heimdallFee,
uint256 validatorId,
uint256 auctionAmount,
bool acceptDelegation,
bytes calldata signerPubkey
) external {
}
function unstake(uint256 validatorId) external onlyStaker(validatorId) {
require(validatorAuction[validatorId].amount == 0);
Status status = validators[validatorId].status;
require(<FILL_ME>)
uint256 exitEpoch = currentEpoch.add(1); // notice period
_unstake(validatorId, exitEpoch);
}
function transferFunds(
uint256 validatorId,
uint256 amount,
address delegator
) external returns (bool) {
}
function delegationDeposit(
uint256 validatorId,
uint256 amount,
address delegator
) external onlyDelegation(validatorId) returns (bool) {
}
function stakeFor(
address user,
uint256 amount,
uint256 heimdallFee,
bool acceptDelegation,
bytes memory signerPubkey
) public onlyWhenUnlocked {
}
function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
}
function restake(
uint256 validatorId,
uint256 amount,
bool stakeRewards
) public onlyWhenUnlocked onlyStaker(validatorId) {
}
function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
}
function migrateDelegation(
uint256 fromValidatorId,
uint256 toValidatorId,
uint256 amount
) public {
}
function updateValidatorState(uint256 validatorId, int256 amount) public onlyDelegation(validatorId) {
}
function increaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) private {
}
function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public onlyDelegation(validatorId) {
}
function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
}
function checkSignatures(
uint256 blockInterval,
bytes32 voteHash,
bytes32 stateRoot,
address proposer,
uint256[3][] calldata sigs
) external onlyRootChain returns (uint256) {
}
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external onlyStaker(validatorId) {
}
function withdrawDelegatorsReward(uint256 validatorId) public onlyDelegation(validatorId) returns (uint256) {
}
function slash(bytes calldata _slashingInfoList) external returns (uint256) {
}
function unjail(uint256 validatorId) public onlyStaker(validatorId) {
}
function updateTimeline(
int256 amount,
int256 stakerCount,
uint256 targetEpoch
) internal {
}
function updateValidatorDelegation(bool delegation) external {
}
/**
Private Methods
*/
function _getAndAssertSigner(bytes memory pub) private view returns (address) {
}
function _isValidator(
Status status,
uint256 amount,
uint256 deactivationEpoch,
uint256 _currentEpoch
) private pure returns (bool) {
}
function _fillUnsignedValidators(UnsignedValidatorsContext memory context, address signer)
private
view
returns(UnsignedValidatorsContext memory)
{
}
function _calculateCheckpointReward(
uint256 blockInterval,
uint256 signedStakePower,
uint256 currentTotalStake
) internal returns (uint256) {
}
function _increaseRewardAndAssertConsensus(
uint256 blockInterval,
address proposer,
uint256 signedStakePower,
bytes32 stateRoot,
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256[] memory deactivatedValidators,
uint256 totalDeactivatedValidators
) private returns (uint256) {
}
function _updateValidatorsRewards(
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256 newRewardPerStake
) private {
}
function _updateRewardsAndCommit(
uint256 validatorId,
uint256 currentRewardPerStake,
uint256 newRewardPerStake
) private {
}
function _updateRewards(uint256 validatorId) private {
}
function _getEligibleValidatorReward(
uint256 validatorId,
uint256 validatorStakePower,
uint256 currentRewardPerStake,
uint256 initialRewardPerStake
) private pure returns (uint256) {
}
function _increaseValidatorReward(uint256 validatorId, uint256 reward) private {
}
function _increaseValidatorRewardWithDelegation(
uint256 validatorId,
uint256 validatorsStake,
uint256 delegatedAmount,
uint256 reward
) private {
}
function _getValidatorAndDelegationReward(
uint256 validatorId,
uint256 validatorsStake,
uint256 reward,
uint256 combinedStakePower
) internal view returns (uint256, uint256) {
}
function _evaluateValidatorAndDelegationReward(uint256 validatorId)
private
view
returns (uint256 validatorReward, uint256 delegatorsReward)
{
}
function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
}
function _stakeFor(
address user,
uint256 amount,
bool acceptDelegation,
bytes memory signerPubkey
) internal returns (uint256) {
}
function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
}
function _finalizeCommit() internal {
}
function _liquidateRewards(uint256 validatorId, address validatorUser) private {
}
function _transferToken(address destination, uint256 amount) private {
}
function _transferTokenFrom(
address from,
address destination,
uint256 amount
) private {
}
function _transferAndTopUp(
address user,
address from,
uint256 fee,
uint256 additionalAmount
) private {
}
function _claimFee(address user, uint256 amount) private {
}
function _insertSigner(address newSigner) internal {
}
function _removeSigner(address signerToDelete) internal {
}
}
| validators[validatorId].activationEpoch>0&&validators[validatorId].deactivationEpoch==0&&(status==Status.Active||status==Status.Locked) | 94,670 | validators[validatorId].activationEpoch>0&&validators[validatorId].deactivationEpoch==0&&(status==Status.Active||status==Status.Locked) |
"not allowed" | pragma solidity 0.5.17;
contract StakeManager is
StakeManagerStorage,
Initializable,
IStakeManager,
DelegateProxyForwarder,
StakeManagerStorageExtension
{
using SafeMath for uint256;
using Merkle for bytes32;
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
struct UnsignedValidatorsContext {
uint256 unsignedValidatorIndex;
uint256 validatorIndex;
uint256[] unsignedValidators;
address[] validators;
uint256 totalValidators;
}
struct UnstakedValidatorsContext {
uint256 deactivationEpoch;
uint256[] deactivatedValidators;
uint256 validatorIndex;
}
modifier onlyStaker(uint256 validatorId) {
}
function _assertStaker(uint256 validatorId) private view {
}
modifier onlyDelegation(uint256 validatorId) {
}
function _assertDelegation(uint256 validatorId) private view {
}
constructor() public GovernanceLockable(address(0x0)) initializer {}
function initialize(
address _registry,
address _rootchain,
address _token,
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _governance,
address _owner,
address _extensionCode
) external initializer {
}
function isOwner() public view returns (bool) {
}
/**
Public View Methods
*/
function getRegistry() public view returns (address) {
}
/**
@dev Owner of validator slot NFT
*/
function ownerOf(uint256 tokenId) public view returns (address) {
}
function epoch() public view returns (uint256) {
}
function withdrawalDelay() public view returns (uint256) {
}
function validatorStake(uint256 validatorId) public view returns (uint256) {
}
function getValidatorId(address user) public view returns (uint256) {
}
function delegatedAmount(uint256 validatorId) public view returns (uint256) {
}
function delegatorsReward(uint256 validatorId) public view returns (uint256) {
}
function validatorReward(uint256 validatorId) public view returns (uint256) {
}
function currentValidatorSetSize() public view returns (uint256) {
}
function currentValidatorSetTotalStake() public view returns (uint256) {
}
function getValidatorContract(uint256 validatorId) public view returns (address) {
}
function isValidator(uint256 validatorId) public view returns (bool) {
}
/**
Governance Methods
*/
function setDelegationEnabled(bool enabled) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function forceUnstake(uint256 validatorId) external onlyGovernance {
}
function setCurrentEpoch(uint256 _currentEpoch) external onlyGovernance {
}
function setStakingToken(address _token) public onlyGovernance {
}
/**
@dev Change the number of validators required to allow a passed header root
*/
function updateValidatorThreshold(uint256 newThreshold) public onlyGovernance {
}
function updateCheckPointBlockInterval(uint256 _blocks) public onlyGovernance {
}
function updateCheckpointReward(uint256 newReward) public onlyGovernance {
}
function updateCheckpointRewardParams(
uint256 _rewardDecreasePerCheckpoint,
uint256 _maxRewardedCheckpoints,
uint256 _checkpointRewardDelta
) public onlyGovernance {
}
// New implementation upgrade
function migrateValidatorsData(uint256 validatorIdFrom, uint256 validatorIdTo) public onlyOwner {
}
function insertSigners(address[] memory _signers) public onlyOwner {
}
/**
@dev Users must exit before this update or all funds may get lost
*/
function updateValidatorContractAddress(uint256 validatorId, address newContractAddress) public onlyGovernance {
}
function updateDynastyValue(uint256 newDynasty) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function stopAuctions(uint256 forNCheckpoints) public onlyGovernance {
}
function updateProposerBonus(uint256 newProposerBonus) public onlyGovernance {
}
function updateSignerUpdateLimit(uint256 _limit) public onlyGovernance {
}
function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyGovernance {
}
function drainValidatorShares(
uint256 validatorId,
address tokenAddr,
address payable destination,
uint256 amount
) external onlyGovernance {
}
function drain(address destination, uint256 amount) external onlyGovernance {
}
function reinitialize(
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _extensionCode
) external onlyGovernance {
}
/**
Public Methods
*/
function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
}
function claimFee(
uint256 accumFeeAmount,
uint256 index,
bytes memory proof
) public {
}
function totalStakedFor(address user) external view returns (uint256) {
}
function startAuction(
uint256 validatorId,
uint256 amount,
bool _acceptDelegation,
bytes calldata _signerPubkey
) external onlyWhenUnlocked {
}
function confirmAuctionBid(
uint256 validatorId,
uint256 heimdallFee /** for new validator */
) external onlyWhenUnlocked {
}
function dethroneAndStake(
address auctionUser,
uint256 heimdallFee,
uint256 validatorId,
uint256 auctionAmount,
bool acceptDelegation,
bytes calldata signerPubkey
) external {
}
function unstake(uint256 validatorId) external onlyStaker(validatorId) {
}
function transferFunds(
uint256 validatorId,
uint256 amount,
address delegator
) external returns (bool) {
require(<FILL_ME>)
return token.transfer(delegator, amount);
}
function delegationDeposit(
uint256 validatorId,
uint256 amount,
address delegator
) external onlyDelegation(validatorId) returns (bool) {
}
function stakeFor(
address user,
uint256 amount,
uint256 heimdallFee,
bool acceptDelegation,
bytes memory signerPubkey
) public onlyWhenUnlocked {
}
function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
}
function restake(
uint256 validatorId,
uint256 amount,
bool stakeRewards
) public onlyWhenUnlocked onlyStaker(validatorId) {
}
function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
}
function migrateDelegation(
uint256 fromValidatorId,
uint256 toValidatorId,
uint256 amount
) public {
}
function updateValidatorState(uint256 validatorId, int256 amount) public onlyDelegation(validatorId) {
}
function increaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) private {
}
function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public onlyDelegation(validatorId) {
}
function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
}
function checkSignatures(
uint256 blockInterval,
bytes32 voteHash,
bytes32 stateRoot,
address proposer,
uint256[3][] calldata sigs
) external onlyRootChain returns (uint256) {
}
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external onlyStaker(validatorId) {
}
function withdrawDelegatorsReward(uint256 validatorId) public onlyDelegation(validatorId) returns (uint256) {
}
function slash(bytes calldata _slashingInfoList) external returns (uint256) {
}
function unjail(uint256 validatorId) public onlyStaker(validatorId) {
}
function updateTimeline(
int256 amount,
int256 stakerCount,
uint256 targetEpoch
) internal {
}
function updateValidatorDelegation(bool delegation) external {
}
/**
Private Methods
*/
function _getAndAssertSigner(bytes memory pub) private view returns (address) {
}
function _isValidator(
Status status,
uint256 amount,
uint256 deactivationEpoch,
uint256 _currentEpoch
) private pure returns (bool) {
}
function _fillUnsignedValidators(UnsignedValidatorsContext memory context, address signer)
private
view
returns(UnsignedValidatorsContext memory)
{
}
function _calculateCheckpointReward(
uint256 blockInterval,
uint256 signedStakePower,
uint256 currentTotalStake
) internal returns (uint256) {
}
function _increaseRewardAndAssertConsensus(
uint256 blockInterval,
address proposer,
uint256 signedStakePower,
bytes32 stateRoot,
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256[] memory deactivatedValidators,
uint256 totalDeactivatedValidators
) private returns (uint256) {
}
function _updateValidatorsRewards(
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256 newRewardPerStake
) private {
}
function _updateRewardsAndCommit(
uint256 validatorId,
uint256 currentRewardPerStake,
uint256 newRewardPerStake
) private {
}
function _updateRewards(uint256 validatorId) private {
}
function _getEligibleValidatorReward(
uint256 validatorId,
uint256 validatorStakePower,
uint256 currentRewardPerStake,
uint256 initialRewardPerStake
) private pure returns (uint256) {
}
function _increaseValidatorReward(uint256 validatorId, uint256 reward) private {
}
function _increaseValidatorRewardWithDelegation(
uint256 validatorId,
uint256 validatorsStake,
uint256 delegatedAmount,
uint256 reward
) private {
}
function _getValidatorAndDelegationReward(
uint256 validatorId,
uint256 validatorsStake,
uint256 reward,
uint256 combinedStakePower
) internal view returns (uint256, uint256) {
}
function _evaluateValidatorAndDelegationReward(uint256 validatorId)
private
view
returns (uint256 validatorReward, uint256 delegatorsReward)
{
}
function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
}
function _stakeFor(
address user,
uint256 amount,
bool acceptDelegation,
bytes memory signerPubkey
) internal returns (uint256) {
}
function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
}
function _finalizeCommit() internal {
}
function _liquidateRewards(uint256 validatorId, address validatorUser) private {
}
function _transferToken(address destination, uint256 amount) private {
}
function _transferTokenFrom(
address from,
address destination,
uint256 amount
) private {
}
function _transferAndTopUp(
address user,
address from,
uint256 fee,
uint256 additionalAmount
) private {
}
function _claimFee(address user, uint256 amount) private {
}
function _insertSigner(address newSigner) internal {
}
function _removeSigner(address signerToDelete) internal {
}
}
| validators[validatorId].contractAddress==msg.sender||Registry(registry).getSlashingManagerAddress()==msg.sender,"not allowed" | 94,670 | validators[validatorId].contractAddress==msg.sender||Registry(registry).getSlashingManagerAddress()==msg.sender |
"no more slots" | pragma solidity 0.5.17;
contract StakeManager is
StakeManagerStorage,
Initializable,
IStakeManager,
DelegateProxyForwarder,
StakeManagerStorageExtension
{
using SafeMath for uint256;
using Merkle for bytes32;
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
struct UnsignedValidatorsContext {
uint256 unsignedValidatorIndex;
uint256 validatorIndex;
uint256[] unsignedValidators;
address[] validators;
uint256 totalValidators;
}
struct UnstakedValidatorsContext {
uint256 deactivationEpoch;
uint256[] deactivatedValidators;
uint256 validatorIndex;
}
modifier onlyStaker(uint256 validatorId) {
}
function _assertStaker(uint256 validatorId) private view {
}
modifier onlyDelegation(uint256 validatorId) {
}
function _assertDelegation(uint256 validatorId) private view {
}
constructor() public GovernanceLockable(address(0x0)) initializer {}
function initialize(
address _registry,
address _rootchain,
address _token,
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _governance,
address _owner,
address _extensionCode
) external initializer {
}
function isOwner() public view returns (bool) {
}
/**
Public View Methods
*/
function getRegistry() public view returns (address) {
}
/**
@dev Owner of validator slot NFT
*/
function ownerOf(uint256 tokenId) public view returns (address) {
}
function epoch() public view returns (uint256) {
}
function withdrawalDelay() public view returns (uint256) {
}
function validatorStake(uint256 validatorId) public view returns (uint256) {
}
function getValidatorId(address user) public view returns (uint256) {
}
function delegatedAmount(uint256 validatorId) public view returns (uint256) {
}
function delegatorsReward(uint256 validatorId) public view returns (uint256) {
}
function validatorReward(uint256 validatorId) public view returns (uint256) {
}
function currentValidatorSetSize() public view returns (uint256) {
}
function currentValidatorSetTotalStake() public view returns (uint256) {
}
function getValidatorContract(uint256 validatorId) public view returns (address) {
}
function isValidator(uint256 validatorId) public view returns (bool) {
}
/**
Governance Methods
*/
function setDelegationEnabled(bool enabled) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function forceUnstake(uint256 validatorId) external onlyGovernance {
}
function setCurrentEpoch(uint256 _currentEpoch) external onlyGovernance {
}
function setStakingToken(address _token) public onlyGovernance {
}
/**
@dev Change the number of validators required to allow a passed header root
*/
function updateValidatorThreshold(uint256 newThreshold) public onlyGovernance {
}
function updateCheckPointBlockInterval(uint256 _blocks) public onlyGovernance {
}
function updateCheckpointReward(uint256 newReward) public onlyGovernance {
}
function updateCheckpointRewardParams(
uint256 _rewardDecreasePerCheckpoint,
uint256 _maxRewardedCheckpoints,
uint256 _checkpointRewardDelta
) public onlyGovernance {
}
// New implementation upgrade
function migrateValidatorsData(uint256 validatorIdFrom, uint256 validatorIdTo) public onlyOwner {
}
function insertSigners(address[] memory _signers) public onlyOwner {
}
/**
@dev Users must exit before this update or all funds may get lost
*/
function updateValidatorContractAddress(uint256 validatorId, address newContractAddress) public onlyGovernance {
}
function updateDynastyValue(uint256 newDynasty) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function stopAuctions(uint256 forNCheckpoints) public onlyGovernance {
}
function updateProposerBonus(uint256 newProposerBonus) public onlyGovernance {
}
function updateSignerUpdateLimit(uint256 _limit) public onlyGovernance {
}
function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyGovernance {
}
function drainValidatorShares(
uint256 validatorId,
address tokenAddr,
address payable destination,
uint256 amount
) external onlyGovernance {
}
function drain(address destination, uint256 amount) external onlyGovernance {
}
function reinitialize(
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _extensionCode
) external onlyGovernance {
}
/**
Public Methods
*/
function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
}
function claimFee(
uint256 accumFeeAmount,
uint256 index,
bytes memory proof
) public {
}
function totalStakedFor(address user) external view returns (uint256) {
}
function startAuction(
uint256 validatorId,
uint256 amount,
bool _acceptDelegation,
bytes calldata _signerPubkey
) external onlyWhenUnlocked {
}
function confirmAuctionBid(
uint256 validatorId,
uint256 heimdallFee /** for new validator */
) external onlyWhenUnlocked {
}
function dethroneAndStake(
address auctionUser,
uint256 heimdallFee,
uint256 validatorId,
uint256 auctionAmount,
bool acceptDelegation,
bytes calldata signerPubkey
) external {
}
function unstake(uint256 validatorId) external onlyStaker(validatorId) {
}
function transferFunds(
uint256 validatorId,
uint256 amount,
address delegator
) external returns (bool) {
}
function delegationDeposit(
uint256 validatorId,
uint256 amount,
address delegator
) external onlyDelegation(validatorId) returns (bool) {
}
function stakeFor(
address user,
uint256 amount,
uint256 heimdallFee,
bool acceptDelegation,
bytes memory signerPubkey
) public onlyWhenUnlocked {
require(<FILL_ME>)
require(amount >= minDeposit, "not enough deposit");
_transferAndTopUp(user, msg.sender, heimdallFee, amount);
_stakeFor(user, amount, acceptDelegation, signerPubkey);
}
function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
}
function restake(
uint256 validatorId,
uint256 amount,
bool stakeRewards
) public onlyWhenUnlocked onlyStaker(validatorId) {
}
function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
}
function migrateDelegation(
uint256 fromValidatorId,
uint256 toValidatorId,
uint256 amount
) public {
}
function updateValidatorState(uint256 validatorId, int256 amount) public onlyDelegation(validatorId) {
}
function increaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) private {
}
function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public onlyDelegation(validatorId) {
}
function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
}
function checkSignatures(
uint256 blockInterval,
bytes32 voteHash,
bytes32 stateRoot,
address proposer,
uint256[3][] calldata sigs
) external onlyRootChain returns (uint256) {
}
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external onlyStaker(validatorId) {
}
function withdrawDelegatorsReward(uint256 validatorId) public onlyDelegation(validatorId) returns (uint256) {
}
function slash(bytes calldata _slashingInfoList) external returns (uint256) {
}
function unjail(uint256 validatorId) public onlyStaker(validatorId) {
}
function updateTimeline(
int256 amount,
int256 stakerCount,
uint256 targetEpoch
) internal {
}
function updateValidatorDelegation(bool delegation) external {
}
/**
Private Methods
*/
function _getAndAssertSigner(bytes memory pub) private view returns (address) {
}
function _isValidator(
Status status,
uint256 amount,
uint256 deactivationEpoch,
uint256 _currentEpoch
) private pure returns (bool) {
}
function _fillUnsignedValidators(UnsignedValidatorsContext memory context, address signer)
private
view
returns(UnsignedValidatorsContext memory)
{
}
function _calculateCheckpointReward(
uint256 blockInterval,
uint256 signedStakePower,
uint256 currentTotalStake
) internal returns (uint256) {
}
function _increaseRewardAndAssertConsensus(
uint256 blockInterval,
address proposer,
uint256 signedStakePower,
bytes32 stateRoot,
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256[] memory deactivatedValidators,
uint256 totalDeactivatedValidators
) private returns (uint256) {
}
function _updateValidatorsRewards(
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256 newRewardPerStake
) private {
}
function _updateRewardsAndCommit(
uint256 validatorId,
uint256 currentRewardPerStake,
uint256 newRewardPerStake
) private {
}
function _updateRewards(uint256 validatorId) private {
}
function _getEligibleValidatorReward(
uint256 validatorId,
uint256 validatorStakePower,
uint256 currentRewardPerStake,
uint256 initialRewardPerStake
) private pure returns (uint256) {
}
function _increaseValidatorReward(uint256 validatorId, uint256 reward) private {
}
function _increaseValidatorRewardWithDelegation(
uint256 validatorId,
uint256 validatorsStake,
uint256 delegatedAmount,
uint256 reward
) private {
}
function _getValidatorAndDelegationReward(
uint256 validatorId,
uint256 validatorsStake,
uint256 reward,
uint256 combinedStakePower
) internal view returns (uint256, uint256) {
}
function _evaluateValidatorAndDelegationReward(uint256 validatorId)
private
view
returns (uint256 validatorReward, uint256 delegatorsReward)
{
}
function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
}
function _stakeFor(
address user,
uint256 amount,
bool acceptDelegation,
bytes memory signerPubkey
) internal returns (uint256) {
}
function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
}
function _finalizeCommit() internal {
}
function _liquidateRewards(uint256 validatorId, address validatorUser) private {
}
function _transferToken(address destination, uint256 amount) private {
}
function _transferTokenFrom(
address from,
address destination,
uint256 amount
) private {
}
function _transferAndTopUp(
address user,
address from,
uint256 fee,
uint256 additionalAmount
) private {
}
function _claimFee(address user, uint256 amount) private {
}
function _insertSigner(address newSigner) internal {
}
function _removeSigner(address signerToDelete) internal {
}
}
| currentValidatorSetSize()<validatorThreshold,"no more slots" | 94,670 | currentValidatorSetSize()<validatorThreshold |
"No restaking" | pragma solidity 0.5.17;
contract StakeManager is
StakeManagerStorage,
Initializable,
IStakeManager,
DelegateProxyForwarder,
StakeManagerStorageExtension
{
using SafeMath for uint256;
using Merkle for bytes32;
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
struct UnsignedValidatorsContext {
uint256 unsignedValidatorIndex;
uint256 validatorIndex;
uint256[] unsignedValidators;
address[] validators;
uint256 totalValidators;
}
struct UnstakedValidatorsContext {
uint256 deactivationEpoch;
uint256[] deactivatedValidators;
uint256 validatorIndex;
}
modifier onlyStaker(uint256 validatorId) {
}
function _assertStaker(uint256 validatorId) private view {
}
modifier onlyDelegation(uint256 validatorId) {
}
function _assertDelegation(uint256 validatorId) private view {
}
constructor() public GovernanceLockable(address(0x0)) initializer {}
function initialize(
address _registry,
address _rootchain,
address _token,
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _governance,
address _owner,
address _extensionCode
) external initializer {
}
function isOwner() public view returns (bool) {
}
/**
Public View Methods
*/
function getRegistry() public view returns (address) {
}
/**
@dev Owner of validator slot NFT
*/
function ownerOf(uint256 tokenId) public view returns (address) {
}
function epoch() public view returns (uint256) {
}
function withdrawalDelay() public view returns (uint256) {
}
function validatorStake(uint256 validatorId) public view returns (uint256) {
}
function getValidatorId(address user) public view returns (uint256) {
}
function delegatedAmount(uint256 validatorId) public view returns (uint256) {
}
function delegatorsReward(uint256 validatorId) public view returns (uint256) {
}
function validatorReward(uint256 validatorId) public view returns (uint256) {
}
function currentValidatorSetSize() public view returns (uint256) {
}
function currentValidatorSetTotalStake() public view returns (uint256) {
}
function getValidatorContract(uint256 validatorId) public view returns (address) {
}
function isValidator(uint256 validatorId) public view returns (bool) {
}
/**
Governance Methods
*/
function setDelegationEnabled(bool enabled) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function forceUnstake(uint256 validatorId) external onlyGovernance {
}
function setCurrentEpoch(uint256 _currentEpoch) external onlyGovernance {
}
function setStakingToken(address _token) public onlyGovernance {
}
/**
@dev Change the number of validators required to allow a passed header root
*/
function updateValidatorThreshold(uint256 newThreshold) public onlyGovernance {
}
function updateCheckPointBlockInterval(uint256 _blocks) public onlyGovernance {
}
function updateCheckpointReward(uint256 newReward) public onlyGovernance {
}
function updateCheckpointRewardParams(
uint256 _rewardDecreasePerCheckpoint,
uint256 _maxRewardedCheckpoints,
uint256 _checkpointRewardDelta
) public onlyGovernance {
}
// New implementation upgrade
function migrateValidatorsData(uint256 validatorIdFrom, uint256 validatorIdTo) public onlyOwner {
}
function insertSigners(address[] memory _signers) public onlyOwner {
}
/**
@dev Users must exit before this update or all funds may get lost
*/
function updateValidatorContractAddress(uint256 validatorId, address newContractAddress) public onlyGovernance {
}
function updateDynastyValue(uint256 newDynasty) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function stopAuctions(uint256 forNCheckpoints) public onlyGovernance {
}
function updateProposerBonus(uint256 newProposerBonus) public onlyGovernance {
}
function updateSignerUpdateLimit(uint256 _limit) public onlyGovernance {
}
function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyGovernance {
}
function drainValidatorShares(
uint256 validatorId,
address tokenAddr,
address payable destination,
uint256 amount
) external onlyGovernance {
}
function drain(address destination, uint256 amount) external onlyGovernance {
}
function reinitialize(
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _extensionCode
) external onlyGovernance {
}
/**
Public Methods
*/
function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
}
function claimFee(
uint256 accumFeeAmount,
uint256 index,
bytes memory proof
) public {
}
function totalStakedFor(address user) external view returns (uint256) {
}
function startAuction(
uint256 validatorId,
uint256 amount,
bool _acceptDelegation,
bytes calldata _signerPubkey
) external onlyWhenUnlocked {
}
function confirmAuctionBid(
uint256 validatorId,
uint256 heimdallFee /** for new validator */
) external onlyWhenUnlocked {
}
function dethroneAndStake(
address auctionUser,
uint256 heimdallFee,
uint256 validatorId,
uint256 auctionAmount,
bool acceptDelegation,
bytes calldata signerPubkey
) external {
}
function unstake(uint256 validatorId) external onlyStaker(validatorId) {
}
function transferFunds(
uint256 validatorId,
uint256 amount,
address delegator
) external returns (bool) {
}
function delegationDeposit(
uint256 validatorId,
uint256 amount,
address delegator
) external onlyDelegation(validatorId) returns (bool) {
}
function stakeFor(
address user,
uint256 amount,
uint256 heimdallFee,
bool acceptDelegation,
bytes memory signerPubkey
) public onlyWhenUnlocked {
}
function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
}
function restake(
uint256 validatorId,
uint256 amount,
bool stakeRewards
) public onlyWhenUnlocked onlyStaker(validatorId) {
require(<FILL_ME>)
if (amount > 0) {
_transferTokenFrom(msg.sender, address(this), amount);
}
_updateRewards(validatorId);
if (stakeRewards) {
amount = amount.add(validators[validatorId].reward).sub(INITIALIZED_AMOUNT);
validators[validatorId].reward = INITIALIZED_AMOUNT;
}
uint256 newTotalStaked = totalStaked.add(amount);
totalStaked = newTotalStaked;
validators[validatorId].amount = validators[validatorId].amount.add(amount);
updateTimeline(int256(amount), 0, 0);
logger.logStakeUpdate(validatorId);
logger.logRestaked(validatorId, validators[validatorId].amount, newTotalStaked);
}
function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
}
function migrateDelegation(
uint256 fromValidatorId,
uint256 toValidatorId,
uint256 amount
) public {
}
function updateValidatorState(uint256 validatorId, int256 amount) public onlyDelegation(validatorId) {
}
function increaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) private {
}
function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public onlyDelegation(validatorId) {
}
function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
}
function checkSignatures(
uint256 blockInterval,
bytes32 voteHash,
bytes32 stateRoot,
address proposer,
uint256[3][] calldata sigs
) external onlyRootChain returns (uint256) {
}
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external onlyStaker(validatorId) {
}
function withdrawDelegatorsReward(uint256 validatorId) public onlyDelegation(validatorId) returns (uint256) {
}
function slash(bytes calldata _slashingInfoList) external returns (uint256) {
}
function unjail(uint256 validatorId) public onlyStaker(validatorId) {
}
function updateTimeline(
int256 amount,
int256 stakerCount,
uint256 targetEpoch
) internal {
}
function updateValidatorDelegation(bool delegation) external {
}
/**
Private Methods
*/
function _getAndAssertSigner(bytes memory pub) private view returns (address) {
}
function _isValidator(
Status status,
uint256 amount,
uint256 deactivationEpoch,
uint256 _currentEpoch
) private pure returns (bool) {
}
function _fillUnsignedValidators(UnsignedValidatorsContext memory context, address signer)
private
view
returns(UnsignedValidatorsContext memory)
{
}
function _calculateCheckpointReward(
uint256 blockInterval,
uint256 signedStakePower,
uint256 currentTotalStake
) internal returns (uint256) {
}
function _increaseRewardAndAssertConsensus(
uint256 blockInterval,
address proposer,
uint256 signedStakePower,
bytes32 stateRoot,
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256[] memory deactivatedValidators,
uint256 totalDeactivatedValidators
) private returns (uint256) {
}
function _updateValidatorsRewards(
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256 newRewardPerStake
) private {
}
function _updateRewardsAndCommit(
uint256 validatorId,
uint256 currentRewardPerStake,
uint256 newRewardPerStake
) private {
}
function _updateRewards(uint256 validatorId) private {
}
function _getEligibleValidatorReward(
uint256 validatorId,
uint256 validatorStakePower,
uint256 currentRewardPerStake,
uint256 initialRewardPerStake
) private pure returns (uint256) {
}
function _increaseValidatorReward(uint256 validatorId, uint256 reward) private {
}
function _increaseValidatorRewardWithDelegation(
uint256 validatorId,
uint256 validatorsStake,
uint256 delegatedAmount,
uint256 reward
) private {
}
function _getValidatorAndDelegationReward(
uint256 validatorId,
uint256 validatorsStake,
uint256 reward,
uint256 combinedStakePower
) internal view returns (uint256, uint256) {
}
function _evaluateValidatorAndDelegationReward(uint256 validatorId)
private
view
returns (uint256 validatorReward, uint256 delegatorsReward)
{
}
function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
}
function _stakeFor(
address user,
uint256 amount,
bool acceptDelegation,
bytes memory signerPubkey
) internal returns (uint256) {
}
function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
}
function _finalizeCommit() internal {
}
function _liquidateRewards(uint256 validatorId, address validatorUser) private {
}
function _transferToken(address destination, uint256 amount) private {
}
function _transferTokenFrom(
address from,
address destination,
uint256 amount
) private {
}
function _transferAndTopUp(
address user,
address from,
uint256 fee,
uint256 additionalAmount
) private {
}
function _claimFee(address user, uint256 amount) private {
}
function _insertSigner(address newSigner) internal {
}
function _removeSigner(address signerToDelete) internal {
}
}
| validators[validatorId].deactivationEpoch==0,"No restaking" | 94,670 | validators[validatorId].deactivationEpoch==0 |
"Not slash manager" | pragma solidity 0.5.17;
contract StakeManager is
StakeManagerStorage,
Initializable,
IStakeManager,
DelegateProxyForwarder,
StakeManagerStorageExtension
{
using SafeMath for uint256;
using Merkle for bytes32;
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
struct UnsignedValidatorsContext {
uint256 unsignedValidatorIndex;
uint256 validatorIndex;
uint256[] unsignedValidators;
address[] validators;
uint256 totalValidators;
}
struct UnstakedValidatorsContext {
uint256 deactivationEpoch;
uint256[] deactivatedValidators;
uint256 validatorIndex;
}
modifier onlyStaker(uint256 validatorId) {
}
function _assertStaker(uint256 validatorId) private view {
}
modifier onlyDelegation(uint256 validatorId) {
}
function _assertDelegation(uint256 validatorId) private view {
}
constructor() public GovernanceLockable(address(0x0)) initializer {}
function initialize(
address _registry,
address _rootchain,
address _token,
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _governance,
address _owner,
address _extensionCode
) external initializer {
}
function isOwner() public view returns (bool) {
}
/**
Public View Methods
*/
function getRegistry() public view returns (address) {
}
/**
@dev Owner of validator slot NFT
*/
function ownerOf(uint256 tokenId) public view returns (address) {
}
function epoch() public view returns (uint256) {
}
function withdrawalDelay() public view returns (uint256) {
}
function validatorStake(uint256 validatorId) public view returns (uint256) {
}
function getValidatorId(address user) public view returns (uint256) {
}
function delegatedAmount(uint256 validatorId) public view returns (uint256) {
}
function delegatorsReward(uint256 validatorId) public view returns (uint256) {
}
function validatorReward(uint256 validatorId) public view returns (uint256) {
}
function currentValidatorSetSize() public view returns (uint256) {
}
function currentValidatorSetTotalStake() public view returns (uint256) {
}
function getValidatorContract(uint256 validatorId) public view returns (address) {
}
function isValidator(uint256 validatorId) public view returns (bool) {
}
/**
Governance Methods
*/
function setDelegationEnabled(bool enabled) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function forceUnstake(uint256 validatorId) external onlyGovernance {
}
function setCurrentEpoch(uint256 _currentEpoch) external onlyGovernance {
}
function setStakingToken(address _token) public onlyGovernance {
}
/**
@dev Change the number of validators required to allow a passed header root
*/
function updateValidatorThreshold(uint256 newThreshold) public onlyGovernance {
}
function updateCheckPointBlockInterval(uint256 _blocks) public onlyGovernance {
}
function updateCheckpointReward(uint256 newReward) public onlyGovernance {
}
function updateCheckpointRewardParams(
uint256 _rewardDecreasePerCheckpoint,
uint256 _maxRewardedCheckpoints,
uint256 _checkpointRewardDelta
) public onlyGovernance {
}
// New implementation upgrade
function migrateValidatorsData(uint256 validatorIdFrom, uint256 validatorIdTo) public onlyOwner {
}
function insertSigners(address[] memory _signers) public onlyOwner {
}
/**
@dev Users must exit before this update or all funds may get lost
*/
function updateValidatorContractAddress(uint256 validatorId, address newContractAddress) public onlyGovernance {
}
function updateDynastyValue(uint256 newDynasty) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function stopAuctions(uint256 forNCheckpoints) public onlyGovernance {
}
function updateProposerBonus(uint256 newProposerBonus) public onlyGovernance {
}
function updateSignerUpdateLimit(uint256 _limit) public onlyGovernance {
}
function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyGovernance {
}
function drainValidatorShares(
uint256 validatorId,
address tokenAddr,
address payable destination,
uint256 amount
) external onlyGovernance {
}
function drain(address destination, uint256 amount) external onlyGovernance {
}
function reinitialize(
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _extensionCode
) external onlyGovernance {
}
/**
Public Methods
*/
function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
}
function claimFee(
uint256 accumFeeAmount,
uint256 index,
bytes memory proof
) public {
}
function totalStakedFor(address user) external view returns (uint256) {
}
function startAuction(
uint256 validatorId,
uint256 amount,
bool _acceptDelegation,
bytes calldata _signerPubkey
) external onlyWhenUnlocked {
}
function confirmAuctionBid(
uint256 validatorId,
uint256 heimdallFee /** for new validator */
) external onlyWhenUnlocked {
}
function dethroneAndStake(
address auctionUser,
uint256 heimdallFee,
uint256 validatorId,
uint256 auctionAmount,
bool acceptDelegation,
bytes calldata signerPubkey
) external {
}
function unstake(uint256 validatorId) external onlyStaker(validatorId) {
}
function transferFunds(
uint256 validatorId,
uint256 amount,
address delegator
) external returns (bool) {
}
function delegationDeposit(
uint256 validatorId,
uint256 amount,
address delegator
) external onlyDelegation(validatorId) returns (bool) {
}
function stakeFor(
address user,
uint256 amount,
uint256 heimdallFee,
bool acceptDelegation,
bytes memory signerPubkey
) public onlyWhenUnlocked {
}
function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
}
function restake(
uint256 validatorId,
uint256 amount,
bool stakeRewards
) public onlyWhenUnlocked onlyStaker(validatorId) {
}
function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
}
function migrateDelegation(
uint256 fromValidatorId,
uint256 toValidatorId,
uint256 amount
) public {
}
function updateValidatorState(uint256 validatorId, int256 amount) public onlyDelegation(validatorId) {
}
function increaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) private {
}
function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public onlyDelegation(validatorId) {
}
function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
}
function checkSignatures(
uint256 blockInterval,
bytes32 voteHash,
bytes32 stateRoot,
address proposer,
uint256[3][] calldata sigs
) external onlyRootChain returns (uint256) {
}
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external onlyStaker(validatorId) {
}
function withdrawDelegatorsReward(uint256 validatorId) public onlyDelegation(validatorId) returns (uint256) {
}
function slash(bytes calldata _slashingInfoList) external returns (uint256) {
require(<FILL_ME>)
RLPReader.RLPItem[] memory slashingInfoList = _slashingInfoList.toRlpItem().toList();
int256 valJailed;
uint256 jailedAmount;
uint256 totalAmount;
uint256 i;
for (; i < slashingInfoList.length; i++) {
RLPReader.RLPItem[] memory slashData = slashingInfoList[i].toList();
uint256 validatorId = slashData[0].toUint();
_updateRewards(validatorId);
uint256 _amount = slashData[1].toUint();
totalAmount = totalAmount.add(_amount);
address delegationContract = validators[validatorId].contractAddress;
if (delegationContract != address(0x0)) {
uint256 delSlashedAmount =
IValidatorShare(delegationContract).slash(
validators[validatorId].amount,
validators[validatorId].delegatedAmount,
_amount
);
_amount = _amount.sub(delSlashedAmount);
}
uint256 validatorStakeSlashed = validators[validatorId].amount.sub(_amount);
validators[validatorId].amount = validatorStakeSlashed;
if (validatorStakeSlashed == 0) {
_unstake(validatorId, currentEpoch);
} else if (slashData[2].toBoolean()) {
jailedAmount = jailedAmount.add(_jail(validatorId, 1));
valJailed++;
}
}
//update timeline
updateTimeline(-int256(totalAmount.add(jailedAmount)), -valJailed, 0);
return totalAmount;
}
function unjail(uint256 validatorId) public onlyStaker(validatorId) {
}
function updateTimeline(
int256 amount,
int256 stakerCount,
uint256 targetEpoch
) internal {
}
function updateValidatorDelegation(bool delegation) external {
}
/**
Private Methods
*/
function _getAndAssertSigner(bytes memory pub) private view returns (address) {
}
function _isValidator(
Status status,
uint256 amount,
uint256 deactivationEpoch,
uint256 _currentEpoch
) private pure returns (bool) {
}
function _fillUnsignedValidators(UnsignedValidatorsContext memory context, address signer)
private
view
returns(UnsignedValidatorsContext memory)
{
}
function _calculateCheckpointReward(
uint256 blockInterval,
uint256 signedStakePower,
uint256 currentTotalStake
) internal returns (uint256) {
}
function _increaseRewardAndAssertConsensus(
uint256 blockInterval,
address proposer,
uint256 signedStakePower,
bytes32 stateRoot,
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256[] memory deactivatedValidators,
uint256 totalDeactivatedValidators
) private returns (uint256) {
}
function _updateValidatorsRewards(
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256 newRewardPerStake
) private {
}
function _updateRewardsAndCommit(
uint256 validatorId,
uint256 currentRewardPerStake,
uint256 newRewardPerStake
) private {
}
function _updateRewards(uint256 validatorId) private {
}
function _getEligibleValidatorReward(
uint256 validatorId,
uint256 validatorStakePower,
uint256 currentRewardPerStake,
uint256 initialRewardPerStake
) private pure returns (uint256) {
}
function _increaseValidatorReward(uint256 validatorId, uint256 reward) private {
}
function _increaseValidatorRewardWithDelegation(
uint256 validatorId,
uint256 validatorsStake,
uint256 delegatedAmount,
uint256 reward
) private {
}
function _getValidatorAndDelegationReward(
uint256 validatorId,
uint256 validatorsStake,
uint256 reward,
uint256 combinedStakePower
) internal view returns (uint256, uint256) {
}
function _evaluateValidatorAndDelegationReward(uint256 validatorId)
private
view
returns (uint256 validatorReward, uint256 delegatorsReward)
{
}
function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
}
function _stakeFor(
address user,
uint256 amount,
bool acceptDelegation,
bytes memory signerPubkey
) internal returns (uint256) {
}
function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
}
function _finalizeCommit() internal {
}
function _liquidateRewards(uint256 validatorId, address validatorUser) private {
}
function _transferToken(address destination, uint256 amount) private {
}
function _transferTokenFrom(
address from,
address destination,
uint256 amount
) private {
}
function _transferAndTopUp(
address user,
address from,
uint256 fee,
uint256 additionalAmount
) private {
}
function _claimFee(address user, uint256 amount) private {
}
function _insertSigner(address newSigner) internal {
}
function _removeSigner(address signerToDelete) internal {
}
}
| Registry(registry).getSlashingManagerAddress()==msg.sender,"Not slash manager" | 94,670 | Registry(registry).getSlashingManagerAddress()==msg.sender |
"Not jailed" | pragma solidity 0.5.17;
contract StakeManager is
StakeManagerStorage,
Initializable,
IStakeManager,
DelegateProxyForwarder,
StakeManagerStorageExtension
{
using SafeMath for uint256;
using Merkle for bytes32;
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
struct UnsignedValidatorsContext {
uint256 unsignedValidatorIndex;
uint256 validatorIndex;
uint256[] unsignedValidators;
address[] validators;
uint256 totalValidators;
}
struct UnstakedValidatorsContext {
uint256 deactivationEpoch;
uint256[] deactivatedValidators;
uint256 validatorIndex;
}
modifier onlyStaker(uint256 validatorId) {
}
function _assertStaker(uint256 validatorId) private view {
}
modifier onlyDelegation(uint256 validatorId) {
}
function _assertDelegation(uint256 validatorId) private view {
}
constructor() public GovernanceLockable(address(0x0)) initializer {}
function initialize(
address _registry,
address _rootchain,
address _token,
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _governance,
address _owner,
address _extensionCode
) external initializer {
}
function isOwner() public view returns (bool) {
}
/**
Public View Methods
*/
function getRegistry() public view returns (address) {
}
/**
@dev Owner of validator slot NFT
*/
function ownerOf(uint256 tokenId) public view returns (address) {
}
function epoch() public view returns (uint256) {
}
function withdrawalDelay() public view returns (uint256) {
}
function validatorStake(uint256 validatorId) public view returns (uint256) {
}
function getValidatorId(address user) public view returns (uint256) {
}
function delegatedAmount(uint256 validatorId) public view returns (uint256) {
}
function delegatorsReward(uint256 validatorId) public view returns (uint256) {
}
function validatorReward(uint256 validatorId) public view returns (uint256) {
}
function currentValidatorSetSize() public view returns (uint256) {
}
function currentValidatorSetTotalStake() public view returns (uint256) {
}
function getValidatorContract(uint256 validatorId) public view returns (address) {
}
function isValidator(uint256 validatorId) public view returns (bool) {
}
/**
Governance Methods
*/
function setDelegationEnabled(bool enabled) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function forceUnstake(uint256 validatorId) external onlyGovernance {
}
function setCurrentEpoch(uint256 _currentEpoch) external onlyGovernance {
}
function setStakingToken(address _token) public onlyGovernance {
}
/**
@dev Change the number of validators required to allow a passed header root
*/
function updateValidatorThreshold(uint256 newThreshold) public onlyGovernance {
}
function updateCheckPointBlockInterval(uint256 _blocks) public onlyGovernance {
}
function updateCheckpointReward(uint256 newReward) public onlyGovernance {
}
function updateCheckpointRewardParams(
uint256 _rewardDecreasePerCheckpoint,
uint256 _maxRewardedCheckpoints,
uint256 _checkpointRewardDelta
) public onlyGovernance {
}
// New implementation upgrade
function migrateValidatorsData(uint256 validatorIdFrom, uint256 validatorIdTo) public onlyOwner {
}
function insertSigners(address[] memory _signers) public onlyOwner {
}
/**
@dev Users must exit before this update or all funds may get lost
*/
function updateValidatorContractAddress(uint256 validatorId, address newContractAddress) public onlyGovernance {
}
function updateDynastyValue(uint256 newDynasty) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function stopAuctions(uint256 forNCheckpoints) public onlyGovernance {
}
function updateProposerBonus(uint256 newProposerBonus) public onlyGovernance {
}
function updateSignerUpdateLimit(uint256 _limit) public onlyGovernance {
}
function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyGovernance {
}
function drainValidatorShares(
uint256 validatorId,
address tokenAddr,
address payable destination,
uint256 amount
) external onlyGovernance {
}
function drain(address destination, uint256 amount) external onlyGovernance {
}
function reinitialize(
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _extensionCode
) external onlyGovernance {
}
/**
Public Methods
*/
function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
}
function claimFee(
uint256 accumFeeAmount,
uint256 index,
bytes memory proof
) public {
}
function totalStakedFor(address user) external view returns (uint256) {
}
function startAuction(
uint256 validatorId,
uint256 amount,
bool _acceptDelegation,
bytes calldata _signerPubkey
) external onlyWhenUnlocked {
}
function confirmAuctionBid(
uint256 validatorId,
uint256 heimdallFee /** for new validator */
) external onlyWhenUnlocked {
}
function dethroneAndStake(
address auctionUser,
uint256 heimdallFee,
uint256 validatorId,
uint256 auctionAmount,
bool acceptDelegation,
bytes calldata signerPubkey
) external {
}
function unstake(uint256 validatorId) external onlyStaker(validatorId) {
}
function transferFunds(
uint256 validatorId,
uint256 amount,
address delegator
) external returns (bool) {
}
function delegationDeposit(
uint256 validatorId,
uint256 amount,
address delegator
) external onlyDelegation(validatorId) returns (bool) {
}
function stakeFor(
address user,
uint256 amount,
uint256 heimdallFee,
bool acceptDelegation,
bytes memory signerPubkey
) public onlyWhenUnlocked {
}
function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
}
function restake(
uint256 validatorId,
uint256 amount,
bool stakeRewards
) public onlyWhenUnlocked onlyStaker(validatorId) {
}
function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
}
function migrateDelegation(
uint256 fromValidatorId,
uint256 toValidatorId,
uint256 amount
) public {
}
function updateValidatorState(uint256 validatorId, int256 amount) public onlyDelegation(validatorId) {
}
function increaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) private {
}
function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public onlyDelegation(validatorId) {
}
function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
}
function checkSignatures(
uint256 blockInterval,
bytes32 voteHash,
bytes32 stateRoot,
address proposer,
uint256[3][] calldata sigs
) external onlyRootChain returns (uint256) {
}
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external onlyStaker(validatorId) {
}
function withdrawDelegatorsReward(uint256 validatorId) public onlyDelegation(validatorId) returns (uint256) {
}
function slash(bytes calldata _slashingInfoList) external returns (uint256) {
}
function unjail(uint256 validatorId) public onlyStaker(validatorId) {
require(<FILL_ME>)
require(validators[validatorId].deactivationEpoch == 0, "Already unstaking");
uint256 _currentEpoch = currentEpoch;
require(validators[validatorId].jailTime <= _currentEpoch, "Incomplete jail period");
uint256 amount = validators[validatorId].amount;
require(amount >= minDeposit);
address delegationContract = validators[validatorId].contractAddress;
if (delegationContract != address(0x0)) {
IValidatorShare(delegationContract).unlock();
}
// undo timeline so that validator is normal validator
updateTimeline(int256(amount.add(validators[validatorId].delegatedAmount)), 1, 0);
validators[validatorId].status = Status.Active;
address signer = validators[validatorId].signer;
logger.logUnjailed(validatorId, signer);
}
function updateTimeline(
int256 amount,
int256 stakerCount,
uint256 targetEpoch
) internal {
}
function updateValidatorDelegation(bool delegation) external {
}
/**
Private Methods
*/
function _getAndAssertSigner(bytes memory pub) private view returns (address) {
}
function _isValidator(
Status status,
uint256 amount,
uint256 deactivationEpoch,
uint256 _currentEpoch
) private pure returns (bool) {
}
function _fillUnsignedValidators(UnsignedValidatorsContext memory context, address signer)
private
view
returns(UnsignedValidatorsContext memory)
{
}
function _calculateCheckpointReward(
uint256 blockInterval,
uint256 signedStakePower,
uint256 currentTotalStake
) internal returns (uint256) {
}
function _increaseRewardAndAssertConsensus(
uint256 blockInterval,
address proposer,
uint256 signedStakePower,
bytes32 stateRoot,
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256[] memory deactivatedValidators,
uint256 totalDeactivatedValidators
) private returns (uint256) {
}
function _updateValidatorsRewards(
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256 newRewardPerStake
) private {
}
function _updateRewardsAndCommit(
uint256 validatorId,
uint256 currentRewardPerStake,
uint256 newRewardPerStake
) private {
}
function _updateRewards(uint256 validatorId) private {
}
function _getEligibleValidatorReward(
uint256 validatorId,
uint256 validatorStakePower,
uint256 currentRewardPerStake,
uint256 initialRewardPerStake
) private pure returns (uint256) {
}
function _increaseValidatorReward(uint256 validatorId, uint256 reward) private {
}
function _increaseValidatorRewardWithDelegation(
uint256 validatorId,
uint256 validatorsStake,
uint256 delegatedAmount,
uint256 reward
) private {
}
function _getValidatorAndDelegationReward(
uint256 validatorId,
uint256 validatorsStake,
uint256 reward,
uint256 combinedStakePower
) internal view returns (uint256, uint256) {
}
function _evaluateValidatorAndDelegationReward(uint256 validatorId)
private
view
returns (uint256 validatorReward, uint256 delegatorsReward)
{
}
function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
}
function _stakeFor(
address user,
uint256 amount,
bool acceptDelegation,
bytes memory signerPubkey
) internal returns (uint256) {
}
function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
}
function _finalizeCommit() internal {
}
function _liquidateRewards(uint256 validatorId, address validatorUser) private {
}
function _transferToken(address destination, uint256 amount) private {
}
function _transferTokenFrom(
address from,
address destination,
uint256 amount
) private {
}
function _transferAndTopUp(
address user,
address from,
uint256 fee,
uint256 additionalAmount
) private {
}
function _claimFee(address user, uint256 amount) private {
}
function _insertSigner(address newSigner) internal {
}
function _removeSigner(address signerToDelete) internal {
}
}
| validators[validatorId].status==Status.Locked,"Not jailed" | 94,670 | validators[validatorId].status==Status.Locked |
"Incomplete jail period" | pragma solidity 0.5.17;
contract StakeManager is
StakeManagerStorage,
Initializable,
IStakeManager,
DelegateProxyForwarder,
StakeManagerStorageExtension
{
using SafeMath for uint256;
using Merkle for bytes32;
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
struct UnsignedValidatorsContext {
uint256 unsignedValidatorIndex;
uint256 validatorIndex;
uint256[] unsignedValidators;
address[] validators;
uint256 totalValidators;
}
struct UnstakedValidatorsContext {
uint256 deactivationEpoch;
uint256[] deactivatedValidators;
uint256 validatorIndex;
}
modifier onlyStaker(uint256 validatorId) {
}
function _assertStaker(uint256 validatorId) private view {
}
modifier onlyDelegation(uint256 validatorId) {
}
function _assertDelegation(uint256 validatorId) private view {
}
constructor() public GovernanceLockable(address(0x0)) initializer {}
function initialize(
address _registry,
address _rootchain,
address _token,
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _governance,
address _owner,
address _extensionCode
) external initializer {
}
function isOwner() public view returns (bool) {
}
/**
Public View Methods
*/
function getRegistry() public view returns (address) {
}
/**
@dev Owner of validator slot NFT
*/
function ownerOf(uint256 tokenId) public view returns (address) {
}
function epoch() public view returns (uint256) {
}
function withdrawalDelay() public view returns (uint256) {
}
function validatorStake(uint256 validatorId) public view returns (uint256) {
}
function getValidatorId(address user) public view returns (uint256) {
}
function delegatedAmount(uint256 validatorId) public view returns (uint256) {
}
function delegatorsReward(uint256 validatorId) public view returns (uint256) {
}
function validatorReward(uint256 validatorId) public view returns (uint256) {
}
function currentValidatorSetSize() public view returns (uint256) {
}
function currentValidatorSetTotalStake() public view returns (uint256) {
}
function getValidatorContract(uint256 validatorId) public view returns (address) {
}
function isValidator(uint256 validatorId) public view returns (bool) {
}
/**
Governance Methods
*/
function setDelegationEnabled(bool enabled) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function forceUnstake(uint256 validatorId) external onlyGovernance {
}
function setCurrentEpoch(uint256 _currentEpoch) external onlyGovernance {
}
function setStakingToken(address _token) public onlyGovernance {
}
/**
@dev Change the number of validators required to allow a passed header root
*/
function updateValidatorThreshold(uint256 newThreshold) public onlyGovernance {
}
function updateCheckPointBlockInterval(uint256 _blocks) public onlyGovernance {
}
function updateCheckpointReward(uint256 newReward) public onlyGovernance {
}
function updateCheckpointRewardParams(
uint256 _rewardDecreasePerCheckpoint,
uint256 _maxRewardedCheckpoints,
uint256 _checkpointRewardDelta
) public onlyGovernance {
}
// New implementation upgrade
function migrateValidatorsData(uint256 validatorIdFrom, uint256 validatorIdTo) public onlyOwner {
}
function insertSigners(address[] memory _signers) public onlyOwner {
}
/**
@dev Users must exit before this update or all funds may get lost
*/
function updateValidatorContractAddress(uint256 validatorId, address newContractAddress) public onlyGovernance {
}
function updateDynastyValue(uint256 newDynasty) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function stopAuctions(uint256 forNCheckpoints) public onlyGovernance {
}
function updateProposerBonus(uint256 newProposerBonus) public onlyGovernance {
}
function updateSignerUpdateLimit(uint256 _limit) public onlyGovernance {
}
function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyGovernance {
}
function drainValidatorShares(
uint256 validatorId,
address tokenAddr,
address payable destination,
uint256 amount
) external onlyGovernance {
}
function drain(address destination, uint256 amount) external onlyGovernance {
}
function reinitialize(
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _extensionCode
) external onlyGovernance {
}
/**
Public Methods
*/
function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
}
function claimFee(
uint256 accumFeeAmount,
uint256 index,
bytes memory proof
) public {
}
function totalStakedFor(address user) external view returns (uint256) {
}
function startAuction(
uint256 validatorId,
uint256 amount,
bool _acceptDelegation,
bytes calldata _signerPubkey
) external onlyWhenUnlocked {
}
function confirmAuctionBid(
uint256 validatorId,
uint256 heimdallFee /** for new validator */
) external onlyWhenUnlocked {
}
function dethroneAndStake(
address auctionUser,
uint256 heimdallFee,
uint256 validatorId,
uint256 auctionAmount,
bool acceptDelegation,
bytes calldata signerPubkey
) external {
}
function unstake(uint256 validatorId) external onlyStaker(validatorId) {
}
function transferFunds(
uint256 validatorId,
uint256 amount,
address delegator
) external returns (bool) {
}
function delegationDeposit(
uint256 validatorId,
uint256 amount,
address delegator
) external onlyDelegation(validatorId) returns (bool) {
}
function stakeFor(
address user,
uint256 amount,
uint256 heimdallFee,
bool acceptDelegation,
bytes memory signerPubkey
) public onlyWhenUnlocked {
}
function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
}
function restake(
uint256 validatorId,
uint256 amount,
bool stakeRewards
) public onlyWhenUnlocked onlyStaker(validatorId) {
}
function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
}
function migrateDelegation(
uint256 fromValidatorId,
uint256 toValidatorId,
uint256 amount
) public {
}
function updateValidatorState(uint256 validatorId, int256 amount) public onlyDelegation(validatorId) {
}
function increaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) private {
}
function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public onlyDelegation(validatorId) {
}
function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
}
function checkSignatures(
uint256 blockInterval,
bytes32 voteHash,
bytes32 stateRoot,
address proposer,
uint256[3][] calldata sigs
) external onlyRootChain returns (uint256) {
}
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external onlyStaker(validatorId) {
}
function withdrawDelegatorsReward(uint256 validatorId) public onlyDelegation(validatorId) returns (uint256) {
}
function slash(bytes calldata _slashingInfoList) external returns (uint256) {
}
function unjail(uint256 validatorId) public onlyStaker(validatorId) {
require(validators[validatorId].status == Status.Locked, "Not jailed");
require(validators[validatorId].deactivationEpoch == 0, "Already unstaking");
uint256 _currentEpoch = currentEpoch;
require(<FILL_ME>)
uint256 amount = validators[validatorId].amount;
require(amount >= minDeposit);
address delegationContract = validators[validatorId].contractAddress;
if (delegationContract != address(0x0)) {
IValidatorShare(delegationContract).unlock();
}
// undo timeline so that validator is normal validator
updateTimeline(int256(amount.add(validators[validatorId].delegatedAmount)), 1, 0);
validators[validatorId].status = Status.Active;
address signer = validators[validatorId].signer;
logger.logUnjailed(validatorId, signer);
}
function updateTimeline(
int256 amount,
int256 stakerCount,
uint256 targetEpoch
) internal {
}
function updateValidatorDelegation(bool delegation) external {
}
/**
Private Methods
*/
function _getAndAssertSigner(bytes memory pub) private view returns (address) {
}
function _isValidator(
Status status,
uint256 amount,
uint256 deactivationEpoch,
uint256 _currentEpoch
) private pure returns (bool) {
}
function _fillUnsignedValidators(UnsignedValidatorsContext memory context, address signer)
private
view
returns(UnsignedValidatorsContext memory)
{
}
function _calculateCheckpointReward(
uint256 blockInterval,
uint256 signedStakePower,
uint256 currentTotalStake
) internal returns (uint256) {
}
function _increaseRewardAndAssertConsensus(
uint256 blockInterval,
address proposer,
uint256 signedStakePower,
bytes32 stateRoot,
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256[] memory deactivatedValidators,
uint256 totalDeactivatedValidators
) private returns (uint256) {
}
function _updateValidatorsRewards(
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256 newRewardPerStake
) private {
}
function _updateRewardsAndCommit(
uint256 validatorId,
uint256 currentRewardPerStake,
uint256 newRewardPerStake
) private {
}
function _updateRewards(uint256 validatorId) private {
}
function _getEligibleValidatorReward(
uint256 validatorId,
uint256 validatorStakePower,
uint256 currentRewardPerStake,
uint256 initialRewardPerStake
) private pure returns (uint256) {
}
function _increaseValidatorReward(uint256 validatorId, uint256 reward) private {
}
function _increaseValidatorRewardWithDelegation(
uint256 validatorId,
uint256 validatorsStake,
uint256 delegatedAmount,
uint256 reward
) private {
}
function _getValidatorAndDelegationReward(
uint256 validatorId,
uint256 validatorsStake,
uint256 reward,
uint256 combinedStakePower
) internal view returns (uint256, uint256) {
}
function _evaluateValidatorAndDelegationReward(uint256 validatorId)
private
view
returns (uint256 validatorReward, uint256 delegatorsReward)
{
}
function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
}
function _stakeFor(
address user,
uint256 amount,
bool acceptDelegation,
bytes memory signerPubkey
) internal returns (uint256) {
}
function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
}
function _finalizeCommit() internal {
}
function _liquidateRewards(uint256 validatorId, address validatorUser) private {
}
function _transferToken(address destination, uint256 amount) private {
}
function _transferTokenFrom(
address from,
address destination,
uint256 amount
) private {
}
function _transferAndTopUp(
address user,
address from,
uint256 fee,
uint256 additionalAmount
) private {
}
function _claimFee(address user, uint256 amount) private {
}
function _insertSigner(address newSigner) internal {
}
function _removeSigner(address signerToDelete) internal {
}
}
| validators[validatorId].jailTime<=_currentEpoch,"Incomplete jail period" | 94,670 | validators[validatorId].jailTime<=_currentEpoch |
"not validator" | pragma solidity 0.5.17;
contract StakeManager is
StakeManagerStorage,
Initializable,
IStakeManager,
DelegateProxyForwarder,
StakeManagerStorageExtension
{
using SafeMath for uint256;
using Merkle for bytes32;
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
struct UnsignedValidatorsContext {
uint256 unsignedValidatorIndex;
uint256 validatorIndex;
uint256[] unsignedValidators;
address[] validators;
uint256 totalValidators;
}
struct UnstakedValidatorsContext {
uint256 deactivationEpoch;
uint256[] deactivatedValidators;
uint256 validatorIndex;
}
modifier onlyStaker(uint256 validatorId) {
}
function _assertStaker(uint256 validatorId) private view {
}
modifier onlyDelegation(uint256 validatorId) {
}
function _assertDelegation(uint256 validatorId) private view {
}
constructor() public GovernanceLockable(address(0x0)) initializer {}
function initialize(
address _registry,
address _rootchain,
address _token,
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _governance,
address _owner,
address _extensionCode
) external initializer {
}
function isOwner() public view returns (bool) {
}
/**
Public View Methods
*/
function getRegistry() public view returns (address) {
}
/**
@dev Owner of validator slot NFT
*/
function ownerOf(uint256 tokenId) public view returns (address) {
}
function epoch() public view returns (uint256) {
}
function withdrawalDelay() public view returns (uint256) {
}
function validatorStake(uint256 validatorId) public view returns (uint256) {
}
function getValidatorId(address user) public view returns (uint256) {
}
function delegatedAmount(uint256 validatorId) public view returns (uint256) {
}
function delegatorsReward(uint256 validatorId) public view returns (uint256) {
}
function validatorReward(uint256 validatorId) public view returns (uint256) {
}
function currentValidatorSetSize() public view returns (uint256) {
}
function currentValidatorSetTotalStake() public view returns (uint256) {
}
function getValidatorContract(uint256 validatorId) public view returns (address) {
}
function isValidator(uint256 validatorId) public view returns (bool) {
}
/**
Governance Methods
*/
function setDelegationEnabled(bool enabled) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function forceUnstake(uint256 validatorId) external onlyGovernance {
}
function setCurrentEpoch(uint256 _currentEpoch) external onlyGovernance {
}
function setStakingToken(address _token) public onlyGovernance {
}
/**
@dev Change the number of validators required to allow a passed header root
*/
function updateValidatorThreshold(uint256 newThreshold) public onlyGovernance {
}
function updateCheckPointBlockInterval(uint256 _blocks) public onlyGovernance {
}
function updateCheckpointReward(uint256 newReward) public onlyGovernance {
}
function updateCheckpointRewardParams(
uint256 _rewardDecreasePerCheckpoint,
uint256 _maxRewardedCheckpoints,
uint256 _checkpointRewardDelta
) public onlyGovernance {
}
// New implementation upgrade
function migrateValidatorsData(uint256 validatorIdFrom, uint256 validatorIdTo) public onlyOwner {
}
function insertSigners(address[] memory _signers) public onlyOwner {
}
/**
@dev Users must exit before this update or all funds may get lost
*/
function updateValidatorContractAddress(uint256 validatorId, address newContractAddress) public onlyGovernance {
}
function updateDynastyValue(uint256 newDynasty) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function stopAuctions(uint256 forNCheckpoints) public onlyGovernance {
}
function updateProposerBonus(uint256 newProposerBonus) public onlyGovernance {
}
function updateSignerUpdateLimit(uint256 _limit) public onlyGovernance {
}
function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyGovernance {
}
function drainValidatorShares(
uint256 validatorId,
address tokenAddr,
address payable destination,
uint256 amount
) external onlyGovernance {
}
function drain(address destination, uint256 amount) external onlyGovernance {
}
function reinitialize(
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _extensionCode
) external onlyGovernance {
}
/**
Public Methods
*/
function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
}
function claimFee(
uint256 accumFeeAmount,
uint256 index,
bytes memory proof
) public {
}
function totalStakedFor(address user) external view returns (uint256) {
}
function startAuction(
uint256 validatorId,
uint256 amount,
bool _acceptDelegation,
bytes calldata _signerPubkey
) external onlyWhenUnlocked {
}
function confirmAuctionBid(
uint256 validatorId,
uint256 heimdallFee /** for new validator */
) external onlyWhenUnlocked {
}
function dethroneAndStake(
address auctionUser,
uint256 heimdallFee,
uint256 validatorId,
uint256 auctionAmount,
bool acceptDelegation,
bytes calldata signerPubkey
) external {
}
function unstake(uint256 validatorId) external onlyStaker(validatorId) {
}
function transferFunds(
uint256 validatorId,
uint256 amount,
address delegator
) external returns (bool) {
}
function delegationDeposit(
uint256 validatorId,
uint256 amount,
address delegator
) external onlyDelegation(validatorId) returns (bool) {
}
function stakeFor(
address user,
uint256 amount,
uint256 heimdallFee,
bool acceptDelegation,
bytes memory signerPubkey
) public onlyWhenUnlocked {
}
function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
}
function restake(
uint256 validatorId,
uint256 amount,
bool stakeRewards
) public onlyWhenUnlocked onlyStaker(validatorId) {
}
function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
}
function migrateDelegation(
uint256 fromValidatorId,
uint256 toValidatorId,
uint256 amount
) public {
}
function updateValidatorState(uint256 validatorId, int256 amount) public onlyDelegation(validatorId) {
}
function increaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) private {
}
function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public onlyDelegation(validatorId) {
}
function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
}
function checkSignatures(
uint256 blockInterval,
bytes32 voteHash,
bytes32 stateRoot,
address proposer,
uint256[3][] calldata sigs
) external onlyRootChain returns (uint256) {
}
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external onlyStaker(validatorId) {
}
function withdrawDelegatorsReward(uint256 validatorId) public onlyDelegation(validatorId) returns (uint256) {
}
function slash(bytes calldata _slashingInfoList) external returns (uint256) {
}
function unjail(uint256 validatorId) public onlyStaker(validatorId) {
}
function updateTimeline(
int256 amount,
int256 stakerCount,
uint256 targetEpoch
) internal {
}
function updateValidatorDelegation(bool delegation) external {
uint256 validatorId = signerToValidator[msg.sender];
require(<FILL_ME>)
address contractAddr = validators[validatorId].contractAddress;
require(contractAddr != address(0x0), "Delegation is disabled");
IValidatorShare(contractAddr).updateDelegation(delegation);
}
/**
Private Methods
*/
function _getAndAssertSigner(bytes memory pub) private view returns (address) {
}
function _isValidator(
Status status,
uint256 amount,
uint256 deactivationEpoch,
uint256 _currentEpoch
) private pure returns (bool) {
}
function _fillUnsignedValidators(UnsignedValidatorsContext memory context, address signer)
private
view
returns(UnsignedValidatorsContext memory)
{
}
function _calculateCheckpointReward(
uint256 blockInterval,
uint256 signedStakePower,
uint256 currentTotalStake
) internal returns (uint256) {
}
function _increaseRewardAndAssertConsensus(
uint256 blockInterval,
address proposer,
uint256 signedStakePower,
bytes32 stateRoot,
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256[] memory deactivatedValidators,
uint256 totalDeactivatedValidators
) private returns (uint256) {
}
function _updateValidatorsRewards(
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256 newRewardPerStake
) private {
}
function _updateRewardsAndCommit(
uint256 validatorId,
uint256 currentRewardPerStake,
uint256 newRewardPerStake
) private {
}
function _updateRewards(uint256 validatorId) private {
}
function _getEligibleValidatorReward(
uint256 validatorId,
uint256 validatorStakePower,
uint256 currentRewardPerStake,
uint256 initialRewardPerStake
) private pure returns (uint256) {
}
function _increaseValidatorReward(uint256 validatorId, uint256 reward) private {
}
function _increaseValidatorRewardWithDelegation(
uint256 validatorId,
uint256 validatorsStake,
uint256 delegatedAmount,
uint256 reward
) private {
}
function _getValidatorAndDelegationReward(
uint256 validatorId,
uint256 validatorsStake,
uint256 reward,
uint256 combinedStakePower
) internal view returns (uint256, uint256) {
}
function _evaluateValidatorAndDelegationReward(uint256 validatorId)
private
view
returns (uint256 validatorReward, uint256 delegatorsReward)
{
}
function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
}
function _stakeFor(
address user,
uint256 amount,
bool acceptDelegation,
bytes memory signerPubkey
) internal returns (uint256) {
}
function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
}
function _finalizeCommit() internal {
}
function _liquidateRewards(uint256 validatorId, address validatorUser) private {
}
function _transferToken(address destination, uint256 amount) private {
}
function _transferTokenFrom(
address from,
address destination,
uint256 amount
) private {
}
function _transferAndTopUp(
address user,
address from,
uint256 fee,
uint256 additionalAmount
) private {
}
function _claimFee(address user, uint256 amount) private {
}
function _insertSigner(address newSigner) internal {
}
function _removeSigner(address signerToDelete) internal {
}
}
| _isValidator(validators[validatorId].status,validators[validatorId].amount,validators[validatorId].deactivationEpoch,currentEpoch),"not validator" | 94,670 | _isValidator(validators[validatorId].status,validators[validatorId].amount,validators[validatorId].deactivationEpoch,currentEpoch) |
"transfer failed" | pragma solidity 0.5.17;
contract StakeManager is
StakeManagerStorage,
Initializable,
IStakeManager,
DelegateProxyForwarder,
StakeManagerStorageExtension
{
using SafeMath for uint256;
using Merkle for bytes32;
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
struct UnsignedValidatorsContext {
uint256 unsignedValidatorIndex;
uint256 validatorIndex;
uint256[] unsignedValidators;
address[] validators;
uint256 totalValidators;
}
struct UnstakedValidatorsContext {
uint256 deactivationEpoch;
uint256[] deactivatedValidators;
uint256 validatorIndex;
}
modifier onlyStaker(uint256 validatorId) {
}
function _assertStaker(uint256 validatorId) private view {
}
modifier onlyDelegation(uint256 validatorId) {
}
function _assertDelegation(uint256 validatorId) private view {
}
constructor() public GovernanceLockable(address(0x0)) initializer {}
function initialize(
address _registry,
address _rootchain,
address _token,
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _governance,
address _owner,
address _extensionCode
) external initializer {
}
function isOwner() public view returns (bool) {
}
/**
Public View Methods
*/
function getRegistry() public view returns (address) {
}
/**
@dev Owner of validator slot NFT
*/
function ownerOf(uint256 tokenId) public view returns (address) {
}
function epoch() public view returns (uint256) {
}
function withdrawalDelay() public view returns (uint256) {
}
function validatorStake(uint256 validatorId) public view returns (uint256) {
}
function getValidatorId(address user) public view returns (uint256) {
}
function delegatedAmount(uint256 validatorId) public view returns (uint256) {
}
function delegatorsReward(uint256 validatorId) public view returns (uint256) {
}
function validatorReward(uint256 validatorId) public view returns (uint256) {
}
function currentValidatorSetSize() public view returns (uint256) {
}
function currentValidatorSetTotalStake() public view returns (uint256) {
}
function getValidatorContract(uint256 validatorId) public view returns (address) {
}
function isValidator(uint256 validatorId) public view returns (bool) {
}
/**
Governance Methods
*/
function setDelegationEnabled(bool enabled) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function forceUnstake(uint256 validatorId) external onlyGovernance {
}
function setCurrentEpoch(uint256 _currentEpoch) external onlyGovernance {
}
function setStakingToken(address _token) public onlyGovernance {
}
/**
@dev Change the number of validators required to allow a passed header root
*/
function updateValidatorThreshold(uint256 newThreshold) public onlyGovernance {
}
function updateCheckPointBlockInterval(uint256 _blocks) public onlyGovernance {
}
function updateCheckpointReward(uint256 newReward) public onlyGovernance {
}
function updateCheckpointRewardParams(
uint256 _rewardDecreasePerCheckpoint,
uint256 _maxRewardedCheckpoints,
uint256 _checkpointRewardDelta
) public onlyGovernance {
}
// New implementation upgrade
function migrateValidatorsData(uint256 validatorIdFrom, uint256 validatorIdTo) public onlyOwner {
}
function insertSigners(address[] memory _signers) public onlyOwner {
}
/**
@dev Users must exit before this update or all funds may get lost
*/
function updateValidatorContractAddress(uint256 validatorId, address newContractAddress) public onlyGovernance {
}
function updateDynastyValue(uint256 newDynasty) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function stopAuctions(uint256 forNCheckpoints) public onlyGovernance {
}
function updateProposerBonus(uint256 newProposerBonus) public onlyGovernance {
}
function updateSignerUpdateLimit(uint256 _limit) public onlyGovernance {
}
function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyGovernance {
}
function drainValidatorShares(
uint256 validatorId,
address tokenAddr,
address payable destination,
uint256 amount
) external onlyGovernance {
}
function drain(address destination, uint256 amount) external onlyGovernance {
}
function reinitialize(
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _extensionCode
) external onlyGovernance {
}
/**
Public Methods
*/
function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
}
function claimFee(
uint256 accumFeeAmount,
uint256 index,
bytes memory proof
) public {
}
function totalStakedFor(address user) external view returns (uint256) {
}
function startAuction(
uint256 validatorId,
uint256 amount,
bool _acceptDelegation,
bytes calldata _signerPubkey
) external onlyWhenUnlocked {
}
function confirmAuctionBid(
uint256 validatorId,
uint256 heimdallFee /** for new validator */
) external onlyWhenUnlocked {
}
function dethroneAndStake(
address auctionUser,
uint256 heimdallFee,
uint256 validatorId,
uint256 auctionAmount,
bool acceptDelegation,
bytes calldata signerPubkey
) external {
}
function unstake(uint256 validatorId) external onlyStaker(validatorId) {
}
function transferFunds(
uint256 validatorId,
uint256 amount,
address delegator
) external returns (bool) {
}
function delegationDeposit(
uint256 validatorId,
uint256 amount,
address delegator
) external onlyDelegation(validatorId) returns (bool) {
}
function stakeFor(
address user,
uint256 amount,
uint256 heimdallFee,
bool acceptDelegation,
bytes memory signerPubkey
) public onlyWhenUnlocked {
}
function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
}
function restake(
uint256 validatorId,
uint256 amount,
bool stakeRewards
) public onlyWhenUnlocked onlyStaker(validatorId) {
}
function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
}
function migrateDelegation(
uint256 fromValidatorId,
uint256 toValidatorId,
uint256 amount
) public {
}
function updateValidatorState(uint256 validatorId, int256 amount) public onlyDelegation(validatorId) {
}
function increaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) private {
}
function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public onlyDelegation(validatorId) {
}
function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
}
function checkSignatures(
uint256 blockInterval,
bytes32 voteHash,
bytes32 stateRoot,
address proposer,
uint256[3][] calldata sigs
) external onlyRootChain returns (uint256) {
}
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external onlyStaker(validatorId) {
}
function withdrawDelegatorsReward(uint256 validatorId) public onlyDelegation(validatorId) returns (uint256) {
}
function slash(bytes calldata _slashingInfoList) external returns (uint256) {
}
function unjail(uint256 validatorId) public onlyStaker(validatorId) {
}
function updateTimeline(
int256 amount,
int256 stakerCount,
uint256 targetEpoch
) internal {
}
function updateValidatorDelegation(bool delegation) external {
}
/**
Private Methods
*/
function _getAndAssertSigner(bytes memory pub) private view returns (address) {
}
function _isValidator(
Status status,
uint256 amount,
uint256 deactivationEpoch,
uint256 _currentEpoch
) private pure returns (bool) {
}
function _fillUnsignedValidators(UnsignedValidatorsContext memory context, address signer)
private
view
returns(UnsignedValidatorsContext memory)
{
}
function _calculateCheckpointReward(
uint256 blockInterval,
uint256 signedStakePower,
uint256 currentTotalStake
) internal returns (uint256) {
}
function _increaseRewardAndAssertConsensus(
uint256 blockInterval,
address proposer,
uint256 signedStakePower,
bytes32 stateRoot,
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256[] memory deactivatedValidators,
uint256 totalDeactivatedValidators
) private returns (uint256) {
}
function _updateValidatorsRewards(
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256 newRewardPerStake
) private {
}
function _updateRewardsAndCommit(
uint256 validatorId,
uint256 currentRewardPerStake,
uint256 newRewardPerStake
) private {
}
function _updateRewards(uint256 validatorId) private {
}
function _getEligibleValidatorReward(
uint256 validatorId,
uint256 validatorStakePower,
uint256 currentRewardPerStake,
uint256 initialRewardPerStake
) private pure returns (uint256) {
}
function _increaseValidatorReward(uint256 validatorId, uint256 reward) private {
}
function _increaseValidatorRewardWithDelegation(
uint256 validatorId,
uint256 validatorsStake,
uint256 delegatedAmount,
uint256 reward
) private {
}
function _getValidatorAndDelegationReward(
uint256 validatorId,
uint256 validatorsStake,
uint256 reward,
uint256 combinedStakePower
) internal view returns (uint256, uint256) {
}
function _evaluateValidatorAndDelegationReward(uint256 validatorId)
private
view
returns (uint256 validatorReward, uint256 delegatorsReward)
{
}
function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
}
function _stakeFor(
address user,
uint256 amount,
bool acceptDelegation,
bytes memory signerPubkey
) internal returns (uint256) {
}
function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
}
function _finalizeCommit() internal {
}
function _liquidateRewards(uint256 validatorId, address validatorUser) private {
}
function _transferToken(address destination, uint256 amount) private {
require(<FILL_ME>)
}
function _transferTokenFrom(
address from,
address destination,
uint256 amount
) private {
}
function _transferAndTopUp(
address user,
address from,
uint256 fee,
uint256 additionalAmount
) private {
}
function _claimFee(address user, uint256 amount) private {
}
function _insertSigner(address newSigner) internal {
}
function _removeSigner(address signerToDelete) internal {
}
}
| token.transfer(destination,amount),"transfer failed" | 94,670 | token.transfer(destination,amount) |
"transfer from failed" | pragma solidity 0.5.17;
contract StakeManager is
StakeManagerStorage,
Initializable,
IStakeManager,
DelegateProxyForwarder,
StakeManagerStorageExtension
{
using SafeMath for uint256;
using Merkle for bytes32;
using RLPReader for bytes;
using RLPReader for RLPReader.RLPItem;
struct UnsignedValidatorsContext {
uint256 unsignedValidatorIndex;
uint256 validatorIndex;
uint256[] unsignedValidators;
address[] validators;
uint256 totalValidators;
}
struct UnstakedValidatorsContext {
uint256 deactivationEpoch;
uint256[] deactivatedValidators;
uint256 validatorIndex;
}
modifier onlyStaker(uint256 validatorId) {
}
function _assertStaker(uint256 validatorId) private view {
}
modifier onlyDelegation(uint256 validatorId) {
}
function _assertDelegation(uint256 validatorId) private view {
}
constructor() public GovernanceLockable(address(0x0)) initializer {}
function initialize(
address _registry,
address _rootchain,
address _token,
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _governance,
address _owner,
address _extensionCode
) external initializer {
}
function isOwner() public view returns (bool) {
}
/**
Public View Methods
*/
function getRegistry() public view returns (address) {
}
/**
@dev Owner of validator slot NFT
*/
function ownerOf(uint256 tokenId) public view returns (address) {
}
function epoch() public view returns (uint256) {
}
function withdrawalDelay() public view returns (uint256) {
}
function validatorStake(uint256 validatorId) public view returns (uint256) {
}
function getValidatorId(address user) public view returns (uint256) {
}
function delegatedAmount(uint256 validatorId) public view returns (uint256) {
}
function delegatorsReward(uint256 validatorId) public view returns (uint256) {
}
function validatorReward(uint256 validatorId) public view returns (uint256) {
}
function currentValidatorSetSize() public view returns (uint256) {
}
function currentValidatorSetTotalStake() public view returns (uint256) {
}
function getValidatorContract(uint256 validatorId) public view returns (address) {
}
function isValidator(uint256 validatorId) public view returns (bool) {
}
/**
Governance Methods
*/
function setDelegationEnabled(bool enabled) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function forceUnstake(uint256 validatorId) external onlyGovernance {
}
function setCurrentEpoch(uint256 _currentEpoch) external onlyGovernance {
}
function setStakingToken(address _token) public onlyGovernance {
}
/**
@dev Change the number of validators required to allow a passed header root
*/
function updateValidatorThreshold(uint256 newThreshold) public onlyGovernance {
}
function updateCheckPointBlockInterval(uint256 _blocks) public onlyGovernance {
}
function updateCheckpointReward(uint256 newReward) public onlyGovernance {
}
function updateCheckpointRewardParams(
uint256 _rewardDecreasePerCheckpoint,
uint256 _maxRewardedCheckpoints,
uint256 _checkpointRewardDelta
) public onlyGovernance {
}
// New implementation upgrade
function migrateValidatorsData(uint256 validatorIdFrom, uint256 validatorIdTo) public onlyOwner {
}
function insertSigners(address[] memory _signers) public onlyOwner {
}
/**
@dev Users must exit before this update or all funds may get lost
*/
function updateValidatorContractAddress(uint256 validatorId, address newContractAddress) public onlyGovernance {
}
function updateDynastyValue(uint256 newDynasty) public onlyGovernance {
}
// Housekeeping function. @todo remove later
function stopAuctions(uint256 forNCheckpoints) public onlyGovernance {
}
function updateProposerBonus(uint256 newProposerBonus) public onlyGovernance {
}
function updateSignerUpdateLimit(uint256 _limit) public onlyGovernance {
}
function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyGovernance {
}
function drainValidatorShares(
uint256 validatorId,
address tokenAddr,
address payable destination,
uint256 amount
) external onlyGovernance {
}
function drain(address destination, uint256 amount) external onlyGovernance {
}
function reinitialize(
address _NFTContract,
address _stakingLogger,
address _validatorShareFactory,
address _extensionCode
) external onlyGovernance {
}
/**
Public Methods
*/
function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
}
function claimFee(
uint256 accumFeeAmount,
uint256 index,
bytes memory proof
) public {
}
function totalStakedFor(address user) external view returns (uint256) {
}
function startAuction(
uint256 validatorId,
uint256 amount,
bool _acceptDelegation,
bytes calldata _signerPubkey
) external onlyWhenUnlocked {
}
function confirmAuctionBid(
uint256 validatorId,
uint256 heimdallFee /** for new validator */
) external onlyWhenUnlocked {
}
function dethroneAndStake(
address auctionUser,
uint256 heimdallFee,
uint256 validatorId,
uint256 auctionAmount,
bool acceptDelegation,
bytes calldata signerPubkey
) external {
}
function unstake(uint256 validatorId) external onlyStaker(validatorId) {
}
function transferFunds(
uint256 validatorId,
uint256 amount,
address delegator
) external returns (bool) {
}
function delegationDeposit(
uint256 validatorId,
uint256 amount,
address delegator
) external onlyDelegation(validatorId) returns (bool) {
}
function stakeFor(
address user,
uint256 amount,
uint256 heimdallFee,
bool acceptDelegation,
bytes memory signerPubkey
) public onlyWhenUnlocked {
}
function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
}
function restake(
uint256 validatorId,
uint256 amount,
bool stakeRewards
) public onlyWhenUnlocked onlyStaker(validatorId) {
}
function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
}
function migrateDelegation(
uint256 fromValidatorId,
uint256 toValidatorId,
uint256 amount
) public {
}
function updateValidatorState(uint256 validatorId, int256 amount) public onlyDelegation(validatorId) {
}
function increaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) private {
}
function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public onlyDelegation(validatorId) {
}
function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
}
function checkSignatures(
uint256 blockInterval,
bytes32 voteHash,
bytes32 stateRoot,
address proposer,
uint256[3][] calldata sigs
) external onlyRootChain returns (uint256) {
}
function updateCommissionRate(uint256 validatorId, uint256 newCommissionRate) external onlyStaker(validatorId) {
}
function withdrawDelegatorsReward(uint256 validatorId) public onlyDelegation(validatorId) returns (uint256) {
}
function slash(bytes calldata _slashingInfoList) external returns (uint256) {
}
function unjail(uint256 validatorId) public onlyStaker(validatorId) {
}
function updateTimeline(
int256 amount,
int256 stakerCount,
uint256 targetEpoch
) internal {
}
function updateValidatorDelegation(bool delegation) external {
}
/**
Private Methods
*/
function _getAndAssertSigner(bytes memory pub) private view returns (address) {
}
function _isValidator(
Status status,
uint256 amount,
uint256 deactivationEpoch,
uint256 _currentEpoch
) private pure returns (bool) {
}
function _fillUnsignedValidators(UnsignedValidatorsContext memory context, address signer)
private
view
returns(UnsignedValidatorsContext memory)
{
}
function _calculateCheckpointReward(
uint256 blockInterval,
uint256 signedStakePower,
uint256 currentTotalStake
) internal returns (uint256) {
}
function _increaseRewardAndAssertConsensus(
uint256 blockInterval,
address proposer,
uint256 signedStakePower,
bytes32 stateRoot,
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256[] memory deactivatedValidators,
uint256 totalDeactivatedValidators
) private returns (uint256) {
}
function _updateValidatorsRewards(
uint256[] memory unsignedValidators,
uint256 totalUnsignedValidators,
uint256 newRewardPerStake
) private {
}
function _updateRewardsAndCommit(
uint256 validatorId,
uint256 currentRewardPerStake,
uint256 newRewardPerStake
) private {
}
function _updateRewards(uint256 validatorId) private {
}
function _getEligibleValidatorReward(
uint256 validatorId,
uint256 validatorStakePower,
uint256 currentRewardPerStake,
uint256 initialRewardPerStake
) private pure returns (uint256) {
}
function _increaseValidatorReward(uint256 validatorId, uint256 reward) private {
}
function _increaseValidatorRewardWithDelegation(
uint256 validatorId,
uint256 validatorsStake,
uint256 delegatedAmount,
uint256 reward
) private {
}
function _getValidatorAndDelegationReward(
uint256 validatorId,
uint256 validatorsStake,
uint256 reward,
uint256 combinedStakePower
) internal view returns (uint256, uint256) {
}
function _evaluateValidatorAndDelegationReward(uint256 validatorId)
private
view
returns (uint256 validatorReward, uint256 delegatorsReward)
{
}
function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
}
function _stakeFor(
address user,
uint256 amount,
bool acceptDelegation,
bytes memory signerPubkey
) internal returns (uint256) {
}
function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
}
function _finalizeCommit() internal {
}
function _liquidateRewards(uint256 validatorId, address validatorUser) private {
}
function _transferToken(address destination, uint256 amount) private {
}
function _transferTokenFrom(
address from,
address destination,
uint256 amount
) private {
require(<FILL_ME>)
}
function _transferAndTopUp(
address user,
address from,
uint256 fee,
uint256 additionalAmount
) private {
}
function _claimFee(address user, uint256 amount) private {
}
function _insertSigner(address newSigner) internal {
}
function _removeSigner(address signerToDelete) internal {
}
}
| token.transferFrom(from,destination,amount),"transfer from failed" | 94,670 | token.transferFrom(from,destination,amount) |
"Delegate address already used" | // SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
interface RocketNodeStakingInterface {
function getNodeEffectiveRPLStake(address _nodeAddress) external view returns (uint256);
}
contract RocketNodeDelegateVote {
event Registration(address delegateAddress, address nodeAddress, uint256 index);
event Confirmation(address delegateAddress, address nodeAddress);
mapping(uint256 => address) unconfirmedDelegateAddress;
mapping(uint256 => address) unconfirmedNodeAddress;
uint256 unconfirmedIndex;
mapping(address => address) delegateToNode;
mapping(address => address) nodeToDelegate;
function registerDelegateAddress(address nodeAddress) public returns (uint256) {
}
receive() external payable {
uint256 index = msg.value;
address nodeAddress = unconfirmedNodeAddress[index];
address delegateAddress = unconfirmedDelegateAddress[index];
require(delegateAddress != address(0), "Registration invalid");
require(nodeAddress != address(0), "Node address is invalid");
require(nodeAddress == msg.sender, "Registration is for another node address");
require(nodeAddress != delegateAddress, "Node address and delegate address are the same");
require(<FILL_ME>)
delegateToNode[delegateAddress] = nodeAddress;
nodeToDelegate[nodeAddress] = delegateAddress;
emit Confirmation(delegateAddress, nodeAddress);
}
function undelegate() public {
}
function getNodeAddressForDelegate(address delegateAddress) public view returns (address) {
}
function getNodeEffectiveRPLStake(address _rocketNodeStakingAddress, address _address) public view returns (uint256) {
}
}
| delegateToNode[delegateAddress]==address(0),"Delegate address already used" | 94,695 | delegateToNode[delegateAddress]==address(0) |
"mint over" | // SPDX-License-Identifier: NONE
pragma solidity ^0.8.2;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract SocialAI is ERC721A, Ownable, ReentrancyGuard {
string private baseURI = "ipfs://QmTypJGP2QUn8dZ4vHGN9FX5SdvV75rkXHoeHakH8JGghy/";
uint public reservedAmount = 555;
uint public constant maxSupply = 5555;
constructor() ERC721A("SocialAI", "SAI") {}
//internal
function _baseURI() internal view virtual override returns(string memory) {
}
function _startTokenId() internal view virtual override returns(uint256) {
}
// public
function mint() external nonReentrant {
uint supply = totalSupply();
require(<FILL_ME>)
require(_numberMinted(msg.sender) == 0, "limited to 1 per wallet - be FAIR, not GREEDY");
require(msg.sender == tx.origin);
_safeMint(msg.sender, 1);
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function reserve(address _to, uint _mintAmount) public onlyOwner {
}
function withdraw () public payable onlyOwner {
}
}
| supply+1<=maxSupply-reservedAmount,"mint over" | 94,706 | supply+1<=maxSupply-reservedAmount |
"limited to 1 per wallet - be FAIR, not GREEDY" | // SPDX-License-Identifier: NONE
pragma solidity ^0.8.2;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract SocialAI is ERC721A, Ownable, ReentrancyGuard {
string private baseURI = "ipfs://QmTypJGP2QUn8dZ4vHGN9FX5SdvV75rkXHoeHakH8JGghy/";
uint public reservedAmount = 555;
uint public constant maxSupply = 5555;
constructor() ERC721A("SocialAI", "SAI") {}
//internal
function _baseURI() internal view virtual override returns(string memory) {
}
function _startTokenId() internal view virtual override returns(uint256) {
}
// public
function mint() external nonReentrant {
uint supply = totalSupply();
require(supply + 1 <= maxSupply - reservedAmount, "mint over");
require(<FILL_ME>)
require(msg.sender == tx.origin);
_safeMint(msg.sender, 1);
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function reserve(address _to, uint _mintAmount) public onlyOwner {
}
function withdraw () public payable onlyOwner {
}
}
| _numberMinted(msg.sender)==0,"limited to 1 per wallet - be FAIR, not GREEDY" | 94,706 | _numberMinted(msg.sender)==0 |
"Antibot: Transaction sender is in anti-bot cooldown" | /*
MonkeyMoney🐵💵 (MMY)
*/
// SPDX-License-Identifier: No License
pragma solidity 0.8.19;
import "./ERC20.sol";
import "./ERC20Burnable.sol";
import "./Ownable.sol";
import "./Pausable.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router01.sol";
import "./IUniswapV2Router02.sol";
contract Token is ERC20, ERC20Burnable, Ownable, Pausable {
mapping (address => bool) public blacklisted;
uint256 public swapThreshold;
uint256 private _mainPending;
address public mainAddress;
uint16[3] public mainFees;
mapping (address => bool) public isExcludedFromFees;
uint16[3] public totalFees;
bool private _swapping;
IUniswapV2Router02 public routerV2;
address public pairV2;
mapping (address => bool) public AMMPairs;
mapping (address => bool) public isExcludedFromLimits;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
mapping (address => uint256) public lastTrade;
uint256 public tradeCooldownTime;
event BlacklistUpdated(address indexed account, bool isBlacklisted);
event SwapThresholdUpdated(uint256 swapThreshold);
event mainAddressUpdated(address mainAddress);
event mainFeesUpdated(uint16 buyFee, uint16 sellFee, uint16 transferFee);
event mainFeeSent(address recipient, uint256 amount);
event ExcludeFromFees(address indexed account, bool isExcluded);
event RouterV2Updated(address indexed routerV2);
event AMMPairsUpdated(address indexed AMMPair, bool isPair);
event ExcludeFromLimits(address indexed account, bool isExcluded);
event MaxBuyAmountUpdated(uint256 maxBuyAmount);
event MaxSellAmountUpdated(uint256 maxSellAmount);
event TradeCooldownTimeUpdated(uint256 tradeCooldownTime);
constructor()
ERC20(unicode"MonkeyMoney🐵💵", unicode"MMY")
{
}
receive() external payable {}
function decimals() public pure override returns (uint8) {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function blacklist(address account, bool isBlacklisted) external onlyOwner {
}
function _swapTokensForCoin(uint256 tokenAmount) private {
}
function updateSwapThreshold(uint256 _swapThreshold) public onlyOwner {
}
function getAllPending() public view returns (uint256) {
}
function mainAddressSetup(address _newAddress) public onlyOwner {
}
function mainFeesSetup(uint16 _buyFee, uint16 _sellFee, uint16 _transferFee) public onlyOwner {
}
function excludeFromFees(address account, bool isExcluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function _updateRouterV2(address router) private {
}
function setAMMPair(address pair, bool isPair) public onlyOwner {
}
function _setAMMPair(address pair, bool isPair) private {
}
function excludeFromLimits(address account, bool isExcluded) public onlyOwner {
}
function updateMaxBuyAmount(uint256 _maxBuyAmount) public onlyOwner {
}
function updateMaxSellAmount(uint256 _maxSellAmount) public onlyOwner {
}
function updateTradeCooldownTime(uint256 _tradeCooldownTime) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
whenNotPaused
override
{
require(!blacklisted[from] && !blacklisted[to], "Blacklist: Sender or recipient is blacklisted");
if (AMMPairs[from] && !isExcludedFromLimits[to]) { // BUY
require(amount <= maxBuyAmount, "MaxTx: Cannot exceed max buy limit");
}
if (AMMPairs[to] && !isExcludedFromLimits[from]) { // SELL
require(amount <= maxSellAmount, "MaxTx: Cannot exceed max sell limit");
}
if(!isExcludedFromLimits[from])
require(<FILL_ME>)
if(!isExcludedFromLimits[to])
require(lastTrade[to] + tradeCooldownTime <= block.timestamp, "Antibot: Transaction recipient is in anti-bot cooldown");
super._beforeTokenTransfer(from, to, amount);
}
function _afterTokenTransfer(address from, address to, uint256 amount)
internal
override
{
}
}
| lastTrade[from]+tradeCooldownTime<=block.timestamp,"Antibot: Transaction sender is in anti-bot cooldown" | 94,735 | lastTrade[from]+tradeCooldownTime<=block.timestamp |
"Antibot: Transaction recipient is in anti-bot cooldown" | /*
MonkeyMoney🐵💵 (MMY)
*/
// SPDX-License-Identifier: No License
pragma solidity 0.8.19;
import "./ERC20.sol";
import "./ERC20Burnable.sol";
import "./Ownable.sol";
import "./Pausable.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router01.sol";
import "./IUniswapV2Router02.sol";
contract Token is ERC20, ERC20Burnable, Ownable, Pausable {
mapping (address => bool) public blacklisted;
uint256 public swapThreshold;
uint256 private _mainPending;
address public mainAddress;
uint16[3] public mainFees;
mapping (address => bool) public isExcludedFromFees;
uint16[3] public totalFees;
bool private _swapping;
IUniswapV2Router02 public routerV2;
address public pairV2;
mapping (address => bool) public AMMPairs;
mapping (address => bool) public isExcludedFromLimits;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
mapping (address => uint256) public lastTrade;
uint256 public tradeCooldownTime;
event BlacklistUpdated(address indexed account, bool isBlacklisted);
event SwapThresholdUpdated(uint256 swapThreshold);
event mainAddressUpdated(address mainAddress);
event mainFeesUpdated(uint16 buyFee, uint16 sellFee, uint16 transferFee);
event mainFeeSent(address recipient, uint256 amount);
event ExcludeFromFees(address indexed account, bool isExcluded);
event RouterV2Updated(address indexed routerV2);
event AMMPairsUpdated(address indexed AMMPair, bool isPair);
event ExcludeFromLimits(address indexed account, bool isExcluded);
event MaxBuyAmountUpdated(uint256 maxBuyAmount);
event MaxSellAmountUpdated(uint256 maxSellAmount);
event TradeCooldownTimeUpdated(uint256 tradeCooldownTime);
constructor()
ERC20(unicode"MonkeyMoney🐵💵", unicode"MMY")
{
}
receive() external payable {}
function decimals() public pure override returns (uint8) {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function blacklist(address account, bool isBlacklisted) external onlyOwner {
}
function _swapTokensForCoin(uint256 tokenAmount) private {
}
function updateSwapThreshold(uint256 _swapThreshold) public onlyOwner {
}
function getAllPending() public view returns (uint256) {
}
function mainAddressSetup(address _newAddress) public onlyOwner {
}
function mainFeesSetup(uint16 _buyFee, uint16 _sellFee, uint16 _transferFee) public onlyOwner {
}
function excludeFromFees(address account, bool isExcluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function _updateRouterV2(address router) private {
}
function setAMMPair(address pair, bool isPair) public onlyOwner {
}
function _setAMMPair(address pair, bool isPair) private {
}
function excludeFromLimits(address account, bool isExcluded) public onlyOwner {
}
function updateMaxBuyAmount(uint256 _maxBuyAmount) public onlyOwner {
}
function updateMaxSellAmount(uint256 _maxSellAmount) public onlyOwner {
}
function updateTradeCooldownTime(uint256 _tradeCooldownTime) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
whenNotPaused
override
{
require(!blacklisted[from] && !blacklisted[to], "Blacklist: Sender or recipient is blacklisted");
if (AMMPairs[from] && !isExcludedFromLimits[to]) { // BUY
require(amount <= maxBuyAmount, "MaxTx: Cannot exceed max buy limit");
}
if (AMMPairs[to] && !isExcludedFromLimits[from]) { // SELL
require(amount <= maxSellAmount, "MaxTx: Cannot exceed max sell limit");
}
if(!isExcludedFromLimits[from])
require(lastTrade[from] + tradeCooldownTime <= block.timestamp, "Antibot: Transaction sender is in anti-bot cooldown");
if(!isExcludedFromLimits[to])
require(<FILL_ME>)
super._beforeTokenTransfer(from, to, amount);
}
function _afterTokenTransfer(address from, address to, uint256 amount)
internal
override
{
}
}
| lastTrade[to]+tradeCooldownTime<=block.timestamp,"Antibot: Transaction recipient is in anti-bot cooldown" | 94,735 | lastTrade[to]+tradeCooldownTime<=block.timestamp |
null | /*
// Mr Dickey
// DICKEY
// WEBSITE
// https://www.mrdickey.io
// TELEGRAM
// https://t.me/mr_dickey_eth
// TWITTER
// https://twitter.com/mr_dickey_eth
// Hey Dickey, you're so fine,
// You're so fine, you blow my mind.
// Hey Dickey, hey Dickey!
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.16;
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 DICKEY is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Mr Dickey";
string private constant _symbol = "DICKEY";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 20;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 40;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping (address => uint256) public _buyMap;
mapping (address => bool) public preTrader;
address private developmentAddress;
address private marketingAddress;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 20000000 * 10**9;
uint256 public _maxWalletSize = 30000000 * 10**9;
uint256 public _swapTokensAtAmount = 10000 * 10**9;
struct Distribution {
uint256 development;
uint256 marketing;
}
Distribution public distribution;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor(address developmentAddr, address marketingAddr) {
}
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 lockTheSwap {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function setDistribution(uint256 development, uint256 marketing) external onlyOwner {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {
}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
function allowPreTrading(address[] calldata accounts) public onlyOwner {
}
function removePreTrading(address[] calldata accounts) public onlyOwner {
}
}
| _msgSender()==developmentAddress||_msgSender()==marketingAddress | 94,792 | _msgSender()==developmentAddress||_msgSender()==marketingAddress |
"You are exceeding maxWalletAmount" | /**
🎃PUMPKIN🎃
We are the next in line to takeover all other fruits and vegetables
Carrot the happiest and also strongest will beat down all his competitors
You don’t wanna miss out
Twitter: https://twitter.com/pumpkinerc20
TG: https://t.me/pumpkinerc20
*/
// SPDX-License-Identifier: MIT
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);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor (string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library Address{
function sendValue(address payable recipient, uint256 amount) internal {
}
}
abstract 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 {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IRouter {
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 swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract PUMPKIN is ERC20, Ownable{
using Address for address payable;
IRouter public router;
address public pair;
bool private swapping;
bool public swapEnabled;
bool public tradingEnabled;
uint256 tsupply = 1000000000 * 10 ** decimals();
uint256 public swapThreshold = tsupply * 1/100;
uint256 public maxTransactionAmount = tsupply * 2/100;
uint256 public maxWalletAmountSize = tsupply * 2/100;
address private MarketingWallet;
uint256 private tBuyTax = 25;
uint256 private tSellTax = 55;
uint256 private finalBuyTax=1;
uint256 private finalSellTax=1;
uint256 private reduceBuyTaxAt=20;
uint256 private reduceSellTaxAt=20;
uint256 private preventSwapBefore=30;
uint256 private _buyCount=0;
mapping (address => bool) public excludedFromFees;
modifier inSwap() {
}
constructor(address _MarketingWallet) ERC20("Pumpkin", "PUMPKIN") {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
require(amount > 0, "Transfer amount must be greater than zero");
if(!excludedFromFees[sender] && !excludedFromFees[recipient] && !swapping){
require(tradingEnabled, "Trading not active yet");
require(amount <= maxTransactionAmount, "You are exceeding maxTxAmount");
if(recipient != pair){
require(<FILL_ME>)
}
}
uint256 fee;
if (swapping || excludedFromFees[sender] || excludedFromFees[recipient]) fee = 0;
else{
if(recipient == pair) fee = amount * tSellTax / 100;
else fee = amount * tBuyTax / 100;
}
if (swapEnabled && !swapping && sender != pair) swapForFees();
super._transfer(sender, recipient, amount - fee);
if(fee > 0) super._transfer(sender, address(this) ,fee);
}
function swapForFees() private inSwap {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function setSwapEnabled(bool state) external onlyOwner {
}
function setSwapThreshold(uint256 new_amount) external onlyOwner {
}
function enableTrading() external onlyOwner{
}
function reduceFee(uint256 _totalTax, uint256 _totalSellTax) external onlyOwner{
}
function removelimit() external onlyOwner{
}
function updateRouterAndPair(IRouter _router, address _pair) external onlyOwner{
}
function updateExcludedFromFees(address _address, bool state) external onlyOwner {
}
function rescueERC20(address tokenAddress, uint256 amount) external {
}
function rescueETH(uint256 weiAmount) external {
}
// fallbacks
receive() external payable {}
}
| balanceOf(recipient)+amount<=maxWalletAmountSize,"You are exceeding maxWalletAmount" | 94,857 | balanceOf(recipient)+amount<=maxWalletAmountSize |
"The address has reached the limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Zalien is ERC721A, Ownable, ERC2981 {
enum EPublicMintStatus {
NOTACTIVE,
BLUECHIP_MINT,
ALLOWLIST_MINT,
PUBLIC_MINT,
CLOSED
}
EPublicMintStatus public publicMintStatus;
string public baseTokenURI;
string public defaultTokenURI = 'ipfs://bafkreif2mn2ijjtekvu2mzfuxnoo4754rkhcigt4jhticokvnss27fvmay';
uint256 public maxSupply = 4200;
uint256 public publicSalePrice = 0.096 ether;
uint256 public allowListSalePrice = 0.069 ether;
address payable public payMent;
mapping(address => uint256) public usermint;
mapping(address => uint256) public allowlistmint;
mapping(address => uint256) public blurchipmint;
address[] public BlurChipAddress;
bytes32 private _merkleRoot;
constructor() ERC721A ("Zalien", "Zalien") {
}
modifier callerIsUser() {
}
function mint(uint256 _quantity) external payable {
require(publicMintStatus == EPublicMintStatus.PUBLIC_MINT, "Public sale closed");
require(_quantity <= 3, "Invalid quantity");
require(totalSupply() + _quantity <= maxSupply, "Exceed supply");
require(msg.value >= _quantity * publicSalePrice, "Ether is not enough");
require(<FILL_ME>)
usermint[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
function allowListMint(bytes32[] calldata _merkleProof, uint256 _quantity) external payable {
}
function blueChipMint(uint256 _quantity) external payable {
}
function checkBlueHolder(address walletaddress) internal view returns (bool) {
}
function isWhitelistAddress(address _address, bytes32[] calldata _signature) public view returns (bool) {
}
function airdrop(address[] memory mintaddress, uint256[] memory mintquantity) public payable onlyOwner {
}
function withdraw() external onlyOwner {
}
function getHoldTokenIdsByOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBlurChipAddress(address[] calldata _BlurChipAddress) external onlyOwner {
}
function setBaseURI(string calldata _baseTokenURI) external onlyOwner {
}
function setDefaultURI(string calldata _defaultURI) external onlyOwner {
}
function setPublicPrice(uint256 mintprice) external onlyOwner {
}
function setAllowlistPrice(uint256 mintprice) external onlyOwner {
}
function setPublicMintStatus(uint256 status) external onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
function setRoyaltyInfo(address payable receiver, uint96 numerator) public onlyOwner {
}
function setPayMent(address _payMent) external onlyOwner {
}
function DeleteDefaultRoyalty() external onlyOwner {
}
}
| usermint[msg.sender]+_quantity<=3,"The address has reached the limit" | 94,922 | usermint[msg.sender]+_quantity<=3 |
"Caller is not in whitelist or invalid signature" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Zalien is ERC721A, Ownable, ERC2981 {
enum EPublicMintStatus {
NOTACTIVE,
BLUECHIP_MINT,
ALLOWLIST_MINT,
PUBLIC_MINT,
CLOSED
}
EPublicMintStatus public publicMintStatus;
string public baseTokenURI;
string public defaultTokenURI = 'ipfs://bafkreif2mn2ijjtekvu2mzfuxnoo4754rkhcigt4jhticokvnss27fvmay';
uint256 public maxSupply = 4200;
uint256 public publicSalePrice = 0.096 ether;
uint256 public allowListSalePrice = 0.069 ether;
address payable public payMent;
mapping(address => uint256) public usermint;
mapping(address => uint256) public allowlistmint;
mapping(address => uint256) public blurchipmint;
address[] public BlurChipAddress;
bytes32 private _merkleRoot;
constructor() ERC721A ("Zalien", "Zalien") {
}
modifier callerIsUser() {
}
function mint(uint256 _quantity) external payable {
}
function allowListMint(bytes32[] calldata _merkleProof, uint256 _quantity) external payable {
require(publicMintStatus == EPublicMintStatus.ALLOWLIST_MINT, "Allowlist sale closed");
require(_quantity <= 3, "Invalid quantity");
require(totalSupply() + _quantity <= maxSupply, "Exceed supply");
require(msg.value >= _quantity * allowListSalePrice, "Ether is not enough");
require(<FILL_ME>)
require(allowlistmint[msg.sender] + _quantity <= 3, "The address has reached the limit");
allowlistmint[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
function blueChipMint(uint256 _quantity) external payable {
}
function checkBlueHolder(address walletaddress) internal view returns (bool) {
}
function isWhitelistAddress(address _address, bytes32[] calldata _signature) public view returns (bool) {
}
function airdrop(address[] memory mintaddress, uint256[] memory mintquantity) public payable onlyOwner {
}
function withdraw() external onlyOwner {
}
function getHoldTokenIdsByOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBlurChipAddress(address[] calldata _BlurChipAddress) external onlyOwner {
}
function setBaseURI(string calldata _baseTokenURI) external onlyOwner {
}
function setDefaultURI(string calldata _defaultURI) external onlyOwner {
}
function setPublicPrice(uint256 mintprice) external onlyOwner {
}
function setAllowlistPrice(uint256 mintprice) external onlyOwner {
}
function setPublicMintStatus(uint256 status) external onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
function setRoyaltyInfo(address payable receiver, uint96 numerator) public onlyOwner {
}
function setPayMent(address _payMent) external onlyOwner {
}
function DeleteDefaultRoyalty() external onlyOwner {
}
}
| isWhitelistAddress(msg.sender,_merkleProof),"Caller is not in whitelist or invalid signature" | 94,922 | isWhitelistAddress(msg.sender,_merkleProof) |
"The address has reached the limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract Zalien is ERC721A, Ownable, ERC2981 {
enum EPublicMintStatus {
NOTACTIVE,
BLUECHIP_MINT,
ALLOWLIST_MINT,
PUBLIC_MINT,
CLOSED
}
EPublicMintStatus public publicMintStatus;
string public baseTokenURI;
string public defaultTokenURI = 'ipfs://bafkreif2mn2ijjtekvu2mzfuxnoo4754rkhcigt4jhticokvnss27fvmay';
uint256 public maxSupply = 4200;
uint256 public publicSalePrice = 0.096 ether;
uint256 public allowListSalePrice = 0.069 ether;
address payable public payMent;
mapping(address => uint256) public usermint;
mapping(address => uint256) public allowlistmint;
mapping(address => uint256) public blurchipmint;
address[] public BlurChipAddress;
bytes32 private _merkleRoot;
constructor() ERC721A ("Zalien", "Zalien") {
}
modifier callerIsUser() {
}
function mint(uint256 _quantity) external payable {
}
function allowListMint(bytes32[] calldata _merkleProof, uint256 _quantity) external payable {
require(publicMintStatus == EPublicMintStatus.ALLOWLIST_MINT, "Allowlist sale closed");
require(_quantity <= 3, "Invalid quantity");
require(totalSupply() + _quantity <= maxSupply, "Exceed supply");
require(msg.value >= _quantity * allowListSalePrice, "Ether is not enough");
require(isWhitelistAddress(msg.sender, _merkleProof), "Caller is not in whitelist or invalid signature");
require(<FILL_ME>)
allowlistmint[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
function blueChipMint(uint256 _quantity) external payable {
}
function checkBlueHolder(address walletaddress) internal view returns (bool) {
}
function isWhitelistAddress(address _address, bytes32[] calldata _signature) public view returns (bool) {
}
function airdrop(address[] memory mintaddress, uint256[] memory mintquantity) public payable onlyOwner {
}
function withdraw() external onlyOwner {
}
function getHoldTokenIdsByOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBlurChipAddress(address[] calldata _BlurChipAddress) external onlyOwner {
}
function setBaseURI(string calldata _baseTokenURI) external onlyOwner {
}
function setDefaultURI(string calldata _defaultURI) external onlyOwner {
}
function setPublicPrice(uint256 mintprice) external onlyOwner {
}
function setAllowlistPrice(uint256 mintprice) external onlyOwner {
}
function setPublicMintStatus(uint256 status) external onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
function setRoyaltyInfo(address payable receiver, uint96 numerator) public onlyOwner {
}
function setPayMent(address _payMent) external onlyOwner {
}
function DeleteDefaultRoyalty() external onlyOwner {
}
}
| allowlistmint[msg.sender]+_quantity<=3,"The address has reached the limit" | 94,922 | allowlistmint[msg.sender]+_quantity<=3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.