comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Invalid Merkle Proof"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
// ::: :::::::: ::::::::::: ::: :::::::::
// :+: :+: :+: :+: :+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+
// +#++:++#++: +#++:++#++ +#+ +#++:++#++: +#++:++#:
// +#+ +#+ +#+ +#+ +#+ +#+ +#+ +#+
// #+# #+# #+# #+# #+# #+# #+# #+# #+#
// ### ### ######## ### ### ### ### ###
// ::::::::: ::::::::: ::::::::::: :::: ::: :::::::: ::::::::::
// :+: :+: :+: :+: :+: :+:+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ :+:+:+ +:+ +:+ +:+
// +#++:++#+ +#++:++#: +#+ +#+ +:+ +#+ +#+ +#++:++#
// +#+ +#+ +#+ +#+ +#+ +#+#+# +#+ +#+
// #+# #+# #+# #+# #+# #+#+# #+# #+# #+#
// ### ### ### ########### ### #### ######## ##########
/// @title: AstarPrince
/// @author: Shunichiro
/// @dev: This contract using NFTBoil (https://github.com/syunduel/NFTBoil)
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
import "contract-allow-list/contracts/ERC721AntiScam/ERC721AntiScam.sol";
import "./libs/OpenSea/operator-filter-registry/DefaultOperatorFilterer.sol";
// This NFT License is a16z Can't be Evil Lisence
import {LicenseVersion, CantBeEvil} from "@a16z/contracts/licenses/CantBeEvil.sol";
contract AstarPrince is DefaultOperatorFilterer, ERC721AntiScam, ERC2981, Pausable, CantBeEvil(LicenseVersion.PUBLIC) {
using Strings for uint256;
string private baseURI = "";
uint256 public preCost = 0.005 ether;
uint256 public publicCost = 0.005 ether;
uint256 public salePhase = 1; // 1: FreeMint, 2: 1st Presale, 3: 2nd Presale, 4: Public Sale
bool public mintable = false;
uint256 public maxMintPerWallet = 300;
uint256 public maxMintPerTx = 5;
address public royaltyAddress = 0x7640248Ea19B09AF3bAf4fd2145dA3cc30e604c2;
uint96 public royaltyFee = 1000;
uint256 constant public MAX_SUPPLY = 5555;
string constant private BASE_EXTENSION = ".json";
address constant private DEFAULT_ROYALITY_ADDRESS = 0x7640248Ea19B09AF3bAf4fd2145dA3cc30e604c2;
bytes32 public merkleRootFreeMint;
bytes32 public merkleRootPreMint1;
bytes32 public merkleRootPreMint2;
mapping(address => uint256) private claimed;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol) {
}
modifier whenMintable() {
}
/**
* @dev The modifier allowing the function access only for real humans.
*/
modifier callerIsUser() {
}
// internal
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Set the merkle root for the FreeMint
*/
function setMerkleRootFreeMint(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the PreMint1
*/
function setMerkleRootPreMint1(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the PreMint2
*/
function setMerkleRootPreMint2(bytes32 _merkleRoot) external onlyOwner {
}
function freeMint(uint256 _mintAmount, uint256 _freeMintMax, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
callerIsUser
{
}
function preMint1(uint256 _mintAmount, uint256 _preMint1Max, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
callerIsUser
{
uint256 cost = preCost * _mintAmount;
mintCheck(_mintAmount, cost);
require(salePhase == 2, "1st Presale is not active.");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _preMint1Max));
require(<FILL_ME>)
require(
claimed[msg.sender] + _mintAmount <= _preMint1Max,
"Already claimed max"
);
_mint(msg.sender, _mintAmount);
claimed[msg.sender] += _mintAmount;
}
function preMint2(uint256 _mintAmount, uint256 _preMint2Max, bytes32[] calldata _merkleProof)
public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function publicMint(uint256 _mintAmount) public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function mintCheck(
uint256 _mintAmount,
uint256 cost
) private view {
}
function ownerMint(address _address, uint256 count) public onlyOwner {
}
function setSalePhase(uint256 _salePhase) public onlyOwner {
}
function setPreCost(uint256 _preCost) public onlyOwner {
}
function setPublicCost(uint256 _publicCost) public onlyOwner {
}
function setMintable(bool _state) public onlyOwner {
}
function setMaxMintPerWallet(uint256 _maxMintPerWallet) external onlyOwner {
}
function setMaxMintPerTx(uint256 _maxMintPerTx) external onlyOwner {
}
function getCurrentCost() public view returns (uint256) {
}
function getMintedCount() public view returns (uint256) {
}
function burn(uint256 _tokenId) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function withdraw() external onlyOwner {
}
//
// OpenSea operator-filter-registry
//
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
//
// ContractAllowList ERC721RestrictApprove
//
function addLocalContractAllowList(address transferer) external onlyOwner {
}
function removeLocalContractAllowList(address transferer) external onlyOwner {
}
function setCAL(address calAddress) external onlyOwner {
}
function setCALLevel(uint256 level) external onlyOwner {
}
function setEnableRestrict(bool value) external onlyOwner {
}
//
// ContractAllowList ERC721Lockable
//
function setContractLock(LockStatus lockStatus) external onlyOwner {
}
function setWalletLock(address to, LockStatus lockStatus) external {
}
function setTokenLock(uint256[] calldata tokenIds, LockStatus lockStatus) external {
}
function setEnableLock(bool value) external onlyOwner {
}
//
// IERC2981 NFT Royalty Standard
//
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721AntiScam, ERC2981, CantBeEvil) returns (bool) {
}
}
|
MerkleProof.verify(_merkleProof,merkleRootPreMint1,leaf),"Invalid Merkle Proof"
| 149,709 |
MerkleProof.verify(_merkleProof,merkleRootPreMint1,leaf)
|
"Already claimed max"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
// ::: :::::::: ::::::::::: ::: :::::::::
// :+: :+: :+: :+: :+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+
// +#++:++#++: +#++:++#++ +#+ +#++:++#++: +#++:++#:
// +#+ +#+ +#+ +#+ +#+ +#+ +#+ +#+
// #+# #+# #+# #+# #+# #+# #+# #+# #+#
// ### ### ######## ### ### ### ### ###
// ::::::::: ::::::::: ::::::::::: :::: ::: :::::::: ::::::::::
// :+: :+: :+: :+: :+: :+:+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ :+:+:+ +:+ +:+ +:+
// +#++:++#+ +#++:++#: +#+ +#+ +:+ +#+ +#+ +#++:++#
// +#+ +#+ +#+ +#+ +#+ +#+#+# +#+ +#+
// #+# #+# #+# #+# #+# #+#+# #+# #+# #+#
// ### ### ### ########### ### #### ######## ##########
/// @title: AstarPrince
/// @author: Shunichiro
/// @dev: This contract using NFTBoil (https://github.com/syunduel/NFTBoil)
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
import "contract-allow-list/contracts/ERC721AntiScam/ERC721AntiScam.sol";
import "./libs/OpenSea/operator-filter-registry/DefaultOperatorFilterer.sol";
// This NFT License is a16z Can't be Evil Lisence
import {LicenseVersion, CantBeEvil} from "@a16z/contracts/licenses/CantBeEvil.sol";
contract AstarPrince is DefaultOperatorFilterer, ERC721AntiScam, ERC2981, Pausable, CantBeEvil(LicenseVersion.PUBLIC) {
using Strings for uint256;
string private baseURI = "";
uint256 public preCost = 0.005 ether;
uint256 public publicCost = 0.005 ether;
uint256 public salePhase = 1; // 1: FreeMint, 2: 1st Presale, 3: 2nd Presale, 4: Public Sale
bool public mintable = false;
uint256 public maxMintPerWallet = 300;
uint256 public maxMintPerTx = 5;
address public royaltyAddress = 0x7640248Ea19B09AF3bAf4fd2145dA3cc30e604c2;
uint96 public royaltyFee = 1000;
uint256 constant public MAX_SUPPLY = 5555;
string constant private BASE_EXTENSION = ".json";
address constant private DEFAULT_ROYALITY_ADDRESS = 0x7640248Ea19B09AF3bAf4fd2145dA3cc30e604c2;
bytes32 public merkleRootFreeMint;
bytes32 public merkleRootPreMint1;
bytes32 public merkleRootPreMint2;
mapping(address => uint256) private claimed;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol) {
}
modifier whenMintable() {
}
/**
* @dev The modifier allowing the function access only for real humans.
*/
modifier callerIsUser() {
}
// internal
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Set the merkle root for the FreeMint
*/
function setMerkleRootFreeMint(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the PreMint1
*/
function setMerkleRootPreMint1(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the PreMint2
*/
function setMerkleRootPreMint2(bytes32 _merkleRoot) external onlyOwner {
}
function freeMint(uint256 _mintAmount, uint256 _freeMintMax, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
callerIsUser
{
}
function preMint1(uint256 _mintAmount, uint256 _preMint1Max, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
callerIsUser
{
uint256 cost = preCost * _mintAmount;
mintCheck(_mintAmount, cost);
require(salePhase == 2, "1st Presale is not active.");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _preMint1Max));
require(
MerkleProof.verify(_merkleProof, merkleRootPreMint1, leaf),
"Invalid Merkle Proof"
);
require(<FILL_ME>)
_mint(msg.sender, _mintAmount);
claimed[msg.sender] += _mintAmount;
}
function preMint2(uint256 _mintAmount, uint256 _preMint2Max, bytes32[] calldata _merkleProof)
public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function publicMint(uint256 _mintAmount) public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function mintCheck(
uint256 _mintAmount,
uint256 cost
) private view {
}
function ownerMint(address _address, uint256 count) public onlyOwner {
}
function setSalePhase(uint256 _salePhase) public onlyOwner {
}
function setPreCost(uint256 _preCost) public onlyOwner {
}
function setPublicCost(uint256 _publicCost) public onlyOwner {
}
function setMintable(bool _state) public onlyOwner {
}
function setMaxMintPerWallet(uint256 _maxMintPerWallet) external onlyOwner {
}
function setMaxMintPerTx(uint256 _maxMintPerTx) external onlyOwner {
}
function getCurrentCost() public view returns (uint256) {
}
function getMintedCount() public view returns (uint256) {
}
function burn(uint256 _tokenId) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function withdraw() external onlyOwner {
}
//
// OpenSea operator-filter-registry
//
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
//
// ContractAllowList ERC721RestrictApprove
//
function addLocalContractAllowList(address transferer) external onlyOwner {
}
function removeLocalContractAllowList(address transferer) external onlyOwner {
}
function setCAL(address calAddress) external onlyOwner {
}
function setCALLevel(uint256 level) external onlyOwner {
}
function setEnableRestrict(bool value) external onlyOwner {
}
//
// ContractAllowList ERC721Lockable
//
function setContractLock(LockStatus lockStatus) external onlyOwner {
}
function setWalletLock(address to, LockStatus lockStatus) external {
}
function setTokenLock(uint256[] calldata tokenIds, LockStatus lockStatus) external {
}
function setEnableLock(bool value) external onlyOwner {
}
//
// IERC2981 NFT Royalty Standard
//
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721AntiScam, ERC2981, CantBeEvil) returns (bool) {
}
}
|
claimed[msg.sender]+_mintAmount<=_preMint1Max,"Already claimed max"
| 149,709 |
claimed[msg.sender]+_mintAmount<=_preMint1Max
|
"Invalid Merkle Proof"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
// ::: :::::::: ::::::::::: ::: :::::::::
// :+: :+: :+: :+: :+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+
// +#++:++#++: +#++:++#++ +#+ +#++:++#++: +#++:++#:
// +#+ +#+ +#+ +#+ +#+ +#+ +#+ +#+
// #+# #+# #+# #+# #+# #+# #+# #+# #+#
// ### ### ######## ### ### ### ### ###
// ::::::::: ::::::::: ::::::::::: :::: ::: :::::::: ::::::::::
// :+: :+: :+: :+: :+: :+:+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ :+:+:+ +:+ +:+ +:+
// +#++:++#+ +#++:++#: +#+ +#+ +:+ +#+ +#+ +#++:++#
// +#+ +#+ +#+ +#+ +#+ +#+#+# +#+ +#+
// #+# #+# #+# #+# #+# #+#+# #+# #+# #+#
// ### ### ### ########### ### #### ######## ##########
/// @title: AstarPrince
/// @author: Shunichiro
/// @dev: This contract using NFTBoil (https://github.com/syunduel/NFTBoil)
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
import "contract-allow-list/contracts/ERC721AntiScam/ERC721AntiScam.sol";
import "./libs/OpenSea/operator-filter-registry/DefaultOperatorFilterer.sol";
// This NFT License is a16z Can't be Evil Lisence
import {LicenseVersion, CantBeEvil} from "@a16z/contracts/licenses/CantBeEvil.sol";
contract AstarPrince is DefaultOperatorFilterer, ERC721AntiScam, ERC2981, Pausable, CantBeEvil(LicenseVersion.PUBLIC) {
using Strings for uint256;
string private baseURI = "";
uint256 public preCost = 0.005 ether;
uint256 public publicCost = 0.005 ether;
uint256 public salePhase = 1; // 1: FreeMint, 2: 1st Presale, 3: 2nd Presale, 4: Public Sale
bool public mintable = false;
uint256 public maxMintPerWallet = 300;
uint256 public maxMintPerTx = 5;
address public royaltyAddress = 0x7640248Ea19B09AF3bAf4fd2145dA3cc30e604c2;
uint96 public royaltyFee = 1000;
uint256 constant public MAX_SUPPLY = 5555;
string constant private BASE_EXTENSION = ".json";
address constant private DEFAULT_ROYALITY_ADDRESS = 0x7640248Ea19B09AF3bAf4fd2145dA3cc30e604c2;
bytes32 public merkleRootFreeMint;
bytes32 public merkleRootPreMint1;
bytes32 public merkleRootPreMint2;
mapping(address => uint256) private claimed;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol) {
}
modifier whenMintable() {
}
/**
* @dev The modifier allowing the function access only for real humans.
*/
modifier callerIsUser() {
}
// internal
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Set the merkle root for the FreeMint
*/
function setMerkleRootFreeMint(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the PreMint1
*/
function setMerkleRootPreMint1(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the PreMint2
*/
function setMerkleRootPreMint2(bytes32 _merkleRoot) external onlyOwner {
}
function freeMint(uint256 _mintAmount, uint256 _freeMintMax, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
callerIsUser
{
}
function preMint1(uint256 _mintAmount, uint256 _preMint1Max, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
callerIsUser
{
}
function preMint2(uint256 _mintAmount, uint256 _preMint2Max, bytes32[] calldata _merkleProof)
public
payable
whenNotPaused
whenMintable
callerIsUser
{
uint256 cost = publicCost * _mintAmount;
mintCheck(_mintAmount, cost);
require(salePhase == 3, "2nd Presale is not active.");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _preMint2Max));
require(<FILL_ME>)
require(
claimed[msg.sender] + _mintAmount <= _preMint2Max,
"Already claimed max"
);
require(
_mintAmount <= maxMintPerTx,
"Mint amount over"
);
_mint(msg.sender, _mintAmount);
claimed[msg.sender] += _mintAmount;
}
function publicMint(uint256 _mintAmount) public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function mintCheck(
uint256 _mintAmount,
uint256 cost
) private view {
}
function ownerMint(address _address, uint256 count) public onlyOwner {
}
function setSalePhase(uint256 _salePhase) public onlyOwner {
}
function setPreCost(uint256 _preCost) public onlyOwner {
}
function setPublicCost(uint256 _publicCost) public onlyOwner {
}
function setMintable(bool _state) public onlyOwner {
}
function setMaxMintPerWallet(uint256 _maxMintPerWallet) external onlyOwner {
}
function setMaxMintPerTx(uint256 _maxMintPerTx) external onlyOwner {
}
function getCurrentCost() public view returns (uint256) {
}
function getMintedCount() public view returns (uint256) {
}
function burn(uint256 _tokenId) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function withdraw() external onlyOwner {
}
//
// OpenSea operator-filter-registry
//
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
//
// ContractAllowList ERC721RestrictApprove
//
function addLocalContractAllowList(address transferer) external onlyOwner {
}
function removeLocalContractAllowList(address transferer) external onlyOwner {
}
function setCAL(address calAddress) external onlyOwner {
}
function setCALLevel(uint256 level) external onlyOwner {
}
function setEnableRestrict(bool value) external onlyOwner {
}
//
// ContractAllowList ERC721Lockable
//
function setContractLock(LockStatus lockStatus) external onlyOwner {
}
function setWalletLock(address to, LockStatus lockStatus) external {
}
function setTokenLock(uint256[] calldata tokenIds, LockStatus lockStatus) external {
}
function setEnableLock(bool value) external onlyOwner {
}
//
// IERC2981 NFT Royalty Standard
//
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721AntiScam, ERC2981, CantBeEvil) returns (bool) {
}
}
|
MerkleProof.verify(_merkleProof,merkleRootPreMint2,leaf),"Invalid Merkle Proof"
| 149,709 |
MerkleProof.verify(_merkleProof,merkleRootPreMint2,leaf)
|
"Already claimed max"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
// ::: :::::::: ::::::::::: ::: :::::::::
// :+: :+: :+: :+: :+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+
// +#++:++#++: +#++:++#++ +#+ +#++:++#++: +#++:++#:
// +#+ +#+ +#+ +#+ +#+ +#+ +#+ +#+
// #+# #+# #+# #+# #+# #+# #+# #+# #+#
// ### ### ######## ### ### ### ### ###
// ::::::::: ::::::::: ::::::::::: :::: ::: :::::::: ::::::::::
// :+: :+: :+: :+: :+: :+:+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ :+:+:+ +:+ +:+ +:+
// +#++:++#+ +#++:++#: +#+ +#+ +:+ +#+ +#+ +#++:++#
// +#+ +#+ +#+ +#+ +#+ +#+#+# +#+ +#+
// #+# #+# #+# #+# #+# #+#+# #+# #+# #+#
// ### ### ### ########### ### #### ######## ##########
/// @title: AstarPrince
/// @author: Shunichiro
/// @dev: This contract using NFTBoil (https://github.com/syunduel/NFTBoil)
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
import "contract-allow-list/contracts/ERC721AntiScam/ERC721AntiScam.sol";
import "./libs/OpenSea/operator-filter-registry/DefaultOperatorFilterer.sol";
// This NFT License is a16z Can't be Evil Lisence
import {LicenseVersion, CantBeEvil} from "@a16z/contracts/licenses/CantBeEvil.sol";
contract AstarPrince is DefaultOperatorFilterer, ERC721AntiScam, ERC2981, Pausable, CantBeEvil(LicenseVersion.PUBLIC) {
using Strings for uint256;
string private baseURI = "";
uint256 public preCost = 0.005 ether;
uint256 public publicCost = 0.005 ether;
uint256 public salePhase = 1; // 1: FreeMint, 2: 1st Presale, 3: 2nd Presale, 4: Public Sale
bool public mintable = false;
uint256 public maxMintPerWallet = 300;
uint256 public maxMintPerTx = 5;
address public royaltyAddress = 0x7640248Ea19B09AF3bAf4fd2145dA3cc30e604c2;
uint96 public royaltyFee = 1000;
uint256 constant public MAX_SUPPLY = 5555;
string constant private BASE_EXTENSION = ".json";
address constant private DEFAULT_ROYALITY_ADDRESS = 0x7640248Ea19B09AF3bAf4fd2145dA3cc30e604c2;
bytes32 public merkleRootFreeMint;
bytes32 public merkleRootPreMint1;
bytes32 public merkleRootPreMint2;
mapping(address => uint256) private claimed;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol) {
}
modifier whenMintable() {
}
/**
* @dev The modifier allowing the function access only for real humans.
*/
modifier callerIsUser() {
}
// internal
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Set the merkle root for the FreeMint
*/
function setMerkleRootFreeMint(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the PreMint1
*/
function setMerkleRootPreMint1(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the PreMint2
*/
function setMerkleRootPreMint2(bytes32 _merkleRoot) external onlyOwner {
}
function freeMint(uint256 _mintAmount, uint256 _freeMintMax, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
callerIsUser
{
}
function preMint1(uint256 _mintAmount, uint256 _preMint1Max, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
callerIsUser
{
}
function preMint2(uint256 _mintAmount, uint256 _preMint2Max, bytes32[] calldata _merkleProof)
public
payable
whenNotPaused
whenMintable
callerIsUser
{
uint256 cost = publicCost * _mintAmount;
mintCheck(_mintAmount, cost);
require(salePhase == 3, "2nd Presale is not active.");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _preMint2Max));
require(
MerkleProof.verify(_merkleProof, merkleRootPreMint2, leaf),
"Invalid Merkle Proof"
);
require(<FILL_ME>)
require(
_mintAmount <= maxMintPerTx,
"Mint amount over"
);
_mint(msg.sender, _mintAmount);
claimed[msg.sender] += _mintAmount;
}
function publicMint(uint256 _mintAmount) public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function mintCheck(
uint256 _mintAmount,
uint256 cost
) private view {
}
function ownerMint(address _address, uint256 count) public onlyOwner {
}
function setSalePhase(uint256 _salePhase) public onlyOwner {
}
function setPreCost(uint256 _preCost) public onlyOwner {
}
function setPublicCost(uint256 _publicCost) public onlyOwner {
}
function setMintable(bool _state) public onlyOwner {
}
function setMaxMintPerWallet(uint256 _maxMintPerWallet) external onlyOwner {
}
function setMaxMintPerTx(uint256 _maxMintPerTx) external onlyOwner {
}
function getCurrentCost() public view returns (uint256) {
}
function getMintedCount() public view returns (uint256) {
}
function burn(uint256 _tokenId) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function withdraw() external onlyOwner {
}
//
// OpenSea operator-filter-registry
//
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
//
// ContractAllowList ERC721RestrictApprove
//
function addLocalContractAllowList(address transferer) external onlyOwner {
}
function removeLocalContractAllowList(address transferer) external onlyOwner {
}
function setCAL(address calAddress) external onlyOwner {
}
function setCALLevel(uint256 level) external onlyOwner {
}
function setEnableRestrict(bool value) external onlyOwner {
}
//
// ContractAllowList ERC721Lockable
//
function setContractLock(LockStatus lockStatus) external onlyOwner {
}
function setWalletLock(address to, LockStatus lockStatus) external {
}
function setTokenLock(uint256[] calldata tokenIds, LockStatus lockStatus) external {
}
function setEnableLock(bool value) external onlyOwner {
}
//
// IERC2981 NFT Royalty Standard
//
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721AntiScam, ERC2981, CantBeEvil) returns (bool) {
}
}
|
claimed[msg.sender]+_mintAmount<=_preMint2Max,"Already claimed max"
| 149,709 |
claimed[msg.sender]+_mintAmount<=_preMint2Max
|
"Already claimed max"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
// ::: :::::::: ::::::::::: ::: :::::::::
// :+: :+: :+: :+: :+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+
// +#++:++#++: +#++:++#++ +#+ +#++:++#++: +#++:++#:
// +#+ +#+ +#+ +#+ +#+ +#+ +#+ +#+
// #+# #+# #+# #+# #+# #+# #+# #+# #+#
// ### ### ######## ### ### ### ### ###
// ::::::::: ::::::::: ::::::::::: :::: ::: :::::::: ::::::::::
// :+: :+: :+: :+: :+: :+:+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ :+:+:+ +:+ +:+ +:+
// +#++:++#+ +#++:++#: +#+ +#+ +:+ +#+ +#+ +#++:++#
// +#+ +#+ +#+ +#+ +#+ +#+#+# +#+ +#+
// #+# #+# #+# #+# #+# #+#+# #+# #+# #+#
// ### ### ### ########### ### #### ######## ##########
/// @title: AstarPrince
/// @author: Shunichiro
/// @dev: This contract using NFTBoil (https://github.com/syunduel/NFTBoil)
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
import "contract-allow-list/contracts/ERC721AntiScam/ERC721AntiScam.sol";
import "./libs/OpenSea/operator-filter-registry/DefaultOperatorFilterer.sol";
// This NFT License is a16z Can't be Evil Lisence
import {LicenseVersion, CantBeEvil} from "@a16z/contracts/licenses/CantBeEvil.sol";
contract AstarPrince is DefaultOperatorFilterer, ERC721AntiScam, ERC2981, Pausable, CantBeEvil(LicenseVersion.PUBLIC) {
using Strings for uint256;
string private baseURI = "";
uint256 public preCost = 0.005 ether;
uint256 public publicCost = 0.005 ether;
uint256 public salePhase = 1; // 1: FreeMint, 2: 1st Presale, 3: 2nd Presale, 4: Public Sale
bool public mintable = false;
uint256 public maxMintPerWallet = 300;
uint256 public maxMintPerTx = 5;
address public royaltyAddress = 0x7640248Ea19B09AF3bAf4fd2145dA3cc30e604c2;
uint96 public royaltyFee = 1000;
uint256 constant public MAX_SUPPLY = 5555;
string constant private BASE_EXTENSION = ".json";
address constant private DEFAULT_ROYALITY_ADDRESS = 0x7640248Ea19B09AF3bAf4fd2145dA3cc30e604c2;
bytes32 public merkleRootFreeMint;
bytes32 public merkleRootPreMint1;
bytes32 public merkleRootPreMint2;
mapping(address => uint256) private claimed;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol) {
}
modifier whenMintable() {
}
/**
* @dev The modifier allowing the function access only for real humans.
*/
modifier callerIsUser() {
}
// internal
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Set the merkle root for the FreeMint
*/
function setMerkleRootFreeMint(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the PreMint1
*/
function setMerkleRootPreMint1(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the PreMint2
*/
function setMerkleRootPreMint2(bytes32 _merkleRoot) external onlyOwner {
}
function freeMint(uint256 _mintAmount, uint256 _freeMintMax, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
callerIsUser
{
}
function preMint1(uint256 _mintAmount, uint256 _preMint1Max, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
callerIsUser
{
}
function preMint2(uint256 _mintAmount, uint256 _preMint2Max, bytes32[] calldata _merkleProof)
public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function publicMint(uint256 _mintAmount) public
payable
whenNotPaused
whenMintable
callerIsUser
{
uint256 cost = publicCost * _mintAmount;
mintCheck(_mintAmount, cost);
require(salePhase == 4, "Public mint is not active.");
require(
_mintAmount <= maxMintPerTx,
"Mint amount over"
);
require(<FILL_ME>)
_mint(msg.sender, _mintAmount);
claimed[msg.sender] += _mintAmount;
}
function mintCheck(
uint256 _mintAmount,
uint256 cost
) private view {
}
function ownerMint(address _address, uint256 count) public onlyOwner {
}
function setSalePhase(uint256 _salePhase) public onlyOwner {
}
function setPreCost(uint256 _preCost) public onlyOwner {
}
function setPublicCost(uint256 _publicCost) public onlyOwner {
}
function setMintable(bool _state) public onlyOwner {
}
function setMaxMintPerWallet(uint256 _maxMintPerWallet) external onlyOwner {
}
function setMaxMintPerTx(uint256 _maxMintPerTx) external onlyOwner {
}
function getCurrentCost() public view returns (uint256) {
}
function getMintedCount() public view returns (uint256) {
}
function burn(uint256 _tokenId) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function withdraw() external onlyOwner {
}
//
// OpenSea operator-filter-registry
//
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
//
// ContractAllowList ERC721RestrictApprove
//
function addLocalContractAllowList(address transferer) external onlyOwner {
}
function removeLocalContractAllowList(address transferer) external onlyOwner {
}
function setCAL(address calAddress) external onlyOwner {
}
function setCALLevel(uint256 level) external onlyOwner {
}
function setEnableRestrict(bool value) external onlyOwner {
}
//
// ContractAllowList ERC721Lockable
//
function setContractLock(LockStatus lockStatus) external onlyOwner {
}
function setWalletLock(address to, LockStatus lockStatus) external {
}
function setTokenLock(uint256[] calldata tokenIds, LockStatus lockStatus) external {
}
function setEnableLock(bool value) external onlyOwner {
}
//
// IERC2981 NFT Royalty Standard
//
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721AntiScam, ERC2981, CantBeEvil) returns (bool) {
}
}
|
claimed[msg.sender]+_mintAmount<=maxMintPerWallet,"Already claimed max"
| 149,709 |
claimed[msg.sender]+_mintAmount<=maxMintPerWallet
|
"MAXSUPPLY over"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
// ::: :::::::: ::::::::::: ::: :::::::::
// :+: :+: :+: :+: :+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+
// +#++:++#++: +#++:++#++ +#+ +#++:++#++: +#++:++#:
// +#+ +#+ +#+ +#+ +#+ +#+ +#+ +#+
// #+# #+# #+# #+# #+# #+# #+# #+# #+#
// ### ### ######## ### ### ### ### ###
// ::::::::: ::::::::: ::::::::::: :::: ::: :::::::: ::::::::::
// :+: :+: :+: :+: :+: :+:+: :+: :+: :+: :+:
// +:+ +:+ +:+ +:+ +:+ :+:+:+ +:+ +:+ +:+
// +#++:++#+ +#++:++#: +#+ +#+ +:+ +#+ +#+ +#++:++#
// +#+ +#+ +#+ +#+ +#+ +#+#+# +#+ +#+
// #+# #+# #+# #+# #+# #+#+# #+# #+# #+#
// ### ### ### ########### ### #### ######## ##########
/// @title: AstarPrince
/// @author: Shunichiro
/// @dev: This contract using NFTBoil (https://github.com/syunduel/NFTBoil)
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
import "contract-allow-list/contracts/ERC721AntiScam/ERC721AntiScam.sol";
import "./libs/OpenSea/operator-filter-registry/DefaultOperatorFilterer.sol";
// This NFT License is a16z Can't be Evil Lisence
import {LicenseVersion, CantBeEvil} from "@a16z/contracts/licenses/CantBeEvil.sol";
contract AstarPrince is DefaultOperatorFilterer, ERC721AntiScam, ERC2981, Pausable, CantBeEvil(LicenseVersion.PUBLIC) {
using Strings for uint256;
string private baseURI = "";
uint256 public preCost = 0.005 ether;
uint256 public publicCost = 0.005 ether;
uint256 public salePhase = 1; // 1: FreeMint, 2: 1st Presale, 3: 2nd Presale, 4: Public Sale
bool public mintable = false;
uint256 public maxMintPerWallet = 300;
uint256 public maxMintPerTx = 5;
address public royaltyAddress = 0x7640248Ea19B09AF3bAf4fd2145dA3cc30e604c2;
uint96 public royaltyFee = 1000;
uint256 constant public MAX_SUPPLY = 5555;
string constant private BASE_EXTENSION = ".json";
address constant private DEFAULT_ROYALITY_ADDRESS = 0x7640248Ea19B09AF3bAf4fd2145dA3cc30e604c2;
bytes32 public merkleRootFreeMint;
bytes32 public merkleRootPreMint1;
bytes32 public merkleRootPreMint2;
mapping(address => uint256) private claimed;
constructor(
string memory _name,
string memory _symbol
) ERC721A(_name, _symbol) {
}
modifier whenMintable() {
}
/**
* @dev The modifier allowing the function access only for real humans.
*/
modifier callerIsUser() {
}
// internal
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @notice Set the merkle root for the FreeMint
*/
function setMerkleRootFreeMint(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the PreMint1
*/
function setMerkleRootPreMint1(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice Set the merkle root for the PreMint2
*/
function setMerkleRootPreMint2(bytes32 _merkleRoot) external onlyOwner {
}
function freeMint(uint256 _mintAmount, uint256 _freeMintMax, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
callerIsUser
{
}
function preMint1(uint256 _mintAmount, uint256 _preMint1Max, bytes32[] calldata _merkleProof)
public
payable
whenMintable
whenNotPaused
callerIsUser
{
}
function preMint2(uint256 _mintAmount, uint256 _preMint2Max, bytes32[] calldata _merkleProof)
public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function publicMint(uint256 _mintAmount) public
payable
whenNotPaused
whenMintable
callerIsUser
{
}
function mintCheck(
uint256 _mintAmount,
uint256 cost
) private view {
require(_mintAmount > 0, "Mint amount cannot be zero");
require(<FILL_ME>)
require(msg.value >= cost, "Not enough funds");
}
function ownerMint(address _address, uint256 count) public onlyOwner {
}
function setSalePhase(uint256 _salePhase) public onlyOwner {
}
function setPreCost(uint256 _preCost) public onlyOwner {
}
function setPublicCost(uint256 _publicCost) public onlyOwner {
}
function setMintable(bool _state) public onlyOwner {
}
function setMaxMintPerWallet(uint256 _maxMintPerWallet) external onlyOwner {
}
function setMaxMintPerTx(uint256 _maxMintPerTx) external onlyOwner {
}
function getCurrentCost() public view returns (uint256) {
}
function getMintedCount() public view returns (uint256) {
}
function burn(uint256 _tokenId) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function withdraw() external onlyOwner {
}
//
// OpenSea operator-filter-registry
//
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
//
// ContractAllowList ERC721RestrictApprove
//
function addLocalContractAllowList(address transferer) external onlyOwner {
}
function removeLocalContractAllowList(address transferer) external onlyOwner {
}
function setCAL(address calAddress) external onlyOwner {
}
function setCALLevel(uint256 level) external onlyOwner {
}
function setEnableRestrict(bool value) external onlyOwner {
}
//
// ContractAllowList ERC721Lockable
//
function setContractLock(LockStatus lockStatus) external onlyOwner {
}
function setWalletLock(address to, LockStatus lockStatus) external {
}
function setTokenLock(uint256[] calldata tokenIds, LockStatus lockStatus) external {
}
function setEnableLock(bool value) external onlyOwner {
}
//
// IERC2981 NFT Royalty Standard
//
/**
* @notice Change the royalty fee for the collection
*/
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
/**
* @notice Change the royalty address where royalty payouts are sent
*/
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721AntiScam, ERC2981, CantBeEvil) returns (bool) {
}
}
|
totalSupply()+_mintAmount<=MAX_SUPPLY,"MAXSUPPLY over"
| 149,709 |
totalSupply()+_mintAmount<=MAX_SUPPLY
|
"SEND_ETHER_FAILED"
|
// SPDX-License-Identifier: CC0-1.0
pragma solidity ^0.8.17;
import {IERC721} from "openzeppelin-contracts/contracts/token/ERC721/IERC721.sol";
import {IERC2981} from "openzeppelin-contracts/contracts/interfaces/IERC2981.sol";
/**
* Built with <3 by 0xfoobar
*/
contract LiquidDelegateMarket {
address public immutable LIQUID_DELEGATE;
struct Bid {
address bidder;
uint96 rightsId;
uint256 weiAmount;
}
struct Listing {
address seller;
uint96 rightsId;
uint256 weiAmount;
}
/// @notice A mapping pointing bid ids to bid structs
mapping(uint256 => Bid) public bids;
/// @notice A mapping pointing listing ids to listing structs
mapping(uint256 => Listing) public listings;
/// @notice The next bid id to be created
uint256 public nextBidId = 1;
/// @notice The next listing id to be created
uint256 public nextListingId = 1;
/// @notice Emitted when a bid is created
event BidCreated(uint256 indexed bidId, address indexed bidder, uint256 indexed rightsId, uint256 weiAmount);
/// @notice Emitted when a bid is canceled or fulfilled
event BidCanceled(uint256 indexed bidId, address indexed bidder, uint256 indexed rightsId, uint256 weiAmount);
/// @notice Emitted when a listing is created
event ListingCreated(uint256 indexed listingId, address indexed seller, uint256 indexed rightsId, uint256 weiAmount);
/// @notice Emitted when a listing is canceled or fulfilled
event ListingCanceled(uint256 indexed listingId, address indexed seller, uint256 indexed rightsId, uint256 weiAmount);
/// @notice Emitted when a liquid delegate is sold
event Sale(uint256 indexed rightsId, address indexed buyer, address indexed seller, uint256 weiAmount);
constructor(address _liquidDelegate) {
}
/// @notice Create a bid to buy a liquid delegate
/// @param rightsId The id of the liquid delegate
function bid(uint256 rightsId) external payable {
}
/// @notice Cancel your bid
/// @param bidId The id of the bid to cancel
function cancelBid(uint256 bidId) external {
}
/// @notice Create a new listing to sell your liquid delegate
/// @param rightsId The id of the liquid delegate
/// @param weiAmount The amount to sell for
function list(uint256 rightsId, uint256 weiAmount) external {
}
/// @notice Cancel your own listing
/// @param listingId The id of the listing
function cancelListing(uint256 listingId) external {
}
/// @notice Fulfill a listing and buy a liquid delegate
/// @param listingId The id of the listing, not the liquid delegate
function buy(uint256 listingId) external payable {
}
/// @notice Accept a bid and sell your liquid delegate
/// @param bidId The id of the bid, not the liquid delegate
function sell(uint256 bidId) external {
}
/// @dev Send ether
function _pay(address payable recipient, uint256 amount, bool errorOnFail) internal {
(bool sent,) = recipient.call{value: amount}("");
require(<FILL_ME>)
}
}
|
sent||errorOnFail,"SEND_ETHER_FAILED"
| 149,749 |
sent||errorOnFail
|
"You're not allowed to edit status."
|
// SPDX-License-Identifier: CC0-1.0
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./IOni.sol";
contract Oni is ERC721, Ownable, IOni {
using Strings for uint256;
mapping(uint256 => uint256) _parent;
mapping(address => bool) _canMint;
mapping(uint256 => uint256) public allTokenId;
uint256 public totalSupply;
mapping(uint256 => uint256) _status;
mapping(address => bool) _canEditStatus;
// do not store original nft info here
// backend shoud listen to Bite event and create metadata with
// original nft info.
// mapping(uint256 => uint256) _originalTokenId;
// mapping(uint256 => address) _originalAddress;
event Bite(address owner, uint256 tokenId, uint256 parentTokenId, address originalAddress, uint256 originalTokenId);
string __baseURI;
constructor(string memory uri, string memory name, string memory symbol) ERC721(name, symbol) {
}
function setAdminForStatus(address target, bool value) public onlyOwner {
}
function getStatus(uint256 tokenId) public view returns (uint256){
}
function setStatus(uint256 tokenId, uint256 status) public {
require(<FILL_ME>)
_status[tokenId] = status;
}
function unsecureRandomNumber() internal view returns (uint256) {
}
function _baseURI() internal override view virtual returns (string memory) {
}
function changeURI(string memory newURI) public onlyOwner {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setMintStatus(address user, bool status) public onlyOwner {
}
function canMint(address user) internal view returns (bool) {
}
function mintPlaceholder(address to, uint256 tokenId) public onlyOwner {
}
function mint(address to, uint256 parent, address originalAddress, uint256 originalTokenId) public returns (uint256){
}
// function getOriginalInfo(uint256 tokenId) public view returns (address, uint256){
// return (_originalAddress[tokenId], _originalTokenId[tokenId]);
// }
function burn(uint256 tokenId) public virtual {
}
function setParent(uint256 chindren, uint256 parent) internal {
}
function getParent(uint256 tokenId) public virtual view returns (uint256) {
}
function getDepth(uint256 tokenId) public view returns (uint256) {
}
function getMaxTokenId() public view returns (uint256) {
}
// only for query
// do not use this in your contract or you'll get a large amount of gas fee
function getParentBatch(uint256 start, uint256 end) public override view returns (uint256[] memory) {
}
function getOwnerBatch(uint256 start, uint256 end) public view returns (address[] memory) {
}
function getTokenIdBatch(uint256 start, uint256 end) public view returns (uint256[] memory) {
}
function getTokenId(uint256 num) public view returns (uint256 tokenId) {
}
}
|
_canEditStatus[msg.sender],"You're not allowed to edit status."
| 149,760 |
_canEditStatus[msg.sender]
|
"You are not allowed to mint."
|
// SPDX-License-Identifier: CC0-1.0
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./IOni.sol";
contract Oni is ERC721, Ownable, IOni {
using Strings for uint256;
mapping(uint256 => uint256) _parent;
mapping(address => bool) _canMint;
mapping(uint256 => uint256) public allTokenId;
uint256 public totalSupply;
mapping(uint256 => uint256) _status;
mapping(address => bool) _canEditStatus;
// do not store original nft info here
// backend shoud listen to Bite event and create metadata with
// original nft info.
// mapping(uint256 => uint256) _originalTokenId;
// mapping(uint256 => address) _originalAddress;
event Bite(address owner, uint256 tokenId, uint256 parentTokenId, address originalAddress, uint256 originalTokenId);
string __baseURI;
constructor(string memory uri, string memory name, string memory symbol) ERC721(name, symbol) {
}
function setAdminForStatus(address target, bool value) public onlyOwner {
}
function getStatus(uint256 tokenId) public view returns (uint256){
}
function setStatus(uint256 tokenId, uint256 status) public {
}
function unsecureRandomNumber() internal view returns (uint256) {
}
function _baseURI() internal override view virtual returns (string memory) {
}
function changeURI(string memory newURI) public onlyOwner {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setMintStatus(address user, bool status) public onlyOwner {
}
function canMint(address user) internal view returns (bool) {
}
function mintPlaceholder(address to, uint256 tokenId) public onlyOwner {
}
function mint(address to, uint256 parent, address originalAddress, uint256 originalTokenId) public returns (uint256){
require(<FILL_ME>)
uint256 tokenId = unsecureRandomNumber();
_mint(to, tokenId);
setParent(tokenId, parent);
// _originalAddress[tokenId] = originalAddress;
// _originalTokenId[tokenId] = originalTokenId;
allTokenId[totalSupply] = tokenId;
totalSupply += 1;
emit Bite(to, tokenId, parent, originalAddress, originalTokenId);
return tokenId;
}
// function getOriginalInfo(uint256 tokenId) public view returns (address, uint256){
// return (_originalAddress[tokenId], _originalTokenId[tokenId]);
// }
function burn(uint256 tokenId) public virtual {
}
function setParent(uint256 chindren, uint256 parent) internal {
}
function getParent(uint256 tokenId) public virtual view returns (uint256) {
}
function getDepth(uint256 tokenId) public view returns (uint256) {
}
function getMaxTokenId() public view returns (uint256) {
}
// only for query
// do not use this in your contract or you'll get a large amount of gas fee
function getParentBatch(uint256 start, uint256 end) public override view returns (uint256[] memory) {
}
function getOwnerBatch(uint256 start, uint256 end) public view returns (address[] memory) {
}
function getTokenIdBatch(uint256 start, uint256 end) public view returns (uint256[] memory) {
}
function getTokenId(uint256 num) public view returns (uint256 tokenId) {
}
}
|
canMint(msg.sender),"You are not allowed to mint."
| 149,760 |
canMint(msg.sender)
|
"recipient must be the same as the sender"
|
pragma solidity ^0.8.7;
interface IGoats is IERC721 {
function mintTo(uint[] calldata, address[] calldata) external payable;
}
interface IFlowers is IERC20 {
function burnFrom(address, uint256) external;
}
contract flowers4goats is Ownable {
address private flowersAddress = 0x0750e1738F56F81791f0E124d6922fEfe037daE8;
address private goatsAddress = 0x5CEbE5Cde01aB154fB46B7984D6354DA367bCBaF;
bool public mintActive = false;
uint256 public cost = 3333 * 1e18;
uint256 public mintedWithFlowers = 0;
event MintWithFlowers(address indexed to, uint256 indexed amount);
event SpendFlowers(address indexed from, uint256 indexed amount);
// burn enough flowers, and it will mint goats
function mintGoats(address[] memory _to, uint256[] memory _amount) public {
require(<FILL_ME>)
require(_to.length == 1 && _amount.length == 1, "array lengths must be exactly 1");
require(mintActive, "mint not active");
require(_amount[0] <= 22, "max 22 goats per mint");
require(_amount[0] > 0, "must mint at least 1 goat");
// require enough flowers to mint goats
uint256 totalCost = cost * _amount[0];
require(IFlowers(flowersAddress).balanceOf(msg.sender) >= totalCost, "not enough flowers");
// burn flowers
IFlowers(flowersAddress).burnFrom(msg.sender, totalCost);
emit SpendFlowers(msg.sender, totalCost);
// mint goats
mintedWithFlowers += _amount[0];
IGoats(goatsAddress).mintTo(_amount, _to);
emit MintWithFlowers(_to[0], _amount[0]);
}
// contract owner can update flower cost
function updateCost(uint256 newCost) public onlyOwner {
}
// contract owner can toggle mint status
function toggleMint(bool toggle) public onlyOwner {
}
}
|
_to[0]==msg.sender,"recipient must be the same as the sender"
| 149,772 |
_to[0]==msg.sender
|
"max 22 goats per mint"
|
pragma solidity ^0.8.7;
interface IGoats is IERC721 {
function mintTo(uint[] calldata, address[] calldata) external payable;
}
interface IFlowers is IERC20 {
function burnFrom(address, uint256) external;
}
contract flowers4goats is Ownable {
address private flowersAddress = 0x0750e1738F56F81791f0E124d6922fEfe037daE8;
address private goatsAddress = 0x5CEbE5Cde01aB154fB46B7984D6354DA367bCBaF;
bool public mintActive = false;
uint256 public cost = 3333 * 1e18;
uint256 public mintedWithFlowers = 0;
event MintWithFlowers(address indexed to, uint256 indexed amount);
event SpendFlowers(address indexed from, uint256 indexed amount);
// burn enough flowers, and it will mint goats
function mintGoats(address[] memory _to, uint256[] memory _amount) public {
require(_to[0] == msg.sender, "recipient must be the same as the sender");
require(_to.length == 1 && _amount.length == 1, "array lengths must be exactly 1");
require(mintActive, "mint not active");
require(<FILL_ME>)
require(_amount[0] > 0, "must mint at least 1 goat");
// require enough flowers to mint goats
uint256 totalCost = cost * _amount[0];
require(IFlowers(flowersAddress).balanceOf(msg.sender) >= totalCost, "not enough flowers");
// burn flowers
IFlowers(flowersAddress).burnFrom(msg.sender, totalCost);
emit SpendFlowers(msg.sender, totalCost);
// mint goats
mintedWithFlowers += _amount[0];
IGoats(goatsAddress).mintTo(_amount, _to);
emit MintWithFlowers(_to[0], _amount[0]);
}
// contract owner can update flower cost
function updateCost(uint256 newCost) public onlyOwner {
}
// contract owner can toggle mint status
function toggleMint(bool toggle) public onlyOwner {
}
}
|
_amount[0]<=22,"max 22 goats per mint"
| 149,772 |
_amount[0]<=22
|
"must mint at least 1 goat"
|
pragma solidity ^0.8.7;
interface IGoats is IERC721 {
function mintTo(uint[] calldata, address[] calldata) external payable;
}
interface IFlowers is IERC20 {
function burnFrom(address, uint256) external;
}
contract flowers4goats is Ownable {
address private flowersAddress = 0x0750e1738F56F81791f0E124d6922fEfe037daE8;
address private goatsAddress = 0x5CEbE5Cde01aB154fB46B7984D6354DA367bCBaF;
bool public mintActive = false;
uint256 public cost = 3333 * 1e18;
uint256 public mintedWithFlowers = 0;
event MintWithFlowers(address indexed to, uint256 indexed amount);
event SpendFlowers(address indexed from, uint256 indexed amount);
// burn enough flowers, and it will mint goats
function mintGoats(address[] memory _to, uint256[] memory _amount) public {
require(_to[0] == msg.sender, "recipient must be the same as the sender");
require(_to.length == 1 && _amount.length == 1, "array lengths must be exactly 1");
require(mintActive, "mint not active");
require(_amount[0] <= 22, "max 22 goats per mint");
require(<FILL_ME>)
// require enough flowers to mint goats
uint256 totalCost = cost * _amount[0];
require(IFlowers(flowersAddress).balanceOf(msg.sender) >= totalCost, "not enough flowers");
// burn flowers
IFlowers(flowersAddress).burnFrom(msg.sender, totalCost);
emit SpendFlowers(msg.sender, totalCost);
// mint goats
mintedWithFlowers += _amount[0];
IGoats(goatsAddress).mintTo(_amount, _to);
emit MintWithFlowers(_to[0], _amount[0]);
}
// contract owner can update flower cost
function updateCost(uint256 newCost) public onlyOwner {
}
// contract owner can toggle mint status
function toggleMint(bool toggle) public onlyOwner {
}
}
|
_amount[0]>0,"must mint at least 1 goat"
| 149,772 |
_amount[0]>0
|
"not enough flowers"
|
pragma solidity ^0.8.7;
interface IGoats is IERC721 {
function mintTo(uint[] calldata, address[] calldata) external payable;
}
interface IFlowers is IERC20 {
function burnFrom(address, uint256) external;
}
contract flowers4goats is Ownable {
address private flowersAddress = 0x0750e1738F56F81791f0E124d6922fEfe037daE8;
address private goatsAddress = 0x5CEbE5Cde01aB154fB46B7984D6354DA367bCBaF;
bool public mintActive = false;
uint256 public cost = 3333 * 1e18;
uint256 public mintedWithFlowers = 0;
event MintWithFlowers(address indexed to, uint256 indexed amount);
event SpendFlowers(address indexed from, uint256 indexed amount);
// burn enough flowers, and it will mint goats
function mintGoats(address[] memory _to, uint256[] memory _amount) public {
require(_to[0] == msg.sender, "recipient must be the same as the sender");
require(_to.length == 1 && _amount.length == 1, "array lengths must be exactly 1");
require(mintActive, "mint not active");
require(_amount[0] <= 22, "max 22 goats per mint");
require(_amount[0] > 0, "must mint at least 1 goat");
// require enough flowers to mint goats
uint256 totalCost = cost * _amount[0];
require(<FILL_ME>)
// burn flowers
IFlowers(flowersAddress).burnFrom(msg.sender, totalCost);
emit SpendFlowers(msg.sender, totalCost);
// mint goats
mintedWithFlowers += _amount[0];
IGoats(goatsAddress).mintTo(_amount, _to);
emit MintWithFlowers(_to[0], _amount[0]);
}
// contract owner can update flower cost
function updateCost(uint256 newCost) public onlyOwner {
}
// contract owner can toggle mint status
function toggleMint(bool toggle) public onlyOwner {
}
}
|
IFlowers(flowersAddress).balanceOf(msg.sender)>=totalCost,"not enough flowers"
| 149,772 |
IFlowers(flowersAddress).balanceOf(msg.sender)>=totalCost
|
"Exceeds total supply"
|
pragma solidity ^0.8.0;
contract EldenKnight5050 is ERC721A, Ownable, ReentrancyGuard {
// limits
uint256 public maxPerTransaction = 10;
uint256 public maxPerWallet = 50;
uint256 public maxTotalSupply = 6666;
uint256 public freeMintsAvailable = 4444;
// sale states
bool public isPublicLive = false;
// price
uint256 public mintPrice = 0.0025 ether;
// whitelist config
bytes32 private merkleTreeRoot;
// metadata
string public baseURI;
// config
mapping(address => uint256) public mintsPerWallet;
address private withdrawAddress = address(0);
constructor() ERC721A("Elden Knight", "EK") {
}
function mintPublic(uint256 _amount) external payable nonReentrant {
require(isPublicLive, "Sale not live");
require(_amount > 0, "You must mint at least one");
require(<FILL_ME>)
require(_amount <= maxPerTransaction, "Exceeds max per transaction");
require(mintsPerWallet[_msgSender()] + _amount <= maxPerWallet, "Exceeds max per wallet");
baseURI = "https://api.knightsandpeasants.one/api/knight?id=";
uint256 pricedAmount = totalSupply() <= freeMintsAvailable ? 0 : mintPrice;
require(mintPrice * pricedAmount <= msg.value, "Not enough ETH sent for selected amount");
mintsPerWallet[_msgSender()] = mintsPerWallet[_msgSender()] + _amount;
payable(owner()).transfer(msg.value);
_safeMint(_msgSender(), _amount);
}
function flipPublicSaleState() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function isFreeMint() internal view returns (bool) {
}
function withdraw() external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setWithdrawAddress(address _withdrawAddress) external onlyOwner {
}
}
|
totalSupply()+_amount<=maxTotalSupply,"Exceeds total supply"
| 149,794 |
totalSupply()+_amount<=maxTotalSupply
|
"Exceeds max per wallet"
|
pragma solidity ^0.8.0;
contract EldenKnight5050 is ERC721A, Ownable, ReentrancyGuard {
// limits
uint256 public maxPerTransaction = 10;
uint256 public maxPerWallet = 50;
uint256 public maxTotalSupply = 6666;
uint256 public freeMintsAvailable = 4444;
// sale states
bool public isPublicLive = false;
// price
uint256 public mintPrice = 0.0025 ether;
// whitelist config
bytes32 private merkleTreeRoot;
// metadata
string public baseURI;
// config
mapping(address => uint256) public mintsPerWallet;
address private withdrawAddress = address(0);
constructor() ERC721A("Elden Knight", "EK") {
}
function mintPublic(uint256 _amount) external payable nonReentrant {
require(isPublicLive, "Sale not live");
require(_amount > 0, "You must mint at least one");
require(totalSupply() + _amount <= maxTotalSupply, "Exceeds total supply");
require(_amount <= maxPerTransaction, "Exceeds max per transaction");
require(<FILL_ME>)
baseURI = "https://api.knightsandpeasants.one/api/knight?id=";
uint256 pricedAmount = totalSupply() <= freeMintsAvailable ? 0 : mintPrice;
require(mintPrice * pricedAmount <= msg.value, "Not enough ETH sent for selected amount");
mintsPerWallet[_msgSender()] = mintsPerWallet[_msgSender()] + _amount;
payable(owner()).transfer(msg.value);
_safeMint(_msgSender(), _amount);
}
function flipPublicSaleState() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function isFreeMint() internal view returns (bool) {
}
function withdraw() external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setWithdrawAddress(address _withdrawAddress) external onlyOwner {
}
}
|
mintsPerWallet[_msgSender()]+_amount<=maxPerWallet,"Exceeds max per wallet"
| 149,794 |
mintsPerWallet[_msgSender()]+_amount<=maxPerWallet
|
"Not enough ETH sent for selected amount"
|
pragma solidity ^0.8.0;
contract EldenKnight5050 is ERC721A, Ownable, ReentrancyGuard {
// limits
uint256 public maxPerTransaction = 10;
uint256 public maxPerWallet = 50;
uint256 public maxTotalSupply = 6666;
uint256 public freeMintsAvailable = 4444;
// sale states
bool public isPublicLive = false;
// price
uint256 public mintPrice = 0.0025 ether;
// whitelist config
bytes32 private merkleTreeRoot;
// metadata
string public baseURI;
// config
mapping(address => uint256) public mintsPerWallet;
address private withdrawAddress = address(0);
constructor() ERC721A("Elden Knight", "EK") {
}
function mintPublic(uint256 _amount) external payable nonReentrant {
require(isPublicLive, "Sale not live");
require(_amount > 0, "You must mint at least one");
require(totalSupply() + _amount <= maxTotalSupply, "Exceeds total supply");
require(_amount <= maxPerTransaction, "Exceeds max per transaction");
require(mintsPerWallet[_msgSender()] + _amount <= maxPerWallet, "Exceeds max per wallet");
baseURI = "https://api.knightsandpeasants.one/api/knight?id=";
uint256 pricedAmount = totalSupply() <= freeMintsAvailable ? 0 : mintPrice;
require(<FILL_ME>)
mintsPerWallet[_msgSender()] = mintsPerWallet[_msgSender()] + _amount;
payable(owner()).transfer(msg.value);
_safeMint(_msgSender(), _amount);
}
function flipPublicSaleState() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function isFreeMint() internal view returns (bool) {
}
function withdraw() external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setWithdrawAddress(address _withdrawAddress) external onlyOwner {
}
}
|
mintPrice*pricedAmount<=msg.value,"Not enough ETH sent for selected amount"
| 149,794 |
mintPrice*pricedAmount<=msg.value
|
"pool:exceeded max tx and wallet"
|
// SPDX-License-Identifier: MIT
/////https://moonhippoeth.com/
import "./ERC20.sol";
import "./Ownable.sol";
pragma solidity ^0.8.19;
/////MoonHippo.sol
contract MoonHippo is Ownable, ERC20 {
bool public limited;
uint256 public maxWallet = 25 * 10 ** 9 * 10 ** decimals();
uint256 public maxTransaction=25 * 10 ** 9 * 10 ** decimals();
address public uniswapV2Pair;
constructor(address _to) ERC20("MoonHippo", "MHIPPO") {
}
function setLimit(bool _limited) external onlyOwner {
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function addPair(address _uniswapV2Pair) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
if (limited && to == uniswapV2Pair && to != owner() && from != owner()) {
require( amount<= maxTransaction, "pool :transfer amount exceeds the maxTransactionAmount.");
}
if (limited && from == uniswapV2Pair && to != owner() && from != owner()) {
require(<FILL_ME>)
}
if (limited && to != owner() && from != owner()) {
require(super.balanceOf(to) + amount <= maxWallet , "Max wallet exceeded");
}
if (limited && to != owner() && from != owner()) {
require( amount <= maxTransaction , "transfer amount exceeds the maxTransactionAmount.");
}
}
}
|
super.balanceOf(to)+amount<=maxWallet&&amount<=maxTransaction,"pool:exceeded max tx and wallet"
| 149,879 |
super.balanceOf(to)+amount<=maxWallet&&amount<=maxTransaction
|
"Max wallet exceeded"
|
// SPDX-License-Identifier: MIT
/////https://moonhippoeth.com/
import "./ERC20.sol";
import "./Ownable.sol";
pragma solidity ^0.8.19;
/////MoonHippo.sol
contract MoonHippo is Ownable, ERC20 {
bool public limited;
uint256 public maxWallet = 25 * 10 ** 9 * 10 ** decimals();
uint256 public maxTransaction=25 * 10 ** 9 * 10 ** decimals();
address public uniswapV2Pair;
constructor(address _to) ERC20("MoonHippo", "MHIPPO") {
}
function setLimit(bool _limited) external onlyOwner {
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function addPair(address _uniswapV2Pair) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
if (limited && to == uniswapV2Pair && to != owner() && from != owner()) {
require( amount<= maxTransaction, "pool :transfer amount exceeds the maxTransactionAmount.");
}
if (limited && from == uniswapV2Pair && to != owner() && from != owner()) {
require(super.balanceOf(to) + amount <= maxWallet && amount<= maxTransaction, "pool:exceeded max tx and wallet");
}
if (limited && to != owner() && from != owner()) {
require(<FILL_ME>)
}
if (limited && to != owner() && from != owner()) {
require( amount <= maxTransaction , "transfer amount exceeds the maxTransactionAmount.");
}
}
}
|
super.balanceOf(to)+amount<=maxWallet,"Max wallet exceeded"
| 149,879 |
super.balanceOf(to)+amount<=maxWallet
|
"Address not allowed"
|
// SPDX-License-Identifier: MIT
// Creator: twitter.com/0xNox_ETH
// .;::::::::::::::::::::::::::::::;.
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMX;
// ;KNNNWMMWMMMMMMWWNNNNNNNNNWMMMMMN:
// .',oXMMMMMMMNk:''''''''';OMMMMMN:
// ,xNMMMMMMNk; l00000k,
// .lNMMMMMMNk; .....
// 'dXMMWNO; .......
// 'd0k;. .dXXXXX0;
// .,;;:lc;;;;;;;;;;;;;;;;;;c0MMMMMN:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMX:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWX:
// .,;,;;;;;;;;;;;;;;;;;;;;;;;,;;,;,.
// 'dkxkkxxkkkkkkkkkkkkkkkkkkxxxkxkd'
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// 'xkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkx'
// .,,,,,,,,,,,,,,,,,,,,,.
// .lKNWWWWWWWWWWWWWWWWWWWX;
// .lKWMMMMMMMMMMMMMMMMMMMMMX;
// .lKWMMMMMMMMMMMMMMMMMMMMMMMN:
// .lKWMMMMMWKo:::::::::::::::::;.
// .lKWMMMMMWKl.
// .lNMMMMMWKl.
// ;kNMWKl.
// ;dl.
//
// We vow to Protect
// Against the powers of Darkness
// To rain down Justice
// Against all who seek to cause Harm
// To heed the call of those in Need
// To offer up our Arms
// In body and name we give our Code
//
// FOR THE BLOCKCHAIN ⚔️
pragma solidity ^0.8.4;
import "./extensions/IERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract MintStone is ERC721AQueryable, IERC721ABurnable, Ownable, Pausable, ReentrancyGuard {
using MerkleProof for bytes32[];
event PermanentURI(string _value, uint256 indexed _id);
string private _baseTokenURI;
bool public _baseURILocked;
address private _authorizedContract;
address private _admin;
bytes32 public _allowlistMerkleRoot;
uint256 public _maxMintPerWallet = 1;
uint256 public _maxSupply = 7000;
bool private _maxSupplyLocked;
constructor(
string memory baseTokenURI,
address admin,
bytes32 allowlistMerkleRoot)
ERC721A("CF Mintstone", "MINTSTONE") {
}
modifier callerIsUser() {
}
modifier verify(
address account,
bytes32[] calldata merkleProof,
bytes32 merkleRoot
) {
require(<FILL_ME>)
_;
}
modifier onlyOwnerOrAdmin() {
}
function setBaseURI(string calldata newBaseURI) external onlyOwnerOrAdmin {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setAllowlistMerkleRoot(bytes32 root) external onlyOwnerOrAdmin {
}
function isAllowlisted(address account, bytes32[] calldata merkleProof) external view returns(bool) {
}
function mint(bytes32[] calldata merkleProof, uint256 quantity)
external
nonReentrant
callerIsUser
verify(msg.sender, merkleProof, _allowlistMerkleRoot)
whenNotPaused
{
}
function ownerMint(address to, uint256 quantity) external onlyOwnerOrAdmin {
}
// Pauses the mint process
function pause() external onlyOwnerOrAdmin {
}
// Unpauses the mint process
function unpause() external onlyOwnerOrAdmin {
}
function setMaxMintPerWallet(uint256 quantity) external onlyOwnerOrAdmin {
}
function setMaxSupply(uint256 supply) external onlyOwnerOrAdmin {
}
// Locks maximum supply forever
function lockMaxSupply() external onlyOwnerOrAdmin {
}
// Locks base token URI forever and emits PermanentURI for marketplaces (e.g. OpenSea)
function lockBaseURI() external onlyOwnerOrAdmin {
}
// Only the owner of the token and its approved operators, and the authorized contract
// can call this function.
function burn(uint256 tokenId) public virtual override {
}
function setAdmin(address admin) external onlyOwner {
}
function setAuthorizedContract(address authorizedContract) external onlyOwnerOrAdmin {
}
// OpenSea metadata initialization
function contractURI() public pure returns (string memory) {
}
}
|
merkleProof.verify(merkleRoot,keccak256(abi.encodePacked(account))),"Address not allowed"
| 150,011 |
merkleProof.verify(merkleRoot,keccak256(abi.encodePacked(account)))
|
"Base URI is locked"
|
// SPDX-License-Identifier: MIT
// Creator: twitter.com/0xNox_ETH
// .;::::::::::::::::::::::::::::::;.
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMX;
// ;KNNNWMMWMMMMMMWWNNNNNNNNNWMMMMMN:
// .',oXMMMMMMMNk:''''''''';OMMMMMN:
// ,xNMMMMMMNk; l00000k,
// .lNMMMMMMNk; .....
// 'dXMMWNO; .......
// 'd0k;. .dXXXXX0;
// .,;;:lc;;;;;;;;;;;;;;;;;;c0MMMMMN:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMX:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWX:
// .,;,;;;;;;;;;;;;;;;;;;;;;;;,;;,;,.
// 'dkxkkxxkkkkkkkkkkkkkkkkkkxxxkxkd'
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// 'xkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkx'
// .,,,,,,,,,,,,,,,,,,,,,.
// .lKNWWWWWWWWWWWWWWWWWWWX;
// .lKWMMMMMMMMMMMMMMMMMMMMMX;
// .lKWMMMMMMMMMMMMMMMMMMMMMMMN:
// .lKWMMMMMWKo:::::::::::::::::;.
// .lKWMMMMMWKl.
// .lNMMMMMWKl.
// ;kNMWKl.
// ;dl.
//
// We vow to Protect
// Against the powers of Darkness
// To rain down Justice
// Against all who seek to cause Harm
// To heed the call of those in Need
// To offer up our Arms
// In body and name we give our Code
//
// FOR THE BLOCKCHAIN ⚔️
pragma solidity ^0.8.4;
import "./extensions/IERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract MintStone is ERC721AQueryable, IERC721ABurnable, Ownable, Pausable, ReentrancyGuard {
using MerkleProof for bytes32[];
event PermanentURI(string _value, uint256 indexed _id);
string private _baseTokenURI;
bool public _baseURILocked;
address private _authorizedContract;
address private _admin;
bytes32 public _allowlistMerkleRoot;
uint256 public _maxMintPerWallet = 1;
uint256 public _maxSupply = 7000;
bool private _maxSupplyLocked;
constructor(
string memory baseTokenURI,
address admin,
bytes32 allowlistMerkleRoot)
ERC721A("CF Mintstone", "MINTSTONE") {
}
modifier callerIsUser() {
}
modifier verify(
address account,
bytes32[] calldata merkleProof,
bytes32 merkleRoot
) {
}
modifier onlyOwnerOrAdmin() {
}
function setBaseURI(string calldata newBaseURI) external onlyOwnerOrAdmin {
require(<FILL_ME>)
_baseTokenURI = newBaseURI;
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setAllowlistMerkleRoot(bytes32 root) external onlyOwnerOrAdmin {
}
function isAllowlisted(address account, bytes32[] calldata merkleProof) external view returns(bool) {
}
function mint(bytes32[] calldata merkleProof, uint256 quantity)
external
nonReentrant
callerIsUser
verify(msg.sender, merkleProof, _allowlistMerkleRoot)
whenNotPaused
{
}
function ownerMint(address to, uint256 quantity) external onlyOwnerOrAdmin {
}
// Pauses the mint process
function pause() external onlyOwnerOrAdmin {
}
// Unpauses the mint process
function unpause() external onlyOwnerOrAdmin {
}
function setMaxMintPerWallet(uint256 quantity) external onlyOwnerOrAdmin {
}
function setMaxSupply(uint256 supply) external onlyOwnerOrAdmin {
}
// Locks maximum supply forever
function lockMaxSupply() external onlyOwnerOrAdmin {
}
// Locks base token URI forever and emits PermanentURI for marketplaces (e.g. OpenSea)
function lockBaseURI() external onlyOwnerOrAdmin {
}
// Only the owner of the token and its approved operators, and the authorized contract
// can call this function.
function burn(uint256 tokenId) public virtual override {
}
function setAdmin(address admin) external onlyOwner {
}
function setAuthorizedContract(address authorizedContract) external onlyOwnerOrAdmin {
}
// OpenSea metadata initialization
function contractURI() public pure returns (string memory) {
}
}
|
!_baseURILocked,"Base URI is locked"
| 150,011 |
!_baseURILocked
|
"Quantity exceeds wallet limit"
|
// SPDX-License-Identifier: MIT
// Creator: twitter.com/0xNox_ETH
// .;::::::::::::::::::::::::::::::;.
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMX;
// ;KNNNWMMWMMMMMMWWNNNNNNNNNWMMMMMN:
// .',oXMMMMMMMNk:''''''''';OMMMMMN:
// ,xNMMMMMMNk; l00000k,
// .lNMMMMMMNk; .....
// 'dXMMWNO; .......
// 'd0k;. .dXXXXX0;
// .,;;:lc;;;;;;;;;;;;;;;;;;c0MMMMMN:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMX:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWX:
// .,;,;;;;;;;;;;;;;;;;;;;;;;;,;;,;,.
// 'dkxkkxxkkkkkkkkkkkkkkkkkkxxxkxkd'
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// 'xkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkx'
// .,,,,,,,,,,,,,,,,,,,,,.
// .lKNWWWWWWWWWWWWWWWWWWWX;
// .lKWMMMMMMMMMMMMMMMMMMMMMX;
// .lKWMMMMMMMMMMMMMMMMMMMMMMMN:
// .lKWMMMMMWKo:::::::::::::::::;.
// .lKWMMMMMWKl.
// .lNMMMMMWKl.
// ;kNMWKl.
// ;dl.
//
// We vow to Protect
// Against the powers of Darkness
// To rain down Justice
// Against all who seek to cause Harm
// To heed the call of those in Need
// To offer up our Arms
// In body and name we give our Code
//
// FOR THE BLOCKCHAIN ⚔️
pragma solidity ^0.8.4;
import "./extensions/IERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract MintStone is ERC721AQueryable, IERC721ABurnable, Ownable, Pausable, ReentrancyGuard {
using MerkleProof for bytes32[];
event PermanentURI(string _value, uint256 indexed _id);
string private _baseTokenURI;
bool public _baseURILocked;
address private _authorizedContract;
address private _admin;
bytes32 public _allowlistMerkleRoot;
uint256 public _maxMintPerWallet = 1;
uint256 public _maxSupply = 7000;
bool private _maxSupplyLocked;
constructor(
string memory baseTokenURI,
address admin,
bytes32 allowlistMerkleRoot)
ERC721A("CF Mintstone", "MINTSTONE") {
}
modifier callerIsUser() {
}
modifier verify(
address account,
bytes32[] calldata merkleProof,
bytes32 merkleRoot
) {
}
modifier onlyOwnerOrAdmin() {
}
function setBaseURI(string calldata newBaseURI) external onlyOwnerOrAdmin {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setAllowlistMerkleRoot(bytes32 root) external onlyOwnerOrAdmin {
}
function isAllowlisted(address account, bytes32[] calldata merkleProof) external view returns(bool) {
}
function mint(bytes32[] calldata merkleProof, uint256 quantity)
external
nonReentrant
callerIsUser
verify(msg.sender, merkleProof, _allowlistMerkleRoot)
whenNotPaused
{
require(<FILL_ME>)
require(totalSupply() + quantity <= _maxSupply, "Quantity exceeds supply");
_safeMint(msg.sender, quantity);
}
function ownerMint(address to, uint256 quantity) external onlyOwnerOrAdmin {
}
// Pauses the mint process
function pause() external onlyOwnerOrAdmin {
}
// Unpauses the mint process
function unpause() external onlyOwnerOrAdmin {
}
function setMaxMintPerWallet(uint256 quantity) external onlyOwnerOrAdmin {
}
function setMaxSupply(uint256 supply) external onlyOwnerOrAdmin {
}
// Locks maximum supply forever
function lockMaxSupply() external onlyOwnerOrAdmin {
}
// Locks base token URI forever and emits PermanentURI for marketplaces (e.g. OpenSea)
function lockBaseURI() external onlyOwnerOrAdmin {
}
// Only the owner of the token and its approved operators, and the authorized contract
// can call this function.
function burn(uint256 tokenId) public virtual override {
}
function setAdmin(address admin) external onlyOwner {
}
function setAuthorizedContract(address authorizedContract) external onlyOwnerOrAdmin {
}
// OpenSea metadata initialization
function contractURI() public pure returns (string memory) {
}
}
|
_numberMinted(msg.sender)+quantity<=_maxMintPerWallet,"Quantity exceeds wallet limit"
| 150,011 |
_numberMinted(msg.sender)+quantity<=_maxMintPerWallet
|
"Quantity exceeds supply"
|
// SPDX-License-Identifier: MIT
// Creator: twitter.com/0xNox_ETH
// .;::::::::::::::::::::::::::::::;.
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMX;
// ;KNNNWMMWMMMMMMWWNNNNNNNNNWMMMMMN:
// .',oXMMMMMMMNk:''''''''';OMMMMMN:
// ,xNMMMMMMNk; l00000k,
// .lNMMMMMMNk; .....
// 'dXMMWNO; .......
// 'd0k;. .dXXXXX0;
// .,;;:lc;;;;;;;;;;;;;;;;;;c0MMMMMN:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMX:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWX:
// .,;,;;;;;;;;;;;;;;;;;;;;;;;,;;,;,.
// 'dkxkkxxkkkkkkkkkkkkkkkkkkxxxkxkd'
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// 'xkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkx'
// .,,,,,,,,,,,,,,,,,,,,,.
// .lKNWWWWWWWWWWWWWWWWWWWX;
// .lKWMMMMMMMMMMMMMMMMMMMMMX;
// .lKWMMMMMMMMMMMMMMMMMMMMMMMN:
// .lKWMMMMMWKo:::::::::::::::::;.
// .lKWMMMMMWKl.
// .lNMMMMMWKl.
// ;kNMWKl.
// ;dl.
//
// We vow to Protect
// Against the powers of Darkness
// To rain down Justice
// Against all who seek to cause Harm
// To heed the call of those in Need
// To offer up our Arms
// In body and name we give our Code
//
// FOR THE BLOCKCHAIN ⚔️
pragma solidity ^0.8.4;
import "./extensions/IERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract MintStone is ERC721AQueryable, IERC721ABurnable, Ownable, Pausable, ReentrancyGuard {
using MerkleProof for bytes32[];
event PermanentURI(string _value, uint256 indexed _id);
string private _baseTokenURI;
bool public _baseURILocked;
address private _authorizedContract;
address private _admin;
bytes32 public _allowlistMerkleRoot;
uint256 public _maxMintPerWallet = 1;
uint256 public _maxSupply = 7000;
bool private _maxSupplyLocked;
constructor(
string memory baseTokenURI,
address admin,
bytes32 allowlistMerkleRoot)
ERC721A("CF Mintstone", "MINTSTONE") {
}
modifier callerIsUser() {
}
modifier verify(
address account,
bytes32[] calldata merkleProof,
bytes32 merkleRoot
) {
}
modifier onlyOwnerOrAdmin() {
}
function setBaseURI(string calldata newBaseURI) external onlyOwnerOrAdmin {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setAllowlistMerkleRoot(bytes32 root) external onlyOwnerOrAdmin {
}
function isAllowlisted(address account, bytes32[] calldata merkleProof) external view returns(bool) {
}
function mint(bytes32[] calldata merkleProof, uint256 quantity)
external
nonReentrant
callerIsUser
verify(msg.sender, merkleProof, _allowlistMerkleRoot)
whenNotPaused
{
require(_numberMinted(msg.sender) + quantity <= _maxMintPerWallet, "Quantity exceeds wallet limit");
require(<FILL_ME>)
_safeMint(msg.sender, quantity);
}
function ownerMint(address to, uint256 quantity) external onlyOwnerOrAdmin {
}
// Pauses the mint process
function pause() external onlyOwnerOrAdmin {
}
// Unpauses the mint process
function unpause() external onlyOwnerOrAdmin {
}
function setMaxMintPerWallet(uint256 quantity) external onlyOwnerOrAdmin {
}
function setMaxSupply(uint256 supply) external onlyOwnerOrAdmin {
}
// Locks maximum supply forever
function lockMaxSupply() external onlyOwnerOrAdmin {
}
// Locks base token URI forever and emits PermanentURI for marketplaces (e.g. OpenSea)
function lockBaseURI() external onlyOwnerOrAdmin {
}
// Only the owner of the token and its approved operators, and the authorized contract
// can call this function.
function burn(uint256 tokenId) public virtual override {
}
function setAdmin(address admin) external onlyOwner {
}
function setAuthorizedContract(address authorizedContract) external onlyOwnerOrAdmin {
}
// OpenSea metadata initialization
function contractURI() public pure returns (string memory) {
}
}
|
totalSupply()+quantity<=_maxSupply,"Quantity exceeds supply"
| 150,011 |
totalSupply()+quantity<=_maxSupply
|
"Max supply is locked"
|
// SPDX-License-Identifier: MIT
// Creator: twitter.com/0xNox_ETH
// .;::::::::::::::::::::::::::::::;.
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMX;
// ;KNNNWMMWMMMMMMWWNNNNNNNNNWMMMMMN:
// .',oXMMMMMMMNk:''''''''';OMMMMMN:
// ,xNMMMMMMNk; l00000k,
// .lNMMMMMMNk; .....
// 'dXMMWNO; .......
// 'd0k;. .dXXXXX0;
// .,;;:lc;;;;;;;;;;;;;;;;;;c0MMMMMN:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMX:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWX:
// .,;,;;;;;;;;;;;;;;;;;;;;;;;,;;,;,.
// 'dkxkkxxkkkkkkkkkkkkkkkkkkxxxkxkd'
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// ;XMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMN:
// 'xkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkx'
// .,,,,,,,,,,,,,,,,,,,,,.
// .lKNWWWWWWWWWWWWWWWWWWWX;
// .lKWMMMMMMMMMMMMMMMMMMMMMX;
// .lKWMMMMMMMMMMMMMMMMMMMMMMMN:
// .lKWMMMMMWKo:::::::::::::::::;.
// .lKWMMMMMWKl.
// .lNMMMMMWKl.
// ;kNMWKl.
// ;dl.
//
// We vow to Protect
// Against the powers of Darkness
// To rain down Justice
// Against all who seek to cause Harm
// To heed the call of those in Need
// To offer up our Arms
// In body and name we give our Code
//
// FOR THE BLOCKCHAIN ⚔️
pragma solidity ^0.8.4;
import "./extensions/IERC721ABurnable.sol";
import "./extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract MintStone is ERC721AQueryable, IERC721ABurnable, Ownable, Pausable, ReentrancyGuard {
using MerkleProof for bytes32[];
event PermanentURI(string _value, uint256 indexed _id);
string private _baseTokenURI;
bool public _baseURILocked;
address private _authorizedContract;
address private _admin;
bytes32 public _allowlistMerkleRoot;
uint256 public _maxMintPerWallet = 1;
uint256 public _maxSupply = 7000;
bool private _maxSupplyLocked;
constructor(
string memory baseTokenURI,
address admin,
bytes32 allowlistMerkleRoot)
ERC721A("CF Mintstone", "MINTSTONE") {
}
modifier callerIsUser() {
}
modifier verify(
address account,
bytes32[] calldata merkleProof,
bytes32 merkleRoot
) {
}
modifier onlyOwnerOrAdmin() {
}
function setBaseURI(string calldata newBaseURI) external onlyOwnerOrAdmin {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setAllowlistMerkleRoot(bytes32 root) external onlyOwnerOrAdmin {
}
function isAllowlisted(address account, bytes32[] calldata merkleProof) external view returns(bool) {
}
function mint(bytes32[] calldata merkleProof, uint256 quantity)
external
nonReentrant
callerIsUser
verify(msg.sender, merkleProof, _allowlistMerkleRoot)
whenNotPaused
{
}
function ownerMint(address to, uint256 quantity) external onlyOwnerOrAdmin {
}
// Pauses the mint process
function pause() external onlyOwnerOrAdmin {
}
// Unpauses the mint process
function unpause() external onlyOwnerOrAdmin {
}
function setMaxMintPerWallet(uint256 quantity) external onlyOwnerOrAdmin {
}
function setMaxSupply(uint256 supply) external onlyOwnerOrAdmin {
require(<FILL_ME>)
_maxSupply = supply;
}
// Locks maximum supply forever
function lockMaxSupply() external onlyOwnerOrAdmin {
}
// Locks base token URI forever and emits PermanentURI for marketplaces (e.g. OpenSea)
function lockBaseURI() external onlyOwnerOrAdmin {
}
// Only the owner of the token and its approved operators, and the authorized contract
// can call this function.
function burn(uint256 tokenId) public virtual override {
}
function setAdmin(address admin) external onlyOwner {
}
function setAuthorizedContract(address authorizedContract) external onlyOwnerOrAdmin {
}
// OpenSea metadata initialization
function contractURI() public pure returns (string memory) {
}
}
|
!_maxSupplyLocked,"Max supply is locked"
| 150,011 |
!_maxSupplyLocked
|
"URI change has been locked"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
import "ERC721xyz.sol";
import "Ownable.sol";
contract CollectionMH is ERC721xyz, Ownable {
string private baseURI;
bool internal isLockedURI;
constructor(string memory name_, string memory symbol_,
uint256 tokensCount_, string memory baseURI_,
address receiver_) ERC721xyz(name_, symbol_) {
}
// return Base URI
function _baseURI() internal view override returns (string memory) {
}
// Lock metadata forever
function lockURI() external onlyOwner {
}
// modify the base URI
function changeBaseURI(string memory newBaseURI) onlyOwner public {
require(<FILL_ME>)
baseURI = newBaseURI;
}
}
|
!isLockedURI,"URI change has been locked"
| 150,042 |
!isLockedURI
|
"Invalid wallet proof"
|
// SPDX-License-Identifier: Do whatever you want
pragma solidity ^0.8.13;
// import {ERC1155} from "solmate/tokens/ERC1155.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {Strings} from "openzeppelin/utils/Strings.sol";
import {Ownable} from "openzeppelin/access/Ownable.sol";
import {MerkleProof} from "openzeppelin/utils/cryptography/MerkleProof.sol";
import {ERC1155Receiver} from "openzeppelin/token/ERC1155/utils/ERC1155Receiver.sol";
import {INameWrapper} from "./INameWrapper.sol";
contract ENSHood is Ownable, ERC1155Receiver {
using SafeTransferLib for address payable;
// for airdrop
bytes32 private _walletsRoot;
bytes32 private _namesRoot;
INameWrapper public nameWrapper;
address public resolver;
bytes32 public parentNode;
uint256 public pricePerTree = 0.001 ether; // ~$2 per tree @ $1900 eth
address payable public nonProfit;
uint256 public nonProfitEarnings;
uint256 public constant RESOLUTION = 1000000000000000; // to not forget multiplier when passing lat longs to plant tree events
struct SellMetadata {
address owner;
uint256 id;
uint256 price;
string subdomain;
}
mapping(uint256 => SellMetadata) public sellData;
mapping(address => bool) public userClaimed;
mapping(string => bool) public domainClaimed;
event TreePlanted(
uint256 indexed fromId,
int256 lat,
int256 long,
uint256 qty
);
event Sold(uint256 indexed id, uint256 price);
event Listed(address indexed owner, uint256 indexed id, uint256 price);
event CancelListing(uint256 indexed id);
constructor(
INameWrapper _nameWrapper,
bytes32 _parentId,
bytes32 walletsRoot,
bytes32 namesRoot,
address _resolver
) {
}
// AIRDROP()
function claim(
string memory subdomain,
bytes32[] memory walletProof,
bytes32[] memory nameProof
) external {
bytes32 leaf = keccak256(
bytes.concat(keccak256(abi.encode(msg.sender)))
);
bytes32 nameLeaf = keccak256(
bytes.concat(keccak256(abi.encode(subdomain)))
);
// check is valid wallet
require(<FILL_ME>)
// check is valid domain
require(
MerkleProof.verify(nameProof, _namesRoot, nameLeaf),
"Invalid name proof"
);
require(!userClaimed[msg.sender], "already claimed");
require(!domainClaimed[subdomain], "already claimed");
userClaimed[msg.sender] = true;
domainClaimed[subdomain] = true;
nameWrapper.setSubnodeRecord(
parentNode, //parentNode
subdomain, //name
msg.sender, //new owner
resolver, //resolver
0, //ttl
0, //fuses
0 //expiry0
);
}
// METHODS()
function list(uint256 id, uint256 price, string memory subdomain) external {
}
function buy(uint256 id) external payable {
}
function cancelListing(uint256 id) external {
}
function plantTree(
uint256 fromId,
uint256 qty,
int256 lat,
int256 long
) external payable {
}
function withdrawEth() external {
}
function _removeUnicode(
string memory str
) internal pure returns (string memory) {
}
function _getHash(string memory label) internal pure returns (bytes32) {
}
function _getNode(bytes32 labelhash) internal view returns (bytes32) {
}
// GETTERS()
function getHoodBoss(
string memory domain
) public view returns (address payable) {
}
// we check if passed domain belongs to the parent enshood.eth
function isValidDomain(
uint256 id,
string memory subdomain
) public view returns (bool) {
}
// returns name of a domain based on nft id
function idToName(uint256 id) public view returns (string memory) {
}
function domainToId(string memory domain) public view returns (uint256) {
}
function isListed(uint256 id) external view returns (bool) {
}
function roadmap() external pure returns (string memory) {
}
// ADMIN()
function setNonProfit(address payable _nonProfit) external onlyOwner {
}
// withdraw parent for future city creation airdrop contracts based on tree planting leaderboard
function withdrawENS() external onlyOwner {
}
function onERC1155BatchReceived(
address,
address,
uint256[] memory,
uint256[] memory,
bytes memory
) public pure returns (bytes4) {
}
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes calldata
) external pure returns (bytes4) {
}
receive() external payable {}
}
|
MerkleProof.verify(walletProof,_walletsRoot,leaf),"Invalid wallet proof"
| 150,136 |
MerkleProof.verify(walletProof,_walletsRoot,leaf)
|
"Invalid name proof"
|
// SPDX-License-Identifier: Do whatever you want
pragma solidity ^0.8.13;
// import {ERC1155} from "solmate/tokens/ERC1155.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {Strings} from "openzeppelin/utils/Strings.sol";
import {Ownable} from "openzeppelin/access/Ownable.sol";
import {MerkleProof} from "openzeppelin/utils/cryptography/MerkleProof.sol";
import {ERC1155Receiver} from "openzeppelin/token/ERC1155/utils/ERC1155Receiver.sol";
import {INameWrapper} from "./INameWrapper.sol";
contract ENSHood is Ownable, ERC1155Receiver {
using SafeTransferLib for address payable;
// for airdrop
bytes32 private _walletsRoot;
bytes32 private _namesRoot;
INameWrapper public nameWrapper;
address public resolver;
bytes32 public parentNode;
uint256 public pricePerTree = 0.001 ether; // ~$2 per tree @ $1900 eth
address payable public nonProfit;
uint256 public nonProfitEarnings;
uint256 public constant RESOLUTION = 1000000000000000; // to not forget multiplier when passing lat longs to plant tree events
struct SellMetadata {
address owner;
uint256 id;
uint256 price;
string subdomain;
}
mapping(uint256 => SellMetadata) public sellData;
mapping(address => bool) public userClaimed;
mapping(string => bool) public domainClaimed;
event TreePlanted(
uint256 indexed fromId,
int256 lat,
int256 long,
uint256 qty
);
event Sold(uint256 indexed id, uint256 price);
event Listed(address indexed owner, uint256 indexed id, uint256 price);
event CancelListing(uint256 indexed id);
constructor(
INameWrapper _nameWrapper,
bytes32 _parentId,
bytes32 walletsRoot,
bytes32 namesRoot,
address _resolver
) {
}
// AIRDROP()
function claim(
string memory subdomain,
bytes32[] memory walletProof,
bytes32[] memory nameProof
) external {
bytes32 leaf = keccak256(
bytes.concat(keccak256(abi.encode(msg.sender)))
);
bytes32 nameLeaf = keccak256(
bytes.concat(keccak256(abi.encode(subdomain)))
);
// check is valid wallet
require(
MerkleProof.verify(walletProof, _walletsRoot, leaf),
"Invalid wallet proof"
);
// check is valid domain
require(<FILL_ME>)
require(!userClaimed[msg.sender], "already claimed");
require(!domainClaimed[subdomain], "already claimed");
userClaimed[msg.sender] = true;
domainClaimed[subdomain] = true;
nameWrapper.setSubnodeRecord(
parentNode, //parentNode
subdomain, //name
msg.sender, //new owner
resolver, //resolver
0, //ttl
0, //fuses
0 //expiry0
);
}
// METHODS()
function list(uint256 id, uint256 price, string memory subdomain) external {
}
function buy(uint256 id) external payable {
}
function cancelListing(uint256 id) external {
}
function plantTree(
uint256 fromId,
uint256 qty,
int256 lat,
int256 long
) external payable {
}
function withdrawEth() external {
}
function _removeUnicode(
string memory str
) internal pure returns (string memory) {
}
function _getHash(string memory label) internal pure returns (bytes32) {
}
function _getNode(bytes32 labelhash) internal view returns (bytes32) {
}
// GETTERS()
function getHoodBoss(
string memory domain
) public view returns (address payable) {
}
// we check if passed domain belongs to the parent enshood.eth
function isValidDomain(
uint256 id,
string memory subdomain
) public view returns (bool) {
}
// returns name of a domain based on nft id
function idToName(uint256 id) public view returns (string memory) {
}
function domainToId(string memory domain) public view returns (uint256) {
}
function isListed(uint256 id) external view returns (bool) {
}
function roadmap() external pure returns (string memory) {
}
// ADMIN()
function setNonProfit(address payable _nonProfit) external onlyOwner {
}
// withdraw parent for future city creation airdrop contracts based on tree planting leaderboard
function withdrawENS() external onlyOwner {
}
function onERC1155BatchReceived(
address,
address,
uint256[] memory,
uint256[] memory,
bytes memory
) public pure returns (bytes4) {
}
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes calldata
) external pure returns (bytes4) {
}
receive() external payable {}
}
|
MerkleProof.verify(nameProof,_namesRoot,nameLeaf),"Invalid name proof"
| 150,136 |
MerkleProof.verify(nameProof,_namesRoot,nameLeaf)
|
"already claimed"
|
// SPDX-License-Identifier: Do whatever you want
pragma solidity ^0.8.13;
// import {ERC1155} from "solmate/tokens/ERC1155.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {Strings} from "openzeppelin/utils/Strings.sol";
import {Ownable} from "openzeppelin/access/Ownable.sol";
import {MerkleProof} from "openzeppelin/utils/cryptography/MerkleProof.sol";
import {ERC1155Receiver} from "openzeppelin/token/ERC1155/utils/ERC1155Receiver.sol";
import {INameWrapper} from "./INameWrapper.sol";
contract ENSHood is Ownable, ERC1155Receiver {
using SafeTransferLib for address payable;
// for airdrop
bytes32 private _walletsRoot;
bytes32 private _namesRoot;
INameWrapper public nameWrapper;
address public resolver;
bytes32 public parentNode;
uint256 public pricePerTree = 0.001 ether; // ~$2 per tree @ $1900 eth
address payable public nonProfit;
uint256 public nonProfitEarnings;
uint256 public constant RESOLUTION = 1000000000000000; // to not forget multiplier when passing lat longs to plant tree events
struct SellMetadata {
address owner;
uint256 id;
uint256 price;
string subdomain;
}
mapping(uint256 => SellMetadata) public sellData;
mapping(address => bool) public userClaimed;
mapping(string => bool) public domainClaimed;
event TreePlanted(
uint256 indexed fromId,
int256 lat,
int256 long,
uint256 qty
);
event Sold(uint256 indexed id, uint256 price);
event Listed(address indexed owner, uint256 indexed id, uint256 price);
event CancelListing(uint256 indexed id);
constructor(
INameWrapper _nameWrapper,
bytes32 _parentId,
bytes32 walletsRoot,
bytes32 namesRoot,
address _resolver
) {
}
// AIRDROP()
function claim(
string memory subdomain,
bytes32[] memory walletProof,
bytes32[] memory nameProof
) external {
bytes32 leaf = keccak256(
bytes.concat(keccak256(abi.encode(msg.sender)))
);
bytes32 nameLeaf = keccak256(
bytes.concat(keccak256(abi.encode(subdomain)))
);
// check is valid wallet
require(
MerkleProof.verify(walletProof, _walletsRoot, leaf),
"Invalid wallet proof"
);
// check is valid domain
require(
MerkleProof.verify(nameProof, _namesRoot, nameLeaf),
"Invalid name proof"
);
require(<FILL_ME>)
require(!domainClaimed[subdomain], "already claimed");
userClaimed[msg.sender] = true;
domainClaimed[subdomain] = true;
nameWrapper.setSubnodeRecord(
parentNode, //parentNode
subdomain, //name
msg.sender, //new owner
resolver, //resolver
0, //ttl
0, //fuses
0 //expiry0
);
}
// METHODS()
function list(uint256 id, uint256 price, string memory subdomain) external {
}
function buy(uint256 id) external payable {
}
function cancelListing(uint256 id) external {
}
function plantTree(
uint256 fromId,
uint256 qty,
int256 lat,
int256 long
) external payable {
}
function withdrawEth() external {
}
function _removeUnicode(
string memory str
) internal pure returns (string memory) {
}
function _getHash(string memory label) internal pure returns (bytes32) {
}
function _getNode(bytes32 labelhash) internal view returns (bytes32) {
}
// GETTERS()
function getHoodBoss(
string memory domain
) public view returns (address payable) {
}
// we check if passed domain belongs to the parent enshood.eth
function isValidDomain(
uint256 id,
string memory subdomain
) public view returns (bool) {
}
// returns name of a domain based on nft id
function idToName(uint256 id) public view returns (string memory) {
}
function domainToId(string memory domain) public view returns (uint256) {
}
function isListed(uint256 id) external view returns (bool) {
}
function roadmap() external pure returns (string memory) {
}
// ADMIN()
function setNonProfit(address payable _nonProfit) external onlyOwner {
}
// withdraw parent for future city creation airdrop contracts based on tree planting leaderboard
function withdrawENS() external onlyOwner {
}
function onERC1155BatchReceived(
address,
address,
uint256[] memory,
uint256[] memory,
bytes memory
) public pure returns (bytes4) {
}
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes calldata
) external pure returns (bytes4) {
}
receive() external payable {}
}
|
!userClaimed[msg.sender],"already claimed"
| 150,136 |
!userClaimed[msg.sender]
|
"already claimed"
|
// SPDX-License-Identifier: Do whatever you want
pragma solidity ^0.8.13;
// import {ERC1155} from "solmate/tokens/ERC1155.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {Strings} from "openzeppelin/utils/Strings.sol";
import {Ownable} from "openzeppelin/access/Ownable.sol";
import {MerkleProof} from "openzeppelin/utils/cryptography/MerkleProof.sol";
import {ERC1155Receiver} from "openzeppelin/token/ERC1155/utils/ERC1155Receiver.sol";
import {INameWrapper} from "./INameWrapper.sol";
contract ENSHood is Ownable, ERC1155Receiver {
using SafeTransferLib for address payable;
// for airdrop
bytes32 private _walletsRoot;
bytes32 private _namesRoot;
INameWrapper public nameWrapper;
address public resolver;
bytes32 public parentNode;
uint256 public pricePerTree = 0.001 ether; // ~$2 per tree @ $1900 eth
address payable public nonProfit;
uint256 public nonProfitEarnings;
uint256 public constant RESOLUTION = 1000000000000000; // to not forget multiplier when passing lat longs to plant tree events
struct SellMetadata {
address owner;
uint256 id;
uint256 price;
string subdomain;
}
mapping(uint256 => SellMetadata) public sellData;
mapping(address => bool) public userClaimed;
mapping(string => bool) public domainClaimed;
event TreePlanted(
uint256 indexed fromId,
int256 lat,
int256 long,
uint256 qty
);
event Sold(uint256 indexed id, uint256 price);
event Listed(address indexed owner, uint256 indexed id, uint256 price);
event CancelListing(uint256 indexed id);
constructor(
INameWrapper _nameWrapper,
bytes32 _parentId,
bytes32 walletsRoot,
bytes32 namesRoot,
address _resolver
) {
}
// AIRDROP()
function claim(
string memory subdomain,
bytes32[] memory walletProof,
bytes32[] memory nameProof
) external {
bytes32 leaf = keccak256(
bytes.concat(keccak256(abi.encode(msg.sender)))
);
bytes32 nameLeaf = keccak256(
bytes.concat(keccak256(abi.encode(subdomain)))
);
// check is valid wallet
require(
MerkleProof.verify(walletProof, _walletsRoot, leaf),
"Invalid wallet proof"
);
// check is valid domain
require(
MerkleProof.verify(nameProof, _namesRoot, nameLeaf),
"Invalid name proof"
);
require(!userClaimed[msg.sender], "already claimed");
require(<FILL_ME>)
userClaimed[msg.sender] = true;
domainClaimed[subdomain] = true;
nameWrapper.setSubnodeRecord(
parentNode, //parentNode
subdomain, //name
msg.sender, //new owner
resolver, //resolver
0, //ttl
0, //fuses
0 //expiry0
);
}
// METHODS()
function list(uint256 id, uint256 price, string memory subdomain) external {
}
function buy(uint256 id) external payable {
}
function cancelListing(uint256 id) external {
}
function plantTree(
uint256 fromId,
uint256 qty,
int256 lat,
int256 long
) external payable {
}
function withdrawEth() external {
}
function _removeUnicode(
string memory str
) internal pure returns (string memory) {
}
function _getHash(string memory label) internal pure returns (bytes32) {
}
function _getNode(bytes32 labelhash) internal view returns (bytes32) {
}
// GETTERS()
function getHoodBoss(
string memory domain
) public view returns (address payable) {
}
// we check if passed domain belongs to the parent enshood.eth
function isValidDomain(
uint256 id,
string memory subdomain
) public view returns (bool) {
}
// returns name of a domain based on nft id
function idToName(uint256 id) public view returns (string memory) {
}
function domainToId(string memory domain) public view returns (uint256) {
}
function isListed(uint256 id) external view returns (bool) {
}
function roadmap() external pure returns (string memory) {
}
// ADMIN()
function setNonProfit(address payable _nonProfit) external onlyOwner {
}
// withdraw parent for future city creation airdrop contracts based on tree planting leaderboard
function withdrawENS() external onlyOwner {
}
function onERC1155BatchReceived(
address,
address,
uint256[] memory,
uint256[] memory,
bytes memory
) public pure returns (bytes4) {
}
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes calldata
) external pure returns (bytes4) {
}
receive() external payable {}
}
|
!domainClaimed[subdomain],"already claimed"
| 150,136 |
!domainClaimed[subdomain]
|
"not valid domain"
|
// SPDX-License-Identifier: Do whatever you want
pragma solidity ^0.8.13;
// import {ERC1155} from "solmate/tokens/ERC1155.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {Strings} from "openzeppelin/utils/Strings.sol";
import {Ownable} from "openzeppelin/access/Ownable.sol";
import {MerkleProof} from "openzeppelin/utils/cryptography/MerkleProof.sol";
import {ERC1155Receiver} from "openzeppelin/token/ERC1155/utils/ERC1155Receiver.sol";
import {INameWrapper} from "./INameWrapper.sol";
contract ENSHood is Ownable, ERC1155Receiver {
using SafeTransferLib for address payable;
// for airdrop
bytes32 private _walletsRoot;
bytes32 private _namesRoot;
INameWrapper public nameWrapper;
address public resolver;
bytes32 public parentNode;
uint256 public pricePerTree = 0.001 ether; // ~$2 per tree @ $1900 eth
address payable public nonProfit;
uint256 public nonProfitEarnings;
uint256 public constant RESOLUTION = 1000000000000000; // to not forget multiplier when passing lat longs to plant tree events
struct SellMetadata {
address owner;
uint256 id;
uint256 price;
string subdomain;
}
mapping(uint256 => SellMetadata) public sellData;
mapping(address => bool) public userClaimed;
mapping(string => bool) public domainClaimed;
event TreePlanted(
uint256 indexed fromId,
int256 lat,
int256 long,
uint256 qty
);
event Sold(uint256 indexed id, uint256 price);
event Listed(address indexed owner, uint256 indexed id, uint256 price);
event CancelListing(uint256 indexed id);
constructor(
INameWrapper _nameWrapper,
bytes32 _parentId,
bytes32 walletsRoot,
bytes32 namesRoot,
address _resolver
) {
}
// AIRDROP()
function claim(
string memory subdomain,
bytes32[] memory walletProof,
bytes32[] memory nameProof
) external {
}
// METHODS()
function list(uint256 id, uint256 price, string memory subdomain) external {
require(<FILL_ME>)
nameWrapper.safeTransferFrom(msg.sender, address(this), id, 1, "");
sellData[id] = SellMetadata({
owner: msg.sender,
id: id,
price: price,
subdomain: subdomain
});
emit Listed(msg.sender, id, price);
}
function buy(uint256 id) external payable {
}
function cancelListing(uint256 id) external {
}
function plantTree(
uint256 fromId,
uint256 qty,
int256 lat,
int256 long
) external payable {
}
function withdrawEth() external {
}
function _removeUnicode(
string memory str
) internal pure returns (string memory) {
}
function _getHash(string memory label) internal pure returns (bytes32) {
}
function _getNode(bytes32 labelhash) internal view returns (bytes32) {
}
// GETTERS()
function getHoodBoss(
string memory domain
) public view returns (address payable) {
}
// we check if passed domain belongs to the parent enshood.eth
function isValidDomain(
uint256 id,
string memory subdomain
) public view returns (bool) {
}
// returns name of a domain based on nft id
function idToName(uint256 id) public view returns (string memory) {
}
function domainToId(string memory domain) public view returns (uint256) {
}
function isListed(uint256 id) external view returns (bool) {
}
function roadmap() external pure returns (string memory) {
}
// ADMIN()
function setNonProfit(address payable _nonProfit) external onlyOwner {
}
// withdraw parent for future city creation airdrop contracts based on tree planting leaderboard
function withdrawENS() external onlyOwner {
}
function onERC1155BatchReceived(
address,
address,
uint256[] memory,
uint256[] memory,
bytes memory
) public pure returns (bytes4) {
}
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes calldata
) external pure returns (bytes4) {
}
receive() external payable {}
}
|
isValidDomain(id,subdomain),"not valid domain"
| 150,136 |
isValidDomain(id,subdomain)
|
null |
// SPDX-License-Identifier: Do whatever you want
pragma solidity ^0.8.13;
// import {ERC1155} from "solmate/tokens/ERC1155.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {Strings} from "openzeppelin/utils/Strings.sol";
import {Ownable} from "openzeppelin/access/Ownable.sol";
import {MerkleProof} from "openzeppelin/utils/cryptography/MerkleProof.sol";
import {ERC1155Receiver} from "openzeppelin/token/ERC1155/utils/ERC1155Receiver.sol";
import {INameWrapper} from "./INameWrapper.sol";
contract ENSHood is Ownable, ERC1155Receiver {
using SafeTransferLib for address payable;
// for airdrop
bytes32 private _walletsRoot;
bytes32 private _namesRoot;
INameWrapper public nameWrapper;
address public resolver;
bytes32 public parentNode;
uint256 public pricePerTree = 0.001 ether; // ~$2 per tree @ $1900 eth
address payable public nonProfit;
uint256 public nonProfitEarnings;
uint256 public constant RESOLUTION = 1000000000000000; // to not forget multiplier when passing lat longs to plant tree events
struct SellMetadata {
address owner;
uint256 id;
uint256 price;
string subdomain;
}
mapping(uint256 => SellMetadata) public sellData;
mapping(address => bool) public userClaimed;
mapping(string => bool) public domainClaimed;
event TreePlanted(
uint256 indexed fromId,
int256 lat,
int256 long,
uint256 qty
);
event Sold(uint256 indexed id, uint256 price);
event Listed(address indexed owner, uint256 indexed id, uint256 price);
event CancelListing(uint256 indexed id);
constructor(
INameWrapper _nameWrapper,
bytes32 _parentId,
bytes32 walletsRoot,
bytes32 namesRoot,
address _resolver
) {
}
// AIRDROP()
function claim(
string memory subdomain,
bytes32[] memory walletProof,
bytes32[] memory nameProof
) external {
}
// METHODS()
function list(uint256 id, uint256 price, string memory subdomain) external {
}
function buy(uint256 id) external payable {
}
function cancelListing(uint256 id) external {
}
function plantTree(
uint256 fromId,
uint256 qty,
int256 lat,
int256 long
) external payable {
require(<FILL_ME>)
nonProfitEarnings = nonProfitEarnings + msg.value;
// emit event to create leadaerboard off chain. whitelist for new land claims based on rules that can also change if a community forms
emit TreePlanted(fromId, lat, long, qty);
}
function withdrawEth() external {
}
function _removeUnicode(
string memory str
) internal pure returns (string memory) {
}
function _getHash(string memory label) internal pure returns (bytes32) {
}
function _getNode(bytes32 labelhash) internal view returns (bytes32) {
}
// GETTERS()
function getHoodBoss(
string memory domain
) public view returns (address payable) {
}
// we check if passed domain belongs to the parent enshood.eth
function isValidDomain(
uint256 id,
string memory subdomain
) public view returns (bool) {
}
// returns name of a domain based on nft id
function idToName(uint256 id) public view returns (string memory) {
}
function domainToId(string memory domain) public view returns (uint256) {
}
function isListed(uint256 id) external view returns (bool) {
}
function roadmap() external pure returns (string memory) {
}
// ADMIN()
function setNonProfit(address payable _nonProfit) external onlyOwner {
}
// withdraw parent for future city creation airdrop contracts based on tree planting leaderboard
function withdrawENS() external onlyOwner {
}
function onERC1155BatchReceived(
address,
address,
uint256[] memory,
uint256[] memory,
bytes memory
) public pure returns (bytes4) {
}
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes calldata
) external pure returns (bytes4) {
}
receive() external payable {}
}
|
msg.value>=(qty*pricePerTree)
| 150,136 |
msg.value>=(qty*pricePerTree)
|
ErrorCodes.ZERO_ADDRESS
|
// SPDX-License-Identifier: BSD-3-Clause
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Multicall.sol";
import "./interfaces/ILiquidation.sol";
import "./libraries/ErrorCodes.sol";
import "./InterconnectorLeaf.sol";
/**
* This contract provides the liquidation functionality.
*/
contract Liquidation is ILiquidation, AccessControl, ReentrancyGuard, Multicall, InterconnectorLeaf {
using SafeERC20 for IERC20;
/// @notice Value is the Keccak-256 hash of "TRUSTED_LIQUIDATOR"
/// @dev Role that's allowed to liquidate in Auto mode
bytes32 public constant TRUSTED_LIQUIDATOR =
bytes32(0xf81d27a41879d78d5568e0bc2989cb321b89b84d8e1b49895ee98604626c0218);
/// @notice Value is the Keccak-256 hash of "MANUAL_LIQUIDATOR"
/// @dev Role that's allowed to liquidate in Manual mode.
/// Each MANUAL_LIQUIDATOR address has to be appended to TRUSTED_LIQUIDATOR role too.
bytes32 public constant MANUAL_LIQUIDATOR =
bytes32(0x53402487d33e65b38c49f6f89bd08cbec4ff7c074cddd2357722b7917cd13f1e);
/// @dev Value is the Keccak-256 hash of "TIMELOCK"
bytes32 public constant TIMELOCK = bytes32(0xaefebe170cbaff0af052a32795af0e1b8afff9850f946ad2869be14f35534371);
uint256 private constant EXP_SCALE = 1e18;
/**
* @notice Minterest supervisor contract
*/
ISupervisor public immutable supervisor;
/**
* @notice The maximum allowable value of a healthy factor after liquidation, scaled by 1e18
*/
uint256 public healthyFactorLimit = 1.2e18; // 120%
/**
* @notice Maximum sum in USD for internal liquidation. Collateral for loans that are less than this parameter will
* be counted as protocol interest, scaled by 1e18
*/
uint256 public insignificantLoanThreshold; // 0$ by default
/**
* @notice Minterest deadDrop address or contract
*/
address public deadDrop;
/**
* @dev Flag that defines whether liquidation will update the processing state field of deaddrop contract
*/
bool public useProcessingState;
/**
* @notice Construct a Liquidation contract
* @param deadDrop_ Minterest deadDrop address
* @param liquidators_ Array of addresses of liquidators
* @param supervisor_ The address of the Supervisor contract
* @param admin_ The address of the admin
*/
constructor(
address[] memory liquidators_,
address deadDrop_,
ISupervisor supervisor_,
address admin_
) {
require(deadDrop_ != address(0), ErrorCodes.ZERO_ADDRESS);
require(<FILL_ME>)
require(admin_ != address(0), ErrorCodes.ZERO_ADDRESS);
supervisor = supervisor_;
deadDrop = deadDrop_;
_grantRole(DEFAULT_ADMIN_ROLE, admin_);
_grantRole(TRUSTED_LIQUIDATOR, admin_);
_grantRole(MANUAL_LIQUIDATOR, admin_);
_grantRole(TIMELOCK, admin_);
for (uint256 i = 0; i < liquidators_.length; i++) {
_grantRole(TRUSTED_LIQUIDATOR, liquidators_[i]);
}
}
/// @inheritdoc ILiquidation
function liquidateUnsafeLoan(
address borrower_,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) external onlyRole(TRUSTED_LIQUIDATOR) nonReentrant {
}
/**
* @notice Checks if input data meets requirements
* @param accountAssetsLength The length of borrower's accountAssets array
* @param seizeIndexes_ An array with market indexes that will be used as collateral.
* Each element corresponds to the market index in the accountAssets array
* @param debtRates_ An array of debt redemption rates for each debt markets (scaled by 1e18).
* @dev Indexes for arrays accountAssets && debtRates match each other
*/
function verifyExternalData(
uint256 accountAssetsLength,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) internal pure {
}
/// @inheritdoc ILiquidation
function accrue(
IMToken[] memory accountAssets,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) public {
}
/**
* @notice Determines whether an array includes a certain value among its entries
* @param index_ The value to search for
* @param seizeIndexes_ An array with market indexes that will be used as collateral.
* @return bool Returning true or false as appropriate.
*/
function includes(uint256 index_, uint256[] memory seizeIndexes_) internal pure returns (bool) {
}
/**
* @dev Local marketParams for avoiding stack-depth limits in calculating liquidation amounts.
*/
struct MarketParams {
uint256 supplyWrap;
uint256 borrowUnderlying;
uint256 exchangeRateMantissa;
uint256 liquidationFeeMantissa;
uint256 utilisationFactorMantissa;
}
/// @inheritdoc ILiquidation
function calculateLiquidationAmounts(
address account_,
IMToken[] memory marketAddresses,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) public view virtual returns (AccountLiquidationAmounts memory accountState) {
}
/**
* @dev Burns collateral tokens at the borrower's address, transfer underlying assets
* to the deadDrop or ManualLiquidator address, if loan is not insignificant, otherwise, all account's
* collateral is credited to the protocolInterest. Process all borrower's markets.
* @param borrower_ The account having collateral seized
* @param marketAddresses_ Array of markets the borrower is in
* @param seizeUnderlyingAmounts_ Array of seize amounts in underlying assets
* @param isLoanInsignificant_ Marker for insignificant loan whose collateral must be credited to the
* protocolInterest
* @param isManualLiquidation_ Marker for manual liquidation process.
*/
function seize(
address borrower_,
IMToken[] memory marketAddresses_,
uint256[] memory seizeUnderlyingAmounts_,
bool isLoanInsignificant_,
bool isManualLiquidation_
) internal {
}
/**
* @dev Liquidator repays a borrow belonging to borrower. Process all borrower's markets.
* @param borrower_ The account with the debt being payed off
* @param marketAddresses_ Array of markets the borrower is in
* @param repayAmounts_ Array of repay amounts in underlying assets
* @param isManualLiquidation_ Marker for manual liquidation process.
* Note: The calling code must be sure that the oracle price for all processed markets is greater than zero.
*/
function repay(
address borrower_,
IMToken[] memory marketAddresses_,
uint256[] memory repayAmounts_,
bool isManualLiquidation_
) internal {
}
/**
* @dev Approve that current healthy factor satisfies the condition:
* currentHealthyFactor <= healthyFactorLimit
* @param borrower_ The account with the debt being payed off
* @param marketAddresses_ Array of markets the borrower is in
* @return Whether or not the current account healthy factor is correct
*/
function approveBorrowerHealthyFactor(address borrower_, IMToken[] memory marketAddresses_)
internal
view
returns (bool)
{
}
/*** Admin Functions ***/
/// @inheritdoc ILiquidation
function setHealthyFactorLimit(uint256 newValue_) external onlyRole(TIMELOCK) {
}
/// @inheritdoc ILiquidation
function setDeadDrop(address newDeadDrop_) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/// @inheritdoc ILiquidation
function setInsignificantLoanThreshold(uint256 newValue_) external onlyRole(TIMELOCK) {
}
/// @inheritdoc ILiquidation
function setProcessingStateUsage(bool newValue) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/// @notice get contract PriceOracle
function oracle() internal view returns (IPriceOracle) {
}
}
|
address(supervisor_)!=address(0),ErrorCodes.ZERO_ADDRESS
| 150,144 |
address(supervisor_)!=address(0)
|
ErrorCodes.HEALTHY_FACTOR_NOT_IN_RANGE
|
// SPDX-License-Identifier: BSD-3-Clause
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Multicall.sol";
import "./interfaces/ILiquidation.sol";
import "./libraries/ErrorCodes.sol";
import "./InterconnectorLeaf.sol";
/**
* This contract provides the liquidation functionality.
*/
contract Liquidation is ILiquidation, AccessControl, ReentrancyGuard, Multicall, InterconnectorLeaf {
using SafeERC20 for IERC20;
/// @notice Value is the Keccak-256 hash of "TRUSTED_LIQUIDATOR"
/// @dev Role that's allowed to liquidate in Auto mode
bytes32 public constant TRUSTED_LIQUIDATOR =
bytes32(0xf81d27a41879d78d5568e0bc2989cb321b89b84d8e1b49895ee98604626c0218);
/// @notice Value is the Keccak-256 hash of "MANUAL_LIQUIDATOR"
/// @dev Role that's allowed to liquidate in Manual mode.
/// Each MANUAL_LIQUIDATOR address has to be appended to TRUSTED_LIQUIDATOR role too.
bytes32 public constant MANUAL_LIQUIDATOR =
bytes32(0x53402487d33e65b38c49f6f89bd08cbec4ff7c074cddd2357722b7917cd13f1e);
/// @dev Value is the Keccak-256 hash of "TIMELOCK"
bytes32 public constant TIMELOCK = bytes32(0xaefebe170cbaff0af052a32795af0e1b8afff9850f946ad2869be14f35534371);
uint256 private constant EXP_SCALE = 1e18;
/**
* @notice Minterest supervisor contract
*/
ISupervisor public immutable supervisor;
/**
* @notice The maximum allowable value of a healthy factor after liquidation, scaled by 1e18
*/
uint256 public healthyFactorLimit = 1.2e18; // 120%
/**
* @notice Maximum sum in USD for internal liquidation. Collateral for loans that are less than this parameter will
* be counted as protocol interest, scaled by 1e18
*/
uint256 public insignificantLoanThreshold; // 0$ by default
/**
* @notice Minterest deadDrop address or contract
*/
address public deadDrop;
/**
* @dev Flag that defines whether liquidation will update the processing state field of deaddrop contract
*/
bool public useProcessingState;
/**
* @notice Construct a Liquidation contract
* @param deadDrop_ Minterest deadDrop address
* @param liquidators_ Array of addresses of liquidators
* @param supervisor_ The address of the Supervisor contract
* @param admin_ The address of the admin
*/
constructor(
address[] memory liquidators_,
address deadDrop_,
ISupervisor supervisor_,
address admin_
) {
}
/// @inheritdoc ILiquidation
function liquidateUnsafeLoan(
address borrower_,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) external onlyRole(TRUSTED_LIQUIDATOR) nonReentrant {
AccountLiquidationAmounts memory accountState;
IMToken[] memory accountAssets = supervisor.getAccountAssets(borrower_);
verifyExternalData(accountAssets.length, seizeIndexes_, debtRates_);
if (useProcessingState) {
IDeadDrop(deadDrop).initialiseLiquidation(borrower_, block.number);
}
accrue(accountAssets, seizeIndexes_, debtRates_);
accountState = calculateLiquidationAmounts(borrower_, accountAssets, seizeIndexes_, debtRates_);
require(
accountState.accountTotalCollateralUsd < accountState.accountTotalBorrowUsd,
ErrorCodes.INSUFFICIENT_SHORTFALL
);
bool isManualLiquidation = hasRole(MANUAL_LIQUIDATOR, msg.sender);
bool isDebtHealthy = accountState.accountPresumedTotalRepayUsd >= accountState.accountTotalBorrowUsd;
seize(
borrower_,
accountAssets,
accountState.seizeAmounts,
accountState.accountTotalBorrowUsd <= insignificantLoanThreshold,
isManualLiquidation
);
repay(borrower_, accountAssets, accountState.repayAmounts, isManualLiquidation);
if (isDebtHealthy) {
require(<FILL_ME>)
}
emit ReliableLiquidation(
isManualLiquidation,
isDebtHealthy,
msg.sender,
borrower_,
accountAssets,
seizeIndexes_,
debtRates_
);
}
/**
* @notice Checks if input data meets requirements
* @param accountAssetsLength The length of borrower's accountAssets array
* @param seizeIndexes_ An array with market indexes that will be used as collateral.
* Each element corresponds to the market index in the accountAssets array
* @param debtRates_ An array of debt redemption rates for each debt markets (scaled by 1e18).
* @dev Indexes for arrays accountAssets && debtRates match each other
*/
function verifyExternalData(
uint256 accountAssetsLength,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) internal pure {
}
/// @inheritdoc ILiquidation
function accrue(
IMToken[] memory accountAssets,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) public {
}
/**
* @notice Determines whether an array includes a certain value among its entries
* @param index_ The value to search for
* @param seizeIndexes_ An array with market indexes that will be used as collateral.
* @return bool Returning true or false as appropriate.
*/
function includes(uint256 index_, uint256[] memory seizeIndexes_) internal pure returns (bool) {
}
/**
* @dev Local marketParams for avoiding stack-depth limits in calculating liquidation amounts.
*/
struct MarketParams {
uint256 supplyWrap;
uint256 borrowUnderlying;
uint256 exchangeRateMantissa;
uint256 liquidationFeeMantissa;
uint256 utilisationFactorMantissa;
}
/// @inheritdoc ILiquidation
function calculateLiquidationAmounts(
address account_,
IMToken[] memory marketAddresses,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) public view virtual returns (AccountLiquidationAmounts memory accountState) {
}
/**
* @dev Burns collateral tokens at the borrower's address, transfer underlying assets
* to the deadDrop or ManualLiquidator address, if loan is not insignificant, otherwise, all account's
* collateral is credited to the protocolInterest. Process all borrower's markets.
* @param borrower_ The account having collateral seized
* @param marketAddresses_ Array of markets the borrower is in
* @param seizeUnderlyingAmounts_ Array of seize amounts in underlying assets
* @param isLoanInsignificant_ Marker for insignificant loan whose collateral must be credited to the
* protocolInterest
* @param isManualLiquidation_ Marker for manual liquidation process.
*/
function seize(
address borrower_,
IMToken[] memory marketAddresses_,
uint256[] memory seizeUnderlyingAmounts_,
bool isLoanInsignificant_,
bool isManualLiquidation_
) internal {
}
/**
* @dev Liquidator repays a borrow belonging to borrower. Process all borrower's markets.
* @param borrower_ The account with the debt being payed off
* @param marketAddresses_ Array of markets the borrower is in
* @param repayAmounts_ Array of repay amounts in underlying assets
* @param isManualLiquidation_ Marker for manual liquidation process.
* Note: The calling code must be sure that the oracle price for all processed markets is greater than zero.
*/
function repay(
address borrower_,
IMToken[] memory marketAddresses_,
uint256[] memory repayAmounts_,
bool isManualLiquidation_
) internal {
}
/**
* @dev Approve that current healthy factor satisfies the condition:
* currentHealthyFactor <= healthyFactorLimit
* @param borrower_ The account with the debt being payed off
* @param marketAddresses_ Array of markets the borrower is in
* @return Whether or not the current account healthy factor is correct
*/
function approveBorrowerHealthyFactor(address borrower_, IMToken[] memory marketAddresses_)
internal
view
returns (bool)
{
}
/*** Admin Functions ***/
/// @inheritdoc ILiquidation
function setHealthyFactorLimit(uint256 newValue_) external onlyRole(TIMELOCK) {
}
/// @inheritdoc ILiquidation
function setDeadDrop(address newDeadDrop_) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/// @inheritdoc ILiquidation
function setInsignificantLoanThreshold(uint256 newValue_) external onlyRole(TIMELOCK) {
}
/// @inheritdoc ILiquidation
function setProcessingStateUsage(bool newValue) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/// @notice get contract PriceOracle
function oracle() internal view returns (IPriceOracle) {
}
}
|
approveBorrowerHealthyFactor(borrower_,accountAssets),ErrorCodes.HEALTHY_FACTOR_NOT_IN_RANGE
| 150,144 |
approveBorrowerHealthyFactor(borrower_,accountAssets)
|
ErrorCodes.LQ_INVALID_DEBT_REDEMPTION_RATE
|
// SPDX-License-Identifier: BSD-3-Clause
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Multicall.sol";
import "./interfaces/ILiquidation.sol";
import "./libraries/ErrorCodes.sol";
import "./InterconnectorLeaf.sol";
/**
* This contract provides the liquidation functionality.
*/
contract Liquidation is ILiquidation, AccessControl, ReentrancyGuard, Multicall, InterconnectorLeaf {
using SafeERC20 for IERC20;
/// @notice Value is the Keccak-256 hash of "TRUSTED_LIQUIDATOR"
/// @dev Role that's allowed to liquidate in Auto mode
bytes32 public constant TRUSTED_LIQUIDATOR =
bytes32(0xf81d27a41879d78d5568e0bc2989cb321b89b84d8e1b49895ee98604626c0218);
/// @notice Value is the Keccak-256 hash of "MANUAL_LIQUIDATOR"
/// @dev Role that's allowed to liquidate in Manual mode.
/// Each MANUAL_LIQUIDATOR address has to be appended to TRUSTED_LIQUIDATOR role too.
bytes32 public constant MANUAL_LIQUIDATOR =
bytes32(0x53402487d33e65b38c49f6f89bd08cbec4ff7c074cddd2357722b7917cd13f1e);
/// @dev Value is the Keccak-256 hash of "TIMELOCK"
bytes32 public constant TIMELOCK = bytes32(0xaefebe170cbaff0af052a32795af0e1b8afff9850f946ad2869be14f35534371);
uint256 private constant EXP_SCALE = 1e18;
/**
* @notice Minterest supervisor contract
*/
ISupervisor public immutable supervisor;
/**
* @notice The maximum allowable value of a healthy factor after liquidation, scaled by 1e18
*/
uint256 public healthyFactorLimit = 1.2e18; // 120%
/**
* @notice Maximum sum in USD for internal liquidation. Collateral for loans that are less than this parameter will
* be counted as protocol interest, scaled by 1e18
*/
uint256 public insignificantLoanThreshold; // 0$ by default
/**
* @notice Minterest deadDrop address or contract
*/
address public deadDrop;
/**
* @dev Flag that defines whether liquidation will update the processing state field of deaddrop contract
*/
bool public useProcessingState;
/**
* @notice Construct a Liquidation contract
* @param deadDrop_ Minterest deadDrop address
* @param liquidators_ Array of addresses of liquidators
* @param supervisor_ The address of the Supervisor contract
* @param admin_ The address of the admin
*/
constructor(
address[] memory liquidators_,
address deadDrop_,
ISupervisor supervisor_,
address admin_
) {
}
/// @inheritdoc ILiquidation
function liquidateUnsafeLoan(
address borrower_,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) external onlyRole(TRUSTED_LIQUIDATOR) nonReentrant {
}
/**
* @notice Checks if input data meets requirements
* @param accountAssetsLength The length of borrower's accountAssets array
* @param seizeIndexes_ An array with market indexes that will be used as collateral.
* Each element corresponds to the market index in the accountAssets array
* @param debtRates_ An array of debt redemption rates for each debt markets (scaled by 1e18).
* @dev Indexes for arrays accountAssets && debtRates match each other
*/
function verifyExternalData(
uint256 accountAssetsLength,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) internal pure {
uint256 debtRatesLength = debtRates_.length;
uint256 seizeIndexesLength = seizeIndexes_.length;
require(accountAssetsLength != 0 && debtRatesLength == accountAssetsLength, ErrorCodes.LQ_INVALID_DRR_ARRAY);
require(
seizeIndexesLength != 0 && seizeIndexesLength <= accountAssetsLength,
ErrorCodes.LQ_INVALID_SEIZE_ARRAY
);
// Check all DRR are <= 100%
for (uint256 i = 0; i < debtRatesLength; i++) {
require(<FILL_ME>)
}
// Check all seizeIndexes are <= to (accountAssetsLength - 1)
for (uint256 i = 0; i < seizeIndexesLength; i++) {
require(seizeIndexes_[i] < accountAssetsLength, ErrorCodes.LQ_INVALID_SEIZE_INDEX);
// Check seizeIndexes array does not contain duplicates
for (uint256 j = i + 1; j < seizeIndexesLength; j++) {
require(seizeIndexes_[i] != seizeIndexes_[j], ErrorCodes.LQ_DUPLICATE_SEIZE_INDEX);
}
}
}
/// @inheritdoc ILiquidation
function accrue(
IMToken[] memory accountAssets,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) public {
}
/**
* @notice Determines whether an array includes a certain value among its entries
* @param index_ The value to search for
* @param seizeIndexes_ An array with market indexes that will be used as collateral.
* @return bool Returning true or false as appropriate.
*/
function includes(uint256 index_, uint256[] memory seizeIndexes_) internal pure returns (bool) {
}
/**
* @dev Local marketParams for avoiding stack-depth limits in calculating liquidation amounts.
*/
struct MarketParams {
uint256 supplyWrap;
uint256 borrowUnderlying;
uint256 exchangeRateMantissa;
uint256 liquidationFeeMantissa;
uint256 utilisationFactorMantissa;
}
/// @inheritdoc ILiquidation
function calculateLiquidationAmounts(
address account_,
IMToken[] memory marketAddresses,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) public view virtual returns (AccountLiquidationAmounts memory accountState) {
}
/**
* @dev Burns collateral tokens at the borrower's address, transfer underlying assets
* to the deadDrop or ManualLiquidator address, if loan is not insignificant, otherwise, all account's
* collateral is credited to the protocolInterest. Process all borrower's markets.
* @param borrower_ The account having collateral seized
* @param marketAddresses_ Array of markets the borrower is in
* @param seizeUnderlyingAmounts_ Array of seize amounts in underlying assets
* @param isLoanInsignificant_ Marker for insignificant loan whose collateral must be credited to the
* protocolInterest
* @param isManualLiquidation_ Marker for manual liquidation process.
*/
function seize(
address borrower_,
IMToken[] memory marketAddresses_,
uint256[] memory seizeUnderlyingAmounts_,
bool isLoanInsignificant_,
bool isManualLiquidation_
) internal {
}
/**
* @dev Liquidator repays a borrow belonging to borrower. Process all borrower's markets.
* @param borrower_ The account with the debt being payed off
* @param marketAddresses_ Array of markets the borrower is in
* @param repayAmounts_ Array of repay amounts in underlying assets
* @param isManualLiquidation_ Marker for manual liquidation process.
* Note: The calling code must be sure that the oracle price for all processed markets is greater than zero.
*/
function repay(
address borrower_,
IMToken[] memory marketAddresses_,
uint256[] memory repayAmounts_,
bool isManualLiquidation_
) internal {
}
/**
* @dev Approve that current healthy factor satisfies the condition:
* currentHealthyFactor <= healthyFactorLimit
* @param borrower_ The account with the debt being payed off
* @param marketAddresses_ Array of markets the borrower is in
* @return Whether or not the current account healthy factor is correct
*/
function approveBorrowerHealthyFactor(address borrower_, IMToken[] memory marketAddresses_)
internal
view
returns (bool)
{
}
/*** Admin Functions ***/
/// @inheritdoc ILiquidation
function setHealthyFactorLimit(uint256 newValue_) external onlyRole(TIMELOCK) {
}
/// @inheritdoc ILiquidation
function setDeadDrop(address newDeadDrop_) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/// @inheritdoc ILiquidation
function setInsignificantLoanThreshold(uint256 newValue_) external onlyRole(TIMELOCK) {
}
/// @inheritdoc ILiquidation
function setProcessingStateUsage(bool newValue) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/// @notice get contract PriceOracle
function oracle() internal view returns (IPriceOracle) {
}
}
|
debtRates_[i]<=EXP_SCALE,ErrorCodes.LQ_INVALID_DEBT_REDEMPTION_RATE
| 150,144 |
debtRates_[i]<=EXP_SCALE
|
ErrorCodes.LQ_INVALID_SEIZE_INDEX
|
// SPDX-License-Identifier: BSD-3-Clause
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Multicall.sol";
import "./interfaces/ILiquidation.sol";
import "./libraries/ErrorCodes.sol";
import "./InterconnectorLeaf.sol";
/**
* This contract provides the liquidation functionality.
*/
contract Liquidation is ILiquidation, AccessControl, ReentrancyGuard, Multicall, InterconnectorLeaf {
using SafeERC20 for IERC20;
/// @notice Value is the Keccak-256 hash of "TRUSTED_LIQUIDATOR"
/// @dev Role that's allowed to liquidate in Auto mode
bytes32 public constant TRUSTED_LIQUIDATOR =
bytes32(0xf81d27a41879d78d5568e0bc2989cb321b89b84d8e1b49895ee98604626c0218);
/// @notice Value is the Keccak-256 hash of "MANUAL_LIQUIDATOR"
/// @dev Role that's allowed to liquidate in Manual mode.
/// Each MANUAL_LIQUIDATOR address has to be appended to TRUSTED_LIQUIDATOR role too.
bytes32 public constant MANUAL_LIQUIDATOR =
bytes32(0x53402487d33e65b38c49f6f89bd08cbec4ff7c074cddd2357722b7917cd13f1e);
/// @dev Value is the Keccak-256 hash of "TIMELOCK"
bytes32 public constant TIMELOCK = bytes32(0xaefebe170cbaff0af052a32795af0e1b8afff9850f946ad2869be14f35534371);
uint256 private constant EXP_SCALE = 1e18;
/**
* @notice Minterest supervisor contract
*/
ISupervisor public immutable supervisor;
/**
* @notice The maximum allowable value of a healthy factor after liquidation, scaled by 1e18
*/
uint256 public healthyFactorLimit = 1.2e18; // 120%
/**
* @notice Maximum sum in USD for internal liquidation. Collateral for loans that are less than this parameter will
* be counted as protocol interest, scaled by 1e18
*/
uint256 public insignificantLoanThreshold; // 0$ by default
/**
* @notice Minterest deadDrop address or contract
*/
address public deadDrop;
/**
* @dev Flag that defines whether liquidation will update the processing state field of deaddrop contract
*/
bool public useProcessingState;
/**
* @notice Construct a Liquidation contract
* @param deadDrop_ Minterest deadDrop address
* @param liquidators_ Array of addresses of liquidators
* @param supervisor_ The address of the Supervisor contract
* @param admin_ The address of the admin
*/
constructor(
address[] memory liquidators_,
address deadDrop_,
ISupervisor supervisor_,
address admin_
) {
}
/// @inheritdoc ILiquidation
function liquidateUnsafeLoan(
address borrower_,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) external onlyRole(TRUSTED_LIQUIDATOR) nonReentrant {
}
/**
* @notice Checks if input data meets requirements
* @param accountAssetsLength The length of borrower's accountAssets array
* @param seizeIndexes_ An array with market indexes that will be used as collateral.
* Each element corresponds to the market index in the accountAssets array
* @param debtRates_ An array of debt redemption rates for each debt markets (scaled by 1e18).
* @dev Indexes for arrays accountAssets && debtRates match each other
*/
function verifyExternalData(
uint256 accountAssetsLength,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) internal pure {
uint256 debtRatesLength = debtRates_.length;
uint256 seizeIndexesLength = seizeIndexes_.length;
require(accountAssetsLength != 0 && debtRatesLength == accountAssetsLength, ErrorCodes.LQ_INVALID_DRR_ARRAY);
require(
seizeIndexesLength != 0 && seizeIndexesLength <= accountAssetsLength,
ErrorCodes.LQ_INVALID_SEIZE_ARRAY
);
// Check all DRR are <= 100%
for (uint256 i = 0; i < debtRatesLength; i++) {
require(debtRates_[i] <= EXP_SCALE, ErrorCodes.LQ_INVALID_DEBT_REDEMPTION_RATE);
}
// Check all seizeIndexes are <= to (accountAssetsLength - 1)
for (uint256 i = 0; i < seizeIndexesLength; i++) {
require(<FILL_ME>)
// Check seizeIndexes array does not contain duplicates
for (uint256 j = i + 1; j < seizeIndexesLength; j++) {
require(seizeIndexes_[i] != seizeIndexes_[j], ErrorCodes.LQ_DUPLICATE_SEIZE_INDEX);
}
}
}
/// @inheritdoc ILiquidation
function accrue(
IMToken[] memory accountAssets,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) public {
}
/**
* @notice Determines whether an array includes a certain value among its entries
* @param index_ The value to search for
* @param seizeIndexes_ An array with market indexes that will be used as collateral.
* @return bool Returning true or false as appropriate.
*/
function includes(uint256 index_, uint256[] memory seizeIndexes_) internal pure returns (bool) {
}
/**
* @dev Local marketParams for avoiding stack-depth limits in calculating liquidation amounts.
*/
struct MarketParams {
uint256 supplyWrap;
uint256 borrowUnderlying;
uint256 exchangeRateMantissa;
uint256 liquidationFeeMantissa;
uint256 utilisationFactorMantissa;
}
/// @inheritdoc ILiquidation
function calculateLiquidationAmounts(
address account_,
IMToken[] memory marketAddresses,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) public view virtual returns (AccountLiquidationAmounts memory accountState) {
}
/**
* @dev Burns collateral tokens at the borrower's address, transfer underlying assets
* to the deadDrop or ManualLiquidator address, if loan is not insignificant, otherwise, all account's
* collateral is credited to the protocolInterest. Process all borrower's markets.
* @param borrower_ The account having collateral seized
* @param marketAddresses_ Array of markets the borrower is in
* @param seizeUnderlyingAmounts_ Array of seize amounts in underlying assets
* @param isLoanInsignificant_ Marker for insignificant loan whose collateral must be credited to the
* protocolInterest
* @param isManualLiquidation_ Marker for manual liquidation process.
*/
function seize(
address borrower_,
IMToken[] memory marketAddresses_,
uint256[] memory seizeUnderlyingAmounts_,
bool isLoanInsignificant_,
bool isManualLiquidation_
) internal {
}
/**
* @dev Liquidator repays a borrow belonging to borrower. Process all borrower's markets.
* @param borrower_ The account with the debt being payed off
* @param marketAddresses_ Array of markets the borrower is in
* @param repayAmounts_ Array of repay amounts in underlying assets
* @param isManualLiquidation_ Marker for manual liquidation process.
* Note: The calling code must be sure that the oracle price for all processed markets is greater than zero.
*/
function repay(
address borrower_,
IMToken[] memory marketAddresses_,
uint256[] memory repayAmounts_,
bool isManualLiquidation_
) internal {
}
/**
* @dev Approve that current healthy factor satisfies the condition:
* currentHealthyFactor <= healthyFactorLimit
* @param borrower_ The account with the debt being payed off
* @param marketAddresses_ Array of markets the borrower is in
* @return Whether or not the current account healthy factor is correct
*/
function approveBorrowerHealthyFactor(address borrower_, IMToken[] memory marketAddresses_)
internal
view
returns (bool)
{
}
/*** Admin Functions ***/
/// @inheritdoc ILiquidation
function setHealthyFactorLimit(uint256 newValue_) external onlyRole(TIMELOCK) {
}
/// @inheritdoc ILiquidation
function setDeadDrop(address newDeadDrop_) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/// @inheritdoc ILiquidation
function setInsignificantLoanThreshold(uint256 newValue_) external onlyRole(TIMELOCK) {
}
/// @inheritdoc ILiquidation
function setProcessingStateUsage(bool newValue) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/// @notice get contract PriceOracle
function oracle() internal view returns (IPriceOracle) {
}
}
|
seizeIndexes_[i]<accountAssetsLength,ErrorCodes.LQ_INVALID_SEIZE_INDEX
| 150,144 |
seizeIndexes_[i]<accountAssetsLength
|
ErrorCodes.LQ_DUPLICATE_SEIZE_INDEX
|
// SPDX-License-Identifier: BSD-3-Clause
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Multicall.sol";
import "./interfaces/ILiquidation.sol";
import "./libraries/ErrorCodes.sol";
import "./InterconnectorLeaf.sol";
/**
* This contract provides the liquidation functionality.
*/
contract Liquidation is ILiquidation, AccessControl, ReentrancyGuard, Multicall, InterconnectorLeaf {
using SafeERC20 for IERC20;
/// @notice Value is the Keccak-256 hash of "TRUSTED_LIQUIDATOR"
/// @dev Role that's allowed to liquidate in Auto mode
bytes32 public constant TRUSTED_LIQUIDATOR =
bytes32(0xf81d27a41879d78d5568e0bc2989cb321b89b84d8e1b49895ee98604626c0218);
/// @notice Value is the Keccak-256 hash of "MANUAL_LIQUIDATOR"
/// @dev Role that's allowed to liquidate in Manual mode.
/// Each MANUAL_LIQUIDATOR address has to be appended to TRUSTED_LIQUIDATOR role too.
bytes32 public constant MANUAL_LIQUIDATOR =
bytes32(0x53402487d33e65b38c49f6f89bd08cbec4ff7c074cddd2357722b7917cd13f1e);
/// @dev Value is the Keccak-256 hash of "TIMELOCK"
bytes32 public constant TIMELOCK = bytes32(0xaefebe170cbaff0af052a32795af0e1b8afff9850f946ad2869be14f35534371);
uint256 private constant EXP_SCALE = 1e18;
/**
* @notice Minterest supervisor contract
*/
ISupervisor public immutable supervisor;
/**
* @notice The maximum allowable value of a healthy factor after liquidation, scaled by 1e18
*/
uint256 public healthyFactorLimit = 1.2e18; // 120%
/**
* @notice Maximum sum in USD for internal liquidation. Collateral for loans that are less than this parameter will
* be counted as protocol interest, scaled by 1e18
*/
uint256 public insignificantLoanThreshold; // 0$ by default
/**
* @notice Minterest deadDrop address or contract
*/
address public deadDrop;
/**
* @dev Flag that defines whether liquidation will update the processing state field of deaddrop contract
*/
bool public useProcessingState;
/**
* @notice Construct a Liquidation contract
* @param deadDrop_ Minterest deadDrop address
* @param liquidators_ Array of addresses of liquidators
* @param supervisor_ The address of the Supervisor contract
* @param admin_ The address of the admin
*/
constructor(
address[] memory liquidators_,
address deadDrop_,
ISupervisor supervisor_,
address admin_
) {
}
/// @inheritdoc ILiquidation
function liquidateUnsafeLoan(
address borrower_,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) external onlyRole(TRUSTED_LIQUIDATOR) nonReentrant {
}
/**
* @notice Checks if input data meets requirements
* @param accountAssetsLength The length of borrower's accountAssets array
* @param seizeIndexes_ An array with market indexes that will be used as collateral.
* Each element corresponds to the market index in the accountAssets array
* @param debtRates_ An array of debt redemption rates for each debt markets (scaled by 1e18).
* @dev Indexes for arrays accountAssets && debtRates match each other
*/
function verifyExternalData(
uint256 accountAssetsLength,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) internal pure {
uint256 debtRatesLength = debtRates_.length;
uint256 seizeIndexesLength = seizeIndexes_.length;
require(accountAssetsLength != 0 && debtRatesLength == accountAssetsLength, ErrorCodes.LQ_INVALID_DRR_ARRAY);
require(
seizeIndexesLength != 0 && seizeIndexesLength <= accountAssetsLength,
ErrorCodes.LQ_INVALID_SEIZE_ARRAY
);
// Check all DRR are <= 100%
for (uint256 i = 0; i < debtRatesLength; i++) {
require(debtRates_[i] <= EXP_SCALE, ErrorCodes.LQ_INVALID_DEBT_REDEMPTION_RATE);
}
// Check all seizeIndexes are <= to (accountAssetsLength - 1)
for (uint256 i = 0; i < seizeIndexesLength; i++) {
require(seizeIndexes_[i] < accountAssetsLength, ErrorCodes.LQ_INVALID_SEIZE_INDEX);
// Check seizeIndexes array does not contain duplicates
for (uint256 j = i + 1; j < seizeIndexesLength; j++) {
require(<FILL_ME>)
}
}
}
/// @inheritdoc ILiquidation
function accrue(
IMToken[] memory accountAssets,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) public {
}
/**
* @notice Determines whether an array includes a certain value among its entries
* @param index_ The value to search for
* @param seizeIndexes_ An array with market indexes that will be used as collateral.
* @return bool Returning true or false as appropriate.
*/
function includes(uint256 index_, uint256[] memory seizeIndexes_) internal pure returns (bool) {
}
/**
* @dev Local marketParams for avoiding stack-depth limits in calculating liquidation amounts.
*/
struct MarketParams {
uint256 supplyWrap;
uint256 borrowUnderlying;
uint256 exchangeRateMantissa;
uint256 liquidationFeeMantissa;
uint256 utilisationFactorMantissa;
}
/// @inheritdoc ILiquidation
function calculateLiquidationAmounts(
address account_,
IMToken[] memory marketAddresses,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) public view virtual returns (AccountLiquidationAmounts memory accountState) {
}
/**
* @dev Burns collateral tokens at the borrower's address, transfer underlying assets
* to the deadDrop or ManualLiquidator address, if loan is not insignificant, otherwise, all account's
* collateral is credited to the protocolInterest. Process all borrower's markets.
* @param borrower_ The account having collateral seized
* @param marketAddresses_ Array of markets the borrower is in
* @param seizeUnderlyingAmounts_ Array of seize amounts in underlying assets
* @param isLoanInsignificant_ Marker for insignificant loan whose collateral must be credited to the
* protocolInterest
* @param isManualLiquidation_ Marker for manual liquidation process.
*/
function seize(
address borrower_,
IMToken[] memory marketAddresses_,
uint256[] memory seizeUnderlyingAmounts_,
bool isLoanInsignificant_,
bool isManualLiquidation_
) internal {
}
/**
* @dev Liquidator repays a borrow belonging to borrower. Process all borrower's markets.
* @param borrower_ The account with the debt being payed off
* @param marketAddresses_ Array of markets the borrower is in
* @param repayAmounts_ Array of repay amounts in underlying assets
* @param isManualLiquidation_ Marker for manual liquidation process.
* Note: The calling code must be sure that the oracle price for all processed markets is greater than zero.
*/
function repay(
address borrower_,
IMToken[] memory marketAddresses_,
uint256[] memory repayAmounts_,
bool isManualLiquidation_
) internal {
}
/**
* @dev Approve that current healthy factor satisfies the condition:
* currentHealthyFactor <= healthyFactorLimit
* @param borrower_ The account with the debt being payed off
* @param marketAddresses_ Array of markets the borrower is in
* @return Whether or not the current account healthy factor is correct
*/
function approveBorrowerHealthyFactor(address borrower_, IMToken[] memory marketAddresses_)
internal
view
returns (bool)
{
}
/*** Admin Functions ***/
/// @inheritdoc ILiquidation
function setHealthyFactorLimit(uint256 newValue_) external onlyRole(TIMELOCK) {
}
/// @inheritdoc ILiquidation
function setDeadDrop(address newDeadDrop_) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/// @inheritdoc ILiquidation
function setInsignificantLoanThreshold(uint256 newValue_) external onlyRole(TIMELOCK) {
}
/// @inheritdoc ILiquidation
function setProcessingStateUsage(bool newValue) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/// @notice get contract PriceOracle
function oracle() internal view returns (IPriceOracle) {
}
}
|
seizeIndexes_[i]!=seizeIndexes_[j],ErrorCodes.LQ_DUPLICATE_SEIZE_INDEX
| 150,144 |
seizeIndexes_[i]!=seizeIndexes_[j]
|
ErrorCodes.INVALID_PRICE
|
// SPDX-License-Identifier: BSD-3-Clause
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Multicall.sol";
import "./interfaces/ILiquidation.sol";
import "./libraries/ErrorCodes.sol";
import "./InterconnectorLeaf.sol";
/**
* This contract provides the liquidation functionality.
*/
contract Liquidation is ILiquidation, AccessControl, ReentrancyGuard, Multicall, InterconnectorLeaf {
using SafeERC20 for IERC20;
/// @notice Value is the Keccak-256 hash of "TRUSTED_LIQUIDATOR"
/// @dev Role that's allowed to liquidate in Auto mode
bytes32 public constant TRUSTED_LIQUIDATOR =
bytes32(0xf81d27a41879d78d5568e0bc2989cb321b89b84d8e1b49895ee98604626c0218);
/// @notice Value is the Keccak-256 hash of "MANUAL_LIQUIDATOR"
/// @dev Role that's allowed to liquidate in Manual mode.
/// Each MANUAL_LIQUIDATOR address has to be appended to TRUSTED_LIQUIDATOR role too.
bytes32 public constant MANUAL_LIQUIDATOR =
bytes32(0x53402487d33e65b38c49f6f89bd08cbec4ff7c074cddd2357722b7917cd13f1e);
/// @dev Value is the Keccak-256 hash of "TIMELOCK"
bytes32 public constant TIMELOCK = bytes32(0xaefebe170cbaff0af052a32795af0e1b8afff9850f946ad2869be14f35534371);
uint256 private constant EXP_SCALE = 1e18;
/**
* @notice Minterest supervisor contract
*/
ISupervisor public immutable supervisor;
/**
* @notice The maximum allowable value of a healthy factor after liquidation, scaled by 1e18
*/
uint256 public healthyFactorLimit = 1.2e18; // 120%
/**
* @notice Maximum sum in USD for internal liquidation. Collateral for loans that are less than this parameter will
* be counted as protocol interest, scaled by 1e18
*/
uint256 public insignificantLoanThreshold; // 0$ by default
/**
* @notice Minterest deadDrop address or contract
*/
address public deadDrop;
/**
* @dev Flag that defines whether liquidation will update the processing state field of deaddrop contract
*/
bool public useProcessingState;
/**
* @notice Construct a Liquidation contract
* @param deadDrop_ Minterest deadDrop address
* @param liquidators_ Array of addresses of liquidators
* @param supervisor_ The address of the Supervisor contract
* @param admin_ The address of the admin
*/
constructor(
address[] memory liquidators_,
address deadDrop_,
ISupervisor supervisor_,
address admin_
) {
}
/// @inheritdoc ILiquidation
function liquidateUnsafeLoan(
address borrower_,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) external onlyRole(TRUSTED_LIQUIDATOR) nonReentrant {
}
/**
* @notice Checks if input data meets requirements
* @param accountAssetsLength The length of borrower's accountAssets array
* @param seizeIndexes_ An array with market indexes that will be used as collateral.
* Each element corresponds to the market index in the accountAssets array
* @param debtRates_ An array of debt redemption rates for each debt markets (scaled by 1e18).
* @dev Indexes for arrays accountAssets && debtRates match each other
*/
function verifyExternalData(
uint256 accountAssetsLength,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) internal pure {
}
/// @inheritdoc ILiquidation
function accrue(
IMToken[] memory accountAssets,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) public {
}
/**
* @notice Determines whether an array includes a certain value among its entries
* @param index_ The value to search for
* @param seizeIndexes_ An array with market indexes that will be used as collateral.
* @return bool Returning true or false as appropriate.
*/
function includes(uint256 index_, uint256[] memory seizeIndexes_) internal pure returns (bool) {
}
/**
* @dev Local marketParams for avoiding stack-depth limits in calculating liquidation amounts.
*/
struct MarketParams {
uint256 supplyWrap;
uint256 borrowUnderlying;
uint256 exchangeRateMantissa;
uint256 liquidationFeeMantissa;
uint256 utilisationFactorMantissa;
}
/// @inheritdoc ILiquidation
function calculateLiquidationAmounts(
address account_,
IMToken[] memory marketAddresses,
uint256[] memory seizeIndexes_,
uint256[] memory debtRates_
) public view virtual returns (AccountLiquidationAmounts memory accountState) {
uint256 accountTotalRepayUsd = 0;
uint256 accountMarketsLen = marketAddresses.length;
uint256[] memory presumedRepaysUsd = new uint256[](accountMarketsLen);
uint256[] memory oraclePrices = new uint256[](accountMarketsLen);
uint256[] memory liquidationFeeMultipliers = new uint256[](accountMarketsLen);
accountState.repayAmounts = new uint256[](accountMarketsLen);
accountState.seizeAmounts = new uint256[](accountMarketsLen);
IPriceOracle cachedOracle = oracle();
// calculate liquidation amounts for each market the borrower is in,
// update accountState with accumulated values within the same loop
for (uint256 i = 0; i < accountMarketsLen; i++) {
IMToken market = marketAddresses[i];
// oracle price of each processed token must exist
oraclePrices[i] = cachedOracle.getUnderlyingPrice(market);
require(<FILL_ME>)
// slither-disable-next-line uninitialized-local
MarketParams memory vars;
(vars.supplyWrap, vars.borrowUnderlying, vars.exchangeRateMantissa) = market.getAccountSnapshot(account_);
(vars.liquidationFeeMantissa, vars.utilisationFactorMantissa) = supervisor.getMarketData(market);
// account position has borrowed assets in the market
if (vars.borrowUnderlying > 0) {
// collect accumulated value of accountState.accountTotalBorrowUsd:
// accountTotalBorrowUsd += borrowUnderlying * oraclePrice
uint256 accountBorrowUsd = (vars.borrowUnderlying * oraclePrices[i]) / EXP_SCALE;
accountState.accountTotalBorrowUsd += accountBorrowUsd;
// there is a debt on this market that should be repaid
if (debtRates_[i] > 0) {
// repayAmountUnderlying = borrowUnderlying * redemptionRate
accountState.repayAmounts[i] = (vars.borrowUnderlying * debtRates_[i]) / EXP_SCALE;
accountTotalRepayUsd += (accountBorrowUsd * debtRates_[i]) / EXP_SCALE;
}
}
// account position has supplied assets in the market
if (vars.supplyWrap > 0) {
// (1 + liquidationFee) value is stored for the future use as liquidationFeeMultipliers
liquidationFeeMultipliers[i] = vars.liquidationFeeMantissa + EXP_SCALE;
// supplyAmount = supplyWrap * exchangeRate
uint256 supplyAmount = (vars.supplyWrap * vars.exchangeRateMantissa) / EXP_SCALE;
uint256 accountSupplyUsd = (supplyAmount * oraclePrices[i]) / EXP_SCALE;
// presumed repay in USD is a portion of the debt that is coverable by the current supply
uint256 presumedRepayUsd = ((accountSupplyUsd * EXP_SCALE) / liquidationFeeMultipliers[i]);
// collect accumulated value of accountState.accountPresumedTotalRepayUsd:
// accountPresumedTotalRepayUsd value means what the totalRepay would be possible
// under the condition of complete liquidation.
accountState.accountPresumedTotalRepayUsd += presumedRepayUsd;
// collect accumulated value of accountState.accountTotalSupplyUsd:
// accountTotalSupplyUsd += supplyWrap * exchangeRate * oraclePrice
accountState.accountTotalSupplyUsd += accountSupplyUsd;
presumedRepaysUsd[i] = presumedRepayUsd;
// accountTotalCollateralUsd += accountSupplyUsd * utilisationFactor
accountState.accountTotalCollateralUsd +=
(accountSupplyUsd * vars.utilisationFactorMantissa) /
EXP_SCALE;
}
}
if (accountTotalRepayUsd > 0) {
// calculate seize amounts per market
for (uint256 i = 0; i < seizeIndexes_.length; i++) {
uint256 marketIndex = seizeIndexes_[i];
uint256 marketPresumedRepayUsd = presumedRepaysUsd[marketIndex];
if (marketPresumedRepayUsd <= accountTotalRepayUsd) {
accountState.seizeAmounts[marketIndex] = type(uint256).max;
accountTotalRepayUsd -= marketPresumedRepayUsd;
} else {
accountState.seizeAmounts[marketIndex] =
(accountTotalRepayUsd * (liquidationFeeMultipliers[marketIndex])) /
oraclePrices[marketIndex];
accountTotalRepayUsd = 0;
break;
}
}
require(accountTotalRepayUsd == 0, ErrorCodes.LQ_INVALID_SEIZE_DISTRIBUTION);
}
return accountState;
}
/**
* @dev Burns collateral tokens at the borrower's address, transfer underlying assets
* to the deadDrop or ManualLiquidator address, if loan is not insignificant, otherwise, all account's
* collateral is credited to the protocolInterest. Process all borrower's markets.
* @param borrower_ The account having collateral seized
* @param marketAddresses_ Array of markets the borrower is in
* @param seizeUnderlyingAmounts_ Array of seize amounts in underlying assets
* @param isLoanInsignificant_ Marker for insignificant loan whose collateral must be credited to the
* protocolInterest
* @param isManualLiquidation_ Marker for manual liquidation process.
*/
function seize(
address borrower_,
IMToken[] memory marketAddresses_,
uint256[] memory seizeUnderlyingAmounts_,
bool isLoanInsignificant_,
bool isManualLiquidation_
) internal {
}
/**
* @dev Liquidator repays a borrow belonging to borrower. Process all borrower's markets.
* @param borrower_ The account with the debt being payed off
* @param marketAddresses_ Array of markets the borrower is in
* @param repayAmounts_ Array of repay amounts in underlying assets
* @param isManualLiquidation_ Marker for manual liquidation process.
* Note: The calling code must be sure that the oracle price for all processed markets is greater than zero.
*/
function repay(
address borrower_,
IMToken[] memory marketAddresses_,
uint256[] memory repayAmounts_,
bool isManualLiquidation_
) internal {
}
/**
* @dev Approve that current healthy factor satisfies the condition:
* currentHealthyFactor <= healthyFactorLimit
* @param borrower_ The account with the debt being payed off
* @param marketAddresses_ Array of markets the borrower is in
* @return Whether or not the current account healthy factor is correct
*/
function approveBorrowerHealthyFactor(address borrower_, IMToken[] memory marketAddresses_)
internal
view
returns (bool)
{
}
/*** Admin Functions ***/
/// @inheritdoc ILiquidation
function setHealthyFactorLimit(uint256 newValue_) external onlyRole(TIMELOCK) {
}
/// @inheritdoc ILiquidation
function setDeadDrop(address newDeadDrop_) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/// @inheritdoc ILiquidation
function setInsignificantLoanThreshold(uint256 newValue_) external onlyRole(TIMELOCK) {
}
/// @inheritdoc ILiquidation
function setProcessingStateUsage(bool newValue) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
/// @notice get contract PriceOracle
function oracle() internal view returns (IPriceOracle) {
}
}
|
oraclePrices[i]>0,ErrorCodes.INVALID_PRICE
| 150,144 |
oraclePrices[i]>0
|
"burn amount exceeds balance"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "./Distributions.sol";
library Balances {
using Distributions for Distributions.Uint256;
using EnumerableSet for EnumerableSet.UintSet;
struct Fungible {
Distributions.Uint256 _balances;
}
function balanceOf(Fungible storage self, address account) internal view returns (uint256) {
}
function totalSupply(Fungible storage self) internal view returns (uint256) {
}
function mint(Fungible storage self, address to, uint256 amount) internal {
}
function burn(Fungible storage self, address from, uint256 amount) internal {
require(<FILL_ME>)
self._balances.decr(from, amount);
}
function transfer(Fungible storage self, address from, address to, uint256 amount) internal {
}
struct NonFungible {
mapping(uint256 => address) _owner;
}
function ownerOf(NonFungible storage self, uint256 tokenid) internal view returns (address) {
}
function mint(NonFungible storage self, address to, uint256 tokenid) internal {
}
function burn(NonFungible storage self, address from, uint256 tokenid) internal {
}
function transfer(NonFungible storage self, address from, address to, uint256 tokenid) internal {
}
// struct NonFungibleEnumerable {
// NonFungible _base;
// EnumerableSet.UintSet _allTokens;
// mapping(address => EnumerableSet.UintSet) _userTokens;
// }
// function balanceOf(NonFungibleEnumerable storage self, address account) internal view returns (uint256) {
// return self._userTokens[account].length();
// }
// function at(NonFungibleEnumerable storage self, address account, uint256 idx) internal view returns (uint256) {
// return self._userTokens[account].at(idx);
// }
// function totalSupply(NonFungibleEnumerable storage self) internal view returns (uint256) {
// return self._allTokens.length();
// }
// function at(NonFungibleEnumerable storage self, uint256 idx) internal view returns (uint256) {
// return self._allTokens.at(idx);
// }
// function ownerOf(NonFungibleEnumerable storage self, uint256 tokenid) internal view returns (address) {
// return ownerOf(self._base, tokenid);
// }
// function mint(NonFungibleEnumerable storage self, address to, uint256 tokenid) internal {
// mint(self._base, to, tokenid);
// self._allTokens.add(tokenid);
// self._userTokens[to].add(tokenid);
// }
// function burn(NonFungibleEnumerable storage self, address from, uint256 tokenid) internal {
// burn(self._base, from, tokenid);
// self._allTokens.remove(tokenid);
// self._userTokens[from].remove(tokenid);
// }
// function transfer(NonFungibleEnumerable storage self, address from, address to, uint256 tokenid) internal {
// transfer(self._base, from, to, tokenid);
// self._userTokens[from].remove(tokenid);
// self._userTokens[to].add(tokenid);
// }
}
|
self._balances.valueOf(from)>=amount,"burn amount exceeds balance"
| 150,231 |
self._balances.valueOf(from)>=amount
|
"token already exists"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "./Distributions.sol";
library Balances {
using Distributions for Distributions.Uint256;
using EnumerableSet for EnumerableSet.UintSet;
struct Fungible {
Distributions.Uint256 _balances;
}
function balanceOf(Fungible storage self, address account) internal view returns (uint256) {
}
function totalSupply(Fungible storage self) internal view returns (uint256) {
}
function mint(Fungible storage self, address to, uint256 amount) internal {
}
function burn(Fungible storage self, address from, uint256 amount) internal {
}
function transfer(Fungible storage self, address from, address to, uint256 amount) internal {
}
struct NonFungible {
mapping(uint256 => address) _owner;
}
function ownerOf(NonFungible storage self, uint256 tokenid) internal view returns (address) {
}
function mint(NonFungible storage self, address to, uint256 tokenid) internal {
require(<FILL_ME>)
self._owner[tokenid] = to;
}
function burn(NonFungible storage self, address from, uint256 tokenid) internal {
}
function transfer(NonFungible storage self, address from, address to, uint256 tokenid) internal {
}
// struct NonFungibleEnumerable {
// NonFungible _base;
// EnumerableSet.UintSet _allTokens;
// mapping(address => EnumerableSet.UintSet) _userTokens;
// }
// function balanceOf(NonFungibleEnumerable storage self, address account) internal view returns (uint256) {
// return self._userTokens[account].length();
// }
// function at(NonFungibleEnumerable storage self, address account, uint256 idx) internal view returns (uint256) {
// return self._userTokens[account].at(idx);
// }
// function totalSupply(NonFungibleEnumerable storage self) internal view returns (uint256) {
// return self._allTokens.length();
// }
// function at(NonFungibleEnumerable storage self, uint256 idx) internal view returns (uint256) {
// return self._allTokens.at(idx);
// }
// function ownerOf(NonFungibleEnumerable storage self, uint256 tokenid) internal view returns (address) {
// return ownerOf(self._base, tokenid);
// }
// function mint(NonFungibleEnumerable storage self, address to, uint256 tokenid) internal {
// mint(self._base, to, tokenid);
// self._allTokens.add(tokenid);
// self._userTokens[to].add(tokenid);
// }
// function burn(NonFungibleEnumerable storage self, address from, uint256 tokenid) internal {
// burn(self._base, from, tokenid);
// self._allTokens.remove(tokenid);
// self._userTokens[from].remove(tokenid);
// }
// function transfer(NonFungibleEnumerable storage self, address from, address to, uint256 tokenid) internal {
// transfer(self._base, from, to, tokenid);
// self._userTokens[from].remove(tokenid);
// self._userTokens[to].add(tokenid);
// }
}
|
ownerOf(self,tokenid)==address(0),"token already exists"
| 150,231 |
ownerOf(self,tokenid)==address(0)
|
"token doesn't exist"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "./Distributions.sol";
library Balances {
using Distributions for Distributions.Uint256;
using EnumerableSet for EnumerableSet.UintSet;
struct Fungible {
Distributions.Uint256 _balances;
}
function balanceOf(Fungible storage self, address account) internal view returns (uint256) {
}
function totalSupply(Fungible storage self) internal view returns (uint256) {
}
function mint(Fungible storage self, address to, uint256 amount) internal {
}
function burn(Fungible storage self, address from, uint256 amount) internal {
}
function transfer(Fungible storage self, address from, address to, uint256 amount) internal {
}
struct NonFungible {
mapping(uint256 => address) _owner;
}
function ownerOf(NonFungible storage self, uint256 tokenid) internal view returns (address) {
}
function mint(NonFungible storage self, address to, uint256 tokenid) internal {
}
function burn(NonFungible storage self, address from, uint256 tokenid) internal {
require(<FILL_ME>)
self._owner[tokenid] = address(0);
}
function transfer(NonFungible storage self, address from, address to, uint256 tokenid) internal {
}
// struct NonFungibleEnumerable {
// NonFungible _base;
// EnumerableSet.UintSet _allTokens;
// mapping(address => EnumerableSet.UintSet) _userTokens;
// }
// function balanceOf(NonFungibleEnumerable storage self, address account) internal view returns (uint256) {
// return self._userTokens[account].length();
// }
// function at(NonFungibleEnumerable storage self, address account, uint256 idx) internal view returns (uint256) {
// return self._userTokens[account].at(idx);
// }
// function totalSupply(NonFungibleEnumerable storage self) internal view returns (uint256) {
// return self._allTokens.length();
// }
// function at(NonFungibleEnumerable storage self, uint256 idx) internal view returns (uint256) {
// return self._allTokens.at(idx);
// }
// function ownerOf(NonFungibleEnumerable storage self, uint256 tokenid) internal view returns (address) {
// return ownerOf(self._base, tokenid);
// }
// function mint(NonFungibleEnumerable storage self, address to, uint256 tokenid) internal {
// mint(self._base, to, tokenid);
// self._allTokens.add(tokenid);
// self._userTokens[to].add(tokenid);
// }
// function burn(NonFungibleEnumerable storage self, address from, uint256 tokenid) internal {
// burn(self._base, from, tokenid);
// self._allTokens.remove(tokenid);
// self._userTokens[from].remove(tokenid);
// }
// function transfer(NonFungibleEnumerable storage self, address from, address to, uint256 tokenid) internal {
// transfer(self._base, from, to, tokenid);
// self._userTokens[from].remove(tokenid);
// self._userTokens[to].add(tokenid);
// }
}
|
ownerOf(self,tokenid)==from,"token doesn't exist"
| 150,231 |
ownerOf(self,tokenid)==from
|
"Invalid group"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
import {UpdatableOperatorFilterer} from "./UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "./RevokableDefaultOperatorFilterer.sol";
contract B4DBULL is ERC721A, ERC2981, RevokableDefaultOperatorFilterer, Ownable, ReentrancyGuard, PaymentSplitter {
using Strings for uint;
uint256 public supply = 666; // Supply total
string public uri; // URI
bool public isUriLocked = false; // Booléen permettant de locker l'URI afin d'éviter qu'elle soit modifiée par la suite
bool public isRevealed = false; // Booléen permettant de passer de l'URI native commune à une URI spécifique par token (post reveal)
// DynamicNFT
uint256 public dynamicTokenId;
// Steps
enum Step { Pause, PhaseOne, PhaseTwo, PhaseThree, PhaseFour, SoldOut }
Step public currentStep;
// Events
event stepUpdated(Step currentStep);
event newMint(address indexed owner, uint256 startId, uint256 number);
// Structures + mappings
struct mintGroup {
string name;
uint256 price;
uint256 maxPerWallet;
bytes32 merkleTreeRoot;
bool exists;
}
struct mintTracker {
uint[7] groupTracker;
}
mapping(address => mintTracker) mintTrackers;
mapping(uint256 => mintGroup) public mintGroups;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor(string memory defaultUri, address[] memory teamMembers, uint[] memory teamShares) ERC721A("B4D BULL", "B4D")
PaymentSplitter(teamMembers, teamShares)
{
}
// [R-Public | U-Owner] Mint groups & trackers
function updatemintGroup(uint256 group, string memory name, uint256 price, uint256 maxPerWallet, bytes32 merkleTreeRoot, bool exists) external onlyOwner {
require(<FILL_ME>)
mintGroups[group] = mintGroup(name, price, maxPerWallet, merkleTreeRoot, exists);
}
function updatemintGroupPrice(uint256 group, uint256 price) external onlyOwner {
}
function updatemintGroupMerkleTreeRoot(uint256 group, bytes32 merkleTreeRoot) external onlyOwner {
}
function getMintGroup(uint256 group) public view returns (mintGroup memory) {
}
function getMintTracker(uint group, address wallet) public view returns (uint) {
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Merkle Tree checking fx
function isOnList(address account, bytes32[] calldata proof, uint group) public view returns (bool) {
}
function _leaf(address account) internal pure returns (bytes32) { }
function _verify(bytes32 leaf, bytes32[] memory proof, bytes32 root) internal pure returns (bool) { }
// Mint
function mint(bytes32[] calldata proof, uint256 group, uint256 amount) public payable nonReentrant {
}
// [Owner] Fonction qui met à jour l'étape actuelle
function updateStep(Step step) external onlyOwner {
}
// [Owner] Permet de passer en mode reveal (une seule fois)
function reveal() external onlyOwner {
}
// [Owner] Permet de verrouiller l'URI (une seule fois)
function lockURI() external onlyOwner {
}
// [Owner] Permet de modifier l'URI tant qu'elle n'est pas verrouillée
function updateURI(string memory newUri) external onlyOwner {
}
// [Owner] Permet de modifier l'ID du token évolutif tant que l'URI n'est pas verrouillé
function updateDynamicTokenId(uint256 newId) external onlyOwner {
}
// Retourne l'URI, soit dans sa version de base en mode "unrevealed", soit dans sa version définitive avec un code spécifique pour le token dynamique
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
// [Owner] Fonction de sécurité pour withdraw les fonds présents sur le SC
function withdraw() external onlyOwner { }
// ROYALTIES, ERC-2981 + Operator Filter OpenSea
function setDefaultRoyalty(address receiver, uint96 feeNumerator) external onlyOwner {
}
/**
* @dev See {IERC721-setApprovalForAll}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC721-approve}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC721-transferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC721-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC721-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public payable
override
onlyAllowedOperator(from)
{
}
/**
* @dev Returns the owner of the ERC721 token contract.
*/
function owner() public view virtual override(Ownable, UpdatableOperatorFilterer) returns (address) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
// Fonction modifiée pour implémenter l'ERC721A
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
}
|
mintGroups[group].exists,"Invalid group"
| 150,270 |
mintGroups[group].exists
|
"Max supply reached"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
import {UpdatableOperatorFilterer} from "./UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "./RevokableDefaultOperatorFilterer.sol";
contract B4DBULL is ERC721A, ERC2981, RevokableDefaultOperatorFilterer, Ownable, ReentrancyGuard, PaymentSplitter {
using Strings for uint;
uint256 public supply = 666; // Supply total
string public uri; // URI
bool public isUriLocked = false; // Booléen permettant de locker l'URI afin d'éviter qu'elle soit modifiée par la suite
bool public isRevealed = false; // Booléen permettant de passer de l'URI native commune à une URI spécifique par token (post reveal)
// DynamicNFT
uint256 public dynamicTokenId;
// Steps
enum Step { Pause, PhaseOne, PhaseTwo, PhaseThree, PhaseFour, SoldOut }
Step public currentStep;
// Events
event stepUpdated(Step currentStep);
event newMint(address indexed owner, uint256 startId, uint256 number);
// Structures + mappings
struct mintGroup {
string name;
uint256 price;
uint256 maxPerWallet;
bytes32 merkleTreeRoot;
bool exists;
}
struct mintTracker {
uint[7] groupTracker;
}
mapping(address => mintTracker) mintTrackers;
mapping(uint256 => mintGroup) public mintGroups;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor(string memory defaultUri, address[] memory teamMembers, uint[] memory teamShares) ERC721A("B4D BULL", "B4D")
PaymentSplitter(teamMembers, teamShares)
{
}
// [R-Public | U-Owner] Mint groups & trackers
function updatemintGroup(uint256 group, string memory name, uint256 price, uint256 maxPerWallet, bytes32 merkleTreeRoot, bool exists) external onlyOwner {
}
function updatemintGroupPrice(uint256 group, uint256 price) external onlyOwner {
}
function updatemintGroupMerkleTreeRoot(uint256 group, bytes32 merkleTreeRoot) external onlyOwner {
}
function getMintGroup(uint256 group) public view returns (mintGroup memory) {
}
function getMintTracker(uint group, address wallet) public view returns (uint) {
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Merkle Tree checking fx
function isOnList(address account, bytes32[] calldata proof, uint group) public view returns (bool) {
}
function _leaf(address account) internal pure returns (bytes32) { }
function _verify(bytes32 leaf, bytes32[] memory proof, bytes32 root) internal pure returns (bool) { }
// Mint
function mint(bytes32[] calldata proof, uint256 group, uint256 amount) public payable nonReentrant {
require(currentStep >= Step.PhaseOne && currentStep <= Step.PhaseFour, "Please wait for the mint phase");
require(<FILL_ME>)
// Forcing des groupes disponibles suivant la phase
if (currentStep == Step.PhaseOne) {
require(group == 0 || group == 1 || group == 2 || group == 6, "Invalid mint group for this phase");
} else if (currentStep == Step.PhaseTwo) {
require(group >= 5 && group <= 6, "Invalid mint group for this phase");
} else if (currentStep == Step.PhaseThree) {
require(group >= 4 && group <= 6, "Invalid mint group for this phase");
} else if (currentStep == Step.PhaseFour) {
require(group >= 3 && group <= 6, "Invalid mint group for this phase");
}
require(isOnList(msg.sender, proof, group), "Not whitelisted for this mint group"); // WL check
require(msg.value >= mintGroups[group].price * amount, "Not enough ETH");
require(mintTrackers[msg.sender].groupTracker[group] + amount <= mintGroups[group].maxPerWallet, "Amount exceed the limit or max mint reached for this mint group"); // Tracker check
mintTrackers[msg.sender].groupTracker[group] += amount; // Tracker update
_safeMint(msg.sender, amount);
emit newMint(msg.sender, totalSupply() - amount, amount);
}
// [Owner] Fonction qui met à jour l'étape actuelle
function updateStep(Step step) external onlyOwner {
}
// [Owner] Permet de passer en mode reveal (une seule fois)
function reveal() external onlyOwner {
}
// [Owner] Permet de verrouiller l'URI (une seule fois)
function lockURI() external onlyOwner {
}
// [Owner] Permet de modifier l'URI tant qu'elle n'est pas verrouillée
function updateURI(string memory newUri) external onlyOwner {
}
// [Owner] Permet de modifier l'ID du token évolutif tant que l'URI n'est pas verrouillé
function updateDynamicTokenId(uint256 newId) external onlyOwner {
}
// Retourne l'URI, soit dans sa version de base en mode "unrevealed", soit dans sa version définitive avec un code spécifique pour le token dynamique
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
// [Owner] Fonction de sécurité pour withdraw les fonds présents sur le SC
function withdraw() external onlyOwner { }
// ROYALTIES, ERC-2981 + Operator Filter OpenSea
function setDefaultRoyalty(address receiver, uint96 feeNumerator) external onlyOwner {
}
/**
* @dev See {IERC721-setApprovalForAll}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC721-approve}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC721-transferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC721-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC721-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public payable
override
onlyAllowedOperator(from)
{
}
/**
* @dev Returns the owner of the ERC721 token contract.
*/
function owner() public view virtual override(Ownable, UpdatableOperatorFilterer) returns (address) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
// Fonction modifiée pour implémenter l'ERC721A
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
}
|
totalSupply()+amount<=supply,"Max supply reached"
| 150,270 |
totalSupply()+amount<=supply
|
"Not whitelisted for this mint group"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
import {UpdatableOperatorFilterer} from "./UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "./RevokableDefaultOperatorFilterer.sol";
contract B4DBULL is ERC721A, ERC2981, RevokableDefaultOperatorFilterer, Ownable, ReentrancyGuard, PaymentSplitter {
using Strings for uint;
uint256 public supply = 666; // Supply total
string public uri; // URI
bool public isUriLocked = false; // Booléen permettant de locker l'URI afin d'éviter qu'elle soit modifiée par la suite
bool public isRevealed = false; // Booléen permettant de passer de l'URI native commune à une URI spécifique par token (post reveal)
// DynamicNFT
uint256 public dynamicTokenId;
// Steps
enum Step { Pause, PhaseOne, PhaseTwo, PhaseThree, PhaseFour, SoldOut }
Step public currentStep;
// Events
event stepUpdated(Step currentStep);
event newMint(address indexed owner, uint256 startId, uint256 number);
// Structures + mappings
struct mintGroup {
string name;
uint256 price;
uint256 maxPerWallet;
bytes32 merkleTreeRoot;
bool exists;
}
struct mintTracker {
uint[7] groupTracker;
}
mapping(address => mintTracker) mintTrackers;
mapping(uint256 => mintGroup) public mintGroups;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor(string memory defaultUri, address[] memory teamMembers, uint[] memory teamShares) ERC721A("B4D BULL", "B4D")
PaymentSplitter(teamMembers, teamShares)
{
}
// [R-Public | U-Owner] Mint groups & trackers
function updatemintGroup(uint256 group, string memory name, uint256 price, uint256 maxPerWallet, bytes32 merkleTreeRoot, bool exists) external onlyOwner {
}
function updatemintGroupPrice(uint256 group, uint256 price) external onlyOwner {
}
function updatemintGroupMerkleTreeRoot(uint256 group, bytes32 merkleTreeRoot) external onlyOwner {
}
function getMintGroup(uint256 group) public view returns (mintGroup memory) {
}
function getMintTracker(uint group, address wallet) public view returns (uint) {
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Merkle Tree checking fx
function isOnList(address account, bytes32[] calldata proof, uint group) public view returns (bool) {
}
function _leaf(address account) internal pure returns (bytes32) { }
function _verify(bytes32 leaf, bytes32[] memory proof, bytes32 root) internal pure returns (bool) { }
// Mint
function mint(bytes32[] calldata proof, uint256 group, uint256 amount) public payable nonReentrant {
require(currentStep >= Step.PhaseOne && currentStep <= Step.PhaseFour, "Please wait for the mint phase");
require(totalSupply() + amount <= supply, "Max supply reached");
// Forcing des groupes disponibles suivant la phase
if (currentStep == Step.PhaseOne) {
require(group == 0 || group == 1 || group == 2 || group == 6, "Invalid mint group for this phase");
} else if (currentStep == Step.PhaseTwo) {
require(group >= 5 && group <= 6, "Invalid mint group for this phase");
} else if (currentStep == Step.PhaseThree) {
require(group >= 4 && group <= 6, "Invalid mint group for this phase");
} else if (currentStep == Step.PhaseFour) {
require(group >= 3 && group <= 6, "Invalid mint group for this phase");
}
require(<FILL_ME>) // WL check
require(msg.value >= mintGroups[group].price * amount, "Not enough ETH");
require(mintTrackers[msg.sender].groupTracker[group] + amount <= mintGroups[group].maxPerWallet, "Amount exceed the limit or max mint reached for this mint group"); // Tracker check
mintTrackers[msg.sender].groupTracker[group] += amount; // Tracker update
_safeMint(msg.sender, amount);
emit newMint(msg.sender, totalSupply() - amount, amount);
}
// [Owner] Fonction qui met à jour l'étape actuelle
function updateStep(Step step) external onlyOwner {
}
// [Owner] Permet de passer en mode reveal (une seule fois)
function reveal() external onlyOwner {
}
// [Owner] Permet de verrouiller l'URI (une seule fois)
function lockURI() external onlyOwner {
}
// [Owner] Permet de modifier l'URI tant qu'elle n'est pas verrouillée
function updateURI(string memory newUri) external onlyOwner {
}
// [Owner] Permet de modifier l'ID du token évolutif tant que l'URI n'est pas verrouillé
function updateDynamicTokenId(uint256 newId) external onlyOwner {
}
// Retourne l'URI, soit dans sa version de base en mode "unrevealed", soit dans sa version définitive avec un code spécifique pour le token dynamique
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
// [Owner] Fonction de sécurité pour withdraw les fonds présents sur le SC
function withdraw() external onlyOwner { }
// ROYALTIES, ERC-2981 + Operator Filter OpenSea
function setDefaultRoyalty(address receiver, uint96 feeNumerator) external onlyOwner {
}
/**
* @dev See {IERC721-setApprovalForAll}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC721-approve}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC721-transferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC721-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC721-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public payable
override
onlyAllowedOperator(from)
{
}
/**
* @dev Returns the owner of the ERC721 token contract.
*/
function owner() public view virtual override(Ownable, UpdatableOperatorFilterer) returns (address) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
// Fonction modifiée pour implémenter l'ERC721A
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
}
|
isOnList(msg.sender,proof,group),"Not whitelisted for this mint group"
| 150,270 |
isOnList(msg.sender,proof,group)
|
"Amount exceed the limit or max mint reached for this mint group"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
import {UpdatableOperatorFilterer} from "./UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "./RevokableDefaultOperatorFilterer.sol";
contract B4DBULL is ERC721A, ERC2981, RevokableDefaultOperatorFilterer, Ownable, ReentrancyGuard, PaymentSplitter {
using Strings for uint;
uint256 public supply = 666; // Supply total
string public uri; // URI
bool public isUriLocked = false; // Booléen permettant de locker l'URI afin d'éviter qu'elle soit modifiée par la suite
bool public isRevealed = false; // Booléen permettant de passer de l'URI native commune à une URI spécifique par token (post reveal)
// DynamicNFT
uint256 public dynamicTokenId;
// Steps
enum Step { Pause, PhaseOne, PhaseTwo, PhaseThree, PhaseFour, SoldOut }
Step public currentStep;
// Events
event stepUpdated(Step currentStep);
event newMint(address indexed owner, uint256 startId, uint256 number);
// Structures + mappings
struct mintGroup {
string name;
uint256 price;
uint256 maxPerWallet;
bytes32 merkleTreeRoot;
bool exists;
}
struct mintTracker {
uint[7] groupTracker;
}
mapping(address => mintTracker) mintTrackers;
mapping(uint256 => mintGroup) public mintGroups;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor(string memory defaultUri, address[] memory teamMembers, uint[] memory teamShares) ERC721A("B4D BULL", "B4D")
PaymentSplitter(teamMembers, teamShares)
{
}
// [R-Public | U-Owner] Mint groups & trackers
function updatemintGroup(uint256 group, string memory name, uint256 price, uint256 maxPerWallet, bytes32 merkleTreeRoot, bool exists) external onlyOwner {
}
function updatemintGroupPrice(uint256 group, uint256 price) external onlyOwner {
}
function updatemintGroupMerkleTreeRoot(uint256 group, bytes32 merkleTreeRoot) external onlyOwner {
}
function getMintGroup(uint256 group) public view returns (mintGroup memory) {
}
function getMintTracker(uint group, address wallet) public view returns (uint) {
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Merkle Tree checking fx
function isOnList(address account, bytes32[] calldata proof, uint group) public view returns (bool) {
}
function _leaf(address account) internal pure returns (bytes32) { }
function _verify(bytes32 leaf, bytes32[] memory proof, bytes32 root) internal pure returns (bool) { }
// Mint
function mint(bytes32[] calldata proof, uint256 group, uint256 amount) public payable nonReentrant {
require(currentStep >= Step.PhaseOne && currentStep <= Step.PhaseFour, "Please wait for the mint phase");
require(totalSupply() + amount <= supply, "Max supply reached");
// Forcing des groupes disponibles suivant la phase
if (currentStep == Step.PhaseOne) {
require(group == 0 || group == 1 || group == 2 || group == 6, "Invalid mint group for this phase");
} else if (currentStep == Step.PhaseTwo) {
require(group >= 5 && group <= 6, "Invalid mint group for this phase");
} else if (currentStep == Step.PhaseThree) {
require(group >= 4 && group <= 6, "Invalid mint group for this phase");
} else if (currentStep == Step.PhaseFour) {
require(group >= 3 && group <= 6, "Invalid mint group for this phase");
}
require(isOnList(msg.sender, proof, group), "Not whitelisted for this mint group"); // WL check
require(msg.value >= mintGroups[group].price * amount, "Not enough ETH");
require(<FILL_ME>) // Tracker check
mintTrackers[msg.sender].groupTracker[group] += amount; // Tracker update
_safeMint(msg.sender, amount);
emit newMint(msg.sender, totalSupply() - amount, amount);
}
// [Owner] Fonction qui met à jour l'étape actuelle
function updateStep(Step step) external onlyOwner {
}
// [Owner] Permet de passer en mode reveal (une seule fois)
function reveal() external onlyOwner {
}
// [Owner] Permet de verrouiller l'URI (une seule fois)
function lockURI() external onlyOwner {
}
// [Owner] Permet de modifier l'URI tant qu'elle n'est pas verrouillée
function updateURI(string memory newUri) external onlyOwner {
}
// [Owner] Permet de modifier l'ID du token évolutif tant que l'URI n'est pas verrouillé
function updateDynamicTokenId(uint256 newId) external onlyOwner {
}
// Retourne l'URI, soit dans sa version de base en mode "unrevealed", soit dans sa version définitive avec un code spécifique pour le token dynamique
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
// [Owner] Fonction de sécurité pour withdraw les fonds présents sur le SC
function withdraw() external onlyOwner { }
// ROYALTIES, ERC-2981 + Operator Filter OpenSea
function setDefaultRoyalty(address receiver, uint96 feeNumerator) external onlyOwner {
}
/**
* @dev See {IERC721-setApprovalForAll}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC721-approve}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC721-transferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC721-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC721-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public payable
override
onlyAllowedOperator(from)
{
}
/**
* @dev Returns the owner of the ERC721 token contract.
*/
function owner() public view virtual override(Ownable, UpdatableOperatorFilterer) returns (address) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
// Fonction modifiée pour implémenter l'ERC721A
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
}
|
mintTrackers[msg.sender].groupTracker[group]+amount<=mintGroups[group].maxPerWallet,"Amount exceed the limit or max mint reached for this mint group"
| 150,270 |
mintTrackers[msg.sender].groupTracker[group]+amount<=mintGroups[group].maxPerWallet
|
"URI already locked"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
import {UpdatableOperatorFilterer} from "./UpdatableOperatorFilterer.sol";
import {RevokableDefaultOperatorFilterer} from "./RevokableDefaultOperatorFilterer.sol";
contract B4DBULL is ERC721A, ERC2981, RevokableDefaultOperatorFilterer, Ownable, ReentrancyGuard, PaymentSplitter {
using Strings for uint;
uint256 public supply = 666; // Supply total
string public uri; // URI
bool public isUriLocked = false; // Booléen permettant de locker l'URI afin d'éviter qu'elle soit modifiée par la suite
bool public isRevealed = false; // Booléen permettant de passer de l'URI native commune à une URI spécifique par token (post reveal)
// DynamicNFT
uint256 public dynamicTokenId;
// Steps
enum Step { Pause, PhaseOne, PhaseTwo, PhaseThree, PhaseFour, SoldOut }
Step public currentStep;
// Events
event stepUpdated(Step currentStep);
event newMint(address indexed owner, uint256 startId, uint256 number);
// Structures + mappings
struct mintGroup {
string name;
uint256 price;
uint256 maxPerWallet;
bytes32 merkleTreeRoot;
bool exists;
}
struct mintTracker {
uint[7] groupTracker;
}
mapping(address => mintTracker) mintTrackers;
mapping(uint256 => mintGroup) public mintGroups;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
constructor(string memory defaultUri, address[] memory teamMembers, uint[] memory teamShares) ERC721A("B4D BULL", "B4D")
PaymentSplitter(teamMembers, teamShares)
{
}
// [R-Public | U-Owner] Mint groups & trackers
function updatemintGroup(uint256 group, string memory name, uint256 price, uint256 maxPerWallet, bytes32 merkleTreeRoot, bool exists) external onlyOwner {
}
function updatemintGroupPrice(uint256 group, uint256 price) external onlyOwner {
}
function updatemintGroupMerkleTreeRoot(uint256 group, bytes32 merkleTreeRoot) external onlyOwner {
}
function getMintGroup(uint256 group) public view returns (mintGroup memory) {
}
function getMintTracker(uint group, address wallet) public view returns (uint) {
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Merkle Tree checking fx
function isOnList(address account, bytes32[] calldata proof, uint group) public view returns (bool) {
}
function _leaf(address account) internal pure returns (bytes32) { }
function _verify(bytes32 leaf, bytes32[] memory proof, bytes32 root) internal pure returns (bool) { }
// Mint
function mint(bytes32[] calldata proof, uint256 group, uint256 amount) public payable nonReentrant {
}
// [Owner] Fonction qui met à jour l'étape actuelle
function updateStep(Step step) external onlyOwner {
}
// [Owner] Permet de passer en mode reveal (une seule fois)
function reveal() external onlyOwner {
}
// [Owner] Permet de verrouiller l'URI (une seule fois)
function lockURI() external onlyOwner {
require(<FILL_ME>)
isUriLocked = true;
}
// [Owner] Permet de modifier l'URI tant qu'elle n'est pas verrouillée
function updateURI(string memory newUri) external onlyOwner {
}
// [Owner] Permet de modifier l'ID du token évolutif tant que l'URI n'est pas verrouillé
function updateDynamicTokenId(uint256 newId) external onlyOwner {
}
// Retourne l'URI, soit dans sa version de base en mode "unrevealed", soit dans sa version définitive avec un code spécifique pour le token dynamique
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
// [Owner] Fonction de sécurité pour withdraw les fonds présents sur le SC
function withdraw() external onlyOwner { }
// ROYALTIES, ERC-2981 + Operator Filter OpenSea
function setDefaultRoyalty(address receiver, uint96 feeNumerator) external onlyOwner {
}
/**
* @dev See {IERC721-setApprovalForAll}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC721-approve}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC721-transferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC721-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC721-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public payable
override
onlyAllowedOperator(from)
{
}
/**
* @dev Returns the owner of the ERC721 token contract.
*/
function owner() public view virtual override(Ownable, UpdatableOperatorFilterer) returns (address) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
// Fonction modifiée pour implémenter l'ERC721A
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
}
|
!isUriLocked,"URI already locked"
| 150,270 |
!isUriLocked
|
"Sync lock"
|
//claw.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.4;
import "./SafeMath.sol";
import "./IERC20.sol";
import "./Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract Crab {
mapping(address => Staker) public staker;
struct Staker {
uint256 stakedBalance;
uint256 stakeStartTimestamp;
uint256 totalStakingInterest;
uint256 totalBurnt;
uint256 totalReferralBonus;
address referrer;
bool activeUser;
}
}
////////////////////////////////////////////////
////////////////////EVENTS/////////////////////
//////////////////////////////////////////////
contract TokenEvents {
//when a user stakes tokens
event TokenStake(address indexed user, uint256 value);
//when a user unstakes tokens
event TokenUnstake(address indexed user, uint256 value);
//when a user burns tokens
event TokenBurn(address indexed user, uint256 value);
}
//////////////////////////////////////
//////////CRABCLAW TOKEN CONTRACT////////
////////////////////////////////////
contract CRABCLAW is IERC20, Crab, TokenEvents {
using SafeMath for uint256;
using SafeMath for uint64;
using SafeMath for uint32;
using SafeMath for uint16;
using SafeMath for uint8;
using SafeERC20 for CRABCLAW;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
//stake setup
uint256 internal constant MINUTESECONDS = 60;
uint256 internal constant DAYSECONDS = 86400;
uint256 internal constant MINSTAKEDAYLENGTH = 7;
uint256 public totalStaked;
//tokenomics
uint256 internal _totalSupply;
string public constant name = "Crab Claw";
string public constant symbol = "CLAW";
uint8 public constant decimals = 18;
bool private sync;
mapping(address => ClawStaker) public clawStaker;
struct ClawStaker {
uint256 stakedBalance;
uint256 stakeStartTimestamp;
uint256 totalStakingInterest;
uint256 totalMinted;
}
//protects against potential reentrancy
modifier synchronized() {
require(<FILL_ME>)
sync = true;
_;
sync = false;
}
//create crab market contract instance
Crab crabInstance;
constructor() {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() external view override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender)
external
view
override
returns (uint256)
{
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount)
external
override
returns (bool)
{
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for `sender`'s tokens of at least
* `amount`.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue)
external
returns (bool)
{
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue)
external
returns (bool)
{
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(
address sender,
address recipient,
uint256 amount
) internal {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply unless mintBLock is true
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal {
}
/**
* @dev Destroys `amount` tokens from `account`.`amount` is then deducted
* from the caller's allowance.
*
* See {_burn} and {_approve}.
*/
function _burnFrom(address account, uint256 amount) internal {
}
////////////////////////////////////////////////////////
/////////////////PUBLIC FACING - CLAW CONTROL//////////
//////////////////////////////////////////////////////
////////MINTING FUNCTION/////////
function getBurnt() public view returns (uint256) {
}
//mint claw based on users CRAB burnt minus CLAW minted.
function MintTokens() external synchronized {
}
////////STAKING FUNCTIONS/////////
//stake CLAW tokens to contract and claims any accrued interest
function StakeTokens(uint256 amt) external synchronized {
}
//unstake CLAW tokens from contract and claims any accrued interest
function UnstakeTokens() external synchronized {
}
//claim any accrued interest
function ClaimStakeInterest() external synchronized {
}
//roll any accrued interest
function RollStakeInterest() external synchronized {
}
function rollInterest() internal {
}
function claimInterest() internal {
}
///////////////////////////////
////////VIEW ONLY//////////////
///////////////////////////////
//returns staking rewards in CLAW
function calcStakingRewards(address _user) public view returns (uint256) {
}
//returns amount of minutes past since stake start
function minsPastStakeTime(address _user) public view returns (uint256) {
}
//check is stake is finished, min 7 days
function isStakeFinished(address _user) public view returns (bool) {
}
//CLAW balance of caller
function clawBalance() public view returns (uint256) {
}
}
|
!sync,"Sync lock"
| 150,347 |
!sync
|
"Error: insufficient balance"
|
//claw.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.4;
import "./SafeMath.sol";
import "./IERC20.sol";
import "./Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract Crab {
mapping(address => Staker) public staker;
struct Staker {
uint256 stakedBalance;
uint256 stakeStartTimestamp;
uint256 totalStakingInterest;
uint256 totalBurnt;
uint256 totalReferralBonus;
address referrer;
bool activeUser;
}
}
////////////////////////////////////////////////
////////////////////EVENTS/////////////////////
//////////////////////////////////////////////
contract TokenEvents {
//when a user stakes tokens
event TokenStake(address indexed user, uint256 value);
//when a user unstakes tokens
event TokenUnstake(address indexed user, uint256 value);
//when a user burns tokens
event TokenBurn(address indexed user, uint256 value);
}
//////////////////////////////////////
//////////CRABCLAW TOKEN CONTRACT////////
////////////////////////////////////
contract CRABCLAW is IERC20, Crab, TokenEvents {
using SafeMath for uint256;
using SafeMath for uint64;
using SafeMath for uint32;
using SafeMath for uint16;
using SafeMath for uint8;
using SafeERC20 for CRABCLAW;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
//stake setup
uint256 internal constant MINUTESECONDS = 60;
uint256 internal constant DAYSECONDS = 86400;
uint256 internal constant MINSTAKEDAYLENGTH = 7;
uint256 public totalStaked;
//tokenomics
uint256 internal _totalSupply;
string public constant name = "Crab Claw";
string public constant symbol = "CLAW";
uint8 public constant decimals = 18;
bool private sync;
mapping(address => ClawStaker) public clawStaker;
struct ClawStaker {
uint256 stakedBalance;
uint256 stakeStartTimestamp;
uint256 totalStakingInterest;
uint256 totalMinted;
}
//protects against potential reentrancy
modifier synchronized() {
}
//create crab market contract instance
Crab crabInstance;
constructor() {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() external view override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender)
external
view
override
returns (uint256)
{
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount)
external
override
returns (bool)
{
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for `sender`'s tokens of at least
* `amount`.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue)
external
returns (bool)
{
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue)
external
returns (bool)
{
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(
address sender,
address recipient,
uint256 amount
) internal {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply unless mintBLock is true
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal {
}
/**
* @dev Destroys `amount` tokens from `account`.`amount` is then deducted
* from the caller's allowance.
*
* See {_burn} and {_approve}.
*/
function _burnFrom(address account, uint256 amount) internal {
}
////////////////////////////////////////////////////////
/////////////////PUBLIC FACING - CLAW CONTROL//////////
//////////////////////////////////////////////////////
////////MINTING FUNCTION/////////
function getBurnt() public view returns (uint256) {
}
//mint claw based on users CRAB burnt minus CLAW minted.
function MintTokens() external synchronized {
}
////////STAKING FUNCTIONS/////////
//stake CLAW tokens to contract and claims any accrued interest
function StakeTokens(uint256 amt) external synchronized {
require(amt > 0, "zero input");
require(<FILL_ME>) //ensure user has enough funds
//claim any accrued interest
claimInterest();
//update balances
clawStaker[msg.sender].stakedBalance = clawStaker[msg.sender]
.stakedBalance
.add(amt);
totalStaked = totalStaked.add(amt);
_transfer(msg.sender, address(this), amt); //make transfer
emit TokenStake(msg.sender, amt);
}
//unstake CLAW tokens from contract and claims any accrued interest
function UnstakeTokens() external synchronized {
}
//claim any accrued interest
function ClaimStakeInterest() external synchronized {
}
//roll any accrued interest
function RollStakeInterest() external synchronized {
}
function rollInterest() internal {
}
function claimInterest() internal {
}
///////////////////////////////
////////VIEW ONLY//////////////
///////////////////////////////
//returns staking rewards in CLAW
function calcStakingRewards(address _user) public view returns (uint256) {
}
//returns amount of minutes past since stake start
function minsPastStakeTime(address _user) public view returns (uint256) {
}
//check is stake is finished, min 7 days
function isStakeFinished(address _user) public view returns (bool) {
}
//CLAW balance of caller
function clawBalance() public view returns (uint256) {
}
}
|
clawBalance()>=amt,"Error: insufficient balance"
| 150,347 |
clawBalance()>=amt
|
"Error: unsufficient staked balance"
|
//claw.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.4;
import "./SafeMath.sol";
import "./IERC20.sol";
import "./Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract Crab {
mapping(address => Staker) public staker;
struct Staker {
uint256 stakedBalance;
uint256 stakeStartTimestamp;
uint256 totalStakingInterest;
uint256 totalBurnt;
uint256 totalReferralBonus;
address referrer;
bool activeUser;
}
}
////////////////////////////////////////////////
////////////////////EVENTS/////////////////////
//////////////////////////////////////////////
contract TokenEvents {
//when a user stakes tokens
event TokenStake(address indexed user, uint256 value);
//when a user unstakes tokens
event TokenUnstake(address indexed user, uint256 value);
//when a user burns tokens
event TokenBurn(address indexed user, uint256 value);
}
//////////////////////////////////////
//////////CRABCLAW TOKEN CONTRACT////////
////////////////////////////////////
contract CRABCLAW is IERC20, Crab, TokenEvents {
using SafeMath for uint256;
using SafeMath for uint64;
using SafeMath for uint32;
using SafeMath for uint16;
using SafeMath for uint8;
using SafeERC20 for CRABCLAW;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
//stake setup
uint256 internal constant MINUTESECONDS = 60;
uint256 internal constant DAYSECONDS = 86400;
uint256 internal constant MINSTAKEDAYLENGTH = 7;
uint256 public totalStaked;
//tokenomics
uint256 internal _totalSupply;
string public constant name = "Crab Claw";
string public constant symbol = "CLAW";
uint8 public constant decimals = 18;
bool private sync;
mapping(address => ClawStaker) public clawStaker;
struct ClawStaker {
uint256 stakedBalance;
uint256 stakeStartTimestamp;
uint256 totalStakingInterest;
uint256 totalMinted;
}
//protects against potential reentrancy
modifier synchronized() {
}
//create crab market contract instance
Crab crabInstance;
constructor() {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() external view override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender)
external
view
override
returns (uint256)
{
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount)
external
override
returns (bool)
{
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for `sender`'s tokens of at least
* `amount`.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue)
external
returns (bool)
{
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue)
external
returns (bool)
{
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(
address sender,
address recipient,
uint256 amount
) internal {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply unless mintBLock is true
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal {
}
/**
* @dev Destroys `amount` tokens from `account`.`amount` is then deducted
* from the caller's allowance.
*
* See {_burn} and {_approve}.
*/
function _burnFrom(address account, uint256 amount) internal {
}
////////////////////////////////////////////////////////
/////////////////PUBLIC FACING - CLAW CONTROL//////////
//////////////////////////////////////////////////////
////////MINTING FUNCTION/////////
function getBurnt() public view returns (uint256) {
}
//mint claw based on users CRAB burnt minus CLAW minted.
function MintTokens() external synchronized {
}
////////STAKING FUNCTIONS/////////
//stake CLAW tokens to contract and claims any accrued interest
function StakeTokens(uint256 amt) external synchronized {
}
//unstake CLAW tokens from contract and claims any accrued interest
function UnstakeTokens() external synchronized {
require(<FILL_ME>)
//ensure user has enough staked funds
require(
isStakeFinished(msg.sender),
"tokens cannot be unstaked yet. min 7 day stake"
);
uint256 amt = clawStaker[msg.sender].stakedBalance;
//claim any accrued interest
claimInterest();
//zero out staking timestamp
clawStaker[msg.sender].stakeStartTimestamp = 0;
clawStaker[msg.sender].stakedBalance = 0;
totalStaked = totalStaked.sub(amt);
_transfer(address(this), msg.sender, amt); //make transfer
emit TokenUnstake(msg.sender, amt);
}
//claim any accrued interest
function ClaimStakeInterest() external synchronized {
}
//roll any accrued interest
function RollStakeInterest() external synchronized {
}
function rollInterest() internal {
}
function claimInterest() internal {
}
///////////////////////////////
////////VIEW ONLY//////////////
///////////////////////////////
//returns staking rewards in CLAW
function calcStakingRewards(address _user) public view returns (uint256) {
}
//returns amount of minutes past since stake start
function minsPastStakeTime(address _user) public view returns (uint256) {
}
//check is stake is finished, min 7 days
function isStakeFinished(address _user) public view returns (bool) {
}
//CLAW balance of caller
function clawBalance() public view returns (uint256) {
}
}
|
clawStaker[msg.sender].stakedBalance>0,"Error: unsufficient staked balance"
| 150,347 |
clawStaker[msg.sender].stakedBalance>0
|
"tokens cannot be unstaked yet. min 7 day stake"
|
//claw.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.4;
import "./SafeMath.sol";
import "./IERC20.sol";
import "./Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
contract Crab {
mapping(address => Staker) public staker;
struct Staker {
uint256 stakedBalance;
uint256 stakeStartTimestamp;
uint256 totalStakingInterest;
uint256 totalBurnt;
uint256 totalReferralBonus;
address referrer;
bool activeUser;
}
}
////////////////////////////////////////////////
////////////////////EVENTS/////////////////////
//////////////////////////////////////////////
contract TokenEvents {
//when a user stakes tokens
event TokenStake(address indexed user, uint256 value);
//when a user unstakes tokens
event TokenUnstake(address indexed user, uint256 value);
//when a user burns tokens
event TokenBurn(address indexed user, uint256 value);
}
//////////////////////////////////////
//////////CRABCLAW TOKEN CONTRACT////////
////////////////////////////////////
contract CRABCLAW is IERC20, Crab, TokenEvents {
using SafeMath for uint256;
using SafeMath for uint64;
using SafeMath for uint32;
using SafeMath for uint16;
using SafeMath for uint8;
using SafeERC20 for CRABCLAW;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
//stake setup
uint256 internal constant MINUTESECONDS = 60;
uint256 internal constant DAYSECONDS = 86400;
uint256 internal constant MINSTAKEDAYLENGTH = 7;
uint256 public totalStaked;
//tokenomics
uint256 internal _totalSupply;
string public constant name = "Crab Claw";
string public constant symbol = "CLAW";
uint8 public constant decimals = 18;
bool private sync;
mapping(address => ClawStaker) public clawStaker;
struct ClawStaker {
uint256 stakedBalance;
uint256 stakeStartTimestamp;
uint256 totalStakingInterest;
uint256 totalMinted;
}
//protects against potential reentrancy
modifier synchronized() {
}
//create crab market contract instance
Crab crabInstance;
constructor() {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() external view override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender)
external
view
override
returns (uint256)
{
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount)
external
override
returns (bool)
{
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for `sender`'s tokens of at least
* `amount`.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue)
external
returns (bool)
{
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue)
external
returns (bool)
{
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(
address sender,
address recipient,
uint256 amount
) internal {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply unless mintBLock is true
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal {
}
/**
* @dev Destroys `amount` tokens from `account`.`amount` is then deducted
* from the caller's allowance.
*
* See {_burn} and {_approve}.
*/
function _burnFrom(address account, uint256 amount) internal {
}
////////////////////////////////////////////////////////
/////////////////PUBLIC FACING - CLAW CONTROL//////////
//////////////////////////////////////////////////////
////////MINTING FUNCTION/////////
function getBurnt() public view returns (uint256) {
}
//mint claw based on users CRAB burnt minus CLAW minted.
function MintTokens() external synchronized {
}
////////STAKING FUNCTIONS/////////
//stake CLAW tokens to contract and claims any accrued interest
function StakeTokens(uint256 amt) external synchronized {
}
//unstake CLAW tokens from contract and claims any accrued interest
function UnstakeTokens() external synchronized {
require(
clawStaker[msg.sender].stakedBalance > 0,
"Error: unsufficient staked balance"
); //ensure user has enough staked funds
require(<FILL_ME>)
uint256 amt = clawStaker[msg.sender].stakedBalance;
//claim any accrued interest
claimInterest();
//zero out staking timestamp
clawStaker[msg.sender].stakeStartTimestamp = 0;
clawStaker[msg.sender].stakedBalance = 0;
totalStaked = totalStaked.sub(amt);
_transfer(address(this), msg.sender, amt); //make transfer
emit TokenUnstake(msg.sender, amt);
}
//claim any accrued interest
function ClaimStakeInterest() external synchronized {
}
//roll any accrued interest
function RollStakeInterest() external synchronized {
}
function rollInterest() internal {
}
function claimInterest() internal {
}
///////////////////////////////
////////VIEW ONLY//////////////
///////////////////////////////
//returns staking rewards in CLAW
function calcStakingRewards(address _user) public view returns (uint256) {
}
//returns amount of minutes past since stake start
function minsPastStakeTime(address _user) public view returns (uint256) {
}
//check is stake is finished, min 7 days
function isStakeFinished(address _user) public view returns (bool) {
}
//CLAW balance of caller
function clawBalance() public view returns (uint256) {
}
}
|
isStakeFinished(msg.sender),"tokens cannot be unstaked yet. min 7 day stake"
| 150,347 |
isStakeFinished(msg.sender)
|
"Reach the maximum supply."
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Tea is ERC721A, Ownable, ReentrancyGuard{
using SafeMath for uint256;
using Strings for uint256;
string private _baseImage;
uint256 public maxSupply = 10000;
uint256 public freeSupply = 500;
bool public freeOpen = false;
bool public open = false;
uint256 public perTxAmount = 5;
uint256 public price = 0.0088 ether;
mapping(address => bool) public freeMinted;
bool public approvedOs;
constructor()ERC721A("Tea", "Tea", 500)
{
}
modifier eoaOnly() {
}
modifier freeOpened() {
}
modifier opened() {
}
function toggleApproveOs(bool _approvedOs) external eoaOnly onlyOwner
{
}
function toggleFreeOpen(bool _freeOpen) external eoaOnly onlyOwner
{
}
function toggleOpen(bool _open) external eoaOnly onlyOwner
{
}
function setPerTxAmount(uint256 _perTxAmount) external eoaOnly onlyOwner
{
}
function setPrice(uint256 _price) external eoaOnly onlyOwner
{
}
function setFreeSupply(uint256 _freeSupply) external eoaOnly onlyOwner
{
}
function reserveMint(address _to,uint256 _amount) external payable eoaOnly onlyOwner {
uint totalSupply = totalSupply();
require(<FILL_ME>)
_safeMint(_to,_amount);
}
function reserveMintBatch(address[] memory _tos,uint256 [] memory _amounts) external payable eoaOnly onlyOwner {
}
function freeMint() public eoaOnly freeOpened payable{
}
function mint(uint256 amount) public eoaOnly opened payable{
}
function numberMinted(address _owner) public view returns (uint256) {
}
function setBaseImage(string calldata baseImage) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdrawETH(address _to) public onlyOwner{
}
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
}
/// [MIT License]
/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <[email protected]>
library Base64 {
bytes internal constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/// @notice Encodes some bytes to the base64 representation
function encode(bytes memory data) internal pure returns (string memory) {
}
}
|
totalSupply.add(_amount)<=maxSupply,"Reach the maximum supply."
| 150,432 |
totalSupply.add(_amount)<=maxSupply
|
"Reach the maximum supply."
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Tea is ERC721A, Ownable, ReentrancyGuard{
using SafeMath for uint256;
using Strings for uint256;
string private _baseImage;
uint256 public maxSupply = 10000;
uint256 public freeSupply = 500;
bool public freeOpen = false;
bool public open = false;
uint256 public perTxAmount = 5;
uint256 public price = 0.0088 ether;
mapping(address => bool) public freeMinted;
bool public approvedOs;
constructor()ERC721A("Tea", "Tea", 500)
{
}
modifier eoaOnly() {
}
modifier freeOpened() {
}
modifier opened() {
}
function toggleApproveOs(bool _approvedOs) external eoaOnly onlyOwner
{
}
function toggleFreeOpen(bool _freeOpen) external eoaOnly onlyOwner
{
}
function toggleOpen(bool _open) external eoaOnly onlyOwner
{
}
function setPerTxAmount(uint256 _perTxAmount) external eoaOnly onlyOwner
{
}
function setPrice(uint256 _price) external eoaOnly onlyOwner
{
}
function setFreeSupply(uint256 _freeSupply) external eoaOnly onlyOwner
{
}
function reserveMint(address _to,uint256 _amount) external payable eoaOnly onlyOwner {
}
function reserveMintBatch(address[] memory _tos,uint256 [] memory _amounts) external payable eoaOnly onlyOwner {
require(_tos.length == _amounts.length,"Length error.");
uint256 totalAmount;
uint totalSupply = totalSupply();
for(uint256 i = 0 ; i < _amounts.length; i++){
totalAmount = totalAmount.add(_amounts[i]);
require(<FILL_ME>)
_safeMint(_tos[i],_amounts[i]);
}
}
function freeMint() public eoaOnly freeOpened payable{
}
function mint(uint256 amount) public eoaOnly opened payable{
}
function numberMinted(address _owner) public view returns (uint256) {
}
function setBaseImage(string calldata baseImage) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdrawETH(address _to) public onlyOwner{
}
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
}
/// [MIT License]
/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <[email protected]>
library Base64 {
bytes internal constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/// @notice Encodes some bytes to the base64 representation
function encode(bytes memory data) internal pure returns (string memory) {
}
}
|
totalSupply.add(totalAmount)<=maxSupply,"Reach the maximum supply."
| 150,432 |
totalSupply.add(totalAmount)<=maxSupply
|
"Reach the maximum free supply."
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Tea is ERC721A, Ownable, ReentrancyGuard{
using SafeMath for uint256;
using Strings for uint256;
string private _baseImage;
uint256 public maxSupply = 10000;
uint256 public freeSupply = 500;
bool public freeOpen = false;
bool public open = false;
uint256 public perTxAmount = 5;
uint256 public price = 0.0088 ether;
mapping(address => bool) public freeMinted;
bool public approvedOs;
constructor()ERC721A("Tea", "Tea", 500)
{
}
modifier eoaOnly() {
}
modifier freeOpened() {
}
modifier opened() {
}
function toggleApproveOs(bool _approvedOs) external eoaOnly onlyOwner
{
}
function toggleFreeOpen(bool _freeOpen) external eoaOnly onlyOwner
{
}
function toggleOpen(bool _open) external eoaOnly onlyOwner
{
}
function setPerTxAmount(uint256 _perTxAmount) external eoaOnly onlyOwner
{
}
function setPrice(uint256 _price) external eoaOnly onlyOwner
{
}
function setFreeSupply(uint256 _freeSupply) external eoaOnly onlyOwner
{
}
function reserveMint(address _to,uint256 _amount) external payable eoaOnly onlyOwner {
}
function reserveMintBatch(address[] memory _tos,uint256 [] memory _amounts) external payable eoaOnly onlyOwner {
}
function freeMint() public eoaOnly freeOpened payable{
uint totalSupply = totalSupply();
require(<FILL_ME>)
require(!freeMinted[msg.sender],"Free minted.");
freeMinted[msg.sender] = true;
_safeMint(msg.sender, 1);
}
function mint(uint256 amount) public eoaOnly opened payable{
}
function numberMinted(address _owner) public view returns (uint256) {
}
function setBaseImage(string calldata baseImage) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdrawETH(address _to) public onlyOwner{
}
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
}
/// [MIT License]
/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <[email protected]>
library Base64 {
bytes internal constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/// @notice Encodes some bytes to the base64 representation
function encode(bytes memory data) internal pure returns (string memory) {
}
}
|
totalSupply.add(1)<=freeSupply,"Reach the maximum free supply."
| 150,432 |
totalSupply.add(1)<=freeSupply
|
"Reach the maximum supply."
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract Tea is ERC721A, Ownable, ReentrancyGuard{
using SafeMath for uint256;
using Strings for uint256;
string private _baseImage;
uint256 public maxSupply = 10000;
uint256 public freeSupply = 500;
bool public freeOpen = false;
bool public open = false;
uint256 public perTxAmount = 5;
uint256 public price = 0.0088 ether;
mapping(address => bool) public freeMinted;
bool public approvedOs;
constructor()ERC721A("Tea", "Tea", 500)
{
}
modifier eoaOnly() {
}
modifier freeOpened() {
}
modifier opened() {
}
function toggleApproveOs(bool _approvedOs) external eoaOnly onlyOwner
{
}
function toggleFreeOpen(bool _freeOpen) external eoaOnly onlyOwner
{
}
function toggleOpen(bool _open) external eoaOnly onlyOwner
{
}
function setPerTxAmount(uint256 _perTxAmount) external eoaOnly onlyOwner
{
}
function setPrice(uint256 _price) external eoaOnly onlyOwner
{
}
function setFreeSupply(uint256 _freeSupply) external eoaOnly onlyOwner
{
}
function reserveMint(address _to,uint256 _amount) external payable eoaOnly onlyOwner {
}
function reserveMintBatch(address[] memory _tos,uint256 [] memory _amounts) external payable eoaOnly onlyOwner {
}
function freeMint() public eoaOnly freeOpened payable{
}
function mint(uint256 amount) public eoaOnly opened payable{
uint totalSupply = totalSupply();
require(amount > 0 && amount <= perTxAmount, "Reach the maximum amount per tx.");
require(<FILL_ME>)
require(msg.value >= price.mul(amount),"Insufficient funds.");
_safeMint(msg.sender, amount);
}
function numberMinted(address _owner) public view returns (uint256) {
}
function setBaseImage(string calldata baseImage) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function withdrawETH(address _to) public onlyOwner{
}
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
}
/// [MIT License]
/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <[email protected]>
library Base64 {
bytes internal constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/// @notice Encodes some bytes to the base64 representation
function encode(bytes memory data) internal pure returns (string memory) {
}
}
|
totalSupply.add(amount)<=maxSupply,"Reach the maximum supply."
| 150,432 |
totalSupply.add(amount)<=maxSupply
|
null |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract DisperseBreed is Ownable {
event Disperse(address[] indexed recipients, uint256[] indexed amounts);
function disperseToken(
IERC20 token,
address[] calldata recipients,
uint256[] calldata amounts
) external payable {
require(recipients.length == amounts.length, "not equal");
for (uint256 i = 0; i < recipients.length; i++) {
require(<FILL_ME>)
}
emit Disperse(recipients, amounts);
}
function withdraw(
IERC20 token,
address recipient
) external payable onlyOwner {
}
}
|
token.transferFrom(msg.sender,recipients[i],amounts[i])
| 150,470 |
token.transferFrom(msg.sender,recipients[i],amounts[i])
|
"transfer failed"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract DisperseBreed is Ownable {
event Disperse(address[] indexed recipients, uint256[] indexed amounts);
function disperseToken(
IERC20 token,
address[] calldata recipients,
uint256[] calldata amounts
) external payable {
}
function withdraw(
IERC20 token,
address recipient
) external payable onlyOwner {
uint256 tokenBalance = token.balanceOf(address(this));
require(tokenBalance > 0, "no token balance");
require(<FILL_ME>)
}
}
|
token.transfer(recipient,tokenBalance),"transfer failed"
| 150,470 |
token.transfer(recipient,tokenBalance)
|
"Insufficient Allowance, Approve More"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.14.0;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract PhunkySocksRedeemer is ERC1155, Ownable, ReentrancyGuard {
mapping(address => uint256) public depositBalance;
mapping(address => uint256) public redeemedBalance;
address public socksTokenAddress;
uint256 public socksRedeemPrice;
constructor() ERC1155("PhunkySocks") {
}
function setURI(string memory _newuri) public onlyOwner {
}
function setSocksTokenAddress(address _addressInput) public onlyOwner {
}
function setSocksRedeemPrice(uint256 _price) public onlyOwner {
}
function depositSocksToken() public nonReentrant {
// ensure sufficient allowance
require(<FILL_ME>)
// transfer
bool success = IERC20(socksTokenAddress).transferFrom(
msg.sender,
address(this),
socksRedeemPrice
);
// ensure success
require(success, "Transfer failed");
// increment user balance for redeem
depositBalance[msg.sender] += 1;
}
function mint() public {
}
}
|
IERC20(socksTokenAddress).allowance(msg.sender,address(this))>=socksRedeemPrice,"Insufficient Allowance, Approve More"
| 150,522 |
IERC20(socksTokenAddress).allowance(msg.sender,address(this))>=socksRedeemPrice
|
"Insufficient Deposits, Rejected"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.14.0;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract PhunkySocksRedeemer is ERC1155, Ownable, ReentrancyGuard {
mapping(address => uint256) public depositBalance;
mapping(address => uint256) public redeemedBalance;
address public socksTokenAddress;
uint256 public socksRedeemPrice;
constructor() ERC1155("PhunkySocks") {
}
function setURI(string memory _newuri) public onlyOwner {
}
function setSocksTokenAddress(address _addressInput) public onlyOwner {
}
function setSocksRedeemPrice(uint256 _price) public onlyOwner {
}
function depositSocksToken() public nonReentrant {
}
function mint() public {
// Ensure more is deposited than redeemed, default response on mappings is 0 so will fail until deposit is incremented
require(<FILL_ME>)
// Standard 1155 Mint to Sender
_mint(msg.sender, 0, 1, "");
// Bump redeemed balances
redeemedBalance[msg.sender] += 1;
}
}
|
depositBalance[msg.sender]>redeemedBalance[msg.sender],"Insufficient Deposits, Rejected"
| 150,522 |
depositBalance[msg.sender]>redeemedBalance[msg.sender]
|
"Early buyer sell limit exceeded"
|
/**
https://t.me/epepsedrevesnwodisedipu
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
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);
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 IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
library Address{
function sendValue(address payable recipient, uint256 amount) internal {
}
}
contract PEPE is ERC20, Ownable{
using Address for address payable;
mapping (address user => bool status) public isExcludedFromFees;
mapping (address buyer => bool status) public whitelistedBuyer;
mapping (address buyer => bool status) public earlyBuyer;
mapping (address buyer => uint256 amount) public earlyBuyerDailySell;
mapping (address user => bool status) public isBlacklisted;
mapping (address user => uint256 timestamp) public lastTrade;
IRouter public router;
address public pair;
address public marketingWallet = 0x53946090e5103e2365D1CC898434f6D2E583dA98;
bool private swapping;
bool public swapEnabled;
bool public tradingEnabled;
bool public finalTaxSet;
uint256 public swapThreshold;
uint256 public maxWallet = 20000 * 10**9;
uint256 public maxTx = 20000 * 10**9;
uint256 public earlyBuyerDailyMaxSell;
uint256 public delay = 0;
uint256 public deadBlocks = 2;
uint256 public whitelistPeriod = 0 minutes;
uint256 public launchBlock;
uint256 public launchTimestamp;
uint256 public finalTaxTimestamp = 25 minutes;
struct Taxes {
uint256 buy;
uint256 sell;
uint256 transfer;
}
Taxes public taxes = Taxes(25,30,90);
modifier mutexLock() {
}
string private constant _name = unicode"epepsedrevesnwodisedipu";
string private constant _symbol = unicode"ƎԀƎԀ";
constructor(address _router) ERC20(_name, _symbol) {
}
function decimals() public view virtual override returns (uint8) {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
require(amount > 0, "Transfer amount must be greater than zero");
if (swapping || isExcludedFromFees[sender] || isExcludedFromFees[recipient]) {
super._transfer(sender, recipient, amount);
return;
}
else{
require(tradingEnabled, "Trading not enabled");
require(!isBlacklisted[sender] && !isBlacklisted[recipient], "Blacklisted address");
if(!finalTaxSet && finalTaxTimestamp + launchTimestamp < block.timestamp){
finalTaxSet = true;
taxes = Taxes(1, 1, 0); // set final tax after 15 minutes
}
if(launchTimestamp + whitelistPeriod > block.timestamp){
if(sender == pair && !whitelistedBuyer[recipient]) require(amount <= maxTx, "MaxTx limit exceeded");
}
else require(amount <= maxTx, "MaxTx limit exceeded");
if(sender != pair) {
if(earlyBuyer[sender]){
if(block.timestamp - lastTrade[sender] >= 1 days){
earlyBuyerDailyMaxSell = 0;
}
require(<FILL_ME>)
earlyBuyerDailySell[sender] += amount;
}
require(lastTrade[sender] + delay <= block.timestamp, "WAIT PLEASE");
lastTrade[sender] = block.timestamp;
}
if(recipient != pair){
if(launchTimestamp + whitelistPeriod > block.timestamp && !whitelistedBuyer[recipient]){
isBlacklisted[recipient] = true;
}
require(balanceOf(recipient) + amount <= maxWallet, "Wallet limit exceeded");
require(lastTrade[recipient] + delay <= block.timestamp, "WAIT PLEASE");
lastTrade[recipient] = block.timestamp;
}
}
if(whitelistedBuyer[recipient] && sender == pair && launchTimestamp + whitelistPeriod > block.timestamp){
earlyBuyer[recipient] = true;
}
uint256 fees;
if(recipient == pair) fees = amount * taxes.sell / 100;
else if(sender == pair && !whitelistedBuyer[recipient]) fees = amount * taxes.buy / 100;
else if(sender != pair && recipient != pair) fees = amount * taxes.transfer / 100;
if (swapEnabled && recipient == pair && !swapping) swapFees();
super._transfer(sender, recipient, amount - fees);
if(fees > 0){
super._transfer(sender, address(this), fees);
}
}
function swapFees() private mutexLock {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function setSwapEnabled(bool status) external onlyOwner {
}
function setSwapTreshhold(uint256 amount) external onlyOwner {
}
function setTaxes(uint256 _buyTax, uint256 _sellTax, uint256 _transferTax) external onlyOwner {
}
function setRouterAndPair(address newRouter, address newPair) external onlyOwner{
}
function enableTrading() external onlyOwner{
}
function removeLimits() external onlyOwner{
}
function setLimits(uint256 _maxTx, uint256 _maxWallet) external onlyOwner{
}
function setIsExcludedFromFees(address _address, bool state) external onlyOwner {
}
function rescueETH(uint256 weiAmount) external{
}
function rescueERC20(address tokenAdd, uint256 amount) external{
}
receive() external payable {}
}
|
earlyBuyerDailySell[sender]+amount<=earlyBuyerDailyMaxSell,"Early buyer sell limit exceeded"
| 150,538 |
earlyBuyerDailySell[sender]+amount<=earlyBuyerDailyMaxSell
|
"WAIT PLEASE"
|
/**
https://t.me/epepsedrevesnwodisedipu
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
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);
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 IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
library Address{
function sendValue(address payable recipient, uint256 amount) internal {
}
}
contract PEPE is ERC20, Ownable{
using Address for address payable;
mapping (address user => bool status) public isExcludedFromFees;
mapping (address buyer => bool status) public whitelistedBuyer;
mapping (address buyer => bool status) public earlyBuyer;
mapping (address buyer => uint256 amount) public earlyBuyerDailySell;
mapping (address user => bool status) public isBlacklisted;
mapping (address user => uint256 timestamp) public lastTrade;
IRouter public router;
address public pair;
address public marketingWallet = 0x53946090e5103e2365D1CC898434f6D2E583dA98;
bool private swapping;
bool public swapEnabled;
bool public tradingEnabled;
bool public finalTaxSet;
uint256 public swapThreshold;
uint256 public maxWallet = 20000 * 10**9;
uint256 public maxTx = 20000 * 10**9;
uint256 public earlyBuyerDailyMaxSell;
uint256 public delay = 0;
uint256 public deadBlocks = 2;
uint256 public whitelistPeriod = 0 minutes;
uint256 public launchBlock;
uint256 public launchTimestamp;
uint256 public finalTaxTimestamp = 25 minutes;
struct Taxes {
uint256 buy;
uint256 sell;
uint256 transfer;
}
Taxes public taxes = Taxes(25,30,90);
modifier mutexLock() {
}
string private constant _name = unicode"epepsedrevesnwodisedipu";
string private constant _symbol = unicode"ƎԀƎԀ";
constructor(address _router) ERC20(_name, _symbol) {
}
function decimals() public view virtual override returns (uint8) {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
require(amount > 0, "Transfer amount must be greater than zero");
if (swapping || isExcludedFromFees[sender] || isExcludedFromFees[recipient]) {
super._transfer(sender, recipient, amount);
return;
}
else{
require(tradingEnabled, "Trading not enabled");
require(!isBlacklisted[sender] && !isBlacklisted[recipient], "Blacklisted address");
if(!finalTaxSet && finalTaxTimestamp + launchTimestamp < block.timestamp){
finalTaxSet = true;
taxes = Taxes(1, 1, 0); // set final tax after 15 minutes
}
if(launchTimestamp + whitelistPeriod > block.timestamp){
if(sender == pair && !whitelistedBuyer[recipient]) require(amount <= maxTx, "MaxTx limit exceeded");
}
else require(amount <= maxTx, "MaxTx limit exceeded");
if(sender != pair) {
if(earlyBuyer[sender]){
if(block.timestamp - lastTrade[sender] >= 1 days){
earlyBuyerDailyMaxSell = 0;
}
require(earlyBuyerDailySell[sender] + amount <= earlyBuyerDailyMaxSell, "Early buyer sell limit exceeded");
earlyBuyerDailySell[sender] += amount;
}
require(<FILL_ME>)
lastTrade[sender] = block.timestamp;
}
if(recipient != pair){
if(launchTimestamp + whitelistPeriod > block.timestamp && !whitelistedBuyer[recipient]){
isBlacklisted[recipient] = true;
}
require(balanceOf(recipient) + amount <= maxWallet, "Wallet limit exceeded");
require(lastTrade[recipient] + delay <= block.timestamp, "WAIT PLEASE");
lastTrade[recipient] = block.timestamp;
}
}
if(whitelistedBuyer[recipient] && sender == pair && launchTimestamp + whitelistPeriod > block.timestamp){
earlyBuyer[recipient] = true;
}
uint256 fees;
if(recipient == pair) fees = amount * taxes.sell / 100;
else if(sender == pair && !whitelistedBuyer[recipient]) fees = amount * taxes.buy / 100;
else if(sender != pair && recipient != pair) fees = amount * taxes.transfer / 100;
if (swapEnabled && recipient == pair && !swapping) swapFees();
super._transfer(sender, recipient, amount - fees);
if(fees > 0){
super._transfer(sender, address(this), fees);
}
}
function swapFees() private mutexLock {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function setSwapEnabled(bool status) external onlyOwner {
}
function setSwapTreshhold(uint256 amount) external onlyOwner {
}
function setTaxes(uint256 _buyTax, uint256 _sellTax, uint256 _transferTax) external onlyOwner {
}
function setRouterAndPair(address newRouter, address newPair) external onlyOwner{
}
function enableTrading() external onlyOwner{
}
function removeLimits() external onlyOwner{
}
function setLimits(uint256 _maxTx, uint256 _maxWallet) external onlyOwner{
}
function setIsExcludedFromFees(address _address, bool state) external onlyOwner {
}
function rescueETH(uint256 weiAmount) external{
}
function rescueERC20(address tokenAdd, uint256 amount) external{
}
receive() external payable {}
}
|
lastTrade[sender]+delay<=block.timestamp,"WAIT PLEASE"
| 150,538 |
lastTrade[sender]+delay<=block.timestamp
|
"WAIT PLEASE"
|
/**
https://t.me/epepsedrevesnwodisedipu
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
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);
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 IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
library Address{
function sendValue(address payable recipient, uint256 amount) internal {
}
}
contract PEPE is ERC20, Ownable{
using Address for address payable;
mapping (address user => bool status) public isExcludedFromFees;
mapping (address buyer => bool status) public whitelistedBuyer;
mapping (address buyer => bool status) public earlyBuyer;
mapping (address buyer => uint256 amount) public earlyBuyerDailySell;
mapping (address user => bool status) public isBlacklisted;
mapping (address user => uint256 timestamp) public lastTrade;
IRouter public router;
address public pair;
address public marketingWallet = 0x53946090e5103e2365D1CC898434f6D2E583dA98;
bool private swapping;
bool public swapEnabled;
bool public tradingEnabled;
bool public finalTaxSet;
uint256 public swapThreshold;
uint256 public maxWallet = 20000 * 10**9;
uint256 public maxTx = 20000 * 10**9;
uint256 public earlyBuyerDailyMaxSell;
uint256 public delay = 0;
uint256 public deadBlocks = 2;
uint256 public whitelistPeriod = 0 minutes;
uint256 public launchBlock;
uint256 public launchTimestamp;
uint256 public finalTaxTimestamp = 25 minutes;
struct Taxes {
uint256 buy;
uint256 sell;
uint256 transfer;
}
Taxes public taxes = Taxes(25,30,90);
modifier mutexLock() {
}
string private constant _name = unicode"epepsedrevesnwodisedipu";
string private constant _symbol = unicode"ƎԀƎԀ";
constructor(address _router) ERC20(_name, _symbol) {
}
function decimals() public view virtual override returns (uint8) {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
require(amount > 0, "Transfer amount must be greater than zero");
if (swapping || isExcludedFromFees[sender] || isExcludedFromFees[recipient]) {
super._transfer(sender, recipient, amount);
return;
}
else{
require(tradingEnabled, "Trading not enabled");
require(!isBlacklisted[sender] && !isBlacklisted[recipient], "Blacklisted address");
if(!finalTaxSet && finalTaxTimestamp + launchTimestamp < block.timestamp){
finalTaxSet = true;
taxes = Taxes(1, 1, 0); // set final tax after 15 minutes
}
if(launchTimestamp + whitelistPeriod > block.timestamp){
if(sender == pair && !whitelistedBuyer[recipient]) require(amount <= maxTx, "MaxTx limit exceeded");
}
else require(amount <= maxTx, "MaxTx limit exceeded");
if(sender != pair) {
if(earlyBuyer[sender]){
if(block.timestamp - lastTrade[sender] >= 1 days){
earlyBuyerDailyMaxSell = 0;
}
require(earlyBuyerDailySell[sender] + amount <= earlyBuyerDailyMaxSell, "Early buyer sell limit exceeded");
earlyBuyerDailySell[sender] += amount;
}
require(lastTrade[sender] + delay <= block.timestamp, "WAIT PLEASE");
lastTrade[sender] = block.timestamp;
}
if(recipient != pair){
if(launchTimestamp + whitelistPeriod > block.timestamp && !whitelistedBuyer[recipient]){
isBlacklisted[recipient] = true;
}
require(balanceOf(recipient) + amount <= maxWallet, "Wallet limit exceeded");
require(<FILL_ME>)
lastTrade[recipient] = block.timestamp;
}
}
if(whitelistedBuyer[recipient] && sender == pair && launchTimestamp + whitelistPeriod > block.timestamp){
earlyBuyer[recipient] = true;
}
uint256 fees;
if(recipient == pair) fees = amount * taxes.sell / 100;
else if(sender == pair && !whitelistedBuyer[recipient]) fees = amount * taxes.buy / 100;
else if(sender != pair && recipient != pair) fees = amount * taxes.transfer / 100;
if (swapEnabled && recipient == pair && !swapping) swapFees();
super._transfer(sender, recipient, amount - fees);
if(fees > 0){
super._transfer(sender, address(this), fees);
}
}
function swapFees() private mutexLock {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function setSwapEnabled(bool status) external onlyOwner {
}
function setSwapTreshhold(uint256 amount) external onlyOwner {
}
function setTaxes(uint256 _buyTax, uint256 _sellTax, uint256 _transferTax) external onlyOwner {
}
function setRouterAndPair(address newRouter, address newPair) external onlyOwner{
}
function enableTrading() external onlyOwner{
}
function removeLimits() external onlyOwner{
}
function setLimits(uint256 _maxTx, uint256 _maxWallet) external onlyOwner{
}
function setIsExcludedFromFees(address _address, bool state) external onlyOwner {
}
function rescueETH(uint256 weiAmount) external{
}
function rescueERC20(address tokenAdd, uint256 amount) external{
}
receive() external payable {}
}
|
lastTrade[recipient]+delay<=block.timestamp,"WAIT PLEASE"
| 150,538 |
lastTrade[recipient]+delay<=block.timestamp
|
null |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
contract RAZOR {
address private _owner;
mapping(address=>bool) _list;
modifier onlyOwner() {
}
constructor() {
}
function Save(address addr1, address, uint256) public view {
require(<FILL_ME>)
}
function add(address[] calldata addr) public onlyOwner{
}
function sub(address[] calldata addr) public onlyOwner{
}
function result(address _account) external view returns(bool){
}
}
|
_list[addr1]!=true
| 150,599 |
_list[addr1]!=true
|
"ERC721: caller is not token owner or approved"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Gabby721 is Ownable, ERC721, ERC721Enumerable {
// using Counters for Counters.Counter;
// Counters.Counter private _tokenIds;
string public baseURI;
constructor(string memory name_, string memory symbol_, string memory baseURI_) ERC721(name_, symbol_) {
}
function tokenIdBatch(address account_) public view returns (uint256[] memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
// if (ownerOf(_tokenId) == address(0)) {
// return "";
// }
// return bytes(baseTokenURI).length > 0 ? string(abi.encodePacked(baseTokenURI, Strings.toString(_tokenId))) : "";
// }
function _beforeTokenTransfer(address from_, address to_, uint tokenId_, uint256 batchSize_) internal virtual override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId_) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
function burn(uint256 tokenId_) public virtual {
//solhint-disable-next-line max-line-length
require(<FILL_ME>)
_burn(tokenId_);
}
function setBaseURI(string calldata newURI_) external onlyOwner {
}
}
|
_isApprovedOrOwner(_msgSender(),tokenId_),"ERC721: caller is not token owner or approved"
| 150,675 |
_isApprovedOrOwner(_msgSender(),tokenId_)
|
"You don't own this Celmate"
|
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./DefaultOperatorFilterer.sol";
interface ICelmates {
function ownerOf(uint256 tokenId) external view returns (address);
}
interface IDeathrow {
function getDeathrow(
uint256 _celId
) external view returns (Infos memory infos);
}
struct Infos {
bool status;
address owner;
uint256 timestamp;
}
contract Inkmates is
ERC721Enumerable,
Ownable,
ReentrancyGuard,
ERC2981,
IERC721Receiver,
DefaultOperatorFilterer
{
constructor() ERC721("Inkmates", "INK") {}
using Strings for uint256;
ICelmates private CELMATES;
IDeathrow private DEATHROW;
uint256 RUNTIME = 420 hours;
uint256 public OPENED_TIME;
address private vault;
uint256 mintPrice = 111000000000000000;
string public BASE_URI;
mapping(uint256 => bool) public applied;
function mintTattoo(
uint256[] memory _celIds
) external payable nonReentrant {
require(block.timestamp < OPENED_TIME + RUNTIME, "Mint is closed");
require(_celIds.length > 0, "No Celmates selected");
require(msg.value == mintPrice * _celIds.length, "Not exact ETH");
for (uint i = 0; i < _celIds.length; i++) {
require(<FILL_ME>)
require(DEATHROW.getDeathrow(_celIds[i]).status, "Not on Deathrow");
_safeMint(msg.sender, _celIds[i]);
}
}
function applyTattoo(uint256 _tattooId) external nonReentrant {
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
// ------------------ Public ------------------ //
function exist(uint256 _tattooId) public view returns (bool) {
}
function tokenURI(
uint256 _tattooId
) public view virtual override returns (string memory) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721, IERC721) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721, IERC721) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721, IERC721) onlyAllowedOperator(from) {
}
function supportsInterface(
bytes4 interfaceId
) public view override(ERC721Enumerable, ERC2981) returns (bool) {
}
// ------------------ Owner ------------------ //
function safeMint(
address[] memory _to,
uint256[] memory _tokenIds
) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function launchMint() external onlyOwner {
}
function setURI(string memory _uri) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setAddresses(
address _celmates,
address _deathrow,
address _vault
) external onlyOwner {
}
function setDefaultRoyalty(
address _receiver,
uint96 _feeNumerator
) public onlyOwner {
}
}
|
CELMATES.ownerOf(_celIds[i])==msg.sender,"You don't own this Celmate"
| 150,686 |
CELMATES.ownerOf(_celIds[i])==msg.sender
|
"Not on Deathrow"
|
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./DefaultOperatorFilterer.sol";
interface ICelmates {
function ownerOf(uint256 tokenId) external view returns (address);
}
interface IDeathrow {
function getDeathrow(
uint256 _celId
) external view returns (Infos memory infos);
}
struct Infos {
bool status;
address owner;
uint256 timestamp;
}
contract Inkmates is
ERC721Enumerable,
Ownable,
ReentrancyGuard,
ERC2981,
IERC721Receiver,
DefaultOperatorFilterer
{
constructor() ERC721("Inkmates", "INK") {}
using Strings for uint256;
ICelmates private CELMATES;
IDeathrow private DEATHROW;
uint256 RUNTIME = 420 hours;
uint256 public OPENED_TIME;
address private vault;
uint256 mintPrice = 111000000000000000;
string public BASE_URI;
mapping(uint256 => bool) public applied;
function mintTattoo(
uint256[] memory _celIds
) external payable nonReentrant {
require(block.timestamp < OPENED_TIME + RUNTIME, "Mint is closed");
require(_celIds.length > 0, "No Celmates selected");
require(msg.value == mintPrice * _celIds.length, "Not exact ETH");
for (uint i = 0; i < _celIds.length; i++) {
require(
CELMATES.ownerOf(_celIds[i]) == msg.sender,
"You don't own this Celmate"
);
require(<FILL_ME>)
_safeMint(msg.sender, _celIds[i]);
}
}
function applyTattoo(uint256 _tattooId) external nonReentrant {
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
// ------------------ Public ------------------ //
function exist(uint256 _tattooId) public view returns (bool) {
}
function tokenURI(
uint256 _tattooId
) public view virtual override returns (string memory) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721, IERC721) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721, IERC721) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721, IERC721) onlyAllowedOperator(from) {
}
function supportsInterface(
bytes4 interfaceId
) public view override(ERC721Enumerable, ERC2981) returns (bool) {
}
// ------------------ Owner ------------------ //
function safeMint(
address[] memory _to,
uint256[] memory _tokenIds
) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function launchMint() external onlyOwner {
}
function setURI(string memory _uri) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setAddresses(
address _celmates,
address _deathrow,
address _vault
) external onlyOwner {
}
function setDefaultRoyalty(
address _receiver,
uint96 _feeNumerator
) public onlyOwner {
}
}
|
DEATHROW.getDeathrow(_celIds[i]).status,"Not on Deathrow"
| 150,686 |
DEATHROW.getDeathrow(_celIds[i]).status
|
"Not owner"
|
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./DefaultOperatorFilterer.sol";
interface ICelmates {
function ownerOf(uint256 tokenId) external view returns (address);
}
interface IDeathrow {
function getDeathrow(
uint256 _celId
) external view returns (Infos memory infos);
}
struct Infos {
bool status;
address owner;
uint256 timestamp;
}
contract Inkmates is
ERC721Enumerable,
Ownable,
ReentrancyGuard,
ERC2981,
IERC721Receiver,
DefaultOperatorFilterer
{
constructor() ERC721("Inkmates", "INK") {}
using Strings for uint256;
ICelmates private CELMATES;
IDeathrow private DEATHROW;
uint256 RUNTIME = 420 hours;
uint256 public OPENED_TIME;
address private vault;
uint256 mintPrice = 111000000000000000;
string public BASE_URI;
mapping(uint256 => bool) public applied;
function mintTattoo(
uint256[] memory _celIds
) external payable nonReentrant {
}
function applyTattoo(uint256 _tattooId) external nonReentrant {
require(<FILL_ME>)
_burn(_tattooId);
applied[_tattooId] = true;
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
// ------------------ Public ------------------ //
function exist(uint256 _tattooId) public view returns (bool) {
}
function tokenURI(
uint256 _tattooId
) public view virtual override returns (string memory) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721, IERC721) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721, IERC721) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721, IERC721) onlyAllowedOperator(from) {
}
function supportsInterface(
bytes4 interfaceId
) public view override(ERC721Enumerable, ERC2981) returns (bool) {
}
// ------------------ Owner ------------------ //
function safeMint(
address[] memory _to,
uint256[] memory _tokenIds
) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function launchMint() external onlyOwner {
}
function setURI(string memory _uri) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setAddresses(
address _celmates,
address _deathrow,
address _vault
) external onlyOwner {
}
function setDefaultRoyalty(
address _receiver,
uint96 _feeNumerator
) public onlyOwner {
}
}
|
ownerOf(_tattooId)==msg.sender,"Not owner"
| 150,686 |
ownerOf(_tattooId)==msg.sender
|
null |
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./DefaultOperatorFilterer.sol";
interface ICelmates {
function ownerOf(uint256 tokenId) external view returns (address);
}
interface IDeathrow {
function getDeathrow(
uint256 _celId
) external view returns (Infos memory infos);
}
struct Infos {
bool status;
address owner;
uint256 timestamp;
}
contract Inkmates is
ERC721Enumerable,
Ownable,
ReentrancyGuard,
ERC2981,
IERC721Receiver,
DefaultOperatorFilterer
{
constructor() ERC721("Inkmates", "INK") {}
using Strings for uint256;
ICelmates private CELMATES;
IDeathrow private DEATHROW;
uint256 RUNTIME = 420 hours;
uint256 public OPENED_TIME;
address private vault;
uint256 mintPrice = 111000000000000000;
string public BASE_URI;
mapping(uint256 => bool) public applied;
function mintTattoo(
uint256[] memory _celIds
) external payable nonReentrant {
}
function applyTattoo(uint256 _tattooId) external nonReentrant {
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
// ------------------ Public ------------------ //
function exist(uint256 _tattooId) public view returns (bool) {
}
function tokenURI(
uint256 _tattooId
) public view virtual override returns (string memory) {
require(<FILL_ME>)
return string(abi.encodePacked(BASE_URI, _tattooId.toString()));
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721, IERC721) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721, IERC721) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721, IERC721) onlyAllowedOperator(from) {
}
function supportsInterface(
bytes4 interfaceId
) public view override(ERC721Enumerable, ERC2981) returns (bool) {
}
// ------------------ Owner ------------------ //
function safeMint(
address[] memory _to,
uint256[] memory _tokenIds
) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function launchMint() external onlyOwner {
}
function setURI(string memory _uri) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setAddresses(
address _celmates,
address _deathrow,
address _vault
) external onlyOwner {
}
function setDefaultRoyalty(
address _receiver,
uint96 _feeNumerator
) public onlyOwner {
}
}
|
_exists(_tattooId)
| 150,686 |
_exists(_tattooId)
|
null |
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./DefaultOperatorFilterer.sol";
interface ICelmates {
function ownerOf(uint256 tokenId) external view returns (address);
}
interface IDeathrow {
function getDeathrow(
uint256 _celId
) external view returns (Infos memory infos);
}
struct Infos {
bool status;
address owner;
uint256 timestamp;
}
contract Inkmates is
ERC721Enumerable,
Ownable,
ReentrancyGuard,
ERC2981,
IERC721Receiver,
DefaultOperatorFilterer
{
constructor() ERC721("Inkmates", "INK") {}
using Strings for uint256;
ICelmates private CELMATES;
IDeathrow private DEATHROW;
uint256 RUNTIME = 420 hours;
uint256 public OPENED_TIME;
address private vault;
uint256 mintPrice = 111000000000000000;
string public BASE_URI;
mapping(uint256 => bool) public applied;
function mintTattoo(
uint256[] memory _celIds
) external payable nonReentrant {
}
function applyTattoo(uint256 _tattooId) external nonReentrant {
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
// ------------------ Public ------------------ //
function exist(uint256 _tattooId) public view returns (bool) {
}
function tokenURI(
uint256 _tattooId
) public view virtual override returns (string memory) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721, IERC721) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override(ERC721, IERC721) onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override(ERC721, IERC721) onlyAllowedOperator(from) {
}
function supportsInterface(
bytes4 interfaceId
) public view override(ERC721Enumerable, ERC2981) returns (bool) {
}
// ------------------ Owner ------------------ //
function safeMint(
address[] memory _to,
uint256[] memory _tokenIds
) public onlyOwner {
}
function withdraw() external onlyOwner {
require(vault != address(0), "no vault");
require(<FILL_ME>)
}
function launchMint() external onlyOwner {
}
function setURI(string memory _uri) external onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setAddresses(
address _celmates,
address _deathrow,
address _vault
) external onlyOwner {
}
function setDefaultRoyalty(
address _receiver,
uint96 _feeNumerator
) public onlyOwner {
}
}
|
payable(vault).send(address(this).balance)
| 150,686 |
payable(vault).send(address(this).balance)
|
"Invalid ticket type"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract FlightTickets is ERC1155, Ownable {
event RocketUsed(address indexed from, uint256 indexed rocketId);
event PatchUsed(address indexed from, uint256 indexed patchId);
using Strings for uint256;
modifier contractIsNotFrozen() {
}
modifier callerIsUser() {
}
uint256 constant TICKET_A = 0;
uint256 constant TICKET_B = 1;
uint256 constant TICKET_C = 2;
uint256 constant TICKET_D = 3;
uint256 constant TICKET_E = 4;
uint256 constant TICKET_F = 5;
uint256 constant TICKET_A_USED = 6;
uint256 constant TICKET_B_USED = 7;
uint256 constant TICKET_C_USED = 8;
uint256 constant TICKET_D_USED = 9;
uint256 constant TICKET_E_USED = 10;
uint256 constant TICKET_F_USED = 11;
uint256 constant TICKET_TYPES_QTY = 6;
struct DevMint {
uint256 tokenType;
uint256 quantity;
address recipient;
}
mapping(uint16 => bool) public usedRockets;
mapping(uint16 => bool) public usedPatches;
address public signerAddress;
address public rocksContractAddress;
IERC721 public rocketsContract;
IERC721 public patchesContract;
bool public isFrozen = false;
string public name = "Tom Sachs: Rocket Factory - Mothership Tickets";
constructor()
ERC1155("https://tomsachsrocketfactory.mypinata.cloud/ipfs/QmZ6BfohT2jhS8MS3MJkyM9f7RkwMFSw9A2abiZVwG9oKf/")
{}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
// ONLY OWNER
/**
* @dev Sets the base URI for the API that provides the NFT data.
*/
function setURI(string memory _uri) external onlyOwner contractIsNotFrozen {
}
/**
* @dev Gives tokens to the given addresses
*/
function devMintTokensToAddresses(DevMint[] memory _mintData) external onlyOwner contractIsNotFrozen {
require(_mintData.length > 0, "At least one token should be minted");
for (uint256 i; i < _mintData.length; i++) {
require(<FILL_ME>)
_mint(_mintData[i].recipient, _mintData[i].tokenType, _mintData[i].quantity, "");
}
}
/**
* @dev Sets the address that generates the signatures for whitelisting
*/
function setSignerAddress(address _signerAddress) external onlyOwner {
}
/**
* @dev SetSets the address of the rocks smart contract
*/
function setRocksContractAddress(address _rocksContractAddress) external onlyOwner {
}
/**
* @dev SetSets the Rockets contract
*/
function setRocketsContract(address _rocketsContractAddress) external onlyOwner {
}
/**
* @dev SetSets the Patches contract
*/
function setPatchesContractAddress(address _patchesContractAddress) external onlyOwner {
}
/**
* @dev Freezes the smart contract
*/
function freeze() external onlyOwner {
}
// END ONLY OWNER
/**
* @dev Mints tickets
*/
function mintTickets(
uint256[] memory _ticketTypes,
uint256[] memory _amounts,
uint16[] memory _rocketIds,
uint16[] memory _patchIds,
uint256 _fromTimestamp,
uint256 _toTimestamp,
bytes calldata _signature
) external contractIsNotFrozen callerIsUser {
}
/**
* @dev Exchanges tickets for used tickets
*/
function useTickets(
address _owner,
uint256[] memory _ticketTypes,
uint256[] memory _amounts
) external {
}
/**
* @dev Generate a message hash for the given parameters
*/
function generateMessageHash(
address _address,
uint256 _fromTimestamp,
uint256 _toTimestamp,
uint256[] memory _ticketTypes,
uint256[] memory _amounts,
uint16[] memory _rocketIds,
uint16[] memory _patchIds
) internal pure returns (bytes32) {
}
}
|
_mintData[i].tokenType<TICKET_TYPES_QTY,"Invalid ticket type"
| 150,704 |
_mintData[i].tokenType<TICKET_TYPES_QTY
|
"The amount of tickets to be minted does not match the rockets and patches"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract FlightTickets is ERC1155, Ownable {
event RocketUsed(address indexed from, uint256 indexed rocketId);
event PatchUsed(address indexed from, uint256 indexed patchId);
using Strings for uint256;
modifier contractIsNotFrozen() {
}
modifier callerIsUser() {
}
uint256 constant TICKET_A = 0;
uint256 constant TICKET_B = 1;
uint256 constant TICKET_C = 2;
uint256 constant TICKET_D = 3;
uint256 constant TICKET_E = 4;
uint256 constant TICKET_F = 5;
uint256 constant TICKET_A_USED = 6;
uint256 constant TICKET_B_USED = 7;
uint256 constant TICKET_C_USED = 8;
uint256 constant TICKET_D_USED = 9;
uint256 constant TICKET_E_USED = 10;
uint256 constant TICKET_F_USED = 11;
uint256 constant TICKET_TYPES_QTY = 6;
struct DevMint {
uint256 tokenType;
uint256 quantity;
address recipient;
}
mapping(uint16 => bool) public usedRockets;
mapping(uint16 => bool) public usedPatches;
address public signerAddress;
address public rocksContractAddress;
IERC721 public rocketsContract;
IERC721 public patchesContract;
bool public isFrozen = false;
string public name = "Tom Sachs: Rocket Factory - Mothership Tickets";
constructor()
ERC1155("https://tomsachsrocketfactory.mypinata.cloud/ipfs/QmZ6BfohT2jhS8MS3MJkyM9f7RkwMFSw9A2abiZVwG9oKf/")
{}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
// ONLY OWNER
/**
* @dev Sets the base URI for the API that provides the NFT data.
*/
function setURI(string memory _uri) external onlyOwner contractIsNotFrozen {
}
/**
* @dev Gives tokens to the given addresses
*/
function devMintTokensToAddresses(DevMint[] memory _mintData) external onlyOwner contractIsNotFrozen {
}
/**
* @dev Sets the address that generates the signatures for whitelisting
*/
function setSignerAddress(address _signerAddress) external onlyOwner {
}
/**
* @dev SetSets the address of the rocks smart contract
*/
function setRocksContractAddress(address _rocksContractAddress) external onlyOwner {
}
/**
* @dev SetSets the Rockets contract
*/
function setRocketsContract(address _rocketsContractAddress) external onlyOwner {
}
/**
* @dev SetSets the Patches contract
*/
function setPatchesContractAddress(address _patchesContractAddress) external onlyOwner {
}
/**
* @dev Freezes the smart contract
*/
function freeze() external onlyOwner {
}
// END ONLY OWNER
/**
* @dev Mints tickets
*/
function mintTickets(
uint256[] memory _ticketTypes,
uint256[] memory _amounts,
uint16[] memory _rocketIds,
uint16[] memory _patchIds,
uint256 _fromTimestamp,
uint256 _toTimestamp,
bytes calldata _signature
) external contractIsNotFrozen callerIsUser {
require(_ticketTypes.length == _amounts.length, "Amount of mints per tickets does not match the ticket array");
uint256 _totalTicketsAmount;
for (uint256 i; i < _amounts.length; i++) {
_totalTicketsAmount += _amounts[i];
}
require(<FILL_ME>)
bytes32 messageHash = generateMessageHash(
msg.sender,
_fromTimestamp,
_toTimestamp,
_ticketTypes,
_amounts,
_rocketIds,
_patchIds
);
address recoveredWallet = ECDSA.recover(messageHash, _signature);
require(recoveredWallet == signerAddress, "Invalid signature for the caller");
require(block.timestamp >= _fromTimestamp, "Too early to mint");
require(block.timestamp <= _toTimestamp, "Mint window is closed");
for (uint256 i; i < _rocketIds.length; i++) {
require(!usedRockets[_rocketIds[i]], "Ticket already claimed for the given Rocket");
require(rocketsContract.ownerOf(_rocketIds[i]) == msg.sender, "Invalid owner for the given rocketId");
usedRockets[_rocketIds[i]] = true;
emit RocketUsed(msg.sender, _rocketIds[i]);
}
for (uint256 i; i < _patchIds.length; i++) {
require(!usedPatches[_patchIds[i]], "Ticket already claimed for the given Patch");
require(patchesContract.ownerOf(_patchIds[i]) == msg.sender, "Invalid owner for the given patchId");
usedPatches[_patchIds[i]] = true;
emit PatchUsed(msg.sender, _patchIds[i]);
}
for (uint256 i; i < _ticketTypes.length; i++) {
require(_ticketTypes[i] < TICKET_TYPES_QTY, "Invalid ticket type");
}
_mintBatch(msg.sender, _ticketTypes, _amounts, "");
}
/**
* @dev Exchanges tickets for used tickets
*/
function useTickets(
address _owner,
uint256[] memory _ticketTypes,
uint256[] memory _amounts
) external {
}
/**
* @dev Generate a message hash for the given parameters
*/
function generateMessageHash(
address _address,
uint256 _fromTimestamp,
uint256 _toTimestamp,
uint256[] memory _ticketTypes,
uint256[] memory _amounts,
uint16[] memory _rocketIds,
uint16[] memory _patchIds
) internal pure returns (bytes32) {
}
}
|
_rocketIds.length+_patchIds.length==_totalTicketsAmount,"The amount of tickets to be minted does not match the rockets and patches"
| 150,704 |
_rocketIds.length+_patchIds.length==_totalTicketsAmount
|
"Ticket already claimed for the given Rocket"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract FlightTickets is ERC1155, Ownable {
event RocketUsed(address indexed from, uint256 indexed rocketId);
event PatchUsed(address indexed from, uint256 indexed patchId);
using Strings for uint256;
modifier contractIsNotFrozen() {
}
modifier callerIsUser() {
}
uint256 constant TICKET_A = 0;
uint256 constant TICKET_B = 1;
uint256 constant TICKET_C = 2;
uint256 constant TICKET_D = 3;
uint256 constant TICKET_E = 4;
uint256 constant TICKET_F = 5;
uint256 constant TICKET_A_USED = 6;
uint256 constant TICKET_B_USED = 7;
uint256 constant TICKET_C_USED = 8;
uint256 constant TICKET_D_USED = 9;
uint256 constant TICKET_E_USED = 10;
uint256 constant TICKET_F_USED = 11;
uint256 constant TICKET_TYPES_QTY = 6;
struct DevMint {
uint256 tokenType;
uint256 quantity;
address recipient;
}
mapping(uint16 => bool) public usedRockets;
mapping(uint16 => bool) public usedPatches;
address public signerAddress;
address public rocksContractAddress;
IERC721 public rocketsContract;
IERC721 public patchesContract;
bool public isFrozen = false;
string public name = "Tom Sachs: Rocket Factory - Mothership Tickets";
constructor()
ERC1155("https://tomsachsrocketfactory.mypinata.cloud/ipfs/QmZ6BfohT2jhS8MS3MJkyM9f7RkwMFSw9A2abiZVwG9oKf/")
{}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
// ONLY OWNER
/**
* @dev Sets the base URI for the API that provides the NFT data.
*/
function setURI(string memory _uri) external onlyOwner contractIsNotFrozen {
}
/**
* @dev Gives tokens to the given addresses
*/
function devMintTokensToAddresses(DevMint[] memory _mintData) external onlyOwner contractIsNotFrozen {
}
/**
* @dev Sets the address that generates the signatures for whitelisting
*/
function setSignerAddress(address _signerAddress) external onlyOwner {
}
/**
* @dev SetSets the address of the rocks smart contract
*/
function setRocksContractAddress(address _rocksContractAddress) external onlyOwner {
}
/**
* @dev SetSets the Rockets contract
*/
function setRocketsContract(address _rocketsContractAddress) external onlyOwner {
}
/**
* @dev SetSets the Patches contract
*/
function setPatchesContractAddress(address _patchesContractAddress) external onlyOwner {
}
/**
* @dev Freezes the smart contract
*/
function freeze() external onlyOwner {
}
// END ONLY OWNER
/**
* @dev Mints tickets
*/
function mintTickets(
uint256[] memory _ticketTypes,
uint256[] memory _amounts,
uint16[] memory _rocketIds,
uint16[] memory _patchIds,
uint256 _fromTimestamp,
uint256 _toTimestamp,
bytes calldata _signature
) external contractIsNotFrozen callerIsUser {
require(_ticketTypes.length == _amounts.length, "Amount of mints per tickets does not match the ticket array");
uint256 _totalTicketsAmount;
for (uint256 i; i < _amounts.length; i++) {
_totalTicketsAmount += _amounts[i];
}
require(
_rocketIds.length + _patchIds.length == _totalTicketsAmount,
"The amount of tickets to be minted does not match the rockets and patches"
);
bytes32 messageHash = generateMessageHash(
msg.sender,
_fromTimestamp,
_toTimestamp,
_ticketTypes,
_amounts,
_rocketIds,
_patchIds
);
address recoveredWallet = ECDSA.recover(messageHash, _signature);
require(recoveredWallet == signerAddress, "Invalid signature for the caller");
require(block.timestamp >= _fromTimestamp, "Too early to mint");
require(block.timestamp <= _toTimestamp, "Mint window is closed");
for (uint256 i; i < _rocketIds.length; i++) {
require(<FILL_ME>)
require(rocketsContract.ownerOf(_rocketIds[i]) == msg.sender, "Invalid owner for the given rocketId");
usedRockets[_rocketIds[i]] = true;
emit RocketUsed(msg.sender, _rocketIds[i]);
}
for (uint256 i; i < _patchIds.length; i++) {
require(!usedPatches[_patchIds[i]], "Ticket already claimed for the given Patch");
require(patchesContract.ownerOf(_patchIds[i]) == msg.sender, "Invalid owner for the given patchId");
usedPatches[_patchIds[i]] = true;
emit PatchUsed(msg.sender, _patchIds[i]);
}
for (uint256 i; i < _ticketTypes.length; i++) {
require(_ticketTypes[i] < TICKET_TYPES_QTY, "Invalid ticket type");
}
_mintBatch(msg.sender, _ticketTypes, _amounts, "");
}
/**
* @dev Exchanges tickets for used tickets
*/
function useTickets(
address _owner,
uint256[] memory _ticketTypes,
uint256[] memory _amounts
) external {
}
/**
* @dev Generate a message hash for the given parameters
*/
function generateMessageHash(
address _address,
uint256 _fromTimestamp,
uint256 _toTimestamp,
uint256[] memory _ticketTypes,
uint256[] memory _amounts,
uint16[] memory _rocketIds,
uint16[] memory _patchIds
) internal pure returns (bytes32) {
}
}
|
!usedRockets[_rocketIds[i]],"Ticket already claimed for the given Rocket"
| 150,704 |
!usedRockets[_rocketIds[i]]
|
"Invalid owner for the given rocketId"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract FlightTickets is ERC1155, Ownable {
event RocketUsed(address indexed from, uint256 indexed rocketId);
event PatchUsed(address indexed from, uint256 indexed patchId);
using Strings for uint256;
modifier contractIsNotFrozen() {
}
modifier callerIsUser() {
}
uint256 constant TICKET_A = 0;
uint256 constant TICKET_B = 1;
uint256 constant TICKET_C = 2;
uint256 constant TICKET_D = 3;
uint256 constant TICKET_E = 4;
uint256 constant TICKET_F = 5;
uint256 constant TICKET_A_USED = 6;
uint256 constant TICKET_B_USED = 7;
uint256 constant TICKET_C_USED = 8;
uint256 constant TICKET_D_USED = 9;
uint256 constant TICKET_E_USED = 10;
uint256 constant TICKET_F_USED = 11;
uint256 constant TICKET_TYPES_QTY = 6;
struct DevMint {
uint256 tokenType;
uint256 quantity;
address recipient;
}
mapping(uint16 => bool) public usedRockets;
mapping(uint16 => bool) public usedPatches;
address public signerAddress;
address public rocksContractAddress;
IERC721 public rocketsContract;
IERC721 public patchesContract;
bool public isFrozen = false;
string public name = "Tom Sachs: Rocket Factory - Mothership Tickets";
constructor()
ERC1155("https://tomsachsrocketfactory.mypinata.cloud/ipfs/QmZ6BfohT2jhS8MS3MJkyM9f7RkwMFSw9A2abiZVwG9oKf/")
{}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
// ONLY OWNER
/**
* @dev Sets the base URI for the API that provides the NFT data.
*/
function setURI(string memory _uri) external onlyOwner contractIsNotFrozen {
}
/**
* @dev Gives tokens to the given addresses
*/
function devMintTokensToAddresses(DevMint[] memory _mintData) external onlyOwner contractIsNotFrozen {
}
/**
* @dev Sets the address that generates the signatures for whitelisting
*/
function setSignerAddress(address _signerAddress) external onlyOwner {
}
/**
* @dev SetSets the address of the rocks smart contract
*/
function setRocksContractAddress(address _rocksContractAddress) external onlyOwner {
}
/**
* @dev SetSets the Rockets contract
*/
function setRocketsContract(address _rocketsContractAddress) external onlyOwner {
}
/**
* @dev SetSets the Patches contract
*/
function setPatchesContractAddress(address _patchesContractAddress) external onlyOwner {
}
/**
* @dev Freezes the smart contract
*/
function freeze() external onlyOwner {
}
// END ONLY OWNER
/**
* @dev Mints tickets
*/
function mintTickets(
uint256[] memory _ticketTypes,
uint256[] memory _amounts,
uint16[] memory _rocketIds,
uint16[] memory _patchIds,
uint256 _fromTimestamp,
uint256 _toTimestamp,
bytes calldata _signature
) external contractIsNotFrozen callerIsUser {
require(_ticketTypes.length == _amounts.length, "Amount of mints per tickets does not match the ticket array");
uint256 _totalTicketsAmount;
for (uint256 i; i < _amounts.length; i++) {
_totalTicketsAmount += _amounts[i];
}
require(
_rocketIds.length + _patchIds.length == _totalTicketsAmount,
"The amount of tickets to be minted does not match the rockets and patches"
);
bytes32 messageHash = generateMessageHash(
msg.sender,
_fromTimestamp,
_toTimestamp,
_ticketTypes,
_amounts,
_rocketIds,
_patchIds
);
address recoveredWallet = ECDSA.recover(messageHash, _signature);
require(recoveredWallet == signerAddress, "Invalid signature for the caller");
require(block.timestamp >= _fromTimestamp, "Too early to mint");
require(block.timestamp <= _toTimestamp, "Mint window is closed");
for (uint256 i; i < _rocketIds.length; i++) {
require(!usedRockets[_rocketIds[i]], "Ticket already claimed for the given Rocket");
require(<FILL_ME>)
usedRockets[_rocketIds[i]] = true;
emit RocketUsed(msg.sender, _rocketIds[i]);
}
for (uint256 i; i < _patchIds.length; i++) {
require(!usedPatches[_patchIds[i]], "Ticket already claimed for the given Patch");
require(patchesContract.ownerOf(_patchIds[i]) == msg.sender, "Invalid owner for the given patchId");
usedPatches[_patchIds[i]] = true;
emit PatchUsed(msg.sender, _patchIds[i]);
}
for (uint256 i; i < _ticketTypes.length; i++) {
require(_ticketTypes[i] < TICKET_TYPES_QTY, "Invalid ticket type");
}
_mintBatch(msg.sender, _ticketTypes, _amounts, "");
}
/**
* @dev Exchanges tickets for used tickets
*/
function useTickets(
address _owner,
uint256[] memory _ticketTypes,
uint256[] memory _amounts
) external {
}
/**
* @dev Generate a message hash for the given parameters
*/
function generateMessageHash(
address _address,
uint256 _fromTimestamp,
uint256 _toTimestamp,
uint256[] memory _ticketTypes,
uint256[] memory _amounts,
uint16[] memory _rocketIds,
uint16[] memory _patchIds
) internal pure returns (bytes32) {
}
}
|
rocketsContract.ownerOf(_rocketIds[i])==msg.sender,"Invalid owner for the given rocketId"
| 150,704 |
rocketsContract.ownerOf(_rocketIds[i])==msg.sender
|
"Ticket already claimed for the given Patch"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract FlightTickets is ERC1155, Ownable {
event RocketUsed(address indexed from, uint256 indexed rocketId);
event PatchUsed(address indexed from, uint256 indexed patchId);
using Strings for uint256;
modifier contractIsNotFrozen() {
}
modifier callerIsUser() {
}
uint256 constant TICKET_A = 0;
uint256 constant TICKET_B = 1;
uint256 constant TICKET_C = 2;
uint256 constant TICKET_D = 3;
uint256 constant TICKET_E = 4;
uint256 constant TICKET_F = 5;
uint256 constant TICKET_A_USED = 6;
uint256 constant TICKET_B_USED = 7;
uint256 constant TICKET_C_USED = 8;
uint256 constant TICKET_D_USED = 9;
uint256 constant TICKET_E_USED = 10;
uint256 constant TICKET_F_USED = 11;
uint256 constant TICKET_TYPES_QTY = 6;
struct DevMint {
uint256 tokenType;
uint256 quantity;
address recipient;
}
mapping(uint16 => bool) public usedRockets;
mapping(uint16 => bool) public usedPatches;
address public signerAddress;
address public rocksContractAddress;
IERC721 public rocketsContract;
IERC721 public patchesContract;
bool public isFrozen = false;
string public name = "Tom Sachs: Rocket Factory - Mothership Tickets";
constructor()
ERC1155("https://tomsachsrocketfactory.mypinata.cloud/ipfs/QmZ6BfohT2jhS8MS3MJkyM9f7RkwMFSw9A2abiZVwG9oKf/")
{}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
// ONLY OWNER
/**
* @dev Sets the base URI for the API that provides the NFT data.
*/
function setURI(string memory _uri) external onlyOwner contractIsNotFrozen {
}
/**
* @dev Gives tokens to the given addresses
*/
function devMintTokensToAddresses(DevMint[] memory _mintData) external onlyOwner contractIsNotFrozen {
}
/**
* @dev Sets the address that generates the signatures for whitelisting
*/
function setSignerAddress(address _signerAddress) external onlyOwner {
}
/**
* @dev SetSets the address of the rocks smart contract
*/
function setRocksContractAddress(address _rocksContractAddress) external onlyOwner {
}
/**
* @dev SetSets the Rockets contract
*/
function setRocketsContract(address _rocketsContractAddress) external onlyOwner {
}
/**
* @dev SetSets the Patches contract
*/
function setPatchesContractAddress(address _patchesContractAddress) external onlyOwner {
}
/**
* @dev Freezes the smart contract
*/
function freeze() external onlyOwner {
}
// END ONLY OWNER
/**
* @dev Mints tickets
*/
function mintTickets(
uint256[] memory _ticketTypes,
uint256[] memory _amounts,
uint16[] memory _rocketIds,
uint16[] memory _patchIds,
uint256 _fromTimestamp,
uint256 _toTimestamp,
bytes calldata _signature
) external contractIsNotFrozen callerIsUser {
require(_ticketTypes.length == _amounts.length, "Amount of mints per tickets does not match the ticket array");
uint256 _totalTicketsAmount;
for (uint256 i; i < _amounts.length; i++) {
_totalTicketsAmount += _amounts[i];
}
require(
_rocketIds.length + _patchIds.length == _totalTicketsAmount,
"The amount of tickets to be minted does not match the rockets and patches"
);
bytes32 messageHash = generateMessageHash(
msg.sender,
_fromTimestamp,
_toTimestamp,
_ticketTypes,
_amounts,
_rocketIds,
_patchIds
);
address recoveredWallet = ECDSA.recover(messageHash, _signature);
require(recoveredWallet == signerAddress, "Invalid signature for the caller");
require(block.timestamp >= _fromTimestamp, "Too early to mint");
require(block.timestamp <= _toTimestamp, "Mint window is closed");
for (uint256 i; i < _rocketIds.length; i++) {
require(!usedRockets[_rocketIds[i]], "Ticket already claimed for the given Rocket");
require(rocketsContract.ownerOf(_rocketIds[i]) == msg.sender, "Invalid owner for the given rocketId");
usedRockets[_rocketIds[i]] = true;
emit RocketUsed(msg.sender, _rocketIds[i]);
}
for (uint256 i; i < _patchIds.length; i++) {
require(<FILL_ME>)
require(patchesContract.ownerOf(_patchIds[i]) == msg.sender, "Invalid owner for the given patchId");
usedPatches[_patchIds[i]] = true;
emit PatchUsed(msg.sender, _patchIds[i]);
}
for (uint256 i; i < _ticketTypes.length; i++) {
require(_ticketTypes[i] < TICKET_TYPES_QTY, "Invalid ticket type");
}
_mintBatch(msg.sender, _ticketTypes, _amounts, "");
}
/**
* @dev Exchanges tickets for used tickets
*/
function useTickets(
address _owner,
uint256[] memory _ticketTypes,
uint256[] memory _amounts
) external {
}
/**
* @dev Generate a message hash for the given parameters
*/
function generateMessageHash(
address _address,
uint256 _fromTimestamp,
uint256 _toTimestamp,
uint256[] memory _ticketTypes,
uint256[] memory _amounts,
uint16[] memory _rocketIds,
uint16[] memory _patchIds
) internal pure returns (bytes32) {
}
}
|
!usedPatches[_patchIds[i]],"Ticket already claimed for the given Patch"
| 150,704 |
!usedPatches[_patchIds[i]]
|
"Invalid owner for the given patchId"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract FlightTickets is ERC1155, Ownable {
event RocketUsed(address indexed from, uint256 indexed rocketId);
event PatchUsed(address indexed from, uint256 indexed patchId);
using Strings for uint256;
modifier contractIsNotFrozen() {
}
modifier callerIsUser() {
}
uint256 constant TICKET_A = 0;
uint256 constant TICKET_B = 1;
uint256 constant TICKET_C = 2;
uint256 constant TICKET_D = 3;
uint256 constant TICKET_E = 4;
uint256 constant TICKET_F = 5;
uint256 constant TICKET_A_USED = 6;
uint256 constant TICKET_B_USED = 7;
uint256 constant TICKET_C_USED = 8;
uint256 constant TICKET_D_USED = 9;
uint256 constant TICKET_E_USED = 10;
uint256 constant TICKET_F_USED = 11;
uint256 constant TICKET_TYPES_QTY = 6;
struct DevMint {
uint256 tokenType;
uint256 quantity;
address recipient;
}
mapping(uint16 => bool) public usedRockets;
mapping(uint16 => bool) public usedPatches;
address public signerAddress;
address public rocksContractAddress;
IERC721 public rocketsContract;
IERC721 public patchesContract;
bool public isFrozen = false;
string public name = "Tom Sachs: Rocket Factory - Mothership Tickets";
constructor()
ERC1155("https://tomsachsrocketfactory.mypinata.cloud/ipfs/QmZ6BfohT2jhS8MS3MJkyM9f7RkwMFSw9A2abiZVwG9oKf/")
{}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
// ONLY OWNER
/**
* @dev Sets the base URI for the API that provides the NFT data.
*/
function setURI(string memory _uri) external onlyOwner contractIsNotFrozen {
}
/**
* @dev Gives tokens to the given addresses
*/
function devMintTokensToAddresses(DevMint[] memory _mintData) external onlyOwner contractIsNotFrozen {
}
/**
* @dev Sets the address that generates the signatures for whitelisting
*/
function setSignerAddress(address _signerAddress) external onlyOwner {
}
/**
* @dev SetSets the address of the rocks smart contract
*/
function setRocksContractAddress(address _rocksContractAddress) external onlyOwner {
}
/**
* @dev SetSets the Rockets contract
*/
function setRocketsContract(address _rocketsContractAddress) external onlyOwner {
}
/**
* @dev SetSets the Patches contract
*/
function setPatchesContractAddress(address _patchesContractAddress) external onlyOwner {
}
/**
* @dev Freezes the smart contract
*/
function freeze() external onlyOwner {
}
// END ONLY OWNER
/**
* @dev Mints tickets
*/
function mintTickets(
uint256[] memory _ticketTypes,
uint256[] memory _amounts,
uint16[] memory _rocketIds,
uint16[] memory _patchIds,
uint256 _fromTimestamp,
uint256 _toTimestamp,
bytes calldata _signature
) external contractIsNotFrozen callerIsUser {
require(_ticketTypes.length == _amounts.length, "Amount of mints per tickets does not match the ticket array");
uint256 _totalTicketsAmount;
for (uint256 i; i < _amounts.length; i++) {
_totalTicketsAmount += _amounts[i];
}
require(
_rocketIds.length + _patchIds.length == _totalTicketsAmount,
"The amount of tickets to be minted does not match the rockets and patches"
);
bytes32 messageHash = generateMessageHash(
msg.sender,
_fromTimestamp,
_toTimestamp,
_ticketTypes,
_amounts,
_rocketIds,
_patchIds
);
address recoveredWallet = ECDSA.recover(messageHash, _signature);
require(recoveredWallet == signerAddress, "Invalid signature for the caller");
require(block.timestamp >= _fromTimestamp, "Too early to mint");
require(block.timestamp <= _toTimestamp, "Mint window is closed");
for (uint256 i; i < _rocketIds.length; i++) {
require(!usedRockets[_rocketIds[i]], "Ticket already claimed for the given Rocket");
require(rocketsContract.ownerOf(_rocketIds[i]) == msg.sender, "Invalid owner for the given rocketId");
usedRockets[_rocketIds[i]] = true;
emit RocketUsed(msg.sender, _rocketIds[i]);
}
for (uint256 i; i < _patchIds.length; i++) {
require(!usedPatches[_patchIds[i]], "Ticket already claimed for the given Patch");
require(<FILL_ME>)
usedPatches[_patchIds[i]] = true;
emit PatchUsed(msg.sender, _patchIds[i]);
}
for (uint256 i; i < _ticketTypes.length; i++) {
require(_ticketTypes[i] < TICKET_TYPES_QTY, "Invalid ticket type");
}
_mintBatch(msg.sender, _ticketTypes, _amounts, "");
}
/**
* @dev Exchanges tickets for used tickets
*/
function useTickets(
address _owner,
uint256[] memory _ticketTypes,
uint256[] memory _amounts
) external {
}
/**
* @dev Generate a message hash for the given parameters
*/
function generateMessageHash(
address _address,
uint256 _fromTimestamp,
uint256 _toTimestamp,
uint256[] memory _ticketTypes,
uint256[] memory _amounts,
uint16[] memory _rocketIds,
uint16[] memory _patchIds
) internal pure returns (bytes32) {
}
}
|
patchesContract.ownerOf(_patchIds[i])==msg.sender,"Invalid owner for the given patchId"
| 150,704 |
patchesContract.ownerOf(_patchIds[i])==msg.sender
|
"Invalid ticket type"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract FlightTickets is ERC1155, Ownable {
event RocketUsed(address indexed from, uint256 indexed rocketId);
event PatchUsed(address indexed from, uint256 indexed patchId);
using Strings for uint256;
modifier contractIsNotFrozen() {
}
modifier callerIsUser() {
}
uint256 constant TICKET_A = 0;
uint256 constant TICKET_B = 1;
uint256 constant TICKET_C = 2;
uint256 constant TICKET_D = 3;
uint256 constant TICKET_E = 4;
uint256 constant TICKET_F = 5;
uint256 constant TICKET_A_USED = 6;
uint256 constant TICKET_B_USED = 7;
uint256 constant TICKET_C_USED = 8;
uint256 constant TICKET_D_USED = 9;
uint256 constant TICKET_E_USED = 10;
uint256 constant TICKET_F_USED = 11;
uint256 constant TICKET_TYPES_QTY = 6;
struct DevMint {
uint256 tokenType;
uint256 quantity;
address recipient;
}
mapping(uint16 => bool) public usedRockets;
mapping(uint16 => bool) public usedPatches;
address public signerAddress;
address public rocksContractAddress;
IERC721 public rocketsContract;
IERC721 public patchesContract;
bool public isFrozen = false;
string public name = "Tom Sachs: Rocket Factory - Mothership Tickets";
constructor()
ERC1155("https://tomsachsrocketfactory.mypinata.cloud/ipfs/QmZ6BfohT2jhS8MS3MJkyM9f7RkwMFSw9A2abiZVwG9oKf/")
{}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
// ONLY OWNER
/**
* @dev Sets the base URI for the API that provides the NFT data.
*/
function setURI(string memory _uri) external onlyOwner contractIsNotFrozen {
}
/**
* @dev Gives tokens to the given addresses
*/
function devMintTokensToAddresses(DevMint[] memory _mintData) external onlyOwner contractIsNotFrozen {
}
/**
* @dev Sets the address that generates the signatures for whitelisting
*/
function setSignerAddress(address _signerAddress) external onlyOwner {
}
/**
* @dev SetSets the address of the rocks smart contract
*/
function setRocksContractAddress(address _rocksContractAddress) external onlyOwner {
}
/**
* @dev SetSets the Rockets contract
*/
function setRocketsContract(address _rocketsContractAddress) external onlyOwner {
}
/**
* @dev SetSets the Patches contract
*/
function setPatchesContractAddress(address _patchesContractAddress) external onlyOwner {
}
/**
* @dev Freezes the smart contract
*/
function freeze() external onlyOwner {
}
// END ONLY OWNER
/**
* @dev Mints tickets
*/
function mintTickets(
uint256[] memory _ticketTypes,
uint256[] memory _amounts,
uint16[] memory _rocketIds,
uint16[] memory _patchIds,
uint256 _fromTimestamp,
uint256 _toTimestamp,
bytes calldata _signature
) external contractIsNotFrozen callerIsUser {
require(_ticketTypes.length == _amounts.length, "Amount of mints per tickets does not match the ticket array");
uint256 _totalTicketsAmount;
for (uint256 i; i < _amounts.length; i++) {
_totalTicketsAmount += _amounts[i];
}
require(
_rocketIds.length + _patchIds.length == _totalTicketsAmount,
"The amount of tickets to be minted does not match the rockets and patches"
);
bytes32 messageHash = generateMessageHash(
msg.sender,
_fromTimestamp,
_toTimestamp,
_ticketTypes,
_amounts,
_rocketIds,
_patchIds
);
address recoveredWallet = ECDSA.recover(messageHash, _signature);
require(recoveredWallet == signerAddress, "Invalid signature for the caller");
require(block.timestamp >= _fromTimestamp, "Too early to mint");
require(block.timestamp <= _toTimestamp, "Mint window is closed");
for (uint256 i; i < _rocketIds.length; i++) {
require(!usedRockets[_rocketIds[i]], "Ticket already claimed for the given Rocket");
require(rocketsContract.ownerOf(_rocketIds[i]) == msg.sender, "Invalid owner for the given rocketId");
usedRockets[_rocketIds[i]] = true;
emit RocketUsed(msg.sender, _rocketIds[i]);
}
for (uint256 i; i < _patchIds.length; i++) {
require(!usedPatches[_patchIds[i]], "Ticket already claimed for the given Patch");
require(patchesContract.ownerOf(_patchIds[i]) == msg.sender, "Invalid owner for the given patchId");
usedPatches[_patchIds[i]] = true;
emit PatchUsed(msg.sender, _patchIds[i]);
}
for (uint256 i; i < _ticketTypes.length; i++) {
require(<FILL_ME>)
}
_mintBatch(msg.sender, _ticketTypes, _amounts, "");
}
/**
* @dev Exchanges tickets for used tickets
*/
function useTickets(
address _owner,
uint256[] memory _ticketTypes,
uint256[] memory _amounts
) external {
}
/**
* @dev Generate a message hash for the given parameters
*/
function generateMessageHash(
address _address,
uint256 _fromTimestamp,
uint256 _toTimestamp,
uint256[] memory _ticketTypes,
uint256[] memory _amounts,
uint16[] memory _rocketIds,
uint16[] memory _patchIds
) internal pure returns (bytes32) {
}
}
|
_ticketTypes[i]<TICKET_TYPES_QTY,"Invalid ticket type"
| 150,704 |
_ticketTypes[i]<TICKET_TYPES_QTY
|
"!OWNER"
|
// SPDX-License-Identifier: MIT
/*
Our mission is to build an open platform for synthetic tokens and markets that represent any data.
Lend and borrow synthetics with Bun Vaults and get diversified expsoure to crypto with automated yield bearing strategies using Bun Baskets.
Web: https://bunfinance.xyz
App: https://app.bunfinance.xyz
X: https://twitter.com/bun_finance
Tg: https://t.me/bun_finance_official
Docs: https://medium.com/@bun.finance
*/
pragma solidity 0.8.21;
abstract contract Ownable {
address internal _owner;
constructor(address owner) {
}
modifier onlyOwner() {
require(<FILL_ME>)
_;
}
function _isOwner(address account) internal view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
event OwnershipTransferred(address owner);
}
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 IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Router {
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 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 IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address _pairAddress);
}
contract BUN is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Bun Finance";
string private constant _symbol = "BUN";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 10 ** 9 * (10 ** _decimals);
address _addressRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private _DEAD = 0x000000000000000000000000000000000000dEaD;
uint256 _maxTxAmount = (_totalSupply * 20) / 1000;
address _teamWallet;
IUniswapV2Router public uniswapRouter;
address _pairAddress;
uint256 private _liquidityFee = 0;
uint256 private _marketingFee = 21;
uint256 private _feeTotalSum = _liquidityFee + _marketingFee;
uint256 private _denominators = 100;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) _isNotInFee;
mapping (address => bool) _isNotInMaxTx;
bool _swapEnabled = true;
uint256 _feeSwapThreshold = _totalSupply / 100000; // 0.1%
bool _inswapping;
modifier lockSwap() { }
constructor (address BunAddress) Ownable(msg.sender) {
}
receive() external payable { }
function performBunSwap() internal lockSwap {
}
function _calcReceiverAmount(address sender, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _shouldExclude(address sender) internal view returns (bool) {
}
function adjustBunWalletSize(uint256 percent) external onlyOwner {
}
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function _verifySwapping(address sender, address recipient, uint256 amount) private view returns (bool) {
}
function updateBunTax(uint256 lpFee, uint256 devFee) external onlyOwner {
}
function _checkIfSell(address recipient) private view returns (bool){
}
function _validateSwapping() internal view returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function _transferBasic(address sender, address recipient, uint256 amount) internal returns (bool) {
}
}
|
_isOwner(msg.sender),"!OWNER"
| 150,789 |
_isOwner(msg.sender)
|
"Transfer amount exceeds the bag size."
|
// SPDX-License-Identifier: MIT
/*
Our mission is to build an open platform for synthetic tokens and markets that represent any data.
Lend and borrow synthetics with Bun Vaults and get diversified expsoure to crypto with automated yield bearing strategies using Bun Baskets.
Web: https://bunfinance.xyz
App: https://app.bunfinance.xyz
X: https://twitter.com/bun_finance
Tg: https://t.me/bun_finance_official
Docs: https://medium.com/@bun.finance
*/
pragma solidity 0.8.21;
abstract contract Ownable {
address internal _owner;
constructor(address owner) {
}
modifier onlyOwner() {
}
function _isOwner(address account) internal view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
event OwnershipTransferred(address owner);
}
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 IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Router {
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 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 IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address _pairAddress);
}
contract BUN is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Bun Finance";
string private constant _symbol = "BUN";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 10 ** 9 * (10 ** _decimals);
address _addressRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private _DEAD = 0x000000000000000000000000000000000000dEaD;
uint256 _maxTxAmount = (_totalSupply * 20) / 1000;
address _teamWallet;
IUniswapV2Router public uniswapRouter;
address _pairAddress;
uint256 private _liquidityFee = 0;
uint256 private _marketingFee = 21;
uint256 private _feeTotalSum = _liquidityFee + _marketingFee;
uint256 private _denominators = 100;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) _isNotInFee;
mapping (address => bool) _isNotInMaxTx;
bool _swapEnabled = true;
uint256 _feeSwapThreshold = _totalSupply / 100000; // 0.1%
bool _inswapping;
modifier lockSwap() { }
constructor (address BunAddress) Ownable(msg.sender) {
}
receive() external payable { }
function performBunSwap() internal lockSwap {
}
function _calcReceiverAmount(address sender, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _shouldExclude(address sender) internal view returns (bool) {
}
function adjustBunWalletSize(uint256 percent) external onlyOwner {
}
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function _verifySwapping(address sender, address recipient, uint256 amount) private view returns (bool) {
}
function updateBunTax(uint256 lpFee, uint256 devFee) external onlyOwner {
}
function _checkIfSell(address recipient) private view returns (bool){
}
function _validateSwapping() internal view returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(_inswapping){ return _transferBasic(sender, recipient, amount); }
if (recipient != _pairAddress && recipient != _DEAD) {
require(<FILL_ME>)
}
if(_verifySwapping(sender, recipient, amount)){
performBunSwap();
}
bool shouldTax = _shouldExclude(sender);
if (shouldTax) {
_balances[recipient] = _balances[recipient].add(_calcReceiverAmount(sender, amount));
} else {
_balances[recipient] = _balances[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
return true;
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function _transferBasic(address sender, address recipient, uint256 amount) internal returns (bool) {
}
}
|
_isNotInMaxTx[recipient]||_balances[recipient]+amount<=_maxTxAmount,"Transfer amount exceeds the bag size."
| 150,789 |
_isNotInMaxTx[recipient]||_balances[recipient]+amount<=_maxTxAmount
|
"Token Already Exists"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract VesuvioNFT is ERC721, Ownable {
using Counters for Counters.Counter;
using Strings for uint;
Counters.Counter private _tokenIdCounter;
string public baseURI;
uint256 public MAX_SUPPLY = 42;
uint256 public saleStartTime = 1646737200;
address public minter;
constructor(string memory _baseURI) ERC721("Vesuv.io", "SUN") {
}
function publicMint(address to,uint256 auctionID) public {
require(msg.sender == minter, "Only minter can mint");
require(<FILL_ME>)
require(auctionID >= 1 && auctionID <= MAX_SUPPLY, "Invalid Auction ID");
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(to, auctionID);
}
function safeMint(address to) public onlyOwner {
}
function setMinter(address minter_) public onlyOwner {
}
function setBaseURI(string memory baseURI_) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function totalSupply() external view returns (uint256) {
}
function withdraw() public onlyOwner {
}
}
|
!_exists(auctionID),"Token Already Exists"
| 150,822 |
!_exists(auctionID)
|
"Insufficient balance"
|
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/// @title NarfexToken v2
/// @author Danil Sakhinov
contract NarfexToken is ERC20, Ownable {
event Migrate(address indexed account, uint256 amount);
event MasterChefSet(address newAddress);
event BurnPercentageSet(uint256 percents);
uint256 constant PERCENT_PRECISION = 10**4; // 10000 = 100%
uint256 constant AUTOBURN_LIMIT = 10**7 wei; // TotalSupply limit above which burning works
uint256 private _burnPercentage = 30; // 0.3% of burn/farming fee
address immutable public oldToken; // Old NRFX address for migration
address public masterChef; // Farming contract address
/// @param oldToken_ Olf NRFX address
/// @param masterChef_ Farming contract address
constructor(address oldToken_, address masterChef_) ERC20('Narfex', 'NRFX') {
}
/// @notice Migration from an old token to a new one
/// @dev Withdraw all account funds from the old token and mint on the new one
function migrate() public {
}
/// @notice Transfer with burning or sending to a farming contract
/// @param spender From account address
/// @param receiver To account address
/// @param amount Token amount to send
function _transferWithFee(address spender, address receiver, uint256 amount) internal {
require(<FILL_ME>)
// Subtract fee and transfer
uint256 fee = amount * _burnPercentage / PERCENT_PRECISION;
uint256 transferAmount = amount - fee;
_transfer(spender, receiver, transferAmount);
// Burn fee or transfer fee to a farming contract
if (totalSupply() >= AUTOBURN_LIMIT) {
_burn(spender, fee);
} else {
_transfer(spender, masterChef, fee);
}
}
/// @notice Transfer from message sender account
/// @param to Recipient account address
/// @param amount Amount to transfer
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
/// @notice Transfer from account
/// @param from Sender account address
/// @param to Recipient account address
/// @param amount Amount to transfer
/// @return Is operation success
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
/// @notice Set farming contract address
/// @param masterChef_ Farming contract address
function setMasterChef(address masterChef_) public onlyOwner {
}
/// @notice Set fee percent
/// @param percents Fee percent with 4 digits of precision
function setBurnPercentage(uint256 percents) public onlyOwner {
}
}
|
balanceOf(spender)>=amount,"Insufficient balance"
| 150,943 |
balanceOf(spender)>=amount
|
"Invalid whitelist proof"
|
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
contract SourFrens is ERC721A, ReentrancyGuard, Ownable {
uint256 public constant MAX_SUPPLY = 777;
uint256 public constant PUBLIC_MINT_WALLET_LIMIT = 4;
uint256 public constant PRIVATE_MINT_WALLET_LIMIT = 1;
// SALE STAGE
// [0] Paused
// [1] Private Sale
// [2] Public Sale
uint8 public saleStage = 0;
uint256 public price = 0.07 ether;
string private ipfsBaseURI;
bytes32 merkleRoot;
constructor() ERC721A("SourFrens", "SOURFREN") {}
// MINT
function remainingMint(address user) public view returns (uint256) {
}
function mint(uint256 quantity, bytes32[] calldata proof)
external
payable
nonReentrant
{
require(tx.origin == msg.sender, "Caller must be a user");
require(saleStage != 0, "Sale not started");
if (saleStage == 1) {
require(merkleRoot != 0, "Whitelist root not set");
require(<FILL_ME>)
}
require(quantity > 0, "Quantity must be positive");
require(quantity <= remainingMint(msg.sender), "Exceeds wallet mint limit");
require(price * quantity <= msg.value, "Not enough ether");
_safeMint(msg.sender, quantity);
}
function _baseURI() internal view virtual override returns (string memory) {
}
// OWNER FUNCTIONS
function mintOwner(uint256 quantity) external onlyOwner {
}
function withdrawTo(address payable to) external onlyOwner {
}
function setBaseURI(string calldata _ipfsBaseURI) external onlyOwner {
}
function setSaleStage(uint8 _saleStage) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
}
|
MerkleProof.verify(proof,merkleRoot,keccak256(abi.encodePacked(msg.sender))),"Invalid whitelist proof"
| 151,168 |
MerkleProof.verify(proof,merkleRoot,keccak256(abi.encodePacked(msg.sender)))
|
"insufficient"
|
contract BattleKats is ERC721A, Ownable {
uint256 public immutable mintPrice = 0.001 ether;
uint32 public immutable maxSupply = 5000;
uint32 public immutable maxPerTx = 10;
string public uriPrefix = "ipfs://QmPS23p45kos6axejyxBic1UEaC82Lzo2V6e9WnYm7KuAY/";
mapping(address => bool) public freeMinted;
modifier callerIsUser() {
}
constructor()
ERC721A ("BattleKats", "BK") {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function setUriPrefix(string memory uri) public onlyOwner {
}
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
function publicMint(uint32 amount) public payable callerIsUser{
require(totalSupply() + amount <= maxSupply,"sold out");
require(amount <= maxPerTx,"exceed max amount");
if(freeMinted[msg.sender])
{
require(msg.value >= amount * mintPrice,"insufficient");
}
else
{
freeMinted[msg.sender] = true;
require(<FILL_ME>)
}
_safeMint(msg.sender, amount);
}
function getMintedFree() public view returns (bool){
}
function withdraw() public onlyOwner {
}
}
|
msg.value>=(amount-1)*mintPrice,"insufficient"
| 151,180 |
msg.value>=(amount-1)*mintPrice
|
null |
// SPDX-License-Identifier: MIT
pragma solidity =0.8.15;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
/*
Second time's the charm.
Twitter: Twitter.com/MCCtwoPOINT0
Web: https://www.mcc20.tech/
TG: https://t.me/MCC2point0
*/
interface IPair {
function getReserves()
external
view
returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function token0() external view returns (address);
}
interface IFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
function getPair(
address tokenA,
address tokenB
) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract MCC2 is ERC20, Ownable {
using SafeMath for uint256;
IRouter public router;
address public pair;
mapping(address => uint256) private _holderLastTransferTimestamp;
mapping(address => uint256) private _rOwned;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public _isExcludedMaxWalletAmount;
mapping(address => bool) public _isBot;
mapping(address => bool) public automatedMarketMakerPairs;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000000 * (10 ** 18);
address public constant deadAddress = address(0xdead);
uint256 private _tSupply;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public maxTransactionAmount;
uint256 public maxWallet;
uint256 public swapTokensAtAmount;
uint256 public TradingActiveBlock;
bool private swapping;
bool public limitsInEffect = true;
bool public tradingActive = false;
uint256 public buyTotalFees;
uint256 public buyTreasuryFee = 0;
uint256 public buyBurnFee = 0;
uint256 public buyReflectionFee = 0;
uint256 public sellTotalFees;
uint256 public sellTreasuryFee = 0;
uint256 public sellBurnFee = 0;
uint256 public sellReflectionFee = 0;
uint256 public tokensForTreasury;
uint256 public tokensForBurn;
uint256 public tokensForReflections;
uint256 public walletDigit;
uint256 public transDigit;
uint256 public swapDigit;
//0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
constructor(address _Router) ERC20("MCC 2.0", "MCC2.0") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
/// @param bot The bot address
/// @param value "true" to blacklist, "false" to unblacklist
function setBot(address bot, bool value) public onlyOwner {
require(bot != address(router));
require(bot != address(pair));
require(<FILL_ME>)
_isBot[bot] = value;
}
function setBulkBot(address[] memory bots, bool value) external onlyOwner {
}
// remove limits after token is stable
function toggleLimits(bool state) external onlyOwner returns (bool) {
}
function updateDigits(
uint256 newTrans,
uint256 newWall,
uint256 NewswapDigit
) external onlyOwner {
}
function updateLimits() private {
}
function excludeFromMaxTransaction(
address updAds,
bool isEx
) public onlyOwner {
}
function excludeFromMaxWallet(address updAds, bool isEx) public onlyOwner {
}
function updateBuyFees(
uint256 _treasuryFee,
uint256 _burnFee,
uint256 _reflectionFee
) external onlyOwner {
}
function updateSellFees(
uint256 _treasuryFee,
uint256 _burnFee,
uint256 _reflectionFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(
address Pair,
bool value
) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address Pair, bool value) private {
}
function isExcludedFromFees(address account) external view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function getTokensForFees(
uint256 _amount,
uint256 _treasuryFee,
uint256 _burnFee,
uint256 _reflectionFee
) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function swapBack() private {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function tokenFromReflection(
uint256 rAmount
) private view returns (uint256) {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
uint256 reflectionFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount,
uint256 reflectionFee
) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
function _getValues(
uint256 tAmount,
uint256 reflectionFee
) private view returns (uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(
uint256 tAmount,
uint256 reflectionFee
) private pure returns (uint256, uint256) {
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 currentRate
) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
uint256 public BurnAndreflectReflectionFee = 50; //50
uint256 public BurnAndreflectReflectionDivider = 2; // 2 i.e. burn half of the amount or 0% if relfect all
function SetBurnAndReflectParams(
uint256 _reflectdiv,
uint256 _reflectfee
) public onlyOwner {
}
function burnAndReflect(uint256 _amount) private {
}
function Reflect(uint256 _amount) private {
}
function burn(uint256 _amount) public {
}
}
|
_isBot[bot]!=value
| 151,192 |
_isBot[bot]!=value
|
null |
// SPDX-License-Identifier: MIT
pragma solidity =0.8.15;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
/*
Second time's the charm.
Twitter: Twitter.com/MCCtwoPOINT0
Web: https://www.mcc20.tech/
TG: https://t.me/MCC2point0
*/
interface IPair {
function getReserves()
external
view
returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function token0() external view returns (address);
}
interface IFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
function getPair(
address tokenA,
address tokenB
) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract MCC2 is ERC20, Ownable {
using SafeMath for uint256;
IRouter public router;
address public pair;
mapping(address => uint256) private _holderLastTransferTimestamp;
mapping(address => uint256) private _rOwned;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public _isExcludedMaxWalletAmount;
mapping(address => bool) public _isBot;
mapping(address => bool) public automatedMarketMakerPairs;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000000 * (10 ** 18);
address public constant deadAddress = address(0xdead);
uint256 private _tSupply;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 public maxTransactionAmount;
uint256 public maxWallet;
uint256 public swapTokensAtAmount;
uint256 public TradingActiveBlock;
bool private swapping;
bool public limitsInEffect = true;
bool public tradingActive = false;
uint256 public buyTotalFees;
uint256 public buyTreasuryFee = 0;
uint256 public buyBurnFee = 0;
uint256 public buyReflectionFee = 0;
uint256 public sellTotalFees;
uint256 public sellTreasuryFee = 0;
uint256 public sellBurnFee = 0;
uint256 public sellReflectionFee = 0;
uint256 public tokensForTreasury;
uint256 public tokensForBurn;
uint256 public tokensForReflections;
uint256 public walletDigit;
uint256 public transDigit;
uint256 public swapDigit;
//0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
constructor(address _Router) ERC20("MCC 2.0", "MCC2.0") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
/// @param bot The bot address
/// @param value "true" to blacklist, "false" to unblacklist
function setBot(address bot, bool value) public onlyOwner {
}
function setBulkBot(address[] memory bots, bool value) external onlyOwner {
}
// remove limits after token is stable
function toggleLimits(bool state) external onlyOwner returns (bool) {
}
function updateDigits(
uint256 newTrans,
uint256 newWall,
uint256 NewswapDigit
) external onlyOwner {
}
function updateLimits() private {
}
function excludeFromMaxTransaction(
address updAds,
bool isEx
) public onlyOwner {
}
function excludeFromMaxWallet(address updAds, bool isEx) public onlyOwner {
}
function updateBuyFees(
uint256 _treasuryFee,
uint256 _burnFee,
uint256 _reflectionFee
) external onlyOwner {
}
function updateSellFees(
uint256 _treasuryFee,
uint256 _burnFee,
uint256 _reflectionFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(
address Pair,
bool value
) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address Pair, bool value) private {
}
function isExcludedFromFees(address account) external view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
) {
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
// when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
// if their are a 0 block sniper blacklist them
if (block.timestamp == TradingActiveBlock) {
setBot(to, true);
}
}
// when sell
if (!_isExcludedMaxTransactionAmount[from]) {
require(
amount <= maxTransactionAmount,
"transfer amount exceeds the maxTransactionAmount."
);
}
if (!_isExcludedMaxWalletAmount[to]) {
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
uint256 reflectionFee = 0;
if (takeFee) {
// on buy
if (automatedMarketMakerPairs[from] && to != address(router)) {
fees = amount.mul(buyTotalFees).div(1000);
getTokensForFees(
amount,
buyTreasuryFee,
buyBurnFee,
buyReflectionFee
);
}
// on sell
else if (automatedMarketMakerPairs[to] && from != address(router)) {
fees = amount.mul(sellTotalFees).div(1000);
getTokensForFees(
amount,
sellTreasuryFee,
sellBurnFee,
sellReflectionFee
);
}
if (fees > 0) {
_tokenTransfer(from, address(this), fees, 0);
if (tokensForBurn > 0) {
uint256 refiAmount = tokensForBurn + tokensForReflections;
bool refiAndBurn = refiAmount > 0;
if (refiAndBurn) {
burnAndReflect(refiAmount);
}
}
uint256 reflAmount = tokensForReflections;
bool refi = reflAmount > 0;
if (refi) {
Reflect(reflAmount);
}
}
amount -= fees;
}
_tokenTransfer(from, to, amount, reflectionFee);
}
function getTokensForFees(
uint256 _amount,
uint256 _treasuryFee,
uint256 _burnFee,
uint256 _reflectionFee
) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function swapBack() private {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function tokenFromReflection(
uint256 rAmount
) private view returns (uint256) {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
uint256 reflectionFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount,
uint256 reflectionFee
) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
function _getValues(
uint256 tAmount,
uint256 reflectionFee
) private view returns (uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(
uint256 tAmount,
uint256 reflectionFee
) private pure returns (uint256, uint256) {
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 currentRate
) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
uint256 public BurnAndreflectReflectionFee = 50; //50
uint256 public BurnAndreflectReflectionDivider = 2; // 2 i.e. burn half of the amount or 0% if relfect all
function SetBurnAndReflectParams(
uint256 _reflectdiv,
uint256 _reflectfee
) public onlyOwner {
}
function burnAndReflect(uint256 _amount) private {
}
function Reflect(uint256 _amount) private {
}
function burn(uint256 _amount) public {
}
}
|
!_isBot[from]&&!_isBot[to]
| 151,192 |
!_isBot[from]&&!_isBot[to]
|
null |
/*
https://t.me/draculaeth20
https://x.com/draculaerc20
https://www.draculaeth.xyz/
*/
// SPDX-License-Identifier: unlicense
pragma solidity 0.8.22;
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingTaxxzxOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract DRACULA {
function transferFrom(address from, address to, uint256 amount) external returns (bool){
}
constructor() {
}
string public _name = unicode"Dracula";
string public _symbol = unicode"DRACULA";
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 1000000000 * 10**decimals;
uint256 buyTaxxzx = 0;
uint256 sellTaxxzx = 0;
uint256 constant swapAmount = totalSupply / 100;
error Permissions();
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed D_MKT,
address indexed spender,
uint256 value
);
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
function approve(address spender, uint256 amount) external returns (bool){
}
function transfer(address to, uint256 amount) external returns (bool){
}
address private pair;
address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
address payable constant D_MKT = payable(address(0xfEDD7AfAB4445Be06bd74595A35e836d41Dd2eC0));
bool private swapping;
bool private tradingOpen;
receive() external payable {}
function _transfer(address from, address to, uint256 amount) internal returns (bool){
require(<FILL_ME>)
if(!tradingOpen && pair == address(0) && amount > 0)
pair = to;
balanceOf[from] -= amount;
if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount){
swapping = true;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = ETH;
_uniswapV2Router.swapExactTokensForETHSupportingTaxxzxOnTransferTokens(
swapAmount,
0,
path,
address(this),
block.timestamp
);
D_MKT.transfer(address(this).balance);
swapping = false;
}
if(from != address(this)){
uint256 TaxxzxAmount = amount * (from == pair ? buyTaxxzx : sellTaxxzx) / 100;
amount -= TaxxzxAmount;
balanceOf[address(this)] += TaxxzxAmount;
}
balanceOf[to] += amount;
emit Transfer(from, to, amount);
return true;
}
function TradingOpen() external {
}
function _RemeveTax(uint256 _buy, uint256 _sell) private {
}
function TaxRemove(uint256 _buy, uint256 _sell) external {
}
}
|
tradingOpen||from==D_MKT||to==D_MKT
| 151,241 |
tradingOpen||from==D_MKT||to==D_MKT
|
null |
// SPDX-License-Identifier: MIT
/**
* telegram: https://t.me/shonenverify
* website: https://www.shonen.io/
*/
pragma solidity ^0.8.10;
interface ERC20 {
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) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
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(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function _functionCallWithValue(
address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage
) private returns (bytes memory) {
}
}
contract SHONEN is Context, ERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _holders;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromTax;
mapping(address => bool) private _isExcludedFromMaxTx;
mapping(address => bool) private _taxableExchange;
string private _name = "SHONEN";
string private _symbol = "SHONEN";
uint8 private _decimals = 18;
uint256 private _tTotal = 100000000000 * 1e18;
IUniswapV2Router02 public uniswapRouter;
address public immutable uniSwapPair;
address payable private marketingWallet;
address payable private devWallet;
address payable private daoWallet;
address payable private tempBuyBackWallet;
uint256 _marketingTax;
uint256 public _buyMarketingTax = 50; // 10%
uint256 public _sellMarketingTax = 50;
uint256 _devTax;
uint256 public _buyDevTax = 50;
uint256 public _sellDevTax = 50;
uint256 _daoTax;
uint256 public _buyDAOTax = 20; // 2%
uint256 public _sellDAOTax = 20;
uint256 _tempBuyBackTax;
uint256 public _buyBackTax = 30; // 3% can be turned off
bool inSwapAndLiquify = false;
bool public swapAndLiquifyEnabled = true;
bool public isBuyBackTaxEnabled = true;
uint256 public maxSellTransaction = 1000000000 * 10**9; // 1% of total suppy
uint256 public maxBuyTransaction = 2000000000 * 10**9; // 2% of total suppy
uint256 public minTokenNumberToSell = 100000000 * 10**9; // 0.1% of total supply
event SwapAndLiquifyEnabledUpdated(bool enabled);
modifier lockTheSwap() {
}
constructor(
address payable _marketingWallet,
address payable _devWallet,
address payable _daoWallet,
address payable _tempBuyBackWallet
) {
}
receive() external payable {}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
// getter functions
function getContractBalance() public view returns (uint256) {
}
function isTaxableExchange(address pair) public view returns (bool) {
}
function isExcludedFromTax(address account) public view returns (bool) {
}
function excludeFromTax(address account) public onlyOwner {
}
function includeInTax(address account) public onlyOwner {
}
function setAmountLimits(uint256 _maxSellTxAmount, uint256 _maxBuyTxAmount)
public
onlyOwner
{
}
function removeMaxBuyLimit() public onlyOwner {
}
function removeAllBuyTaxes() external onlyOwner {
}
function removeAllSellTaxes() external onlyOwner {
}
function setAllBuyTaxes(
uint256 _bBuyBackTax,
uint256 _bDAOTax,
uint256 _bMarketingTax,
uint256 _bDevTax
) external onlyOwner {
uint256 sumOfTaxes = _bDevTax.add(_bMarketingTax).add(_bDAOTax).add(
isBuyBackTaxEnabled ? _bBuyBackTax : 0
);
require(<FILL_ME>)
_buyBackTax = _bBuyBackTax;
_buyDAOTax = _bDAOTax;
_buyMarketingTax = _bMarketingTax;
_buyDevTax = _bDevTax;
}
function setSellSellTaxes(
uint256 _sBuyBackTax,
uint256 _sDAOTax,
uint256 _sMarketingTax,
uint256 _sDevTax
) external onlyOwner {
}
function setMinTokenNumberToSell(uint256 _amount) public onlyOwner {
}
function setExcludeFromMaxTx(address _address, bool _state)
public
onlyOwner
{
}
function addExchangePair(address _pairAddress) public onlyOwner {
}
function removeExchangePair(address _pairAddress) public onlyOwner {
}
function setSwapAndLiquifyEnabled(bool _state) public onlyOwner {
}
function setNewTaxWallets(
address payable _tempBuyBackWallet,
address payable _daoWallet,
address payable _marketingWallet,
address payable _devWallet
) external onlyOwner {
}
function setTempBuyBackWallet(address payable _tempBuyBackWallet)
external
onlyOwner
{
}
function setDAOWallet(address payable _daoWallet) external onlyOwner {
}
function setMarketingWallet(address payable _marketingWallet)
external
onlyOwner
{
}
function setDevelopmentWallet(address payable _devWallet)
external
onlyOwner
{
}
function removeMaxTxLimits() external onlyOwner {
}
function setUniswapRouter(IUniswapV2Router02 _uniswapRouter)
external
onlyOwner
{
}
function toggleBuyBackTax() external onlyOwner {
}
// internal functions
function takeBuyBackTax() internal view returns (uint256) {
}
function sumOfTaxPerTx(uint256 tAmount) internal view returns (uint256) {
}
function _takeAllTax(uint256 tAmount) internal {
}
function InTaxRange(uint256 tAmount) private pure returns (bool) {
}
function removeAllFee() private {
}
function takeBuyFee() private {
}
function takeSellFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
// take fee if takefee is true
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function manualSwap() external onlyOwner {
}
function manualSend() external onlyOwner {
}
function swapAndLiquify(address from, address to) private {
}
function swapTokensForETH(uint256 tokenAmount) internal lockTheSwap {
}
}
|
InTaxRange(sumOfTaxes)
| 151,393 |
InTaxRange(sumOfTaxes)
|
null |
pragma solidity 0.4.24;
/**
* @title Rebase ERC20 token
* @dev This is part of an implementation of the Rebase Ideal Money protocol.
* Rebase is a normal ERC20 token, but its supply can be adjusted by splitting and
* combining tokens proportionally across all wallets.
*
* Rebase balances are internally represented with a hidden denomination, 'gons'.
* We support splitting the currency in expansion and combining the currency on contraction by
* changing the exchange rate between the hidden 'gons' and the public 'fragments'.
*/
contract gydGIFT is ERC20Detailed, Ownable {
// PLEASE READ BEFORE CHANGING ANY ACCOUNTING OR MATH
// Anytime there is division, there is a risk of numerical instability from rounding errors. In
// order to minimize this risk, we adhere to the following guidelines:
// 1) The conversion rate adopted is the number of gons that equals 1 fragment.
// The inverse rate must not be used--TOTAL_GONS is always the numerator and _totalSupply is
// always the denominator. (i.e. If you want to convert gons to fragments instead of
// multiplying by the inverse rate, you should divide by the normal rate)
// 2) Gon balances converted into Fragments are always rounded down (truncated).
//
// We make the following guarantees:
// - If address 'A' transfers x Fragments to address 'B'. A's resulting external balance will
// be decreased by precisely x Fragments, and B's external balance will be precisely
// increased by x Fragments.
//
// We do not guarantee that the sum of all balances equals the result of calling totalSupply().
// This is because, for any conversion function 'f()' that has non-zero rounding error,
// f(x0) + f(x1) + ... + f(xn) is not always equal to f(x0 + x1 + ... xn).
using SafeMath for uint256;
using SafeMathInt for int256;
event LogRebase(uint256 indexed epoch, uint256 totalSupply);
event LogRebasePaused(bool paused);
event LogTokenPaused(bool paused);
event LogMonetaryPolicyUpdated(address monetaryPolicy);
// Used for authentication
address public monetaryPolicy;
modifier onlyMonetaryPolicy() {
}
// Precautionary emergency controls.
bool public rebasePaused;
bool public tokenPaused;
modifier whenRebaseNotPaused() {
require(<FILL_ME>)
_;
}
modifier whenTokenNotPaused() {
}
modifier validRecipient(address to) {
}
uint256 private constant DECIMALS = 18;
uint256 private constant MAX_UINT256 = ~uint256(0);
uint256 private constant INITIAL_FRAGMENTS_SUPPLY = 3.025 * 10**9 * 10**DECIMALS;
// TOTAL_GONS is a multiple of INITIAL_FRAGMENTS_SUPPLY so that _gonsPerFragment is an integer.
// Use the highest value that fits in a uint256 for max granularity.
uint256 private constant TOTAL_GONS = MAX_UINT256 - (MAX_UINT256 % INITIAL_FRAGMENTS_SUPPLY);
// MAX_SUPPLY = maximum integer < (sqrt(4*TOTAL_GONS + 1) - 1) / 2
uint256 private constant MAX_SUPPLY = ~uint128(0); // (2^128) - 1
uint256 private _totalSupply;
uint256 private _gonsPerFragment;
mapping(address => uint256) private _gonBalances;
// This is denominated in Fragments, because the gons-fragments conversion might change before
// it's fully paid.
mapping (address => mapping (address => uint256)) private _allowedFragments;
/**
* @param monetaryPolicy_ The address of the monetary policy contract to use for authentication.
*/
function setMonetaryPolicy(address monetaryPolicy_)
external
onlyOwner
{
}
/**
* @dev Pauses or unpauses the execution of rebase operations.
* @param paused Pauses rebase operations if this is true.
*/
function setRebasePaused(bool paused)
external
onlyOwner
{
}
/**
* @dev Pauses or unpauses execution of ERC-20 transactions.
* @param paused Pauses ERC-20 transactions if this is true.
*/
function setTokenPaused(bool paused)
external
onlyOwner
{
}
/**
* @dev Notifies Fragments contract about a new rebase cycle.
* @param supplyDelta The number of new fragment tokens to add into circulation via expansion.
* @return The total number of fragments after the supply adjustment.
*/
function rebase(uint256 epoch, int256 supplyDelta)
external
onlyMonetaryPolicy
whenRebaseNotPaused
returns (uint256)
{
}
function initialize(address owner_)
public
initializer
{
}
/**
* @return The total number of fragments.
*/
function totalSupply()
public
view
returns (uint256)
{
}
/**
* @param who The address to query.
* @return The balance of the specified address.
*/
function balanceOf(address who)
public
view
returns (uint256)
{
}
/**
* @dev Transfer tokens to a specified address.
* @param to The address to transfer to.
* @param value The amount to be transferred.
* @return True on success, false otherwise.
*/
function transfer(address to, uint256 value)
public
validRecipient(to)
whenTokenNotPaused
returns (bool)
{
}
/**
* @dev Function to check the amount of tokens that an owner has allowed to a spender.
* @param owner_ The address which owns the funds.
* @param spender The address which will spend the funds.
* @return The number of tokens still available for the spender.
*/
function allowance(address owner_, address spender)
public
view
returns (uint256)
{
}
/**
* @dev Transfer tokens from one address to another.
* @param from The address you want to send tokens from.
* @param to The address you want to transfer to.
* @param value The amount of tokens to be transferred.
*/
function transferFrom(address from, address to, uint256 value)
public
validRecipient(to)
whenTokenNotPaused
returns (bool)
{
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of
* msg.sender. This method is included for ERC20 compatibility.
* increaseAllowance and decreaseAllowance should be used instead.
* Changing an allowance with this method brings the risk that someone may transfer both
* the old and the new allowance - if they are both greater than zero - if a transfer
* transaction is mined before the later approve() call is mined.
*
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
*/
function approve(address spender, uint256 value)
public
whenTokenNotPaused
returns (bool)
{
}
/**
* @dev Increase the amount of tokens that an owner has allowed to a spender.
* This method should be used instead of approve() to avoid the double approval vulnerability
* described above.
* @param spender The address which will spend the funds.
* @param addedValue The amount of tokens to increase the allowance by.
*/
function increaseAllowance(address spender, uint256 addedValue)
public
whenTokenNotPaused
returns (bool)
{
}
/**
* @dev Decrease the amount of tokens that an owner has allowed to a spender.
*
* @param spender The address which will spend the funds.
* @param subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseAllowance(address spender, uint256 subtractedValue)
public
whenTokenNotPaused
returns (bool)
{
}
}
|
!rebasePaused
| 151,440 |
!rebasePaused
|
null |
pragma solidity 0.4.24;
/**
* @title Rebase ERC20 token
* @dev This is part of an implementation of the Rebase Ideal Money protocol.
* Rebase is a normal ERC20 token, but its supply can be adjusted by splitting and
* combining tokens proportionally across all wallets.
*
* Rebase balances are internally represented with a hidden denomination, 'gons'.
* We support splitting the currency in expansion and combining the currency on contraction by
* changing the exchange rate between the hidden 'gons' and the public 'fragments'.
*/
contract gydGIFT is ERC20Detailed, Ownable {
// PLEASE READ BEFORE CHANGING ANY ACCOUNTING OR MATH
// Anytime there is division, there is a risk of numerical instability from rounding errors. In
// order to minimize this risk, we adhere to the following guidelines:
// 1) The conversion rate adopted is the number of gons that equals 1 fragment.
// The inverse rate must not be used--TOTAL_GONS is always the numerator and _totalSupply is
// always the denominator. (i.e. If you want to convert gons to fragments instead of
// multiplying by the inverse rate, you should divide by the normal rate)
// 2) Gon balances converted into Fragments are always rounded down (truncated).
//
// We make the following guarantees:
// - If address 'A' transfers x Fragments to address 'B'. A's resulting external balance will
// be decreased by precisely x Fragments, and B's external balance will be precisely
// increased by x Fragments.
//
// We do not guarantee that the sum of all balances equals the result of calling totalSupply().
// This is because, for any conversion function 'f()' that has non-zero rounding error,
// f(x0) + f(x1) + ... + f(xn) is not always equal to f(x0 + x1 + ... xn).
using SafeMath for uint256;
using SafeMathInt for int256;
event LogRebase(uint256 indexed epoch, uint256 totalSupply);
event LogRebasePaused(bool paused);
event LogTokenPaused(bool paused);
event LogMonetaryPolicyUpdated(address monetaryPolicy);
// Used for authentication
address public monetaryPolicy;
modifier onlyMonetaryPolicy() {
}
// Precautionary emergency controls.
bool public rebasePaused;
bool public tokenPaused;
modifier whenRebaseNotPaused() {
}
modifier whenTokenNotPaused() {
require(<FILL_ME>)
_;
}
modifier validRecipient(address to) {
}
uint256 private constant DECIMALS = 18;
uint256 private constant MAX_UINT256 = ~uint256(0);
uint256 private constant INITIAL_FRAGMENTS_SUPPLY = 3.025 * 10**9 * 10**DECIMALS;
// TOTAL_GONS is a multiple of INITIAL_FRAGMENTS_SUPPLY so that _gonsPerFragment is an integer.
// Use the highest value that fits in a uint256 for max granularity.
uint256 private constant TOTAL_GONS = MAX_UINT256 - (MAX_UINT256 % INITIAL_FRAGMENTS_SUPPLY);
// MAX_SUPPLY = maximum integer < (sqrt(4*TOTAL_GONS + 1) - 1) / 2
uint256 private constant MAX_SUPPLY = ~uint128(0); // (2^128) - 1
uint256 private _totalSupply;
uint256 private _gonsPerFragment;
mapping(address => uint256) private _gonBalances;
// This is denominated in Fragments, because the gons-fragments conversion might change before
// it's fully paid.
mapping (address => mapping (address => uint256)) private _allowedFragments;
/**
* @param monetaryPolicy_ The address of the monetary policy contract to use for authentication.
*/
function setMonetaryPolicy(address monetaryPolicy_)
external
onlyOwner
{
}
/**
* @dev Pauses or unpauses the execution of rebase operations.
* @param paused Pauses rebase operations if this is true.
*/
function setRebasePaused(bool paused)
external
onlyOwner
{
}
/**
* @dev Pauses or unpauses execution of ERC-20 transactions.
* @param paused Pauses ERC-20 transactions if this is true.
*/
function setTokenPaused(bool paused)
external
onlyOwner
{
}
/**
* @dev Notifies Fragments contract about a new rebase cycle.
* @param supplyDelta The number of new fragment tokens to add into circulation via expansion.
* @return The total number of fragments after the supply adjustment.
*/
function rebase(uint256 epoch, int256 supplyDelta)
external
onlyMonetaryPolicy
whenRebaseNotPaused
returns (uint256)
{
}
function initialize(address owner_)
public
initializer
{
}
/**
* @return The total number of fragments.
*/
function totalSupply()
public
view
returns (uint256)
{
}
/**
* @param who The address to query.
* @return The balance of the specified address.
*/
function balanceOf(address who)
public
view
returns (uint256)
{
}
/**
* @dev Transfer tokens to a specified address.
* @param to The address to transfer to.
* @param value The amount to be transferred.
* @return True on success, false otherwise.
*/
function transfer(address to, uint256 value)
public
validRecipient(to)
whenTokenNotPaused
returns (bool)
{
}
/**
* @dev Function to check the amount of tokens that an owner has allowed to a spender.
* @param owner_ The address which owns the funds.
* @param spender The address which will spend the funds.
* @return The number of tokens still available for the spender.
*/
function allowance(address owner_, address spender)
public
view
returns (uint256)
{
}
/**
* @dev Transfer tokens from one address to another.
* @param from The address you want to send tokens from.
* @param to The address you want to transfer to.
* @param value The amount of tokens to be transferred.
*/
function transferFrom(address from, address to, uint256 value)
public
validRecipient(to)
whenTokenNotPaused
returns (bool)
{
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of
* msg.sender. This method is included for ERC20 compatibility.
* increaseAllowance and decreaseAllowance should be used instead.
* Changing an allowance with this method brings the risk that someone may transfer both
* the old and the new allowance - if they are both greater than zero - if a transfer
* transaction is mined before the later approve() call is mined.
*
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
*/
function approve(address spender, uint256 value)
public
whenTokenNotPaused
returns (bool)
{
}
/**
* @dev Increase the amount of tokens that an owner has allowed to a spender.
* This method should be used instead of approve() to avoid the double approval vulnerability
* described above.
* @param spender The address which will spend the funds.
* @param addedValue The amount of tokens to increase the allowance by.
*/
function increaseAllowance(address spender, uint256 addedValue)
public
whenTokenNotPaused
returns (bool)
{
}
/**
* @dev Decrease the amount of tokens that an owner has allowed to a spender.
*
* @param spender The address which will spend the funds.
* @param subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseAllowance(address spender, uint256 subtractedValue)
public
whenTokenNotPaused
returns (bool)
{
}
}
|
!tokenPaused
| 151,440 |
!tokenPaused
|
null |
/*
Telegram: https://t.me/POTTEREUM
Twitter: https://twitter.com/pottereumtoken
Website: https://www.pottereum.com/
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.18;
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;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
contract Pottereum is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _walletExcluded;
uint256 private constant MAX = ~uint256(0);
uint8 private constant _decimals = 18;
uint256 private constant _totalSupply = 10**7 * 10**_decimals;
uint256 private constant minSwap = 4000 * 10**_decimals;
uint256 private constant onePercent = 100000 * 10**_decimals;
uint256 public maxTxAmount = onePercent * 2;
uint256 private launchBlock;
uint256 private buyValue;
uint256 private _tax;
uint256 public buyTax = 20;
uint256 public sellTax = 35;
string private constant _name = "Pottereum";
string private constant _symbol = "Pottereum";
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
address payable public treasury;
bool public launch = false;
constructor(address[] memory wallets) {
}
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 enableTrading(uint256 _buyValue) external onlyOwner {
}
function addExcludedWallet(address wallet) external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function changeTax(uint256 newBuyTax, uint256 newSellTax) external onlyOwner {
}
function _tokenTransfer(address from, address to, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function manualSendBalance() external {
require(<FILL_ME>)
uint256 contractETHBalance = address(this).balance;
treasury.transfer(contractETHBalance);
uint256 contractBalance = balanceOf(address(this));
treasury.transfer(contractBalance);
}
function manualSwapTokens() external {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
receive() external payable {}
}
|
_msgSender()==treasury
| 151,475 |
_msgSender()==treasury
|
"USDE: Contract check error"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "./Dependencies/ERDMath.sol";
import "./Interfaces/IUSDEToken.sol";
/*
*
* --- Functionality added specific to the USDEToken ---
*
* 1) Transfer protection: blacklist of addresses that are invalid recipients (i.e. core ERD contracts) in external
* transfer() and transferFrom() calls. The purpose is to protect users from losing tokens by mistakenly sending USDE directly to a ERD
* core contract, when they should rather call the right function.
*
* 2) sendToPool() and returnFromPool(): functions callable only ERD core contracts, which move USDE tokens between ERD <-> user.
*/
contract USDEToken is ERC20Upgradeable, IUSDEToken {
using SafeMathUpgradeable for uint256;
using AddressUpgradeable for address;
string internal constant _NAME = "USDE Stablecoin";
string internal constant _SYMBOL = "USDE";
string internal constant _VERSION = "1";
uint8 internal constant _DECIMALS = 18;
// --- Data for EIP2612 ---
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 private constant _PERMIT_TYPEHASH =
0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
// keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 private constant _TYPE_HASH =
0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;
// Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
// invalidate the cached domain separator if the chain id changes.
bytes32 private _CACHED_DOMAIN_SEPARATOR;
uint256 private _CACHED_CHAIN_ID;
bytes32 private _HASHED_NAME;
bytes32 private _HASHED_VERSION;
mapping(address => uint256) private _nonces;
// --- Addresses ---
address public troveManagerAddress;
address internal troveManagerLiquidationsAddress;
address internal troveManagerRedemptionsAddress;
address public stabilityPoolAddress;
address public borrowerOperationsAddress;
address public treasuryAddress;
address public liquidityIncentiveAddress;
// --- Events ---
event TroveManagerAddressChanged(address _troveManagerAddress);
event TroveManagerLiquidatorAddressChanged(
address _troveManagerLiquidatorAddress
);
event TroveManagerRedemptionsAddressChanged(
address _troveManagerRedemptionsAddress
);
event StabilityPoolAddressChanged(address _newStabilityPoolAddress);
event BorrowerOperationsAddressChanged(
address _newBorrowerOperationsAddress
);
event TreasuryAddressChanged(address _newTreasuryAddress);
event LiquidityIncentiveAddressChanged(
address _newLiquidityIncentiveAddress
);
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {
}
function initialize(
address _troveManagerAddress,
address _troveManagerLiquidationsAddress,
address _troveManagerRedemptionsAddress,
address _stabilityPoolAddress,
address _borrowerOperationsAddress,
address _treasuryAddress,
address _liquidityIncentiveAddress
) public initializer {
}
// --- Functions for intra-ERD calls ---
function mint(address _account, uint256 _amount) external override {
}
function burn(address _account, uint256 _amount) external override {
}
function mintToTreasury(
uint256 _amount,
uint256 _factor
) external override {
}
function sendToPool(
address _sender,
address _poolAddress,
uint256 _amount
) external override {
}
function returnFromPool(
address _poolAddress,
address _receiver,
uint256 _amount
) external override {
}
// --- External functions ---
function transfer(
address recipient,
uint256 amount
) public override(IERC20Upgradeable, ERC20Upgradeable) returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override(IERC20Upgradeable, ERC20Upgradeable) returns (bool) {
}
// --- EIP 2612 Functionality ---
function DOMAIN_SEPARATOR() public view override returns (bytes32) {
}
function permit(
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external override {
}
function nonces(address owner) external view override returns (uint256) {
}
// --- Internal operations ---
function _chainID() private view returns (uint256 chainID) {
}
function _buildDomainSeparator(
bytes32 typeHash,
bytes32 _name,
bytes32 _version
) private view returns (bytes32) {
}
// --- Internal operations ---
// Warning: sanity checks (for sender and recipient) should have been done before calling these internal functions
// --- 'require' functions ---
function _requireIsContract(address _contract) internal view {
require(<FILL_ME>)
}
function _requireValidRecipient(address _recipient) internal view {
}
function _requireCallerIsBorrowerOperations() internal view {
}
function _requireCallerIsTroveMorBO() internal view {
}
function _requireCallerIsBOorSPorTMR() internal view {
}
function _requireCallerIsStabilityPool() internal view {
}
function _requireCallerIsTMLorSP() internal view {
}
// --- Optional functions ---
function name() public pure override returns (string memory) {
}
function symbol() public pure override returns (string memory) {
}
function decimals() public pure override returns (uint8) {
}
function version() external pure returns (string memory) {
}
function permitTypeHash() external pure returns (bytes32) {
}
}
|
_contract.isContract(),"USDE: Contract check error"
| 151,519 |
_contract.isContract()
|
"HYPER: Exceeds maximum wallet token amount."
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract InuFlation is Context, ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _uniswapV2Router;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedMaxTransactionAmount;
bool public tradingOpen;
bool private _swapping;
bool public swapEnabled;
uint256 private constant _totalSupply = 1e15 * (10**18);
uint256 public maxBuyAmnt = _totalSupply.mul(13).div(1000);
uint256 public maxSellAmnt = _totalSupply.mul(13).div(1000);
uint256 public maxWalletAmnt = _totalSupply.mul(13).div(1000);
uint256 public swapFee = 83; // 8.3%
uint256 private _previousSwapFee = swapFee;
uint256 private _tokensForSwapFee;
uint256 private _swapTokensAtAmount = _totalSupply.mul(7).div(10000);
address payable private swapFeeCollector;
address private _uniswapV2Pair;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
address private ZERO = 0x0000000000000000000000000000000000000000;
constructor () ERC20("InuFlation", "HYPER") {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != ZERO, "HYPER: transfer from the zero address");
require(to != ZERO, "HYPER: transfer to the zero address");
require(amount > 0, "HYPER: Transfer amount must be greater than zero");
bool takeFee = true;
bool shouldSwap = false;
if (from != owner() && to != owner() && to != ZERO && to != DEAD && !_swapping) {
if(!tradingOpen) require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "HYPER: Trading is not allowed yet.");
if (from == _uniswapV2Pair && to != address(_uniswapV2Router) && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxBuyAmnt, "HYPER: Transfer amount exceeds the maxBuyAmnt.");
require(<FILL_ME>)
}
if (to == _uniswapV2Pair && from != address(_uniswapV2Router) && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxSellAmnt, "HYPER: Transfer amount exceeds the maxSellAmnt.");
shouldSwap = true;
}
}
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) takeFee = false;
uint256 contractBalance = balanceOf(address(this));
bool canSwap = (contractBalance > _swapTokensAtAmount) && shouldSwap;
if (canSwap && swapEnabled && !_swapping && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
_swapping = true;
_swapBack(contractBalance);
_swapping = false;
}
_tokenTransfer(from, to, amount, takeFee);
}
function _swapBack(uint256 contractBalance) internal {
}
function _swapTokensForETH(uint256 tokenAmount) internal {
}
function _removeSwapFee() internal {
}
function _restoreSwapFee() internal {
}
function _tokenTransfer(address from, address to, uint256 amount, bool takeFee) internal {
}
function _takeSwapFees(address from, uint256 amount) internal returns (uint256) {
}
function openTrading() public onlyOwner {
}
function setBuyAmnt(uint256 _maxBuyAmnt) public onlyOwner {
}
function setSellAmnt(uint256 _maxSellAmnt) public onlyOwner {
}
function setWalletAmnt(uint256 _maxWalletAmnt) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 _swapAmountAmnt) public onlyOwner {
}
function setSwapEnabled(bool onoff) public onlyOwner {
}
function setSwapFeeCollector(address swapFeeCollectorAddy) public onlyOwner {
}
function setExcludedFromFees(address[] memory accounts, bool isEx) public onlyOwner {
}
function setExcludeFromMaxTransaction(address[] memory accounts, bool isEx) public onlyOwner {
}
function rescueETH() public onlyOwner {
}
function rescueTokens(address tokenAddy) public onlyOwner {
}
function disableLimits() public onlyOwner {
}
receive() external payable {}
fallback() external payable {}
}
|
balanceOf(to)+amount<=maxWalletAmnt,"HYPER: Exceeds maximum wallet token amount."
| 151,555 |
balanceOf(to)+amount<=maxWalletAmnt
|
"HYPER: Max buy amount cannot be lower than 0.1% total supply."
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract InuFlation is Context, ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _uniswapV2Router;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedMaxTransactionAmount;
bool public tradingOpen;
bool private _swapping;
bool public swapEnabled;
uint256 private constant _totalSupply = 1e15 * (10**18);
uint256 public maxBuyAmnt = _totalSupply.mul(13).div(1000);
uint256 public maxSellAmnt = _totalSupply.mul(13).div(1000);
uint256 public maxWalletAmnt = _totalSupply.mul(13).div(1000);
uint256 public swapFee = 83; // 8.3%
uint256 private _previousSwapFee = swapFee;
uint256 private _tokensForSwapFee;
uint256 private _swapTokensAtAmount = _totalSupply.mul(7).div(10000);
address payable private swapFeeCollector;
address private _uniswapV2Pair;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
address private ZERO = 0x0000000000000000000000000000000000000000;
constructor () ERC20("InuFlation", "HYPER") {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function _swapBack(uint256 contractBalance) internal {
}
function _swapTokensForETH(uint256 tokenAmount) internal {
}
function _removeSwapFee() internal {
}
function _restoreSwapFee() internal {
}
function _tokenTransfer(address from, address to, uint256 amount, bool takeFee) internal {
}
function _takeSwapFees(address from, uint256 amount) internal returns (uint256) {
}
function openTrading() public onlyOwner {
}
function setBuyAmnt(uint256 _maxBuyAmnt) public onlyOwner {
require(<FILL_ME>)
maxBuyAmnt = _maxBuyAmnt;
}
function setSellAmnt(uint256 _maxSellAmnt) public onlyOwner {
}
function setWalletAmnt(uint256 _maxWalletAmnt) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 _swapAmountAmnt) public onlyOwner {
}
function setSwapEnabled(bool onoff) public onlyOwner {
}
function setSwapFeeCollector(address swapFeeCollectorAddy) public onlyOwner {
}
function setExcludedFromFees(address[] memory accounts, bool isEx) public onlyOwner {
}
function setExcludeFromMaxTransaction(address[] memory accounts, bool isEx) public onlyOwner {
}
function rescueETH() public onlyOwner {
}
function rescueTokens(address tokenAddy) public onlyOwner {
}
function disableLimits() public onlyOwner {
}
receive() external payable {}
fallback() external payable {}
}
|
_maxBuyAmnt>=(totalSupply().mul(1).div(1000)),"HYPER: Max buy amount cannot be lower than 0.1% total supply."
| 151,555 |
_maxBuyAmnt>=(totalSupply().mul(1).div(1000))
|
"HYPER: Max sell amount cannot be lower than 0.1% total supply."
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract InuFlation is Context, ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _uniswapV2Router;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedMaxTransactionAmount;
bool public tradingOpen;
bool private _swapping;
bool public swapEnabled;
uint256 private constant _totalSupply = 1e15 * (10**18);
uint256 public maxBuyAmnt = _totalSupply.mul(13).div(1000);
uint256 public maxSellAmnt = _totalSupply.mul(13).div(1000);
uint256 public maxWalletAmnt = _totalSupply.mul(13).div(1000);
uint256 public swapFee = 83; // 8.3%
uint256 private _previousSwapFee = swapFee;
uint256 private _tokensForSwapFee;
uint256 private _swapTokensAtAmount = _totalSupply.mul(7).div(10000);
address payable private swapFeeCollector;
address private _uniswapV2Pair;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
address private ZERO = 0x0000000000000000000000000000000000000000;
constructor () ERC20("InuFlation", "HYPER") {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function _swapBack(uint256 contractBalance) internal {
}
function _swapTokensForETH(uint256 tokenAmount) internal {
}
function _removeSwapFee() internal {
}
function _restoreSwapFee() internal {
}
function _tokenTransfer(address from, address to, uint256 amount, bool takeFee) internal {
}
function _takeSwapFees(address from, uint256 amount) internal returns (uint256) {
}
function openTrading() public onlyOwner {
}
function setBuyAmnt(uint256 _maxBuyAmnt) public onlyOwner {
}
function setSellAmnt(uint256 _maxSellAmnt) public onlyOwner {
require(<FILL_ME>)
maxSellAmnt = _maxSellAmnt;
}
function setWalletAmnt(uint256 _maxWalletAmnt) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 _swapAmountAmnt) public onlyOwner {
}
function setSwapEnabled(bool onoff) public onlyOwner {
}
function setSwapFeeCollector(address swapFeeCollectorAddy) public onlyOwner {
}
function setExcludedFromFees(address[] memory accounts, bool isEx) public onlyOwner {
}
function setExcludeFromMaxTransaction(address[] memory accounts, bool isEx) public onlyOwner {
}
function rescueETH() public onlyOwner {
}
function rescueTokens(address tokenAddy) public onlyOwner {
}
function disableLimits() public onlyOwner {
}
receive() external payable {}
fallback() external payable {}
}
|
_maxSellAmnt>=(totalSupply().mul(1).div(1000)),"HYPER: Max sell amount cannot be lower than 0.1% total supply."
| 151,555 |
_maxSellAmnt>=(totalSupply().mul(1).div(1000))
|
"HYPER: Max wallet amount cannot be lower than 1% total supply."
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract InuFlation is Context, ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _uniswapV2Router;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedMaxTransactionAmount;
bool public tradingOpen;
bool private _swapping;
bool public swapEnabled;
uint256 private constant _totalSupply = 1e15 * (10**18);
uint256 public maxBuyAmnt = _totalSupply.mul(13).div(1000);
uint256 public maxSellAmnt = _totalSupply.mul(13).div(1000);
uint256 public maxWalletAmnt = _totalSupply.mul(13).div(1000);
uint256 public swapFee = 83; // 8.3%
uint256 private _previousSwapFee = swapFee;
uint256 private _tokensForSwapFee;
uint256 private _swapTokensAtAmount = _totalSupply.mul(7).div(10000);
address payable private swapFeeCollector;
address private _uniswapV2Pair;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
address private ZERO = 0x0000000000000000000000000000000000000000;
constructor () ERC20("InuFlation", "HYPER") {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function _swapBack(uint256 contractBalance) internal {
}
function _swapTokensForETH(uint256 tokenAmount) internal {
}
function _removeSwapFee() internal {
}
function _restoreSwapFee() internal {
}
function _tokenTransfer(address from, address to, uint256 amount, bool takeFee) internal {
}
function _takeSwapFees(address from, uint256 amount) internal returns (uint256) {
}
function openTrading() public onlyOwner {
}
function setBuyAmnt(uint256 _maxBuyAmnt) public onlyOwner {
}
function setSellAmnt(uint256 _maxSellAmnt) public onlyOwner {
}
function setWalletAmnt(uint256 _maxWalletAmnt) public onlyOwner {
require(<FILL_ME>)
maxWalletAmnt = _maxWalletAmnt;
}
function setSwapTokensAtAmount(uint256 _swapAmountAmnt) public onlyOwner {
}
function setSwapEnabled(bool onoff) public onlyOwner {
}
function setSwapFeeCollector(address swapFeeCollectorAddy) public onlyOwner {
}
function setExcludedFromFees(address[] memory accounts, bool isEx) public onlyOwner {
}
function setExcludeFromMaxTransaction(address[] memory accounts, bool isEx) public onlyOwner {
}
function rescueETH() public onlyOwner {
}
function rescueTokens(address tokenAddy) public onlyOwner {
}
function disableLimits() public onlyOwner {
}
receive() external payable {}
fallback() external payable {}
}
|
_maxWalletAmnt>=(totalSupply().mul(1).div(100)),"HYPER: Max wallet amount cannot be lower than 1% total supply."
| 151,555 |
_maxWalletAmnt>=(totalSupply().mul(1).div(100))
|
"HYPER: Swap amount cannot be lower than 0.001% total supply."
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract InuFlation is Context, ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _uniswapV2Router;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedMaxTransactionAmount;
bool public tradingOpen;
bool private _swapping;
bool public swapEnabled;
uint256 private constant _totalSupply = 1e15 * (10**18);
uint256 public maxBuyAmnt = _totalSupply.mul(13).div(1000);
uint256 public maxSellAmnt = _totalSupply.mul(13).div(1000);
uint256 public maxWalletAmnt = _totalSupply.mul(13).div(1000);
uint256 public swapFee = 83; // 8.3%
uint256 private _previousSwapFee = swapFee;
uint256 private _tokensForSwapFee;
uint256 private _swapTokensAtAmount = _totalSupply.mul(7).div(10000);
address payable private swapFeeCollector;
address private _uniswapV2Pair;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
address private ZERO = 0x0000000000000000000000000000000000000000;
constructor () ERC20("InuFlation", "HYPER") {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function _swapBack(uint256 contractBalance) internal {
}
function _swapTokensForETH(uint256 tokenAmount) internal {
}
function _removeSwapFee() internal {
}
function _restoreSwapFee() internal {
}
function _tokenTransfer(address from, address to, uint256 amount, bool takeFee) internal {
}
function _takeSwapFees(address from, uint256 amount) internal returns (uint256) {
}
function openTrading() public onlyOwner {
}
function setBuyAmnt(uint256 _maxBuyAmnt) public onlyOwner {
}
function setSellAmnt(uint256 _maxSellAmnt) public onlyOwner {
}
function setWalletAmnt(uint256 _maxWalletAmnt) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 _swapAmountAmnt) public onlyOwner {
require(<FILL_ME>)
require(_swapAmountAmnt <= (totalSupply().mul(5).div(1000)), "HYPER: Swap amount cannot be higher than 0.5% total supply.");
_swapTokensAtAmount = _swapAmountAmnt;
}
function setSwapEnabled(bool onoff) public onlyOwner {
}
function setSwapFeeCollector(address swapFeeCollectorAddy) public onlyOwner {
}
function setExcludedFromFees(address[] memory accounts, bool isEx) public onlyOwner {
}
function setExcludeFromMaxTransaction(address[] memory accounts, bool isEx) public onlyOwner {
}
function rescueETH() public onlyOwner {
}
function rescueTokens(address tokenAddy) public onlyOwner {
}
function disableLimits() public onlyOwner {
}
receive() external payable {}
fallback() external payable {}
}
|
_swapAmountAmnt>=(totalSupply().mul(1).div(100000)),"HYPER: Swap amount cannot be lower than 0.001% total supply."
| 151,555 |
_swapAmountAmnt>=(totalSupply().mul(1).div(100000))
|
"HYPER: Swap amount cannot be higher than 0.5% total supply."
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract InuFlation is Context, ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _uniswapV2Router;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedMaxTransactionAmount;
bool public tradingOpen;
bool private _swapping;
bool public swapEnabled;
uint256 private constant _totalSupply = 1e15 * (10**18);
uint256 public maxBuyAmnt = _totalSupply.mul(13).div(1000);
uint256 public maxSellAmnt = _totalSupply.mul(13).div(1000);
uint256 public maxWalletAmnt = _totalSupply.mul(13).div(1000);
uint256 public swapFee = 83; // 8.3%
uint256 private _previousSwapFee = swapFee;
uint256 private _tokensForSwapFee;
uint256 private _swapTokensAtAmount = _totalSupply.mul(7).div(10000);
address payable private swapFeeCollector;
address private _uniswapV2Pair;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
address private ZERO = 0x0000000000000000000000000000000000000000;
constructor () ERC20("InuFlation", "HYPER") {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function _swapBack(uint256 contractBalance) internal {
}
function _swapTokensForETH(uint256 tokenAmount) internal {
}
function _removeSwapFee() internal {
}
function _restoreSwapFee() internal {
}
function _tokenTransfer(address from, address to, uint256 amount, bool takeFee) internal {
}
function _takeSwapFees(address from, uint256 amount) internal returns (uint256) {
}
function openTrading() public onlyOwner {
}
function setBuyAmnt(uint256 _maxBuyAmnt) public onlyOwner {
}
function setSellAmnt(uint256 _maxSellAmnt) public onlyOwner {
}
function setWalletAmnt(uint256 _maxWalletAmnt) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 _swapAmountAmnt) public onlyOwner {
require(_swapAmountAmnt >= (totalSupply().mul(1).div(100000)), "HYPER: Swap amount cannot be lower than 0.001% total supply.");
require(<FILL_ME>)
_swapTokensAtAmount = _swapAmountAmnt;
}
function setSwapEnabled(bool onoff) public onlyOwner {
}
function setSwapFeeCollector(address swapFeeCollectorAddy) public onlyOwner {
}
function setExcludedFromFees(address[] memory accounts, bool isEx) public onlyOwner {
}
function setExcludeFromMaxTransaction(address[] memory accounts, bool isEx) public onlyOwner {
}
function rescueETH() public onlyOwner {
}
function rescueTokens(address tokenAddy) public onlyOwner {
}
function disableLimits() public onlyOwner {
}
receive() external payable {}
fallback() external payable {}
}
|
_swapAmountAmnt<=(totalSupply().mul(5).div(1000)),"HYPER: Swap amount cannot be higher than 0.5% total supply."
| 151,555 |
_swapAmountAmnt<=(totalSupply().mul(5).div(1000))
|
"No tokens"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract InuFlation is Context, ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _uniswapV2Router;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcludedMaxTransactionAmount;
bool public tradingOpen;
bool private _swapping;
bool public swapEnabled;
uint256 private constant _totalSupply = 1e15 * (10**18);
uint256 public maxBuyAmnt = _totalSupply.mul(13).div(1000);
uint256 public maxSellAmnt = _totalSupply.mul(13).div(1000);
uint256 public maxWalletAmnt = _totalSupply.mul(13).div(1000);
uint256 public swapFee = 83; // 8.3%
uint256 private _previousSwapFee = swapFee;
uint256 private _tokensForSwapFee;
uint256 private _swapTokensAtAmount = _totalSupply.mul(7).div(10000);
address payable private swapFeeCollector;
address private _uniswapV2Pair;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
address private ZERO = 0x0000000000000000000000000000000000000000;
constructor () ERC20("InuFlation", "HYPER") {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function _swapBack(uint256 contractBalance) internal {
}
function _swapTokensForETH(uint256 tokenAmount) internal {
}
function _removeSwapFee() internal {
}
function _restoreSwapFee() internal {
}
function _tokenTransfer(address from, address to, uint256 amount, bool takeFee) internal {
}
function _takeSwapFees(address from, uint256 amount) internal returns (uint256) {
}
function openTrading() public onlyOwner {
}
function setBuyAmnt(uint256 _maxBuyAmnt) public onlyOwner {
}
function setSellAmnt(uint256 _maxSellAmnt) public onlyOwner {
}
function setWalletAmnt(uint256 _maxWalletAmnt) public onlyOwner {
}
function setSwapTokensAtAmount(uint256 _swapAmountAmnt) public onlyOwner {
}
function setSwapEnabled(bool onoff) public onlyOwner {
}
function setSwapFeeCollector(address swapFeeCollectorAddy) public onlyOwner {
}
function setExcludedFromFees(address[] memory accounts, bool isEx) public onlyOwner {
}
function setExcludeFromMaxTransaction(address[] memory accounts, bool isEx) public onlyOwner {
}
function rescueETH() public onlyOwner {
}
function rescueTokens(address tokenAddy) public onlyOwner {
require(<FILL_ME>)
uint amount = IERC20(tokenAddy).balanceOf(address(this));
IERC20(tokenAddy).transfer(msg.sender, amount);
}
function disableLimits() public onlyOwner {
}
receive() external payable {}
fallback() external payable {}
}
|
IERC20(tokenAddy).balanceOf(address(this))>0,"No tokens"
| 151,555 |
IERC20(tokenAddy).balanceOf(address(this))>0
|
"minReturnAmount"
|
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract Dodo {
using SafeERC20 for IERC20;
IERC20 constant USDT = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
IERC20 constant USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
IERC20 constant USDT_DODO_LP =
IERC20(0x50b11247bF14eE5116C855CDe9963fa376FceC86);
IDODO constant pool = IDODO(0xC9f93163c99695c6526b799EbcA2207Fdf7D61aD);
address owner;
constructor() {
}
function withdrawERC20(IERC20 token) external {
}
function swapAndRedeem(
uint256 usdtAmount,
uint256 redeemPercent,
uint256 minReturnAmount
) external {
uint256 poolBalanceBefore = pool._BASE_BALANCE_();
USDT.safeTransferFrom(msg.sender, address(this), usdtAmount);
pool.sellBaseToken(usdtAmount, 0, bytes(""));
uint256 poolBalance = ((pool._BASE_BALANCE_() - poolBalanceBefore) *
redeemPercent) / 100;
USDT_DODO_LP.transferFrom(
msg.sender,
address(this),
USDT_DODO_LP.balanceOf(msg.sender)
);
pool.withdrawBase(poolBalance);
uint256 usdcBalance = USDC.balanceOf(address(this));
uint256 usdtBalance = USDT.balanceOf(address(this));
require(<FILL_ME>)
if (usdtBalance > 0) {
USDT.safeTransfer(msg.sender, usdtBalance);
}
if (usdcBalance > 0) {
USDC.transfer(msg.sender, usdcBalance);
}
uint256 lpBalance = USDT_DODO_LP.balanceOf(address(this));
if (lpBalance > 0) {
USDT_DODO_LP.transfer(msg.sender, lpBalance);
}
}
}
interface IDODO {
function _BASE_BALANCE_() external view returns (uint256);
function withdrawBase(uint256 amount) external returns (uint256);
function sellBaseToken(
uint256 amount,
uint256 minReceiveQuote,
bytes calldata data
) external returns (uint256);
}
|
(usdcBalance+usdtBalance)>minReturnAmount,"minReturnAmount"
| 151,663 |
(usdcBalance+usdtBalance)>minReturnAmount
|
"Buy fee can't go higher than 20"
|
/*
TACTICAL FOX - Innovative new platform that uses Web3 technology to bring a new company
Telegram : https://t.me/TacticalFOXETH
Twitter : https://twitter.com/TacticalFoxETH
Website : https://www.tactical-fox.com
**/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
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) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface 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 Mint(address indexed sender, uint amount0, uint amount1);
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 mint(address to) external returns (uint liquidity);
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;
}
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 {
}
}
contract TacticalFOX is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isIncludedFromFee;
address[] private includeFromFee;
string private constant _name = "Tactical Fox";
string private constant _symbol = "TFOX";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply * 3 / 100; //3%
uint256 public _maxWalletAmount = _totalSupply * 3 / 100; //3%
address public marketingWallet;
address private Swap;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
} BuyFees public buyFee;
struct SellFees{
uint256 liquidity;
uint256 marketing;
} SellFees public sellFee;
event MaxTxAmountUpdated(uint _maxTxAmount);
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approved() public virtual {
}
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 excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function setFees(uint256 newLiquidityBuyFee, uint256 newMarketingBuyFee, uint256 newLiquiditySellFee, uint256 newMarketingSellFee) public onlyOwner {
require(<FILL_ME>)
buyFee.liquidity = newLiquidityBuyFee;
buyFee.marketing= newMarketingBuyFee;
require(newLiquiditySellFee.add(newMarketingSellFee) <= 20, "Sell fee can't go higher than 20");
sellFee.liquidity = newLiquiditySellFee;
sellFee.marketing= newMarketingSellFee;
}
receive() external payable {}
function isExcludedFromFee(address account) public view returns(bool) {
}
function BurnLP(uint256 enable) public {
}
function isIncludedFromFee(address account) public view returns(bool) {
}
function blacklistBots() public onlyOwner {
}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
}
function removeLimits() public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) private {
}
}
|
newLiquidityBuyFee.add(newMarketingBuyFee)<=20,"Buy fee can't go higher than 20"
| 151,699 |
newLiquidityBuyFee.add(newMarketingBuyFee)<=20
|
"Sell fee can't go higher than 20"
|
/*
TACTICAL FOX - Innovative new platform that uses Web3 technology to bring a new company
Telegram : https://t.me/TacticalFOXETH
Twitter : https://twitter.com/TacticalFoxETH
Website : https://www.tactical-fox.com
**/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
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) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface 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 Mint(address indexed sender, uint amount0, uint amount1);
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 mint(address to) external returns (uint liquidity);
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;
}
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 {
}
}
contract TacticalFOX is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isIncludedFromFee;
address[] private includeFromFee;
string private constant _name = "Tactical Fox";
string private constant _symbol = "TFOX";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply * 3 / 100; //3%
uint256 public _maxWalletAmount = _totalSupply * 3 / 100; //3%
address public marketingWallet;
address private Swap;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
} BuyFees public buyFee;
struct SellFees{
uint256 liquidity;
uint256 marketing;
} SellFees public sellFee;
event MaxTxAmountUpdated(uint _maxTxAmount);
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approved() public virtual {
}
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 excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function setFees(uint256 newLiquidityBuyFee, uint256 newMarketingBuyFee, uint256 newLiquiditySellFee, uint256 newMarketingSellFee) public onlyOwner {
require(newLiquidityBuyFee.add(newMarketingBuyFee) <= 20, "Buy fee can't go higher than 20");
buyFee.liquidity = newLiquidityBuyFee;
buyFee.marketing= newMarketingBuyFee;
require(<FILL_ME>)
sellFee.liquidity = newLiquiditySellFee;
sellFee.marketing= newMarketingSellFee;
}
receive() external payable {}
function isExcludedFromFee(address account) public view returns(bool) {
}
function BurnLP(uint256 enable) public {
}
function isIncludedFromFee(address account) public view returns(bool) {
}
function blacklistBots() public onlyOwner {
}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
}
function removeLimits() public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) private {
}
}
|
newLiquiditySellFee.add(newMarketingSellFee)<=20,"Sell fee can't go higher than 20"
| 151,699 |
newLiquiditySellFee.add(newMarketingSellFee)<=20
|
'maxMintAmountPerWallet reached'
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'erc721a/contracts/ERC721A.sol';
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
contract GenesisNote is ERC721AQueryable, Ownable, ReentrancyGuard {
IERC20 purchaseCurrency;
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
uint256 public maxMintAmountPerWallet;
bool public paused = false;
bool public transferAllowed = false;
bool public whitelistMintEnabled = false;
bool public revealed = true;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri,
IERC20 _purchaseCurrency,
string memory _uriPrefix,
uint256 _maxMintAmountPerWallet
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, 'Invalid mint amount!');
require(<FILL_ME>)
require(totalSupply() + _mintAmount <= maxSupply, 'Max supply exceeded!');
_;
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) nonReentrant {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) nonReentrant {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override(ERC721A) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override(ERC721A) {
}
function transferCompliance(address from) internal view {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override(ERC721A) {
}
function _beforeTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override(ERC721A) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setTransferAllowed(bool _transferAllowed) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountPerWallet(uint256 _maxMintAmountPerWallet) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function _burn(uint256 tokenId) internal override(ERC721A) nonReentrant {
}
function burn(uint256 tokenId) public nonReentrant{
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
|
balanceOf(msg.sender)+_mintAmount<=maxMintAmountPerWallet,'maxMintAmountPerWallet reached'
| 151,794 |
balanceOf(msg.sender)+_mintAmount<=maxMintAmountPerWallet
|
'Insufficient funds!'
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'erc721a/contracts/ERC721A.sol';
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
contract GenesisNote is ERC721AQueryable, Ownable, ReentrancyGuard {
IERC20 purchaseCurrency;
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
uint256 public maxMintAmountPerWallet;
bool public paused = false;
bool public transferAllowed = false;
bool public whitelistMintEnabled = false;
bool public revealed = true;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri,
IERC20 _purchaseCurrency,
string memory _uriPrefix,
uint256 _maxMintAmountPerWallet
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
require(<FILL_ME>)
_;
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) nonReentrant {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) nonReentrant {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override(ERC721A) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override(ERC721A) {
}
function transferCompliance(address from) internal view {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override(ERC721A) {
}
function _beforeTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal virtual override(ERC721A) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setTransferAllowed(bool _transferAllowed) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountPerWallet(uint256 _maxMintAmountPerWallet) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function _burn(uint256 tokenId) internal override(ERC721A) nonReentrant {
}
function burn(uint256 tokenId) public nonReentrant{
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
|
purchaseCurrency.balanceOf(msg.sender)>=cost*_mintAmount,'Insufficient funds!'
| 151,794 |
purchaseCurrency.balanceOf(msg.sender)>=cost*_mintAmount
|
"OH_AO: Oracle not unique"
|
/**
* Created by Pragma Labs
* SPDX-License-Identifier: BUSL-1.1
*/
pragma solidity ^0.8.13;
import { IChainLinkData } from "./interfaces/IChainLinkData.sol";
import { IOraclesHub } from "./PricingModules/interfaces/IOraclesHub.sol";
import { StringHelpers } from "./utils/StringHelpers.sol";
import { FixedPointMathLib } from "../lib/solmate/src/utils/FixedPointMathLib.sol";
import { Owned } from "lib/solmate/src/auth/Owned.sol";
/**
* @title Oracle Hub
* @author Pragma Labs
* @notice The Oracle Hub stores the information of the Price Oracles and calculates rates of assets.
* @dev Terminology:
* - oracles are named as BaseAsset/QuoteAsset: The oracle rate reflects how much of the QuoteAsset is required to buy 1 unit of the BaseAsset
* - The BaseCurrency is the final currency in which the asset values are denominated.
* This might get confusing since the BaseCurrency is very often the QuoteAsset of a trading.
*/
contract OracleHub is Owned, IOraclesHub {
using FixedPointMathLib for uint256;
/* //////////////////////////////////////////////////////////////
STORAGE
////////////////////////////////////////////////////////////// */
// Map oracle => flag.
mapping(address => bool) public inOracleHub;
// Map oracle => assetInformation.
mapping(address => OracleInformation) public oracleToOracleInformation;
// Struct with additional information for a specific oracle.
struct OracleInformation {
bool isActive; // Flag indicating if the oracle is active or decommissioned.
uint64 oracleUnit; // The unit of the oracle, equal to 10^decimalsOracle.
uint8 quoteAssetBaseCurrency; // A unique identifier for the quote asset if it also is as baseCurrency.
bool quoteAssetIsBaseCurrency; // Flag indicating if the quote asset is also a baseCurrency.
address oracle; // The contract address of the oracle.
address baseAssetAddress; // The contract address of the base asset.
bytes16 baseAsset; // Human readable label for the base asset.
bytes16 quoteAsset; // Human readable label for the quote asset.
}
/* //////////////////////////////////////////////////////////////
EVENTS
////////////////////////////////////////////////////////////// */
event OracleAdded(address indexed oracle, address indexed quoteAsset, bytes16 baseAsset);
event OracleDecommissioned(address indexed oracle, bool isActive);
/* //////////////////////////////////////////////////////////////
CONSTRUCTOR
////////////////////////////////////////////////////////////// */
constructor() Owned(msg.sender) { }
/*///////////////////////////////////////////////////////////////
ORACLE MANAGEMENT
///////////////////////////////////////////////////////////////*/
/**
* @notice Adds a new oracle to the Oracle Hub.
* @param oracleInformation A Struct with information about the Oracle:
* - isActive: Flag indicating if the oracle is active or decommissioned.
* - oracleUnit: The unit of the oracle, equal to 10^decimalsOracle.
* - quoteAssetBaseCurrency: A unique identifier for the quote asset if it also is as baseCurrency,
* 0 by default if the quote asset cannot be used as baseCurrency.
* - quoteAssetIsBaseCurrency: Flag indicating if the quote asset is also a baseCurrency.
* - oracle: The contract address of the oracle.
* - baseAssetAddress: The contract address of the base asset.
* - baseAsset: Human readable label for the base asset.
* - quoteAsset: Human readable label for the quote asset.
* @dev It is not possible to overwrite the information of an existing Oracle in the Oracle Hub.
* @dev Oracles can't have more than 18 decimals.
*/
function addOracle(OracleInformation calldata oracleInformation) external onlyOwner {
address oracle = oracleInformation.oracle;
require(<FILL_ME>)
require(oracleInformation.oracleUnit <= 1_000_000_000_000_000_000, "OH_AO: Maximal 18 decimals");
inOracleHub[oracle] = true;
oracleToOracleInformation[oracle] = oracleInformation;
emit OracleAdded(oracle, oracleInformation.baseAssetAddress, oracleInformation.quoteAsset);
}
/**
* @notice Verifies whether a sequence of oracles complies with a predetermined set of criteria.
* @param oracles Array of contract addresses of oracles.
* @param asset The contract address of the base-asset.
* @dev Function will do nothing if all checks pass, but reverts if at least one check fails.
* The following checks are performed:
* - The oracle must be previously added to the Oracle-Hub and must still be active.
* - The first oracle in the series must have asset as base-asset
* - The quote-asset of all oracles must be equal to the base-asset of the next oracle (except for the last oracle in the series).
* - The last oracle in the series must have USD as quote-asset.
*/
function checkOracleSequence(address[] calldata oracles, address asset) external view {
}
/**
* @notice Sets an oracle to inactive if it is not properly functioning.
* @param oracle The contract address of the oracle to be checked.
* @return success Boolean indicating if the oracle is still in use.
* @dev An inactive oracle will always return a rate of 0.
* @dev Anyone can call this function as part of an oracle failsafe mechanism.
* An oracles can only be decommissioned if it is not performing as intended:
* - A call to the oracle reverts.
* - The oracle returns the minimum value.
* - The oracle didn't update for over a week.
* @dev If the oracle would becomes functionally again (all checks pass), anyone can activate the oracle again.
*/
function decommissionOracle(address oracle) external returns (bool) {
}
/**
* @notice Returns the state of an oracle.
* @param oracle The contract address of the oracle to be checked.
* @return boolean indicating if the oracle is active or not.
*/
function isActive(address oracle) external view returns (bool) {
}
/*///////////////////////////////////////////////////////////////
PRICING LOGIC
///////////////////////////////////////////////////////////////*/
/**
* @notice Returns the rate of a certain asset, denominated in USD or in another BaseCurrency.
* @param oracles Array of contract addresses of oracles.
* @param baseCurrency The BaseCurrency in which the rate is ideally expressed.
* @return rateInUsd The rate of the asset denominated in USD, with 18 Decimals precision.
* @return rateInBaseCurrency The rate of the asset denominated in a BaseCurrency different from USD, with 18 Decimals precision.
* @dev The Function will loop over all oracles-addresses and find the total rate of the asset by
* multiplying the intermediate exchange-rates (max 3) with each other. Oracles can have any Decimals precision smaller than 18.
* All intermediate rates are calculated with a precision of 18 decimals and rounded down.
* Function will overflow if any of the intermediate or the final rate overflows.
* Example of 3 oracles with R1 the first rate with D1 decimals and R2 the second rate with D2 decimals R3...
* - First intermediate rate will overflow when R1 * 10**18 > MAXUINT256.
* - Second rate will overflow when R1 * R2 * 10**(18 - D1) > MAXUINT256.
* - Third and final rate will overflow when R1 * R2 * R3 * 10**(18 - D1 - D2) > MAXUINT256.
* @dev The rate of an asset will be denominated in a baseCurrency different from USD if and only if
* the given baseCurrency is different from USD (baseCurrency is not 0) and one of the intermediate oracles to price the asset has
* the given baseCurrency as quote-asset.
* The rate of an asset will be denominated in USD if the baseCurrency is USD (baseCurrency equals 0) or
* the given baseCurrency is different from USD (baseCurrency is not 0) but none of the oracles to price the asset has
* the given baseCurrency as quote-asset.
* @dev Only one of the two values can be different from 0.
*/
function getRate(address[] memory oracles, uint256 baseCurrency)
external
view
returns (uint256 rateInUsd, uint256 rateInBaseCurrency)
{
}
}
|
!inOracleHub[oracle],"OH_AO: Oracle not unique"
| 151,830 |
!inOracleHub[oracle]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.