comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"not enough eth" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
interface IStakingPool {
function balanceOf(address _owner) external view returns (uint256 balance);
function burn(address _owner, uint256 _amount) external;
}
interface IStandaloneNft721 is IERC721 {
function totalSupply() external view returns (uint256);
function numberMintedByAddress(address _address) external view returns (uint256);
function mintNext(address _to, uint256 _amount) external;
function addToNumberMintedByAddress(address _address, uint256 amount) external;
}
contract Raini721FunctionsV3 is AccessControl, ReentrancyGuard {
using ECDSA for bytes32;
struct PoolType {
uint64 costInUnicorns;
uint64 costInRainbows;
uint64 costInEth;
uint16 maxMintsPerAddress;
uint32 supply;
uint32 mintTimeStart; // the timestamp from which the pack can be minted
bool requiresWhitelist;
}
mapping (uint256 => PoolType) public poolTypes;
uint256 public constant POINT_COST_DECIMALS = 1000000000000000000;
uint256 public rainbowToEth;
uint256 public unicornToEth;
uint256 public minPointsPercentToMint;
uint256 public maxMintsPerTx;
mapping(address => bool) public rainbowPools;
mapping(address => bool) public unicornPools;
mapping(address => mapping(uint256 => uint256)) public numberMintedByAddress;
mapping (uint256 => uint) public numberOfPoolMinted;
uint256 public mintingFeeBasisPoints;
address public verifier;
address public contractOwner;
address payable public ethRecipient;
address payable public feeRecipient;
IStandaloneNft721 public nftContract;
constructor(address _nftContractAddress, uint256 _maxMintsPerTx, address payable _ethRecipient, address payable _feeRecipient, address _contractOwner, address _verifier) {
}
modifier onlyOwner() {
}
function setMaxMintsPerTx(uint256 _maxMintsPerTx)
external onlyOwner {
}
function setNftContract(address _nftContract)
external onlyOwner {
}
function addRainbowPool(address _rainbowPool)
external onlyOwner {
}
function removeRainbowPool(address _rainbowPool)
external onlyOwner {
}
function addUnicornPool(address _unicornPool)
external onlyOwner {
}
function removeUnicornPool(address _unicornPool)
external onlyOwner {
}
function setEtherValues(uint256 _unicornToEth, uint256 _rainbowToEth, uint256 _minPointsPercentToMint)
external onlyOwner {
}
function setFees(uint256 _mintingFeeBasisPoints)
external onlyOwner {
}
function setVerifierAddress(address _verifier)
external onlyOwner {
}
function setFeeRecipient(address payable _feeRecipient)
external onlyOwner {
}
function setEthRecipient(address payable _ethRecipient)
external onlyOwner {
}
function getTotalBalance(address _address, uint256 _start, uint256 _end)
external view returns (uint256[][] memory amounts) {
}
function initPools(
uint256[] memory _poolId,
uint256[] memory _supply,
uint256[] memory _costInUnicorns,
uint256[] memory _costInRainbows,
uint256[] memory _costInEth,
uint256[] memory _maxMintsPerAddress,
uint32[] memory _mintTimeStart,
bool[] memory _requiresWhitelist
) external onlyOwner {
}
struct MintData {
uint256 totalPriceRainbows;
uint256 totalPriceUnicorns;
uint256 minCostRainbows;
uint256 minCostUnicorns;
uint256 fee;
uint256 amountEthToWithdraw;
uint256 maxMints;
uint256 totalToMint;
bool success;
}
function checkSigniture(address msgSender, bytes memory sig, uint256 maxMints) public view returns (bool _success) {
}
function mint(
uint256[] memory _poolType,
uint256[] memory _amount,
bool[] memory _useUnicorns,
address[] memory _rainbowPools,
address[] memory _unicornPools,
bytes memory sig,
uint256 maxMints
) external payable nonReentrant {
require(maxMints == 0 || checkSigniture(_msgSender(), sig, maxMints), 'invalid sig');
MintData memory _locals = MintData({
totalPriceRainbows: 0,
totalPriceUnicorns: 0,
minCostRainbows: 0,
minCostUnicorns: 0,
fee: 0,
amountEthToWithdraw: 0,
maxMints: 0,
totalToMint: 0,
success: false
});
for (uint256 i = 0; i < _poolType.length; i++) {
PoolType memory poolType = poolTypes[_poolType[i]];
_locals.maxMints = poolType.maxMintsPerAddress == 0 ? 10 ** 10 : poolType.maxMintsPerAddress;
if (poolType.requiresWhitelist && (maxMints < _locals.maxMints)) {
_locals.maxMints = maxMints;
}
require(block.timestamp >= poolType.mintTimeStart || hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), 'too early');
require(numberMintedByAddress[_msgSender()][_poolType[i]] + _amount[i] <= _locals.maxMints, "Max mints reached for address");
uint256 numberMinted = numberOfPoolMinted[_poolType[i]];
if (numberMinted + _amount[i] > poolType.supply) {
_amount[i] = poolType.supply - numberMinted;
}
_locals.totalToMint += _amount[i];
if (poolType.maxMintsPerAddress > 0) {
numberMintedByAddress[_msgSender()][_poolType[i]] += _amount[i];
numberOfPoolMinted[_poolType[i]] += _amount[i];
}
if (poolType.costInUnicorns > 0 || poolType.costInRainbows > 0) {
if (_useUnicorns[i]) {
require(poolType.costInUnicorns > 0, "unicorns not allowed");
uint256 cost = poolType.costInUnicorns * _amount[i] * POINT_COST_DECIMALS;
_locals.totalPriceUnicorns += cost;
if (poolType.costInEth > 0) {
_locals.minCostUnicorns += cost;
}
} else {
require(poolType.costInRainbows > 0, "rainbows not allowed");
uint256 cost = poolType.costInRainbows * _amount[i] * POINT_COST_DECIMALS;
_locals.totalPriceRainbows += cost;
if (poolType.costInEth > 0) {
_locals.minCostRainbows += cost;
}
}
if (poolType.costInEth == 0) {
if (poolType.costInRainbows > 0) {
_locals.fee += (poolType.costInRainbows * _amount[i] * POINT_COST_DECIMALS * mintingFeeBasisPoints) / (rainbowToEth * 10000);
} else {
_locals.fee += (poolType.costInUnicorns * _amount[i] * POINT_COST_DECIMALS * mintingFeeBasisPoints) / (unicornToEth * 10000);
}
}
}
_locals.amountEthToWithdraw += poolType.costInEth * _amount[i];
}
if (_locals.totalPriceUnicorns > 0 || _locals.totalPriceRainbows > 0 ) {
for (uint256 n = 0; n < 2; n++) {
bool loopTypeUnicorns = n > 0;
uint256 totalBalance = 0;
uint256 totalPrice = loopTypeUnicorns ? _locals.totalPriceUnicorns : _locals.totalPriceRainbows;
uint256 remainingPrice = totalPrice;
if (totalPrice > 0) {
uint256 loopLength = loopTypeUnicorns ? _unicornPools.length : _rainbowPools.length;
require(loopLength > 0, "invalid pools");
for (uint256 i = 0; i < loopLength; i++) {
IStakingPool pool;
if (loopTypeUnicorns) {
require((unicornPools[_unicornPools[i]]), "invalid unicorn pool");
pool = IStakingPool(_unicornPools[i]);
} else {
require((rainbowPools[_rainbowPools[i]]), "invalid rainbow pool");
pool = IStakingPool(_rainbowPools[i]);
}
uint256 _balance = pool.balanceOf(_msgSender());
totalBalance += _balance;
if (totalBalance >= totalPrice) {
pool.burn(_msgSender(), remainingPrice);
remainingPrice = 0;
break;
} else {
pool.burn(_msgSender(), _balance);
remainingPrice -= _balance;
}
}
if (remainingPrice > 0) {
totalPrice -= loopTypeUnicorns ? _locals.minCostUnicorns : _locals.minCostRainbows;
uint256 minPoints = (totalPrice * minPointsPercentToMint) / 100;
require(totalPrice - remainingPrice >= minPoints, "not enough balance");
uint256 pointsToEth = loopTypeUnicorns ? unicornToEth : rainbowToEth;
require(msg.value * pointsToEth > remainingPrice, "not enough balance");
_locals.fee += remainingPrice / pointsToEth;
}
}
}
}
require(<FILL_ME>)
(_locals.success, ) = _msgSender().call{ value: msg.value - (_locals.amountEthToWithdraw + _locals.fee)}(""); // refund excess Eth
require(_locals.success, "transfer failed");
(_locals.success, ) = feeRecipient.call{ value: _locals.fee }(""); // pay fees
require(_locals.success, "fee transfer failed");
(_locals.success, ) = ethRecipient.call{ value: _locals.amountEthToWithdraw }(""); // pay eth recipient
require(_locals.success, "transfer failed");
require(_locals.totalToMint > 0, 'Allocation exhausted');
require(_locals.totalToMint <= maxMintsPerTx, '_amount over max');
nftContract.mintNext(_msgSender(), _locals.totalToMint);
}
// Allow the owner to withdraw Ether payed into the contract
function withdrawEth(uint256 _amount)
external onlyOwner {
}
}
| _locals.amountEthToWithdraw+_locals.fee<=msg.value,"not enough eth" | 367,638 | _locals.amountEthToWithdraw+_locals.fee<=msg.value |
"transfer failed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
interface IStakingPool {
function balanceOf(address _owner) external view returns (uint256 balance);
function burn(address _owner, uint256 _amount) external;
}
interface IStandaloneNft721 is IERC721 {
function totalSupply() external view returns (uint256);
function numberMintedByAddress(address _address) external view returns (uint256);
function mintNext(address _to, uint256 _amount) external;
function addToNumberMintedByAddress(address _address, uint256 amount) external;
}
contract Raini721FunctionsV3 is AccessControl, ReentrancyGuard {
using ECDSA for bytes32;
struct PoolType {
uint64 costInUnicorns;
uint64 costInRainbows;
uint64 costInEth;
uint16 maxMintsPerAddress;
uint32 supply;
uint32 mintTimeStart; // the timestamp from which the pack can be minted
bool requiresWhitelist;
}
mapping (uint256 => PoolType) public poolTypes;
uint256 public constant POINT_COST_DECIMALS = 1000000000000000000;
uint256 public rainbowToEth;
uint256 public unicornToEth;
uint256 public minPointsPercentToMint;
uint256 public maxMintsPerTx;
mapping(address => bool) public rainbowPools;
mapping(address => bool) public unicornPools;
mapping(address => mapping(uint256 => uint256)) public numberMintedByAddress;
mapping (uint256 => uint) public numberOfPoolMinted;
uint256 public mintingFeeBasisPoints;
address public verifier;
address public contractOwner;
address payable public ethRecipient;
address payable public feeRecipient;
IStandaloneNft721 public nftContract;
constructor(address _nftContractAddress, uint256 _maxMintsPerTx, address payable _ethRecipient, address payable _feeRecipient, address _contractOwner, address _verifier) {
}
modifier onlyOwner() {
}
function setMaxMintsPerTx(uint256 _maxMintsPerTx)
external onlyOwner {
}
function setNftContract(address _nftContract)
external onlyOwner {
}
function addRainbowPool(address _rainbowPool)
external onlyOwner {
}
function removeRainbowPool(address _rainbowPool)
external onlyOwner {
}
function addUnicornPool(address _unicornPool)
external onlyOwner {
}
function removeUnicornPool(address _unicornPool)
external onlyOwner {
}
function setEtherValues(uint256 _unicornToEth, uint256 _rainbowToEth, uint256 _minPointsPercentToMint)
external onlyOwner {
}
function setFees(uint256 _mintingFeeBasisPoints)
external onlyOwner {
}
function setVerifierAddress(address _verifier)
external onlyOwner {
}
function setFeeRecipient(address payable _feeRecipient)
external onlyOwner {
}
function setEthRecipient(address payable _ethRecipient)
external onlyOwner {
}
function getTotalBalance(address _address, uint256 _start, uint256 _end)
external view returns (uint256[][] memory amounts) {
}
function initPools(
uint256[] memory _poolId,
uint256[] memory _supply,
uint256[] memory _costInUnicorns,
uint256[] memory _costInRainbows,
uint256[] memory _costInEth,
uint256[] memory _maxMintsPerAddress,
uint32[] memory _mintTimeStart,
bool[] memory _requiresWhitelist
) external onlyOwner {
}
struct MintData {
uint256 totalPriceRainbows;
uint256 totalPriceUnicorns;
uint256 minCostRainbows;
uint256 minCostUnicorns;
uint256 fee;
uint256 amountEthToWithdraw;
uint256 maxMints;
uint256 totalToMint;
bool success;
}
function checkSigniture(address msgSender, bytes memory sig, uint256 maxMints) public view returns (bool _success) {
}
function mint(
uint256[] memory _poolType,
uint256[] memory _amount,
bool[] memory _useUnicorns,
address[] memory _rainbowPools,
address[] memory _unicornPools,
bytes memory sig,
uint256 maxMints
) external payable nonReentrant {
require(maxMints == 0 || checkSigniture(_msgSender(), sig, maxMints), 'invalid sig');
MintData memory _locals = MintData({
totalPriceRainbows: 0,
totalPriceUnicorns: 0,
minCostRainbows: 0,
minCostUnicorns: 0,
fee: 0,
amountEthToWithdraw: 0,
maxMints: 0,
totalToMint: 0,
success: false
});
for (uint256 i = 0; i < _poolType.length; i++) {
PoolType memory poolType = poolTypes[_poolType[i]];
_locals.maxMints = poolType.maxMintsPerAddress == 0 ? 10 ** 10 : poolType.maxMintsPerAddress;
if (poolType.requiresWhitelist && (maxMints < _locals.maxMints)) {
_locals.maxMints = maxMints;
}
require(block.timestamp >= poolType.mintTimeStart || hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), 'too early');
require(numberMintedByAddress[_msgSender()][_poolType[i]] + _amount[i] <= _locals.maxMints, "Max mints reached for address");
uint256 numberMinted = numberOfPoolMinted[_poolType[i]];
if (numberMinted + _amount[i] > poolType.supply) {
_amount[i] = poolType.supply - numberMinted;
}
_locals.totalToMint += _amount[i];
if (poolType.maxMintsPerAddress > 0) {
numberMintedByAddress[_msgSender()][_poolType[i]] += _amount[i];
numberOfPoolMinted[_poolType[i]] += _amount[i];
}
if (poolType.costInUnicorns > 0 || poolType.costInRainbows > 0) {
if (_useUnicorns[i]) {
require(poolType.costInUnicorns > 0, "unicorns not allowed");
uint256 cost = poolType.costInUnicorns * _amount[i] * POINT_COST_DECIMALS;
_locals.totalPriceUnicorns += cost;
if (poolType.costInEth > 0) {
_locals.minCostUnicorns += cost;
}
} else {
require(poolType.costInRainbows > 0, "rainbows not allowed");
uint256 cost = poolType.costInRainbows * _amount[i] * POINT_COST_DECIMALS;
_locals.totalPriceRainbows += cost;
if (poolType.costInEth > 0) {
_locals.minCostRainbows += cost;
}
}
if (poolType.costInEth == 0) {
if (poolType.costInRainbows > 0) {
_locals.fee += (poolType.costInRainbows * _amount[i] * POINT_COST_DECIMALS * mintingFeeBasisPoints) / (rainbowToEth * 10000);
} else {
_locals.fee += (poolType.costInUnicorns * _amount[i] * POINT_COST_DECIMALS * mintingFeeBasisPoints) / (unicornToEth * 10000);
}
}
}
_locals.amountEthToWithdraw += poolType.costInEth * _amount[i];
}
if (_locals.totalPriceUnicorns > 0 || _locals.totalPriceRainbows > 0 ) {
for (uint256 n = 0; n < 2; n++) {
bool loopTypeUnicorns = n > 0;
uint256 totalBalance = 0;
uint256 totalPrice = loopTypeUnicorns ? _locals.totalPriceUnicorns : _locals.totalPriceRainbows;
uint256 remainingPrice = totalPrice;
if (totalPrice > 0) {
uint256 loopLength = loopTypeUnicorns ? _unicornPools.length : _rainbowPools.length;
require(loopLength > 0, "invalid pools");
for (uint256 i = 0; i < loopLength; i++) {
IStakingPool pool;
if (loopTypeUnicorns) {
require((unicornPools[_unicornPools[i]]), "invalid unicorn pool");
pool = IStakingPool(_unicornPools[i]);
} else {
require((rainbowPools[_rainbowPools[i]]), "invalid rainbow pool");
pool = IStakingPool(_rainbowPools[i]);
}
uint256 _balance = pool.balanceOf(_msgSender());
totalBalance += _balance;
if (totalBalance >= totalPrice) {
pool.burn(_msgSender(), remainingPrice);
remainingPrice = 0;
break;
} else {
pool.burn(_msgSender(), _balance);
remainingPrice -= _balance;
}
}
if (remainingPrice > 0) {
totalPrice -= loopTypeUnicorns ? _locals.minCostUnicorns : _locals.minCostRainbows;
uint256 minPoints = (totalPrice * minPointsPercentToMint) / 100;
require(totalPrice - remainingPrice >= minPoints, "not enough balance");
uint256 pointsToEth = loopTypeUnicorns ? unicornToEth : rainbowToEth;
require(msg.value * pointsToEth > remainingPrice, "not enough balance");
_locals.fee += remainingPrice / pointsToEth;
}
}
}
}
require(_locals.amountEthToWithdraw + _locals.fee <= msg.value, "not enough eth");
(_locals.success, ) = _msgSender().call{ value: msg.value - (_locals.amountEthToWithdraw + _locals.fee)}(""); // refund excess Eth
require(<FILL_ME>)
(_locals.success, ) = feeRecipient.call{ value: _locals.fee }(""); // pay fees
require(_locals.success, "fee transfer failed");
(_locals.success, ) = ethRecipient.call{ value: _locals.amountEthToWithdraw }(""); // pay eth recipient
require(_locals.success, "transfer failed");
require(_locals.totalToMint > 0, 'Allocation exhausted');
require(_locals.totalToMint <= maxMintsPerTx, '_amount over max');
nftContract.mintNext(_msgSender(), _locals.totalToMint);
}
// Allow the owner to withdraw Ether payed into the contract
function withdrawEth(uint256 _amount)
external onlyOwner {
}
}
| _locals.success,"transfer failed" | 367,638 | _locals.success |
'Identity: Unapproved transfer' | // SPDX-License-Identifier: GPL-3.0-only
pragma solidity 0.7.4;
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
library SafeMathLib {
function times(uint a, uint b) public pure returns (uint) {
}
function minus(uint a, uint b) public pure returns (uint) {
}
function plus(uint a, uint b) public pure returns (uint) {
}
}
// ERC 721
contract VotingIdentity {
using SafeMathLib for uint;
mapping (uint => address) public owners;
mapping (address => uint) public balances;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) public operatorApprovals;
mapping (uint => address) public tokenApprovals;
mapping (address => mapping (uint => uint)) public ownershipMap;
mapping (uint => string) public uriMap;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant ERC721_RECEIVED = 0x150b7a02;
/*
* bytes4(keccak256('balanceOf(address)')) == 0x70a08231
* bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
* bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
* bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
* bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
* bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
* bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
* bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
* bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
*
* => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
* 0xa22cb465 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
*/
bytes4 private constant INTERFACE_ID_ERC721 = 0x80ac58cd;
/*
* bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
*/
bytes4 private constant INTERFACE_ID_ERC165 = 0x01ffc9a7;
string constant _name = 'London Elects 2021';
string constant _symbol = 'LDN';
uint public numIdentities = 0;
address public management;
event ManagementUpdated(address oldManagement, address newManagement);
event IdentityCreated(address indexed owner, uint indexed token);
/// @dev This emits when ownership of any NFT changes by any mechanism.
/// This event emits when NFTs are created (`from` == 0) and destroyed
/// (`to` == 0). Exception: during contract creation, any number of NFTs
/// may be created and assigned without emitting Transfer. At the time of
/// any transfer, the approved address for that NFT (if any) is reset to none.
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/// @dev This emits when the approved address for an NFT is changed or
/// reaffirmed. The zero address indicates there is no approved address.
/// When a Transfer event emits, this also indicates that the approved
/// address for that NFT (if any) is reset to none.
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/// @dev This emits when an operator is enabled or disabled for an owner.
/// The operator can manage all NFTs of the owner.
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
modifier managementOnly() {
}
constructor(address mgmt) {
}
// this function creates an identity for free. Only management can call it.
function createIdentityFor(address newId) public managementOnly {
}
function createIdentity(address owner) internal {
}
/// ================= SETTERS =======================================
// change the management key
function setManagement(address newMgmt) external managementOnly {
}
function setTokenUri(uint tokenId, string memory uri) external managementOnly {
}
/// ================= ERC 721 FUNCTIONS =============================================
/// @notice Count all NFTs assigned to an owner
/// @dev NFTs assigned to the zero address are considered invalid, and this
/// function throws for queries about the zero address.
/// @param owner An address for whom to query the balance
/// @return The number of NFTs owned by `owner`, possibly zero
function balanceOf(address owner) external view returns (uint256) {
}
/// @notice Find the owner of an NFT
/// @dev NFTs assigned to zero address are considered invalid, and queries
/// about them do throw.
/// @param tokenId The identifier for an NFT
/// @return The address of the owner of the NFT
function ownerOf(uint256 tokenId) external view returns (address) {
}
/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
/// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE
/// THEY MAY BE PERMANENTLY LOST
/// @dev Throws unless `msg.sender` is the current owner, an authorized
/// operator, or the approved address for this NFT. Throws if `from` is
/// not the current owner. Throws if `to` is the zero address. Throws if
/// `tokenId` is not a valid NFT.
/// @param from The current owner of the NFT
/// @param to The new owner
/// @param tokenId The NFT to transfer
function transferFrom(address from, address to, uint256 tokenId) public {
require(<FILL_ME>)
transfer(from, to, tokenId);
}
/// @notice Transfers the ownership of an NFT from one address to another address
/// @dev Throws unless `msg.sender` is the current owner, an authorized
/// operator, or the approved address for this NFT. Throws if `from` is
/// not the current owner. Throws if `to` is the zero address. Throws if
/// `tokenId` is not a valid NFT. When transfer is complete, this function
/// checks if `to` is a smart contract (code size > 0). If so, it calls
/// `onERC721Received` on `to` and throws if the return value is not
/// `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
/// @param from The current owner of the NFT
/// @param to The new owner
/// @param tokenId The NFT to transfer
/// @param data Additional data with no specified format, sent in call to `to`
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public {
}
/// @notice Transfers the ownership of an NFT from one address to another address
/// @dev This works identically to the other function with an extra data parameter,
/// except this function just sets data to "".
/// @param from The current owner of the NFT
/// @param to The new owner
/// @param tokenId The NFT to transfer
function safeTransferFrom(address from, address to, uint256 tokenId) public {
}
/// @notice Change or reaffirm the approved address for an NFT
/// @dev The zero address indicates there is no approved address.
/// Throws unless `msg.sender` is the current NFT owner, or an authorized
/// operator of the current owner.
/// @param approved The new approved NFT controller
/// @param tokenId The NFT to approve
function approve(address approved, uint256 tokenId) public {
}
/// @notice Enable or disable approval for a third party ("operator") to manage
/// all of `msg.sender`'s assets
/// @dev Emits the ApprovalForAll event. The contract MUST allow
/// multiple operators per owner.
/// @param operator Address to add to the set of authorized operators
/// @param approved True if the operator is approved, false to revoke approval
function setApprovalForAll(address operator, bool approved) external {
}
/// @notice Get the approved address for a single NFT
/// @dev Throws if `tokenId` is not a valid NFT.
/// @param tokenId The NFT to find the approved address for
/// @return The approved address for this NFT, or the zero address if there is none
function getApproved(uint256 tokenId) external view returns (address) {
}
/// @notice Query if an address is an authorized operator for another address
/// @param owner The address that owns the NFTs
/// @param operator The address that acts on behalf of the owner
/// @return True if `operator` is an approved operator for `owner`, false otherwise
function isApprovedForAll(address owner, address operator) public view returns (bool) {
}
/// ================ UTILS =========================
function isApproved(address operator, uint tokenId) public view returns (bool) {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function transfer(address from, address to, uint256 tokenId) internal {
}
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data)
private returns (bool)
{
}
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external pure returns (bool) {
}
/// ================= ERC721Metadata FUNCTIONS =============================================
/// @notice A descriptive name for a collection of NFTs in this contract
function name() external view returns (string memory) {
}
/// @notice An abbreviated name for NFTs in this contract
function symbol() external view returns (string memory) {
}
/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
/// @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC
/// 3986. The URI may point to a JSON file that conforms to the "ERC721
/// Metadata JSON Schema".
function tokenURI(uint256 _tokenId) external view returns (string memory) {
}
/// ================= ERC721Enumerable FUNCTIONS =============================================
/// @notice Count NFTs tracked by this contract
/// @return A count of valid NFTs tracked by this contract, where each one of
/// them has an assigned and queryable owner not equal to the zero address
function totalSupply() external view returns (uint256) {
}
/// @notice Enumerate valid NFTs
/// @dev Throws if `_index` >= `totalSupply()`.
/// @param _index A counter less than `totalSupply()`
/// @return The token identifier for the `_index`th NFT,
/// (sort order not specified)
function tokenByIndex(uint256 _index) external view returns (uint256) {
}
/// @notice Enumerate NFTs assigned to an owner
/// @dev Throws if `_index` >= `balanceOf(_owner)` or if
/// `_owner` is the zero address, representing invalid NFTs.
/// @param _owner An address where we are interested in NFTs owned by them
/// @param _index A counter less than `balanceOf(_owner)`
/// @return The token identifier for the `_index`th NFT assigned to `_owner`,
/// (sort order not specified)
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256) {
}
}
| isApproved(msg.sender,tokenId),'Identity: Unapproved transfer' | 367,719 | isApproved(msg.sender,tokenId) |
"Identity: transfer to non ERC721Receiver implementer" | // SPDX-License-Identifier: GPL-3.0-only
pragma solidity 0.7.4;
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
library SafeMathLib {
function times(uint a, uint b) public pure returns (uint) {
}
function minus(uint a, uint b) public pure returns (uint) {
}
function plus(uint a, uint b) public pure returns (uint) {
}
}
// ERC 721
contract VotingIdentity {
using SafeMathLib for uint;
mapping (uint => address) public owners;
mapping (address => uint) public balances;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) public operatorApprovals;
mapping (uint => address) public tokenApprovals;
mapping (address => mapping (uint => uint)) public ownershipMap;
mapping (uint => string) public uriMap;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant ERC721_RECEIVED = 0x150b7a02;
/*
* bytes4(keccak256('balanceOf(address)')) == 0x70a08231
* bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
* bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
* bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
* bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
* bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
* bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
* bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
* bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
*
* => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
* 0xa22cb465 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
*/
bytes4 private constant INTERFACE_ID_ERC721 = 0x80ac58cd;
/*
* bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
*/
bytes4 private constant INTERFACE_ID_ERC165 = 0x01ffc9a7;
string constant _name = 'London Elects 2021';
string constant _symbol = 'LDN';
uint public numIdentities = 0;
address public management;
event ManagementUpdated(address oldManagement, address newManagement);
event IdentityCreated(address indexed owner, uint indexed token);
/// @dev This emits when ownership of any NFT changes by any mechanism.
/// This event emits when NFTs are created (`from` == 0) and destroyed
/// (`to` == 0). Exception: during contract creation, any number of NFTs
/// may be created and assigned without emitting Transfer. At the time of
/// any transfer, the approved address for that NFT (if any) is reset to none.
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/// @dev This emits when the approved address for an NFT is changed or
/// reaffirmed. The zero address indicates there is no approved address.
/// When a Transfer event emits, this also indicates that the approved
/// address for that NFT (if any) is reset to none.
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/// @dev This emits when an operator is enabled or disabled for an owner.
/// The operator can manage all NFTs of the owner.
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
modifier managementOnly() {
}
constructor(address mgmt) {
}
// this function creates an identity for free. Only management can call it.
function createIdentityFor(address newId) public managementOnly {
}
function createIdentity(address owner) internal {
}
/// ================= SETTERS =======================================
// change the management key
function setManagement(address newMgmt) external managementOnly {
}
function setTokenUri(uint tokenId, string memory uri) external managementOnly {
}
/// ================= ERC 721 FUNCTIONS =============================================
/// @notice Count all NFTs assigned to an owner
/// @dev NFTs assigned to the zero address are considered invalid, and this
/// function throws for queries about the zero address.
/// @param owner An address for whom to query the balance
/// @return The number of NFTs owned by `owner`, possibly zero
function balanceOf(address owner) external view returns (uint256) {
}
/// @notice Find the owner of an NFT
/// @dev NFTs assigned to zero address are considered invalid, and queries
/// about them do throw.
/// @param tokenId The identifier for an NFT
/// @return The address of the owner of the NFT
function ownerOf(uint256 tokenId) external view returns (address) {
}
/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
/// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE
/// THEY MAY BE PERMANENTLY LOST
/// @dev Throws unless `msg.sender` is the current owner, an authorized
/// operator, or the approved address for this NFT. Throws if `from` is
/// not the current owner. Throws if `to` is the zero address. Throws if
/// `tokenId` is not a valid NFT.
/// @param from The current owner of the NFT
/// @param to The new owner
/// @param tokenId The NFT to transfer
function transferFrom(address from, address to, uint256 tokenId) public {
}
/// @notice Transfers the ownership of an NFT from one address to another address
/// @dev Throws unless `msg.sender` is the current owner, an authorized
/// operator, or the approved address for this NFT. Throws if `from` is
/// not the current owner. Throws if `to` is the zero address. Throws if
/// `tokenId` is not a valid NFT. When transfer is complete, this function
/// checks if `to` is a smart contract (code size > 0). If so, it calls
/// `onERC721Received` on `to` and throws if the return value is not
/// `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
/// @param from The current owner of the NFT
/// @param to The new owner
/// @param tokenId The NFT to transfer
/// @param data Additional data with no specified format, sent in call to `to`
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public {
transferFrom(from, to, tokenId);
require(<FILL_ME>)
}
/// @notice Transfers the ownership of an NFT from one address to another address
/// @dev This works identically to the other function with an extra data parameter,
/// except this function just sets data to "".
/// @param from The current owner of the NFT
/// @param to The new owner
/// @param tokenId The NFT to transfer
function safeTransferFrom(address from, address to, uint256 tokenId) public {
}
/// @notice Change or reaffirm the approved address for an NFT
/// @dev The zero address indicates there is no approved address.
/// Throws unless `msg.sender` is the current NFT owner, or an authorized
/// operator of the current owner.
/// @param approved The new approved NFT controller
/// @param tokenId The NFT to approve
function approve(address approved, uint256 tokenId) public {
}
/// @notice Enable or disable approval for a third party ("operator") to manage
/// all of `msg.sender`'s assets
/// @dev Emits the ApprovalForAll event. The contract MUST allow
/// multiple operators per owner.
/// @param operator Address to add to the set of authorized operators
/// @param approved True if the operator is approved, false to revoke approval
function setApprovalForAll(address operator, bool approved) external {
}
/// @notice Get the approved address for a single NFT
/// @dev Throws if `tokenId` is not a valid NFT.
/// @param tokenId The NFT to find the approved address for
/// @return The approved address for this NFT, or the zero address if there is none
function getApproved(uint256 tokenId) external view returns (address) {
}
/// @notice Query if an address is an authorized operator for another address
/// @param owner The address that owns the NFTs
/// @param operator The address that acts on behalf of the owner
/// @return True if `operator` is an approved operator for `owner`, false otherwise
function isApprovedForAll(address owner, address operator) public view returns (bool) {
}
/// ================ UTILS =========================
function isApproved(address operator, uint tokenId) public view returns (bool) {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function transfer(address from, address to, uint256 tokenId) internal {
}
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data)
private returns (bool)
{
}
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external pure returns (bool) {
}
/// ================= ERC721Metadata FUNCTIONS =============================================
/// @notice A descriptive name for a collection of NFTs in this contract
function name() external view returns (string memory) {
}
/// @notice An abbreviated name for NFTs in this contract
function symbol() external view returns (string memory) {
}
/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
/// @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC
/// 3986. The URI may point to a JSON file that conforms to the "ERC721
/// Metadata JSON Schema".
function tokenURI(uint256 _tokenId) external view returns (string memory) {
}
/// ================= ERC721Enumerable FUNCTIONS =============================================
/// @notice Count NFTs tracked by this contract
/// @return A count of valid NFTs tracked by this contract, where each one of
/// them has an assigned and queryable owner not equal to the zero address
function totalSupply() external view returns (uint256) {
}
/// @notice Enumerate valid NFTs
/// @dev Throws if `_index` >= `totalSupply()`.
/// @param _index A counter less than `totalSupply()`
/// @return The token identifier for the `_index`th NFT,
/// (sort order not specified)
function tokenByIndex(uint256 _index) external view returns (uint256) {
}
/// @notice Enumerate NFTs assigned to an owner
/// @dev Throws if `_index` >= `balanceOf(_owner)` or if
/// `_owner` is the zero address, representing invalid NFTs.
/// @param _owner An address where we are interested in NFTs owned by them
/// @param _index A counter less than `balanceOf(_owner)`
/// @return The token identifier for the `_index`th NFT assigned to `_owner`,
/// (sort order not specified)
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256) {
}
}
| checkOnERC721Received(from,to,tokenId,data),"Identity: transfer to non ERC721Receiver implementer" | 367,719 | checkOnERC721Received(from,to,tokenId,data) |
"Identity: Transfer of token that is not own" | // SPDX-License-Identifier: GPL-3.0-only
pragma solidity 0.7.4;
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
*/
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
library SafeMathLib {
function times(uint a, uint b) public pure returns (uint) {
}
function minus(uint a, uint b) public pure returns (uint) {
}
function plus(uint a, uint b) public pure returns (uint) {
}
}
// ERC 721
contract VotingIdentity {
using SafeMathLib for uint;
mapping (uint => address) public owners;
mapping (address => uint) public balances;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) public operatorApprovals;
mapping (uint => address) public tokenApprovals;
mapping (address => mapping (uint => uint)) public ownershipMap;
mapping (uint => string) public uriMap;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant ERC721_RECEIVED = 0x150b7a02;
/*
* bytes4(keccak256('balanceOf(address)')) == 0x70a08231
* bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
* bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
* bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
* bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
* bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
* bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
* bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
* bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
*
* => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
* 0xa22cb465 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
*/
bytes4 private constant INTERFACE_ID_ERC721 = 0x80ac58cd;
/*
* bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
*/
bytes4 private constant INTERFACE_ID_ERC165 = 0x01ffc9a7;
string constant _name = 'London Elects 2021';
string constant _symbol = 'LDN';
uint public numIdentities = 0;
address public management;
event ManagementUpdated(address oldManagement, address newManagement);
event IdentityCreated(address indexed owner, uint indexed token);
/// @dev This emits when ownership of any NFT changes by any mechanism.
/// This event emits when NFTs are created (`from` == 0) and destroyed
/// (`to` == 0). Exception: during contract creation, any number of NFTs
/// may be created and assigned without emitting Transfer. At the time of
/// any transfer, the approved address for that NFT (if any) is reset to none.
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/// @dev This emits when the approved address for an NFT is changed or
/// reaffirmed. The zero address indicates there is no approved address.
/// When a Transfer event emits, this also indicates that the approved
/// address for that NFT (if any) is reset to none.
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/// @dev This emits when an operator is enabled or disabled for an owner.
/// The operator can manage all NFTs of the owner.
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
modifier managementOnly() {
}
constructor(address mgmt) {
}
// this function creates an identity for free. Only management can call it.
function createIdentityFor(address newId) public managementOnly {
}
function createIdentity(address owner) internal {
}
/// ================= SETTERS =======================================
// change the management key
function setManagement(address newMgmt) external managementOnly {
}
function setTokenUri(uint tokenId, string memory uri) external managementOnly {
}
/// ================= ERC 721 FUNCTIONS =============================================
/// @notice Count all NFTs assigned to an owner
/// @dev NFTs assigned to the zero address are considered invalid, and this
/// function throws for queries about the zero address.
/// @param owner An address for whom to query the balance
/// @return The number of NFTs owned by `owner`, possibly zero
function balanceOf(address owner) external view returns (uint256) {
}
/// @notice Find the owner of an NFT
/// @dev NFTs assigned to zero address are considered invalid, and queries
/// about them do throw.
/// @param tokenId The identifier for an NFT
/// @return The address of the owner of the NFT
function ownerOf(uint256 tokenId) external view returns (address) {
}
/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
/// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE
/// THEY MAY BE PERMANENTLY LOST
/// @dev Throws unless `msg.sender` is the current owner, an authorized
/// operator, or the approved address for this NFT. Throws if `from` is
/// not the current owner. Throws if `to` is the zero address. Throws if
/// `tokenId` is not a valid NFT.
/// @param from The current owner of the NFT
/// @param to The new owner
/// @param tokenId The NFT to transfer
function transferFrom(address from, address to, uint256 tokenId) public {
}
/// @notice Transfers the ownership of an NFT from one address to another address
/// @dev Throws unless `msg.sender` is the current owner, an authorized
/// operator, or the approved address for this NFT. Throws if `from` is
/// not the current owner. Throws if `to` is the zero address. Throws if
/// `tokenId` is not a valid NFT. When transfer is complete, this function
/// checks if `to` is a smart contract (code size > 0). If so, it calls
/// `onERC721Received` on `to` and throws if the return value is not
/// `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
/// @param from The current owner of the NFT
/// @param to The new owner
/// @param tokenId The NFT to transfer
/// @param data Additional data with no specified format, sent in call to `to`
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public {
}
/// @notice Transfers the ownership of an NFT from one address to another address
/// @dev This works identically to the other function with an extra data parameter,
/// except this function just sets data to "".
/// @param from The current owner of the NFT
/// @param to The new owner
/// @param tokenId The NFT to transfer
function safeTransferFrom(address from, address to, uint256 tokenId) public {
}
/// @notice Change or reaffirm the approved address for an NFT
/// @dev The zero address indicates there is no approved address.
/// Throws unless `msg.sender` is the current NFT owner, or an authorized
/// operator of the current owner.
/// @param approved The new approved NFT controller
/// @param tokenId The NFT to approve
function approve(address approved, uint256 tokenId) public {
}
/// @notice Enable or disable approval for a third party ("operator") to manage
/// all of `msg.sender`'s assets
/// @dev Emits the ApprovalForAll event. The contract MUST allow
/// multiple operators per owner.
/// @param operator Address to add to the set of authorized operators
/// @param approved True if the operator is approved, false to revoke approval
function setApprovalForAll(address operator, bool approved) external {
}
/// @notice Get the approved address for a single NFT
/// @dev Throws if `tokenId` is not a valid NFT.
/// @param tokenId The NFT to find the approved address for
/// @return The approved address for this NFT, or the zero address if there is none
function getApproved(uint256 tokenId) external view returns (address) {
}
/// @notice Query if an address is an authorized operator for another address
/// @param owner The address that owns the NFTs
/// @param operator The address that acts on behalf of the owner
/// @return True if `operator` is an approved operator for `owner`, false otherwise
function isApprovedForAll(address owner, address operator) public view returns (bool) {
}
/// ================ UTILS =========================
function isApproved(address operator, uint tokenId) public view returns (bool) {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function transfer(address from, address to, uint256 tokenId) internal {
require(<FILL_ME>)
require(to != address(0), "Identity: transfer to the zero address");
// Clear approvals from the previous owner
approve(address(0), tokenId);
owners[tokenId] = to;
// decrement from balances n -> n-1
balances[from] = balances[from].minus(1);
// balances[from] now points to the tip of the "array", set it to 0
ownershipMap[from][balances[from]] = 0;
// balances[to] points past the tip of the array, set it to the token
ownershipMap[to][balances[to]] = tokenId;
// increment balances[to] to point past the end of the array n-1 -> n
balances[to] = balances[to].plus(1);
emit Transfer(from, to, tokenId);
}
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data)
private returns (bool)
{
}
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external pure returns (bool) {
}
/// ================= ERC721Metadata FUNCTIONS =============================================
/// @notice A descriptive name for a collection of NFTs in this contract
function name() external view returns (string memory) {
}
/// @notice An abbreviated name for NFTs in this contract
function symbol() external view returns (string memory) {
}
/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
/// @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC
/// 3986. The URI may point to a JSON file that conforms to the "ERC721
/// Metadata JSON Schema".
function tokenURI(uint256 _tokenId) external view returns (string memory) {
}
/// ================= ERC721Enumerable FUNCTIONS =============================================
/// @notice Count NFTs tracked by this contract
/// @return A count of valid NFTs tracked by this contract, where each one of
/// them has an assigned and queryable owner not equal to the zero address
function totalSupply() external view returns (uint256) {
}
/// @notice Enumerate valid NFTs
/// @dev Throws if `_index` >= `totalSupply()`.
/// @param _index A counter less than `totalSupply()`
/// @return The token identifier for the `_index`th NFT,
/// (sort order not specified)
function tokenByIndex(uint256 _index) external view returns (uint256) {
}
/// @notice Enumerate NFTs assigned to an owner
/// @dev Throws if `_index` >= `balanceOf(_owner)` or if
/// `_owner` is the zero address, representing invalid NFTs.
/// @param _owner An address where we are interested in NFTs owned by them
/// @param _index A counter less than `balanceOf(_owner)`
/// @return The token identifier for the `_index`th NFT assigned to `_owner`,
/// (sort order not specified)
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256) {
}
}
| owners[tokenId]==from,"Identity: Transfer of token that is not own" | 367,719 | owners[tokenId]==from |
"Couldn't take the DAI from the sender" | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.4;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () {
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IPriceConsumerV3DaiWei {
function getLatestPrice() external view returns (int);
}
interface IUniswapV2Router02 {
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function WETH() external returns (address);
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract NexenPlatform is Ownable {
using SafeMath for uint256;
enum RequestState {None, LenderCreated, BorrowerCreated, Cancelled, Matched, Closed, Expired, Disabled}
IERC20 nexenToken;
IERC20 daiToken = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
IPriceConsumerV3DaiWei priceConsumer;
IUniswapV2Router02 uniswapRouter;
bool public paused = false;
bool public genesisPhase = true;
uint256 public amountToReward = 1000 * 10 ** 18;
uint public lenderFee = 1; //1%
uint public borrowerFee = 1; //1%
mapping(address => uint256) public depositedDAIByAddress;
mapping(address => uint256) public depositedWEIByAddress;
struct Request {
// Internal fields
RequestState state;
address payable borrower;
address payable lender;
// Fields for both parties
uint256 daiAmount;
uint256 durationInDays;
uint256 expireIfNotMatchedOn;
// Fields for borrower
uint256 ltv;
uint256 weiAmount;
uint256 daiVsWeiCurrentPrice;
// Fields after matching
uint256 lendingFinishesOn;
}
event OpenRequest(uint256 requestId, address indexed borrower, address indexed lender, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv, uint256 weiAmount, uint256 ethVsDaiCurrentPrice, uint256 lendingFinishesOn, RequestState state);
event UpdateRequest(uint256 requestId, address indexed borrower, address indexed lender, RequestState state);
event CollateralSold(uint256 requestId, uint256 totalCollateral, uint256 totalSold, uint256 totalDAIBought);
uint256 public daiFees;
uint256 public ethFees;
mapping (uint256 => Request) public requests;
receive() external payable {
}
constructor(IERC20 _nexenToken, IPriceConsumerV3DaiWei _priceConsumer, IUniswapV2Router02 _uniswapRouter) {
}
//Calculates the amount of WEI that is needed as a collateral for this amount of DAI and the chosen LTV
function calculateWeiAmount(uint256 _daiAmount, uint256 _ltv, uint256 _daiVsWeiCurrentPrice) public pure returns (uint256) {
}
function depositETH() public payable {
}
function depositDAI(uint256 _amount) public {
require(<FILL_ME>)
depositedDAIByAddress[msg.sender] += _amount;
}
function _setGenesisPhase(bool _genesisPhase, uint256 _amountToReward) public onlyOwner {
}
function _setPaused(bool _paused) public onlyOwner {
}
function calculateCollateral(uint256 daiAmount, uint256 ltv) public view returns (uint256) {
}
function createRequest(bool lend, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv) public {
}
function matchRequestAsLender(uint256 requestId) public {
}
function getLatestDaiVsWeiPrice() public view returns (uint256) {
}
function matchRequestAsBorrower(uint256 requestId, uint256 ltv) public {
}
function cancelRequest(uint256 requestId) public {
}
function finishRequest(uint256 _requestId) public {
}
function canBurnCollateral(uint256 requestId, uint256 daiVsWeiCurrentPrice) public view returns (bool) {
}
function expireNonFullfiledRequest(uint256 _requestId) public {
}
function _expireRequest(uint256 _requestId) public onlyOwner {
}
function burnCollateral(uint256 _requestId, Request storage r) internal {
}
function sellCollateralInUniswap(uint256 daiToTransfer, uint256 weiAmount) internal returns (uint256[] memory) {
}
function getInterest(uint256 _ltv, uint256 _daiAmount) public pure returns (uint256) {
}
function _withdrawDaiFees(uint256 _amount) public onlyOwner {
}
function _withdrawEthFees(uint256 _amount) public onlyOwner {
}
function withdrawDai(uint256 _amount) public {
}
function withdrawEth(uint256 _amount) public {
}
function computeLenderFee(uint256 _value) public view returns (uint256) {
}
function computeBorrowerFee(uint256 _value) public view returns (uint256) {
}
function getExpirationAfter(uint256 amountOfDays) public view returns (uint256) {
}
function requestInfo(uint256 requestId) public view returns (uint256 _tradeId, RequestState _state, address _borrower, address _lender, uint256 _daiAmount, uint256 _durationInDays, uint256 _expireIfNotMatchedOn, uint256 _ltv, uint256 _weiAmount, uint256 _daiVsWeiCurrentPrice, uint256 _lendingFinishesOn) {
}
}
| IERC20(daiToken).transferFrom(msg.sender,address(this),_amount),"Couldn't take the DAI from the sender" | 367,747 | IERC20(daiToken).transferFrom(msg.sender,address(this),_amount) |
"Not enough DAI deposited" | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.4;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () {
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IPriceConsumerV3DaiWei {
function getLatestPrice() external view returns (int);
}
interface IUniswapV2Router02 {
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function WETH() external returns (address);
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract NexenPlatform is Ownable {
using SafeMath for uint256;
enum RequestState {None, LenderCreated, BorrowerCreated, Cancelled, Matched, Closed, Expired, Disabled}
IERC20 nexenToken;
IERC20 daiToken = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
IPriceConsumerV3DaiWei priceConsumer;
IUniswapV2Router02 uniswapRouter;
bool public paused = false;
bool public genesisPhase = true;
uint256 public amountToReward = 1000 * 10 ** 18;
uint public lenderFee = 1; //1%
uint public borrowerFee = 1; //1%
mapping(address => uint256) public depositedDAIByAddress;
mapping(address => uint256) public depositedWEIByAddress;
struct Request {
// Internal fields
RequestState state;
address payable borrower;
address payable lender;
// Fields for both parties
uint256 daiAmount;
uint256 durationInDays;
uint256 expireIfNotMatchedOn;
// Fields for borrower
uint256 ltv;
uint256 weiAmount;
uint256 daiVsWeiCurrentPrice;
// Fields after matching
uint256 lendingFinishesOn;
}
event OpenRequest(uint256 requestId, address indexed borrower, address indexed lender, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv, uint256 weiAmount, uint256 ethVsDaiCurrentPrice, uint256 lendingFinishesOn, RequestState state);
event UpdateRequest(uint256 requestId, address indexed borrower, address indexed lender, RequestState state);
event CollateralSold(uint256 requestId, uint256 totalCollateral, uint256 totalSold, uint256 totalDAIBought);
uint256 public daiFees;
uint256 public ethFees;
mapping (uint256 => Request) public requests;
receive() external payable {
}
constructor(IERC20 _nexenToken, IPriceConsumerV3DaiWei _priceConsumer, IUniswapV2Router02 _uniswapRouter) {
}
//Calculates the amount of WEI that is needed as a collateral for this amount of DAI and the chosen LTV
function calculateWeiAmount(uint256 _daiAmount, uint256 _ltv, uint256 _daiVsWeiCurrentPrice) public pure returns (uint256) {
}
function depositETH() public payable {
}
function depositDAI(uint256 _amount) public {
}
function _setGenesisPhase(bool _genesisPhase, uint256 _amountToReward) public onlyOwner {
}
function _setPaused(bool _paused) public onlyOwner {
}
function calculateCollateral(uint256 daiAmount, uint256 ltv) public view returns (uint256) {
}
function createRequest(bool lend, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv) public {
require(daiAmount >= 100 * 10 ** 18, "Minimum amount is 100 DAI");
require(expireIfNotMatchedOn > block.timestamp, "Invalid expiration date");
require(!paused, "The contract is paused");
Request memory r;
(r.daiAmount, r.durationInDays, r.expireIfNotMatchedOn) = (daiAmount, durationInDays, expireIfNotMatchedOn);
if (lend) {
r.lender = msg.sender;
r.state = RequestState.LenderCreated;
require(<FILL_ME>)
depositedDAIByAddress[msg.sender] -= r.daiAmount;
} else {
require(ltv == 20 || ltv == 40 || ltv == 60, 'Invalid ltv');
r.borrower = msg.sender;
r.state = RequestState.BorrowerCreated;
r.ltv = ltv;
r.daiVsWeiCurrentPrice = uint256(priceConsumer.getLatestPrice());
r.weiAmount = calculateWeiAmount(daiAmount, ltv, r.daiVsWeiCurrentPrice);
require(depositedWEIByAddress[msg.sender] > r.weiAmount, "Not enough ETH deposited");
depositedWEIByAddress[msg.sender] -= r.weiAmount;
}
uint256 requestId = uint256(keccak256(abi.encodePacked(r.borrower, r.lender, r.daiAmount, r.durationInDays, r.expireIfNotMatchedOn, r.ltv)));
require(requests[requestId].state == RequestState.None, 'Request already exists');
requests[requestId] = r;
emit OpenRequest(requestId, r.borrower, r.lender, r.daiAmount, r.durationInDays, r.expireIfNotMatchedOn, r.ltv, r.weiAmount, r.daiVsWeiCurrentPrice, r.lendingFinishesOn, r.state);
}
function matchRequestAsLender(uint256 requestId) public {
}
function getLatestDaiVsWeiPrice() public view returns (uint256) {
}
function matchRequestAsBorrower(uint256 requestId, uint256 ltv) public {
}
function cancelRequest(uint256 requestId) public {
}
function finishRequest(uint256 _requestId) public {
}
function canBurnCollateral(uint256 requestId, uint256 daiVsWeiCurrentPrice) public view returns (bool) {
}
function expireNonFullfiledRequest(uint256 _requestId) public {
}
function _expireRequest(uint256 _requestId) public onlyOwner {
}
function burnCollateral(uint256 _requestId, Request storage r) internal {
}
function sellCollateralInUniswap(uint256 daiToTransfer, uint256 weiAmount) internal returns (uint256[] memory) {
}
function getInterest(uint256 _ltv, uint256 _daiAmount) public pure returns (uint256) {
}
function _withdrawDaiFees(uint256 _amount) public onlyOwner {
}
function _withdrawEthFees(uint256 _amount) public onlyOwner {
}
function withdrawDai(uint256 _amount) public {
}
function withdrawEth(uint256 _amount) public {
}
function computeLenderFee(uint256 _value) public view returns (uint256) {
}
function computeBorrowerFee(uint256 _value) public view returns (uint256) {
}
function getExpirationAfter(uint256 amountOfDays) public view returns (uint256) {
}
function requestInfo(uint256 requestId) public view returns (uint256 _tradeId, RequestState _state, address _borrower, address _lender, uint256 _daiAmount, uint256 _durationInDays, uint256 _expireIfNotMatchedOn, uint256 _ltv, uint256 _weiAmount, uint256 _daiVsWeiCurrentPrice, uint256 _lendingFinishesOn) {
}
}
| depositedDAIByAddress[msg.sender]>=r.daiAmount,"Not enough DAI deposited" | 367,747 | depositedDAIByAddress[msg.sender]>=r.daiAmount |
"Not enough ETH deposited" | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.4;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () {
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IPriceConsumerV3DaiWei {
function getLatestPrice() external view returns (int);
}
interface IUniswapV2Router02 {
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function WETH() external returns (address);
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract NexenPlatform is Ownable {
using SafeMath for uint256;
enum RequestState {None, LenderCreated, BorrowerCreated, Cancelled, Matched, Closed, Expired, Disabled}
IERC20 nexenToken;
IERC20 daiToken = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
IPriceConsumerV3DaiWei priceConsumer;
IUniswapV2Router02 uniswapRouter;
bool public paused = false;
bool public genesisPhase = true;
uint256 public amountToReward = 1000 * 10 ** 18;
uint public lenderFee = 1; //1%
uint public borrowerFee = 1; //1%
mapping(address => uint256) public depositedDAIByAddress;
mapping(address => uint256) public depositedWEIByAddress;
struct Request {
// Internal fields
RequestState state;
address payable borrower;
address payable lender;
// Fields for both parties
uint256 daiAmount;
uint256 durationInDays;
uint256 expireIfNotMatchedOn;
// Fields for borrower
uint256 ltv;
uint256 weiAmount;
uint256 daiVsWeiCurrentPrice;
// Fields after matching
uint256 lendingFinishesOn;
}
event OpenRequest(uint256 requestId, address indexed borrower, address indexed lender, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv, uint256 weiAmount, uint256 ethVsDaiCurrentPrice, uint256 lendingFinishesOn, RequestState state);
event UpdateRequest(uint256 requestId, address indexed borrower, address indexed lender, RequestState state);
event CollateralSold(uint256 requestId, uint256 totalCollateral, uint256 totalSold, uint256 totalDAIBought);
uint256 public daiFees;
uint256 public ethFees;
mapping (uint256 => Request) public requests;
receive() external payable {
}
constructor(IERC20 _nexenToken, IPriceConsumerV3DaiWei _priceConsumer, IUniswapV2Router02 _uniswapRouter) {
}
//Calculates the amount of WEI that is needed as a collateral for this amount of DAI and the chosen LTV
function calculateWeiAmount(uint256 _daiAmount, uint256 _ltv, uint256 _daiVsWeiCurrentPrice) public pure returns (uint256) {
}
function depositETH() public payable {
}
function depositDAI(uint256 _amount) public {
}
function _setGenesisPhase(bool _genesisPhase, uint256 _amountToReward) public onlyOwner {
}
function _setPaused(bool _paused) public onlyOwner {
}
function calculateCollateral(uint256 daiAmount, uint256 ltv) public view returns (uint256) {
}
function createRequest(bool lend, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv) public {
require(daiAmount >= 100 * 10 ** 18, "Minimum amount is 100 DAI");
require(expireIfNotMatchedOn > block.timestamp, "Invalid expiration date");
require(!paused, "The contract is paused");
Request memory r;
(r.daiAmount, r.durationInDays, r.expireIfNotMatchedOn) = (daiAmount, durationInDays, expireIfNotMatchedOn);
if (lend) {
r.lender = msg.sender;
r.state = RequestState.LenderCreated;
require(depositedDAIByAddress[msg.sender] >= r.daiAmount, "Not enough DAI deposited");
depositedDAIByAddress[msg.sender] -= r.daiAmount;
} else {
require(ltv == 20 || ltv == 40 || ltv == 60, 'Invalid ltv');
r.borrower = msg.sender;
r.state = RequestState.BorrowerCreated;
r.ltv = ltv;
r.daiVsWeiCurrentPrice = uint256(priceConsumer.getLatestPrice());
r.weiAmount = calculateWeiAmount(daiAmount, ltv, r.daiVsWeiCurrentPrice);
require(<FILL_ME>)
depositedWEIByAddress[msg.sender] -= r.weiAmount;
}
uint256 requestId = uint256(keccak256(abi.encodePacked(r.borrower, r.lender, r.daiAmount, r.durationInDays, r.expireIfNotMatchedOn, r.ltv)));
require(requests[requestId].state == RequestState.None, 'Request already exists');
requests[requestId] = r;
emit OpenRequest(requestId, r.borrower, r.lender, r.daiAmount, r.durationInDays, r.expireIfNotMatchedOn, r.ltv, r.weiAmount, r.daiVsWeiCurrentPrice, r.lendingFinishesOn, r.state);
}
function matchRequestAsLender(uint256 requestId) public {
}
function getLatestDaiVsWeiPrice() public view returns (uint256) {
}
function matchRequestAsBorrower(uint256 requestId, uint256 ltv) public {
}
function cancelRequest(uint256 requestId) public {
}
function finishRequest(uint256 _requestId) public {
}
function canBurnCollateral(uint256 requestId, uint256 daiVsWeiCurrentPrice) public view returns (bool) {
}
function expireNonFullfiledRequest(uint256 _requestId) public {
}
function _expireRequest(uint256 _requestId) public onlyOwner {
}
function burnCollateral(uint256 _requestId, Request storage r) internal {
}
function sellCollateralInUniswap(uint256 daiToTransfer, uint256 weiAmount) internal returns (uint256[] memory) {
}
function getInterest(uint256 _ltv, uint256 _daiAmount) public pure returns (uint256) {
}
function _withdrawDaiFees(uint256 _amount) public onlyOwner {
}
function _withdrawEthFees(uint256 _amount) public onlyOwner {
}
function withdrawDai(uint256 _amount) public {
}
function withdrawEth(uint256 _amount) public {
}
function computeLenderFee(uint256 _value) public view returns (uint256) {
}
function computeBorrowerFee(uint256 _value) public view returns (uint256) {
}
function getExpirationAfter(uint256 amountOfDays) public view returns (uint256) {
}
function requestInfo(uint256 requestId) public view returns (uint256 _tradeId, RequestState _state, address _borrower, address _lender, uint256 _daiAmount, uint256 _durationInDays, uint256 _expireIfNotMatchedOn, uint256 _ltv, uint256 _weiAmount, uint256 _daiVsWeiCurrentPrice, uint256 _lendingFinishesOn) {
}
}
| depositedWEIByAddress[msg.sender]>r.weiAmount,"Not enough ETH deposited" | 367,747 | depositedWEIByAddress[msg.sender]>r.weiAmount |
'Request already exists' | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.4;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () {
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IPriceConsumerV3DaiWei {
function getLatestPrice() external view returns (int);
}
interface IUniswapV2Router02 {
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function WETH() external returns (address);
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract NexenPlatform is Ownable {
using SafeMath for uint256;
enum RequestState {None, LenderCreated, BorrowerCreated, Cancelled, Matched, Closed, Expired, Disabled}
IERC20 nexenToken;
IERC20 daiToken = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
IPriceConsumerV3DaiWei priceConsumer;
IUniswapV2Router02 uniswapRouter;
bool public paused = false;
bool public genesisPhase = true;
uint256 public amountToReward = 1000 * 10 ** 18;
uint public lenderFee = 1; //1%
uint public borrowerFee = 1; //1%
mapping(address => uint256) public depositedDAIByAddress;
mapping(address => uint256) public depositedWEIByAddress;
struct Request {
// Internal fields
RequestState state;
address payable borrower;
address payable lender;
// Fields for both parties
uint256 daiAmount;
uint256 durationInDays;
uint256 expireIfNotMatchedOn;
// Fields for borrower
uint256 ltv;
uint256 weiAmount;
uint256 daiVsWeiCurrentPrice;
// Fields after matching
uint256 lendingFinishesOn;
}
event OpenRequest(uint256 requestId, address indexed borrower, address indexed lender, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv, uint256 weiAmount, uint256 ethVsDaiCurrentPrice, uint256 lendingFinishesOn, RequestState state);
event UpdateRequest(uint256 requestId, address indexed borrower, address indexed lender, RequestState state);
event CollateralSold(uint256 requestId, uint256 totalCollateral, uint256 totalSold, uint256 totalDAIBought);
uint256 public daiFees;
uint256 public ethFees;
mapping (uint256 => Request) public requests;
receive() external payable {
}
constructor(IERC20 _nexenToken, IPriceConsumerV3DaiWei _priceConsumer, IUniswapV2Router02 _uniswapRouter) {
}
//Calculates the amount of WEI that is needed as a collateral for this amount of DAI and the chosen LTV
function calculateWeiAmount(uint256 _daiAmount, uint256 _ltv, uint256 _daiVsWeiCurrentPrice) public pure returns (uint256) {
}
function depositETH() public payable {
}
function depositDAI(uint256 _amount) public {
}
function _setGenesisPhase(bool _genesisPhase, uint256 _amountToReward) public onlyOwner {
}
function _setPaused(bool _paused) public onlyOwner {
}
function calculateCollateral(uint256 daiAmount, uint256 ltv) public view returns (uint256) {
}
function createRequest(bool lend, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv) public {
require(daiAmount >= 100 * 10 ** 18, "Minimum amount is 100 DAI");
require(expireIfNotMatchedOn > block.timestamp, "Invalid expiration date");
require(!paused, "The contract is paused");
Request memory r;
(r.daiAmount, r.durationInDays, r.expireIfNotMatchedOn) = (daiAmount, durationInDays, expireIfNotMatchedOn);
if (lend) {
r.lender = msg.sender;
r.state = RequestState.LenderCreated;
require(depositedDAIByAddress[msg.sender] >= r.daiAmount, "Not enough DAI deposited");
depositedDAIByAddress[msg.sender] -= r.daiAmount;
} else {
require(ltv == 20 || ltv == 40 || ltv == 60, 'Invalid ltv');
r.borrower = msg.sender;
r.state = RequestState.BorrowerCreated;
r.ltv = ltv;
r.daiVsWeiCurrentPrice = uint256(priceConsumer.getLatestPrice());
r.weiAmount = calculateWeiAmount(daiAmount, ltv, r.daiVsWeiCurrentPrice);
require(depositedWEIByAddress[msg.sender] > r.weiAmount, "Not enough ETH deposited");
depositedWEIByAddress[msg.sender] -= r.weiAmount;
}
uint256 requestId = uint256(keccak256(abi.encodePacked(r.borrower, r.lender, r.daiAmount, r.durationInDays, r.expireIfNotMatchedOn, r.ltv)));
require(<FILL_ME>)
requests[requestId] = r;
emit OpenRequest(requestId, r.borrower, r.lender, r.daiAmount, r.durationInDays, r.expireIfNotMatchedOn, r.ltv, r.weiAmount, r.daiVsWeiCurrentPrice, r.lendingFinishesOn, r.state);
}
function matchRequestAsLender(uint256 requestId) public {
}
function getLatestDaiVsWeiPrice() public view returns (uint256) {
}
function matchRequestAsBorrower(uint256 requestId, uint256 ltv) public {
}
function cancelRequest(uint256 requestId) public {
}
function finishRequest(uint256 _requestId) public {
}
function canBurnCollateral(uint256 requestId, uint256 daiVsWeiCurrentPrice) public view returns (bool) {
}
function expireNonFullfiledRequest(uint256 _requestId) public {
}
function _expireRequest(uint256 _requestId) public onlyOwner {
}
function burnCollateral(uint256 _requestId, Request storage r) internal {
}
function sellCollateralInUniswap(uint256 daiToTransfer, uint256 weiAmount) internal returns (uint256[] memory) {
}
function getInterest(uint256 _ltv, uint256 _daiAmount) public pure returns (uint256) {
}
function _withdrawDaiFees(uint256 _amount) public onlyOwner {
}
function _withdrawEthFees(uint256 _amount) public onlyOwner {
}
function withdrawDai(uint256 _amount) public {
}
function withdrawEth(uint256 _amount) public {
}
function computeLenderFee(uint256 _value) public view returns (uint256) {
}
function computeBorrowerFee(uint256 _value) public view returns (uint256) {
}
function getExpirationAfter(uint256 amountOfDays) public view returns (uint256) {
}
function requestInfo(uint256 requestId) public view returns (uint256 _tradeId, RequestState _state, address _borrower, address _lender, uint256 _daiAmount, uint256 _durationInDays, uint256 _expireIfNotMatchedOn, uint256 _ltv, uint256 _weiAmount, uint256 _daiVsWeiCurrentPrice, uint256 _lendingFinishesOn) {
}
}
| requests[requestId].state==RequestState.None,'Request already exists' | 367,747 | requests[requestId].state==RequestState.None |
'Could not transfer tokens' | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.4;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () {
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IPriceConsumerV3DaiWei {
function getLatestPrice() external view returns (int);
}
interface IUniswapV2Router02 {
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function WETH() external returns (address);
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract NexenPlatform is Ownable {
using SafeMath for uint256;
enum RequestState {None, LenderCreated, BorrowerCreated, Cancelled, Matched, Closed, Expired, Disabled}
IERC20 nexenToken;
IERC20 daiToken = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
IPriceConsumerV3DaiWei priceConsumer;
IUniswapV2Router02 uniswapRouter;
bool public paused = false;
bool public genesisPhase = true;
uint256 public amountToReward = 1000 * 10 ** 18;
uint public lenderFee = 1; //1%
uint public borrowerFee = 1; //1%
mapping(address => uint256) public depositedDAIByAddress;
mapping(address => uint256) public depositedWEIByAddress;
struct Request {
// Internal fields
RequestState state;
address payable borrower;
address payable lender;
// Fields for both parties
uint256 daiAmount;
uint256 durationInDays;
uint256 expireIfNotMatchedOn;
// Fields for borrower
uint256 ltv;
uint256 weiAmount;
uint256 daiVsWeiCurrentPrice;
// Fields after matching
uint256 lendingFinishesOn;
}
event OpenRequest(uint256 requestId, address indexed borrower, address indexed lender, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv, uint256 weiAmount, uint256 ethVsDaiCurrentPrice, uint256 lendingFinishesOn, RequestState state);
event UpdateRequest(uint256 requestId, address indexed borrower, address indexed lender, RequestState state);
event CollateralSold(uint256 requestId, uint256 totalCollateral, uint256 totalSold, uint256 totalDAIBought);
uint256 public daiFees;
uint256 public ethFees;
mapping (uint256 => Request) public requests;
receive() external payable {
}
constructor(IERC20 _nexenToken, IPriceConsumerV3DaiWei _priceConsumer, IUniswapV2Router02 _uniswapRouter) {
}
//Calculates the amount of WEI that is needed as a collateral for this amount of DAI and the chosen LTV
function calculateWeiAmount(uint256 _daiAmount, uint256 _ltv, uint256 _daiVsWeiCurrentPrice) public pure returns (uint256) {
}
function depositETH() public payable {
}
function depositDAI(uint256 _amount) public {
}
function _setGenesisPhase(bool _genesisPhase, uint256 _amountToReward) public onlyOwner {
}
function _setPaused(bool _paused) public onlyOwner {
}
function calculateCollateral(uint256 daiAmount, uint256 ltv) public view returns (uint256) {
}
function createRequest(bool lend, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv) public {
}
function matchRequestAsLender(uint256 requestId) public {
Request storage r = requests[requestId];
require(r.state == RequestState.BorrowerCreated, 'Invalid request');
require(r.expireIfNotMatchedOn > block.timestamp, 'Request expired');
r.lender = msg.sender;
r.lendingFinishesOn = getExpirationAfter(r.durationInDays);
r.state = RequestState.Matched;
require(depositedDAIByAddress[msg.sender] >= r.daiAmount, "Not enough DAI deposited");
depositedDAIByAddress[msg.sender] = depositedDAIByAddress[msg.sender].sub(r.daiAmount);
depositedDAIByAddress[r.borrower] = depositedDAIByAddress[r.borrower].add(r.daiAmount);
if (genesisPhase) {
require(<FILL_ME>)
require(nexenToken.transfer(r.borrower, amountToReward), 'Could not transfer tokens');
}
emit UpdateRequest(requestId, r.borrower, r.lender, r.state);
}
function getLatestDaiVsWeiPrice() public view returns (uint256) {
}
function matchRequestAsBorrower(uint256 requestId, uint256 ltv) public {
}
function cancelRequest(uint256 requestId) public {
}
function finishRequest(uint256 _requestId) public {
}
function canBurnCollateral(uint256 requestId, uint256 daiVsWeiCurrentPrice) public view returns (bool) {
}
function expireNonFullfiledRequest(uint256 _requestId) public {
}
function _expireRequest(uint256 _requestId) public onlyOwner {
}
function burnCollateral(uint256 _requestId, Request storage r) internal {
}
function sellCollateralInUniswap(uint256 daiToTransfer, uint256 weiAmount) internal returns (uint256[] memory) {
}
function getInterest(uint256 _ltv, uint256 _daiAmount) public pure returns (uint256) {
}
function _withdrawDaiFees(uint256 _amount) public onlyOwner {
}
function _withdrawEthFees(uint256 _amount) public onlyOwner {
}
function withdrawDai(uint256 _amount) public {
}
function withdrawEth(uint256 _amount) public {
}
function computeLenderFee(uint256 _value) public view returns (uint256) {
}
function computeBorrowerFee(uint256 _value) public view returns (uint256) {
}
function getExpirationAfter(uint256 amountOfDays) public view returns (uint256) {
}
function requestInfo(uint256 requestId) public view returns (uint256 _tradeId, RequestState _state, address _borrower, address _lender, uint256 _daiAmount, uint256 _durationInDays, uint256 _expireIfNotMatchedOn, uint256 _ltv, uint256 _weiAmount, uint256 _daiVsWeiCurrentPrice, uint256 _lendingFinishesOn) {
}
}
| nexenToken.transfer(msg.sender,amountToReward),'Could not transfer tokens' | 367,747 | nexenToken.transfer(msg.sender,amountToReward) |
'Could not transfer tokens' | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.4;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () {
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IPriceConsumerV3DaiWei {
function getLatestPrice() external view returns (int);
}
interface IUniswapV2Router02 {
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function WETH() external returns (address);
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract NexenPlatform is Ownable {
using SafeMath for uint256;
enum RequestState {None, LenderCreated, BorrowerCreated, Cancelled, Matched, Closed, Expired, Disabled}
IERC20 nexenToken;
IERC20 daiToken = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
IPriceConsumerV3DaiWei priceConsumer;
IUniswapV2Router02 uniswapRouter;
bool public paused = false;
bool public genesisPhase = true;
uint256 public amountToReward = 1000 * 10 ** 18;
uint public lenderFee = 1; //1%
uint public borrowerFee = 1; //1%
mapping(address => uint256) public depositedDAIByAddress;
mapping(address => uint256) public depositedWEIByAddress;
struct Request {
// Internal fields
RequestState state;
address payable borrower;
address payable lender;
// Fields for both parties
uint256 daiAmount;
uint256 durationInDays;
uint256 expireIfNotMatchedOn;
// Fields for borrower
uint256 ltv;
uint256 weiAmount;
uint256 daiVsWeiCurrentPrice;
// Fields after matching
uint256 lendingFinishesOn;
}
event OpenRequest(uint256 requestId, address indexed borrower, address indexed lender, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv, uint256 weiAmount, uint256 ethVsDaiCurrentPrice, uint256 lendingFinishesOn, RequestState state);
event UpdateRequest(uint256 requestId, address indexed borrower, address indexed lender, RequestState state);
event CollateralSold(uint256 requestId, uint256 totalCollateral, uint256 totalSold, uint256 totalDAIBought);
uint256 public daiFees;
uint256 public ethFees;
mapping (uint256 => Request) public requests;
receive() external payable {
}
constructor(IERC20 _nexenToken, IPriceConsumerV3DaiWei _priceConsumer, IUniswapV2Router02 _uniswapRouter) {
}
//Calculates the amount of WEI that is needed as a collateral for this amount of DAI and the chosen LTV
function calculateWeiAmount(uint256 _daiAmount, uint256 _ltv, uint256 _daiVsWeiCurrentPrice) public pure returns (uint256) {
}
function depositETH() public payable {
}
function depositDAI(uint256 _amount) public {
}
function _setGenesisPhase(bool _genesisPhase, uint256 _amountToReward) public onlyOwner {
}
function _setPaused(bool _paused) public onlyOwner {
}
function calculateCollateral(uint256 daiAmount, uint256 ltv) public view returns (uint256) {
}
function createRequest(bool lend, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv) public {
}
function matchRequestAsLender(uint256 requestId) public {
Request storage r = requests[requestId];
require(r.state == RequestState.BorrowerCreated, 'Invalid request');
require(r.expireIfNotMatchedOn > block.timestamp, 'Request expired');
r.lender = msg.sender;
r.lendingFinishesOn = getExpirationAfter(r.durationInDays);
r.state = RequestState.Matched;
require(depositedDAIByAddress[msg.sender] >= r.daiAmount, "Not enough DAI deposited");
depositedDAIByAddress[msg.sender] = depositedDAIByAddress[msg.sender].sub(r.daiAmount);
depositedDAIByAddress[r.borrower] = depositedDAIByAddress[r.borrower].add(r.daiAmount);
if (genesisPhase) {
require(nexenToken.transfer(msg.sender, amountToReward), 'Could not transfer tokens');
require(<FILL_ME>)
}
emit UpdateRequest(requestId, r.borrower, r.lender, r.state);
}
function getLatestDaiVsWeiPrice() public view returns (uint256) {
}
function matchRequestAsBorrower(uint256 requestId, uint256 ltv) public {
}
function cancelRequest(uint256 requestId) public {
}
function finishRequest(uint256 _requestId) public {
}
function canBurnCollateral(uint256 requestId, uint256 daiVsWeiCurrentPrice) public view returns (bool) {
}
function expireNonFullfiledRequest(uint256 _requestId) public {
}
function _expireRequest(uint256 _requestId) public onlyOwner {
}
function burnCollateral(uint256 _requestId, Request storage r) internal {
}
function sellCollateralInUniswap(uint256 daiToTransfer, uint256 weiAmount) internal returns (uint256[] memory) {
}
function getInterest(uint256 _ltv, uint256 _daiAmount) public pure returns (uint256) {
}
function _withdrawDaiFees(uint256 _amount) public onlyOwner {
}
function _withdrawEthFees(uint256 _amount) public onlyOwner {
}
function withdrawDai(uint256 _amount) public {
}
function withdrawEth(uint256 _amount) public {
}
function computeLenderFee(uint256 _value) public view returns (uint256) {
}
function computeBorrowerFee(uint256 _value) public view returns (uint256) {
}
function getExpirationAfter(uint256 amountOfDays) public view returns (uint256) {
}
function requestInfo(uint256 requestId) public view returns (uint256 _tradeId, RequestState _state, address _borrower, address _lender, uint256 _daiAmount, uint256 _durationInDays, uint256 _expireIfNotMatchedOn, uint256 _ltv, uint256 _weiAmount, uint256 _daiVsWeiCurrentPrice, uint256 _lendingFinishesOn) {
}
}
| nexenToken.transfer(r.borrower,amountToReward),'Could not transfer tokens' | 367,747 | nexenToken.transfer(r.borrower,amountToReward) |
'Could not transfer tokens' | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.4;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () {
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IPriceConsumerV3DaiWei {
function getLatestPrice() external view returns (int);
}
interface IUniswapV2Router02 {
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function WETH() external returns (address);
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract NexenPlatform is Ownable {
using SafeMath for uint256;
enum RequestState {None, LenderCreated, BorrowerCreated, Cancelled, Matched, Closed, Expired, Disabled}
IERC20 nexenToken;
IERC20 daiToken = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
IPriceConsumerV3DaiWei priceConsumer;
IUniswapV2Router02 uniswapRouter;
bool public paused = false;
bool public genesisPhase = true;
uint256 public amountToReward = 1000 * 10 ** 18;
uint public lenderFee = 1; //1%
uint public borrowerFee = 1; //1%
mapping(address => uint256) public depositedDAIByAddress;
mapping(address => uint256) public depositedWEIByAddress;
struct Request {
// Internal fields
RequestState state;
address payable borrower;
address payable lender;
// Fields for both parties
uint256 daiAmount;
uint256 durationInDays;
uint256 expireIfNotMatchedOn;
// Fields for borrower
uint256 ltv;
uint256 weiAmount;
uint256 daiVsWeiCurrentPrice;
// Fields after matching
uint256 lendingFinishesOn;
}
event OpenRequest(uint256 requestId, address indexed borrower, address indexed lender, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv, uint256 weiAmount, uint256 ethVsDaiCurrentPrice, uint256 lendingFinishesOn, RequestState state);
event UpdateRequest(uint256 requestId, address indexed borrower, address indexed lender, RequestState state);
event CollateralSold(uint256 requestId, uint256 totalCollateral, uint256 totalSold, uint256 totalDAIBought);
uint256 public daiFees;
uint256 public ethFees;
mapping (uint256 => Request) public requests;
receive() external payable {
}
constructor(IERC20 _nexenToken, IPriceConsumerV3DaiWei _priceConsumer, IUniswapV2Router02 _uniswapRouter) {
}
//Calculates the amount of WEI that is needed as a collateral for this amount of DAI and the chosen LTV
function calculateWeiAmount(uint256 _daiAmount, uint256 _ltv, uint256 _daiVsWeiCurrentPrice) public pure returns (uint256) {
}
function depositETH() public payable {
}
function depositDAI(uint256 _amount) public {
}
function _setGenesisPhase(bool _genesisPhase, uint256 _amountToReward) public onlyOwner {
}
function _setPaused(bool _paused) public onlyOwner {
}
function calculateCollateral(uint256 daiAmount, uint256 ltv) public view returns (uint256) {
}
function createRequest(bool lend, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv) public {
}
function matchRequestAsLender(uint256 requestId) public {
}
function getLatestDaiVsWeiPrice() public view returns (uint256) {
}
function matchRequestAsBorrower(uint256 requestId, uint256 ltv) public {
Request storage r = requests[requestId];
require(r.state == RequestState.LenderCreated, 'Invalid request');
require(r.expireIfNotMatchedOn > block.timestamp, 'Request expired');
r.borrower = msg.sender;
r.lendingFinishesOn = getExpirationAfter(r.durationInDays);
r.state = RequestState.Matched;
r.ltv = ltv;
r.daiVsWeiCurrentPrice = uint256(priceConsumer.getLatestPrice());
r.weiAmount = calculateWeiAmount(r.daiAmount, r.ltv, r.daiVsWeiCurrentPrice);
require(depositedWEIByAddress[msg.sender] > r.weiAmount, "Not enough WEI");
depositedWEIByAddress[msg.sender] = depositedWEIByAddress[msg.sender].sub(r.weiAmount);
depositedDAIByAddress[r.borrower] = depositedDAIByAddress[r.borrower].add(r.daiAmount);
if (genesisPhase) {
require(nexenToken.transfer(msg.sender, amountToReward), 'Could not transfer tokens');
require(<FILL_ME>)
}
emit UpdateRequest(requestId, r.borrower, r.lender, r.state);
}
function cancelRequest(uint256 requestId) public {
}
function finishRequest(uint256 _requestId) public {
}
function canBurnCollateral(uint256 requestId, uint256 daiVsWeiCurrentPrice) public view returns (bool) {
}
function expireNonFullfiledRequest(uint256 _requestId) public {
}
function _expireRequest(uint256 _requestId) public onlyOwner {
}
function burnCollateral(uint256 _requestId, Request storage r) internal {
}
function sellCollateralInUniswap(uint256 daiToTransfer, uint256 weiAmount) internal returns (uint256[] memory) {
}
function getInterest(uint256 _ltv, uint256 _daiAmount) public pure returns (uint256) {
}
function _withdrawDaiFees(uint256 _amount) public onlyOwner {
}
function _withdrawEthFees(uint256 _amount) public onlyOwner {
}
function withdrawDai(uint256 _amount) public {
}
function withdrawEth(uint256 _amount) public {
}
function computeLenderFee(uint256 _value) public view returns (uint256) {
}
function computeBorrowerFee(uint256 _value) public view returns (uint256) {
}
function getExpirationAfter(uint256 amountOfDays) public view returns (uint256) {
}
function requestInfo(uint256 requestId) public view returns (uint256 _tradeId, RequestState _state, address _borrower, address _lender, uint256 _daiAmount, uint256 _durationInDays, uint256 _expireIfNotMatchedOn, uint256 _ltv, uint256 _weiAmount, uint256 _daiVsWeiCurrentPrice, uint256 _lendingFinishesOn) {
}
}
| nexenToken.transfer(r.lender,amountToReward),'Could not transfer tokens' | 367,747 | nexenToken.transfer(r.lender,amountToReward) |
"Not enough DAI deposited" | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.4;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () {
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IPriceConsumerV3DaiWei {
function getLatestPrice() external view returns (int);
}
interface IUniswapV2Router02 {
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function WETH() external returns (address);
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract NexenPlatform is Ownable {
using SafeMath for uint256;
enum RequestState {None, LenderCreated, BorrowerCreated, Cancelled, Matched, Closed, Expired, Disabled}
IERC20 nexenToken;
IERC20 daiToken = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
IPriceConsumerV3DaiWei priceConsumer;
IUniswapV2Router02 uniswapRouter;
bool public paused = false;
bool public genesisPhase = true;
uint256 public amountToReward = 1000 * 10 ** 18;
uint public lenderFee = 1; //1%
uint public borrowerFee = 1; //1%
mapping(address => uint256) public depositedDAIByAddress;
mapping(address => uint256) public depositedWEIByAddress;
struct Request {
// Internal fields
RequestState state;
address payable borrower;
address payable lender;
// Fields for both parties
uint256 daiAmount;
uint256 durationInDays;
uint256 expireIfNotMatchedOn;
// Fields for borrower
uint256 ltv;
uint256 weiAmount;
uint256 daiVsWeiCurrentPrice;
// Fields after matching
uint256 lendingFinishesOn;
}
event OpenRequest(uint256 requestId, address indexed borrower, address indexed lender, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv, uint256 weiAmount, uint256 ethVsDaiCurrentPrice, uint256 lendingFinishesOn, RequestState state);
event UpdateRequest(uint256 requestId, address indexed borrower, address indexed lender, RequestState state);
event CollateralSold(uint256 requestId, uint256 totalCollateral, uint256 totalSold, uint256 totalDAIBought);
uint256 public daiFees;
uint256 public ethFees;
mapping (uint256 => Request) public requests;
receive() external payable {
}
constructor(IERC20 _nexenToken, IPriceConsumerV3DaiWei _priceConsumer, IUniswapV2Router02 _uniswapRouter) {
}
//Calculates the amount of WEI that is needed as a collateral for this amount of DAI and the chosen LTV
function calculateWeiAmount(uint256 _daiAmount, uint256 _ltv, uint256 _daiVsWeiCurrentPrice) public pure returns (uint256) {
}
function depositETH() public payable {
}
function depositDAI(uint256 _amount) public {
}
function _setGenesisPhase(bool _genesisPhase, uint256 _amountToReward) public onlyOwner {
}
function _setPaused(bool _paused) public onlyOwner {
}
function calculateCollateral(uint256 daiAmount, uint256 ltv) public view returns (uint256) {
}
function createRequest(bool lend, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv) public {
}
function matchRequestAsLender(uint256 requestId) public {
}
function getLatestDaiVsWeiPrice() public view returns (uint256) {
}
function matchRequestAsBorrower(uint256 requestId, uint256 ltv) public {
}
function cancelRequest(uint256 requestId) public {
}
function finishRequest(uint256 _requestId) public {
Request storage r = requests[_requestId];
require(r.state == RequestState.Matched, "State needs to be Matched");
require(msg.sender == r.borrower, 'Only borrower can call this');
r.state = RequestState.Closed;
uint256 daiToTransfer = getInterest(r.ltv, r.daiAmount).add(r.daiAmount);
require(<FILL_ME>)
uint256 totalLenderFee = computeLenderFee(r.daiAmount);
uint256 totalBorrowerFee = computeBorrowerFee(r.weiAmount);
daiFees = daiFees.add(totalLenderFee);
ethFees = ethFees.add(totalBorrowerFee);
depositedDAIByAddress[r.lender] += daiToTransfer.sub(totalLenderFee);
depositedDAIByAddress[r.borrower] -= daiToTransfer;
depositedWEIByAddress[r.borrower] += r.weiAmount.sub(totalBorrowerFee);
emit UpdateRequest(_requestId, r.borrower, r.lender, r.state);
}
function canBurnCollateral(uint256 requestId, uint256 daiVsWeiCurrentPrice) public view returns (bool) {
}
function expireNonFullfiledRequest(uint256 _requestId) public {
}
function _expireRequest(uint256 _requestId) public onlyOwner {
}
function burnCollateral(uint256 _requestId, Request storage r) internal {
}
function sellCollateralInUniswap(uint256 daiToTransfer, uint256 weiAmount) internal returns (uint256[] memory) {
}
function getInterest(uint256 _ltv, uint256 _daiAmount) public pure returns (uint256) {
}
function _withdrawDaiFees(uint256 _amount) public onlyOwner {
}
function _withdrawEthFees(uint256 _amount) public onlyOwner {
}
function withdrawDai(uint256 _amount) public {
}
function withdrawEth(uint256 _amount) public {
}
function computeLenderFee(uint256 _value) public view returns (uint256) {
}
function computeBorrowerFee(uint256 _value) public view returns (uint256) {
}
function getExpirationAfter(uint256 amountOfDays) public view returns (uint256) {
}
function requestInfo(uint256 requestId) public view returns (uint256 _tradeId, RequestState _state, address _borrower, address _lender, uint256 _daiAmount, uint256 _durationInDays, uint256 _expireIfNotMatchedOn, uint256 _ltv, uint256 _weiAmount, uint256 _daiVsWeiCurrentPrice, uint256 _lendingFinishesOn) {
}
}
| depositedDAIByAddress[r.borrower]>=daiToTransfer,"Not enough DAI deposited" | 367,747 | depositedDAIByAddress[r.borrower]>=daiToTransfer |
"We cannot burn the collateral" | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.4;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () {
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IPriceConsumerV3DaiWei {
function getLatestPrice() external view returns (int);
}
interface IUniswapV2Router02 {
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function WETH() external returns (address);
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract NexenPlatform is Ownable {
using SafeMath for uint256;
enum RequestState {None, LenderCreated, BorrowerCreated, Cancelled, Matched, Closed, Expired, Disabled}
IERC20 nexenToken;
IERC20 daiToken = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
IPriceConsumerV3DaiWei priceConsumer;
IUniswapV2Router02 uniswapRouter;
bool public paused = false;
bool public genesisPhase = true;
uint256 public amountToReward = 1000 * 10 ** 18;
uint public lenderFee = 1; //1%
uint public borrowerFee = 1; //1%
mapping(address => uint256) public depositedDAIByAddress;
mapping(address => uint256) public depositedWEIByAddress;
struct Request {
// Internal fields
RequestState state;
address payable borrower;
address payable lender;
// Fields for both parties
uint256 daiAmount;
uint256 durationInDays;
uint256 expireIfNotMatchedOn;
// Fields for borrower
uint256 ltv;
uint256 weiAmount;
uint256 daiVsWeiCurrentPrice;
// Fields after matching
uint256 lendingFinishesOn;
}
event OpenRequest(uint256 requestId, address indexed borrower, address indexed lender, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv, uint256 weiAmount, uint256 ethVsDaiCurrentPrice, uint256 lendingFinishesOn, RequestState state);
event UpdateRequest(uint256 requestId, address indexed borrower, address indexed lender, RequestState state);
event CollateralSold(uint256 requestId, uint256 totalCollateral, uint256 totalSold, uint256 totalDAIBought);
uint256 public daiFees;
uint256 public ethFees;
mapping (uint256 => Request) public requests;
receive() external payable {
}
constructor(IERC20 _nexenToken, IPriceConsumerV3DaiWei _priceConsumer, IUniswapV2Router02 _uniswapRouter) {
}
//Calculates the amount of WEI that is needed as a collateral for this amount of DAI and the chosen LTV
function calculateWeiAmount(uint256 _daiAmount, uint256 _ltv, uint256 _daiVsWeiCurrentPrice) public pure returns (uint256) {
}
function depositETH() public payable {
}
function depositDAI(uint256 _amount) public {
}
function _setGenesisPhase(bool _genesisPhase, uint256 _amountToReward) public onlyOwner {
}
function _setPaused(bool _paused) public onlyOwner {
}
function calculateCollateral(uint256 daiAmount, uint256 ltv) public view returns (uint256) {
}
function createRequest(bool lend, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv) public {
}
function matchRequestAsLender(uint256 requestId) public {
}
function getLatestDaiVsWeiPrice() public view returns (uint256) {
}
function matchRequestAsBorrower(uint256 requestId, uint256 ltv) public {
}
function cancelRequest(uint256 requestId) public {
}
function finishRequest(uint256 _requestId) public {
}
function canBurnCollateral(uint256 requestId, uint256 daiVsWeiCurrentPrice) public view returns (bool) {
}
function expireNonFullfiledRequest(uint256 _requestId) public {
}
function _expireRequest(uint256 _requestId) public onlyOwner {
Request storage r = requests[_requestId];
require(r.state == RequestState.Matched, "State needs to be Matched");
uint256 daiVsWeiCurrentPrice = uint256(priceConsumer.getLatestPrice());
require(<FILL_ME>)
r.state = RequestState.Disabled;
burnCollateral(_requestId, r);
}
function burnCollateral(uint256 _requestId, Request storage r) internal {
}
function sellCollateralInUniswap(uint256 daiToTransfer, uint256 weiAmount) internal returns (uint256[] memory) {
}
function getInterest(uint256 _ltv, uint256 _daiAmount) public pure returns (uint256) {
}
function _withdrawDaiFees(uint256 _amount) public onlyOwner {
}
function _withdrawEthFees(uint256 _amount) public onlyOwner {
}
function withdrawDai(uint256 _amount) public {
}
function withdrawEth(uint256 _amount) public {
}
function computeLenderFee(uint256 _value) public view returns (uint256) {
}
function computeBorrowerFee(uint256 _value) public view returns (uint256) {
}
function getExpirationAfter(uint256 amountOfDays) public view returns (uint256) {
}
function requestInfo(uint256 requestId) public view returns (uint256 _tradeId, RequestState _state, address _borrower, address _lender, uint256 _daiAmount, uint256 _durationInDays, uint256 _expireIfNotMatchedOn, uint256 _ltv, uint256 _weiAmount, uint256 _daiVsWeiCurrentPrice, uint256 _lendingFinishesOn) {
}
}
| canBurnCollateral(_requestId,daiVsWeiCurrentPrice),"We cannot burn the collateral" | 367,747 | canBurnCollateral(_requestId,daiVsWeiCurrentPrice) |
"Transfer failed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.4;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () {
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IPriceConsumerV3DaiWei {
function getLatestPrice() external view returns (int);
}
interface IUniswapV2Router02 {
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function WETH() external returns (address);
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract NexenPlatform is Ownable {
using SafeMath for uint256;
enum RequestState {None, LenderCreated, BorrowerCreated, Cancelled, Matched, Closed, Expired, Disabled}
IERC20 nexenToken;
IERC20 daiToken = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
IPriceConsumerV3DaiWei priceConsumer;
IUniswapV2Router02 uniswapRouter;
bool public paused = false;
bool public genesisPhase = true;
uint256 public amountToReward = 1000 * 10 ** 18;
uint public lenderFee = 1; //1%
uint public borrowerFee = 1; //1%
mapping(address => uint256) public depositedDAIByAddress;
mapping(address => uint256) public depositedWEIByAddress;
struct Request {
// Internal fields
RequestState state;
address payable borrower;
address payable lender;
// Fields for both parties
uint256 daiAmount;
uint256 durationInDays;
uint256 expireIfNotMatchedOn;
// Fields for borrower
uint256 ltv;
uint256 weiAmount;
uint256 daiVsWeiCurrentPrice;
// Fields after matching
uint256 lendingFinishesOn;
}
event OpenRequest(uint256 requestId, address indexed borrower, address indexed lender, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv, uint256 weiAmount, uint256 ethVsDaiCurrentPrice, uint256 lendingFinishesOn, RequestState state);
event UpdateRequest(uint256 requestId, address indexed borrower, address indexed lender, RequestState state);
event CollateralSold(uint256 requestId, uint256 totalCollateral, uint256 totalSold, uint256 totalDAIBought);
uint256 public daiFees;
uint256 public ethFees;
mapping (uint256 => Request) public requests;
receive() external payable {
}
constructor(IERC20 _nexenToken, IPriceConsumerV3DaiWei _priceConsumer, IUniswapV2Router02 _uniswapRouter) {
}
//Calculates the amount of WEI that is needed as a collateral for this amount of DAI and the chosen LTV
function calculateWeiAmount(uint256 _daiAmount, uint256 _ltv, uint256 _daiVsWeiCurrentPrice) public pure returns (uint256) {
}
function depositETH() public payable {
}
function depositDAI(uint256 _amount) public {
}
function _setGenesisPhase(bool _genesisPhase, uint256 _amountToReward) public onlyOwner {
}
function _setPaused(bool _paused) public onlyOwner {
}
function calculateCollateral(uint256 daiAmount, uint256 ltv) public view returns (uint256) {
}
function createRequest(bool lend, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv) public {
}
function matchRequestAsLender(uint256 requestId) public {
}
function getLatestDaiVsWeiPrice() public view returns (uint256) {
}
function matchRequestAsBorrower(uint256 requestId, uint256 ltv) public {
}
function cancelRequest(uint256 requestId) public {
}
function finishRequest(uint256 _requestId) public {
}
function canBurnCollateral(uint256 requestId, uint256 daiVsWeiCurrentPrice) public view returns (bool) {
}
function expireNonFullfiledRequest(uint256 _requestId) public {
}
function _expireRequest(uint256 _requestId) public onlyOwner {
}
function burnCollateral(uint256 _requestId, Request storage r) internal {
}
function sellCollateralInUniswap(uint256 daiToTransfer, uint256 weiAmount) internal returns (uint256[] memory) {
}
function getInterest(uint256 _ltv, uint256 _daiAmount) public pure returns (uint256) {
}
function _withdrawDaiFees(uint256 _amount) public onlyOwner {
require(daiFees >= _amount, "Invalid number");
daiFees -= _amount;
require(<FILL_ME>)
}
function _withdrawEthFees(uint256 _amount) public onlyOwner {
}
function withdrawDai(uint256 _amount) public {
}
function withdrawEth(uint256 _amount) public {
}
function computeLenderFee(uint256 _value) public view returns (uint256) {
}
function computeBorrowerFee(uint256 _value) public view returns (uint256) {
}
function getExpirationAfter(uint256 amountOfDays) public view returns (uint256) {
}
function requestInfo(uint256 requestId) public view returns (uint256 _tradeId, RequestState _state, address _borrower, address _lender, uint256 _daiAmount, uint256 _durationInDays, uint256 _expireIfNotMatchedOn, uint256 _ltv, uint256 _weiAmount, uint256 _daiVsWeiCurrentPrice, uint256 _lendingFinishesOn) {
}
}
| daiToken.transfer(msg.sender,_amount),"Transfer failed" | 367,747 | daiToken.transfer(msg.sender,_amount) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.4;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () {
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IPriceConsumerV3DaiWei {
function getLatestPrice() external view returns (int);
}
interface IUniswapV2Router02 {
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function WETH() external returns (address);
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract NexenPlatform is Ownable {
using SafeMath for uint256;
enum RequestState {None, LenderCreated, BorrowerCreated, Cancelled, Matched, Closed, Expired, Disabled}
IERC20 nexenToken;
IERC20 daiToken = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
IPriceConsumerV3DaiWei priceConsumer;
IUniswapV2Router02 uniswapRouter;
bool public paused = false;
bool public genesisPhase = true;
uint256 public amountToReward = 1000 * 10 ** 18;
uint public lenderFee = 1; //1%
uint public borrowerFee = 1; //1%
mapping(address => uint256) public depositedDAIByAddress;
mapping(address => uint256) public depositedWEIByAddress;
struct Request {
// Internal fields
RequestState state;
address payable borrower;
address payable lender;
// Fields for both parties
uint256 daiAmount;
uint256 durationInDays;
uint256 expireIfNotMatchedOn;
// Fields for borrower
uint256 ltv;
uint256 weiAmount;
uint256 daiVsWeiCurrentPrice;
// Fields after matching
uint256 lendingFinishesOn;
}
event OpenRequest(uint256 requestId, address indexed borrower, address indexed lender, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv, uint256 weiAmount, uint256 ethVsDaiCurrentPrice, uint256 lendingFinishesOn, RequestState state);
event UpdateRequest(uint256 requestId, address indexed borrower, address indexed lender, RequestState state);
event CollateralSold(uint256 requestId, uint256 totalCollateral, uint256 totalSold, uint256 totalDAIBought);
uint256 public daiFees;
uint256 public ethFees;
mapping (uint256 => Request) public requests;
receive() external payable {
}
constructor(IERC20 _nexenToken, IPriceConsumerV3DaiWei _priceConsumer, IUniswapV2Router02 _uniswapRouter) {
}
//Calculates the amount of WEI that is needed as a collateral for this amount of DAI and the chosen LTV
function calculateWeiAmount(uint256 _daiAmount, uint256 _ltv, uint256 _daiVsWeiCurrentPrice) public pure returns (uint256) {
}
function depositETH() public payable {
}
function depositDAI(uint256 _amount) public {
}
function _setGenesisPhase(bool _genesisPhase, uint256 _amountToReward) public onlyOwner {
}
function _setPaused(bool _paused) public onlyOwner {
}
function calculateCollateral(uint256 daiAmount, uint256 ltv) public view returns (uint256) {
}
function createRequest(bool lend, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv) public {
}
function matchRequestAsLender(uint256 requestId) public {
}
function getLatestDaiVsWeiPrice() public view returns (uint256) {
}
function matchRequestAsBorrower(uint256 requestId, uint256 ltv) public {
}
function cancelRequest(uint256 requestId) public {
}
function finishRequest(uint256 _requestId) public {
}
function canBurnCollateral(uint256 requestId, uint256 daiVsWeiCurrentPrice) public view returns (bool) {
}
function expireNonFullfiledRequest(uint256 _requestId) public {
}
function _expireRequest(uint256 _requestId) public onlyOwner {
}
function burnCollateral(uint256 _requestId, Request storage r) internal {
}
function sellCollateralInUniswap(uint256 daiToTransfer, uint256 weiAmount) internal returns (uint256[] memory) {
}
function getInterest(uint256 _ltv, uint256 _daiAmount) public pure returns (uint256) {
}
function _withdrawDaiFees(uint256 _amount) public onlyOwner {
}
function _withdrawEthFees(uint256 _amount) public onlyOwner {
}
function withdrawDai(uint256 _amount) public {
require(<FILL_ME>)
depositedDAIByAddress[msg.sender] = depositedDAIByAddress[msg.sender].sub(_amount);
require(daiToken.transfer(msg.sender, _amount));
}
function withdrawEth(uint256 _amount) public {
}
function computeLenderFee(uint256 _value) public view returns (uint256) {
}
function computeBorrowerFee(uint256 _value) public view returns (uint256) {
}
function getExpirationAfter(uint256 amountOfDays) public view returns (uint256) {
}
function requestInfo(uint256 requestId) public view returns (uint256 _tradeId, RequestState _state, address _borrower, address _lender, uint256 _daiAmount, uint256 _durationInDays, uint256 _expireIfNotMatchedOn, uint256 _ltv, uint256 _weiAmount, uint256 _daiVsWeiCurrentPrice, uint256 _lendingFinishesOn) {
}
}
| depositedDAIByAddress[msg.sender]>=_amount | 367,747 | depositedDAIByAddress[msg.sender]>=_amount |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.4;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () {
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IPriceConsumerV3DaiWei {
function getLatestPrice() external view returns (int);
}
interface IUniswapV2Router02 {
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function WETH() external returns (address);
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract NexenPlatform is Ownable {
using SafeMath for uint256;
enum RequestState {None, LenderCreated, BorrowerCreated, Cancelled, Matched, Closed, Expired, Disabled}
IERC20 nexenToken;
IERC20 daiToken = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
IPriceConsumerV3DaiWei priceConsumer;
IUniswapV2Router02 uniswapRouter;
bool public paused = false;
bool public genesisPhase = true;
uint256 public amountToReward = 1000 * 10 ** 18;
uint public lenderFee = 1; //1%
uint public borrowerFee = 1; //1%
mapping(address => uint256) public depositedDAIByAddress;
mapping(address => uint256) public depositedWEIByAddress;
struct Request {
// Internal fields
RequestState state;
address payable borrower;
address payable lender;
// Fields for both parties
uint256 daiAmount;
uint256 durationInDays;
uint256 expireIfNotMatchedOn;
// Fields for borrower
uint256 ltv;
uint256 weiAmount;
uint256 daiVsWeiCurrentPrice;
// Fields after matching
uint256 lendingFinishesOn;
}
event OpenRequest(uint256 requestId, address indexed borrower, address indexed lender, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv, uint256 weiAmount, uint256 ethVsDaiCurrentPrice, uint256 lendingFinishesOn, RequestState state);
event UpdateRequest(uint256 requestId, address indexed borrower, address indexed lender, RequestState state);
event CollateralSold(uint256 requestId, uint256 totalCollateral, uint256 totalSold, uint256 totalDAIBought);
uint256 public daiFees;
uint256 public ethFees;
mapping (uint256 => Request) public requests;
receive() external payable {
}
constructor(IERC20 _nexenToken, IPriceConsumerV3DaiWei _priceConsumer, IUniswapV2Router02 _uniswapRouter) {
}
//Calculates the amount of WEI that is needed as a collateral for this amount of DAI and the chosen LTV
function calculateWeiAmount(uint256 _daiAmount, uint256 _ltv, uint256 _daiVsWeiCurrentPrice) public pure returns (uint256) {
}
function depositETH() public payable {
}
function depositDAI(uint256 _amount) public {
}
function _setGenesisPhase(bool _genesisPhase, uint256 _amountToReward) public onlyOwner {
}
function _setPaused(bool _paused) public onlyOwner {
}
function calculateCollateral(uint256 daiAmount, uint256 ltv) public view returns (uint256) {
}
function createRequest(bool lend, uint256 daiAmount, uint256 durationInDays, uint256 expireIfNotMatchedOn, uint256 ltv) public {
}
function matchRequestAsLender(uint256 requestId) public {
}
function getLatestDaiVsWeiPrice() public view returns (uint256) {
}
function matchRequestAsBorrower(uint256 requestId, uint256 ltv) public {
}
function cancelRequest(uint256 requestId) public {
}
function finishRequest(uint256 _requestId) public {
}
function canBurnCollateral(uint256 requestId, uint256 daiVsWeiCurrentPrice) public view returns (bool) {
}
function expireNonFullfiledRequest(uint256 _requestId) public {
}
function _expireRequest(uint256 _requestId) public onlyOwner {
}
function burnCollateral(uint256 _requestId, Request storage r) internal {
}
function sellCollateralInUniswap(uint256 daiToTransfer, uint256 weiAmount) internal returns (uint256[] memory) {
}
function getInterest(uint256 _ltv, uint256 _daiAmount) public pure returns (uint256) {
}
function _withdrawDaiFees(uint256 _amount) public onlyOwner {
}
function _withdrawEthFees(uint256 _amount) public onlyOwner {
}
function withdrawDai(uint256 _amount) public {
}
function withdrawEth(uint256 _amount) public {
require(<FILL_ME>)
depositedWEIByAddress[msg.sender] = depositedWEIByAddress[msg.sender].sub(_amount);
msg.sender.transfer(_amount);
}
function computeLenderFee(uint256 _value) public view returns (uint256) {
}
function computeBorrowerFee(uint256 _value) public view returns (uint256) {
}
function getExpirationAfter(uint256 amountOfDays) public view returns (uint256) {
}
function requestInfo(uint256 requestId) public view returns (uint256 _tradeId, RequestState _state, address _borrower, address _lender, uint256 _daiAmount, uint256 _durationInDays, uint256 _expireIfNotMatchedOn, uint256 _ltv, uint256 _weiAmount, uint256 _daiVsWeiCurrentPrice, uint256 _lendingFinishesOn) {
}
}
| depositedWEIByAddress[msg.sender]>=_amount | 367,747 | depositedWEIByAddress[msg.sender]>=_amount |
"A1 Serum can not exceed over 7777" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BabyLlamaSerum is ERC1155Supply, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 constant public A1_TYPE = 1;
uint256 constant public A2_TYPE = 2;
uint256 constant public A3_TYPE = 3;
uint256 constant public A1_MAX = 7777;
uint256 constant public A2_MAX = 7777;
uint256 constant public A3_MAX = 10;
address private _laboratoryAddress;
string private _baseURI;
uint256 private _price = 0.07 ether;
bool private _saleOn = false;
address private labManager = 0xd5C98c4e77c5e79D81349cD3C5A5695811F5FD70;
constructor(string memory baseURI_) ERC1155(baseURI_) {
}
function mintA1() public onlyOwner {
require(<FILL_ME>)
_mint( owner(), A1_TYPE, A1_MAX, "");
}
function mintA2( uint256 count ) public payable nonReentrant{
}
function mintA3() public onlyOwner {
}
function setLaboratoryAddress(address laboratoryAddress) public onlyOwner {
}
function burnSerumForAddress(uint256 typeId, address experimenter) public {
}
function setBaseUri(string memory baseURI_) public onlyOwner {
}
function uri(uint256 typeId) public view override returns (string memory){
}
function price() public view returns (uint256) {
}
function saleOn() public view returns (bool){
}
function startSale() public onlyOwner{
}
function closeSale() public onlyOwner{
}
function withdraw() public payable {
}
}
| totalSupply(A1_TYPE)<A1_MAX,"A1 Serum can not exceed over 7777" | 367,794 | totalSupply(A1_TYPE)<A1_MAX |
"Sale On is off" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BabyLlamaSerum is ERC1155Supply, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 constant public A1_TYPE = 1;
uint256 constant public A2_TYPE = 2;
uint256 constant public A3_TYPE = 3;
uint256 constant public A1_MAX = 7777;
uint256 constant public A2_MAX = 7777;
uint256 constant public A3_MAX = 10;
address private _laboratoryAddress;
string private _baseURI;
uint256 private _price = 0.07 ether;
bool private _saleOn = false;
address private labManager = 0xd5C98c4e77c5e79D81349cD3C5A5695811F5FD70;
constructor(string memory baseURI_) ERC1155(baseURI_) {
}
function mintA1() public onlyOwner {
}
function mintA2( uint256 count ) public payable nonReentrant{
uint256 minted = totalSupply(A2_TYPE);
require(<FILL_ME>)
require( msg.value == price() * count, "Invalid value" );
require( minted + count <= A2_MAX, "A2 Serum can not exceed over 7777");
_mint( msg.sender, A2_TYPE, count, "");
withdraw();
}
function mintA3() public onlyOwner {
}
function setLaboratoryAddress(address laboratoryAddress) public onlyOwner {
}
function burnSerumForAddress(uint256 typeId, address experimenter) public {
}
function setBaseUri(string memory baseURI_) public onlyOwner {
}
function uri(uint256 typeId) public view override returns (string memory){
}
function price() public view returns (uint256) {
}
function saleOn() public view returns (bool){
}
function startSale() public onlyOwner{
}
function closeSale() public onlyOwner{
}
function withdraw() public payable {
}
}
| saleOn(),"Sale On is off" | 367,794 | saleOn() |
"A2 Serum can not exceed over 7777" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BabyLlamaSerum is ERC1155Supply, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 constant public A1_TYPE = 1;
uint256 constant public A2_TYPE = 2;
uint256 constant public A3_TYPE = 3;
uint256 constant public A1_MAX = 7777;
uint256 constant public A2_MAX = 7777;
uint256 constant public A3_MAX = 10;
address private _laboratoryAddress;
string private _baseURI;
uint256 private _price = 0.07 ether;
bool private _saleOn = false;
address private labManager = 0xd5C98c4e77c5e79D81349cD3C5A5695811F5FD70;
constructor(string memory baseURI_) ERC1155(baseURI_) {
}
function mintA1() public onlyOwner {
}
function mintA2( uint256 count ) public payable nonReentrant{
uint256 minted = totalSupply(A2_TYPE);
require( saleOn(), "Sale On is off" );
require( msg.value == price() * count, "Invalid value" );
require(<FILL_ME>)
_mint( msg.sender, A2_TYPE, count, "");
withdraw();
}
function mintA3() public onlyOwner {
}
function setLaboratoryAddress(address laboratoryAddress) public onlyOwner {
}
function burnSerumForAddress(uint256 typeId, address experimenter) public {
}
function setBaseUri(string memory baseURI_) public onlyOwner {
}
function uri(uint256 typeId) public view override returns (string memory){
}
function price() public view returns (uint256) {
}
function saleOn() public view returns (bool){
}
function startSale() public onlyOwner{
}
function closeSale() public onlyOwner{
}
function withdraw() public payable {
}
}
| minted+count<=A2_MAX,"A2 Serum can not exceed over 7777" | 367,794 | minted+count<=A2_MAX |
"A3 Serum can not exceed over 10" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BabyLlamaSerum is ERC1155Supply, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 constant public A1_TYPE = 1;
uint256 constant public A2_TYPE = 2;
uint256 constant public A3_TYPE = 3;
uint256 constant public A1_MAX = 7777;
uint256 constant public A2_MAX = 7777;
uint256 constant public A3_MAX = 10;
address private _laboratoryAddress;
string private _baseURI;
uint256 private _price = 0.07 ether;
bool private _saleOn = false;
address private labManager = 0xd5C98c4e77c5e79D81349cD3C5A5695811F5FD70;
constructor(string memory baseURI_) ERC1155(baseURI_) {
}
function mintA1() public onlyOwner {
}
function mintA2( uint256 count ) public payable nonReentrant{
}
function mintA3() public onlyOwner {
require(<FILL_ME>)
_mint( owner(), A3_TYPE, A3_MAX, "");
}
function setLaboratoryAddress(address laboratoryAddress) public onlyOwner {
}
function burnSerumForAddress(uint256 typeId, address experimenter) public {
}
function setBaseUri(string memory baseURI_) public onlyOwner {
}
function uri(uint256 typeId) public view override returns (string memory){
}
function price() public view returns (uint256) {
}
function saleOn() public view returns (bool){
}
function startSale() public onlyOwner{
}
function closeSale() public onlyOwner{
}
function withdraw() public payable {
}
}
| totalSupply(A3_TYPE)<A3_MAX,"A3 Serum can not exceed over 10" | 367,794 | totalSupply(A3_TYPE)<A3_MAX |
"laboratoryAddress is not Contract" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BabyLlamaSerum is ERC1155Supply, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 constant public A1_TYPE = 1;
uint256 constant public A2_TYPE = 2;
uint256 constant public A3_TYPE = 3;
uint256 constant public A1_MAX = 7777;
uint256 constant public A2_MAX = 7777;
uint256 constant public A3_MAX = 10;
address private _laboratoryAddress;
string private _baseURI;
uint256 private _price = 0.07 ether;
bool private _saleOn = false;
address private labManager = 0xd5C98c4e77c5e79D81349cD3C5A5695811F5FD70;
constructor(string memory baseURI_) ERC1155(baseURI_) {
}
function mintA1() public onlyOwner {
}
function mintA2( uint256 count ) public payable nonReentrant{
}
function mintA3() public onlyOwner {
}
function setLaboratoryAddress(address laboratoryAddress) public onlyOwner {
require(<FILL_ME>)
_laboratoryAddress = laboratoryAddress;
}
function burnSerumForAddress(uint256 typeId, address experimenter) public {
}
function setBaseUri(string memory baseURI_) public onlyOwner {
}
function uri(uint256 typeId) public view override returns (string memory){
}
function price() public view returns (uint256) {
}
function saleOn() public view returns (bool){
}
function startSale() public onlyOwner{
}
function closeSale() public onlyOwner{
}
function withdraw() public payable {
}
}
| Address.isContract(laboratoryAddress),"laboratoryAddress is not Contract" | 367,794 | Address.isContract(laboratoryAddress) |
null | /**
*Submitted for verification at snowtrace.io on 2022-03-04
*/
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract Staker {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 0.05 ether;
uint256[] public REFERRAL_PERCENTS = [50, 30, 10];
uint256 constant public DEV_FEE = 80;
uint256 constant public PROTOCOL_FEE = 60;
uint256 constant public PERCENT_STEP = 3;
uint256 constant public WITHDRAW_FEE = 1000; //In base point
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalStaked;
uint256 public totalRefBonus;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256[3] levels;
uint256 bonus;
uint256 totalBonus;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable public protocolWallet;
address payable public devWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable pWallet,address payable dWallet, uint256 startDate) {
require(<FILL_ME>)
require(!isContract(dWallet));
require(startDate > 0);
protocolWallet = pWallet;
devWallet = dWallet;
startUNIX = startDate;
plans.push(Plan(14, 80));
plans.push(Plan(21, 75));
plans.push(Plan(28, 70));
plans.push(Plan(14, 80));
plans.push(Plan(21, 75));
plans.push(Plan(28, 70));
}
function invest(address referrer, uint8 plan) public payable {
}
function withdraw() public {
}
function getContractBalance() public view returns (uint256) {
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
}
function getPercent(uint8 plan) public view returns (uint256) {
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
}
function getUserDividends(address userAddress) public view returns (uint256) {
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
}
function getUserReferrer(address userAddress) public view returns(address) {
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
}
function getUserAvailable(address userAddress) public view returns(uint256) {
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
}
function isContract(address addr) internal view returns (bool) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| !isContract(pWallet) | 367,821 | !isContract(pWallet) |
null | /**
*Submitted for verification at snowtrace.io on 2022-03-04
*/
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract Staker {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 0.05 ether;
uint256[] public REFERRAL_PERCENTS = [50, 30, 10];
uint256 constant public DEV_FEE = 80;
uint256 constant public PROTOCOL_FEE = 60;
uint256 constant public PERCENT_STEP = 3;
uint256 constant public WITHDRAW_FEE = 1000; //In base point
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalStaked;
uint256 public totalRefBonus;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256[3] levels;
uint256 bonus;
uint256 totalBonus;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable public protocolWallet;
address payable public devWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable pWallet,address payable dWallet, uint256 startDate) {
require(!isContract(pWallet));
require(<FILL_ME>)
require(startDate > 0);
protocolWallet = pWallet;
devWallet = dWallet;
startUNIX = startDate;
plans.push(Plan(14, 80));
plans.push(Plan(21, 75));
plans.push(Plan(28, 70));
plans.push(Plan(14, 80));
plans.push(Plan(21, 75));
plans.push(Plan(28, 70));
}
function invest(address referrer, uint8 plan) public payable {
}
function withdraw() public {
}
function getContractBalance() public view returns (uint256) {
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
}
function getPercent(uint8 plan) public view returns (uint256) {
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
}
function getUserDividends(address userAddress) public view returns (uint256) {
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
}
function getUserReferrer(address userAddress) public view returns(address) {
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
}
function getUserAvailable(address userAddress) public view returns(uint256) {
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
}
function isContract(address addr) internal view returns (bool) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| !isContract(dWallet) | 367,821 | !isContract(dWallet) |
"Approve LEV tokens first" | contract Stake is HasOwners, Versioned {
using Math for uint;
uint public weiPerFEE; // Wei for each Fee token
Token public LEV;
Fee public FEE;
address payable public wallet;
address public operator;
uint public intervalSize;
bool public halted;
uint public FEE2Distribute;
uint public totalStakedLEV;
uint public latest = 1;
mapping (address => UserStake) public stakes;
mapping (uint => Interval) public intervals;
event Staked(address indexed user, uint levs, uint startBlock, uint endBlock, uint intervalId);
event Restaked(address indexed user, uint levs, uint startBlock, uint endBlock, uint intervalId);
event Redeemed(address indexed user, uint levs, uint feeEarned, uint startBlock, uint endBlock, uint intervalId);
event FeeCalculated(uint feeCalculated, uint feeReceived, uint weiReceived, uint startBlock, uint endBlock, uint intervalId);
event NewInterval(uint start, uint end, uint intervalId);
event Halted(uint block, uint intervalId);
//account
struct UserStake {uint intervalId; uint quantity; uint worth;}
// per staking interval data
struct Interval {uint worth; uint generatedFEE; uint start; uint end;}
constructor(
address[] memory _owners,
address _operator,
address payable _wallet,
uint _weiPerFee,
address _levToken,
address _feeToken,
uint _intervalSize,
address registry,
address apiKey,
bytes32 userAgreement,
string memory _version
)
HasOwners(_owners)
Versioned(_version)
public validAddress(_wallet) validAddress(_levToken) validAddress(_feeToken) notZero(_weiPerFee) notZero(_intervalSize)
{
}
modifier notHalted { }
function() external payable {}
function setWallet(address payable _wallet) external validAddress(_wallet) onlyOwner {
}
function setIntervalSize(uint _intervalSize) external notZero(_intervalSize) onlyOwner {
}
/// @notice establish an interval if none exists
function ensureInterval() public notHalted {
}
function restake(int signedQuantity) private {
}
function stake(int signedQuantity) external notHalted {
}
function stakeInCurrentPeriod(uint quantity) private {
require(<FILL_ME>)
Interval storage interval = intervals[latest];
stakes[msg.sender].intervalId = latest;
stakes[msg.sender].worth = stakes[msg.sender].worth.plus(quantity.times(intervals[latest].end.minus(block.number)));
stakes[msg.sender].quantity = stakes[msg.sender].quantity.plus(quantity);
interval.worth = interval.worth.plus(quantity.times(interval.end.minus(block.number)));
require(LEV.transferFrom(msg.sender, address(this), quantity), "LEV token transfer was not successful");
totalStakedLEV = totalStakedLEV.plus(quantity);
emit Staked(msg.sender, quantity, interval.start, interval.end, latest);
}
function withdraw() external {
}
function halt() external notHalted onlyOwner {
}
function transferToWalletAfterHalt() public onlyOwner {
}
function transferToken(address token) public validAddress(token) {
}
function redeem(uint howMuchLEV) private {
}
// public for testing purposes only. not intended to be called directly
function calculateIntervalEarning(uint start, uint end) public view returns (uint earnedFEE, uint earnedETH) {
}
function registerApiKey(address registry, address apiKey, bytes32 userAgreement) public onlyOwner {
}
function withdrawFromCustodian(
address custodian,
address[] memory addresses,
uint[] memory uints,
bytes memory signature,
bytes memory proof,
bytes32 root
) public {
}
function exitOnHaltFromCustodian(
address custodian,
address[] memory addresses,
uint[] memory uints,
bytes memory signature,
bytes memory proof,
bytes32 root
) public {
}
}
| LEV.allowance(msg.sender,address(this))>=quantity,"Approve LEV tokens first" | 367,900 | LEV.allowance(msg.sender,address(this))>=quantity |
"LEV token transfer was not successful" | contract Stake is HasOwners, Versioned {
using Math for uint;
uint public weiPerFEE; // Wei for each Fee token
Token public LEV;
Fee public FEE;
address payable public wallet;
address public operator;
uint public intervalSize;
bool public halted;
uint public FEE2Distribute;
uint public totalStakedLEV;
uint public latest = 1;
mapping (address => UserStake) public stakes;
mapping (uint => Interval) public intervals;
event Staked(address indexed user, uint levs, uint startBlock, uint endBlock, uint intervalId);
event Restaked(address indexed user, uint levs, uint startBlock, uint endBlock, uint intervalId);
event Redeemed(address indexed user, uint levs, uint feeEarned, uint startBlock, uint endBlock, uint intervalId);
event FeeCalculated(uint feeCalculated, uint feeReceived, uint weiReceived, uint startBlock, uint endBlock, uint intervalId);
event NewInterval(uint start, uint end, uint intervalId);
event Halted(uint block, uint intervalId);
//account
struct UserStake {uint intervalId; uint quantity; uint worth;}
// per staking interval data
struct Interval {uint worth; uint generatedFEE; uint start; uint end;}
constructor(
address[] memory _owners,
address _operator,
address payable _wallet,
uint _weiPerFee,
address _levToken,
address _feeToken,
uint _intervalSize,
address registry,
address apiKey,
bytes32 userAgreement,
string memory _version
)
HasOwners(_owners)
Versioned(_version)
public validAddress(_wallet) validAddress(_levToken) validAddress(_feeToken) notZero(_weiPerFee) notZero(_intervalSize)
{
}
modifier notHalted { }
function() external payable {}
function setWallet(address payable _wallet) external validAddress(_wallet) onlyOwner {
}
function setIntervalSize(uint _intervalSize) external notZero(_intervalSize) onlyOwner {
}
/// @notice establish an interval if none exists
function ensureInterval() public notHalted {
}
function restake(int signedQuantity) private {
}
function stake(int signedQuantity) external notHalted {
}
function stakeInCurrentPeriod(uint quantity) private {
require(LEV.allowance(msg.sender, address(this)) >= quantity, "Approve LEV tokens first");
Interval storage interval = intervals[latest];
stakes[msg.sender].intervalId = latest;
stakes[msg.sender].worth = stakes[msg.sender].worth.plus(quantity.times(intervals[latest].end.minus(block.number)));
stakes[msg.sender].quantity = stakes[msg.sender].quantity.plus(quantity);
interval.worth = interval.worth.plus(quantity.times(interval.end.minus(block.number)));
require(<FILL_ME>)
totalStakedLEV = totalStakedLEV.plus(quantity);
emit Staked(msg.sender, quantity, interval.start, interval.end, latest);
}
function withdraw() external {
}
function halt() external notHalted onlyOwner {
}
function transferToWalletAfterHalt() public onlyOwner {
}
function transferToken(address token) public validAddress(token) {
}
function redeem(uint howMuchLEV) private {
}
// public for testing purposes only. not intended to be called directly
function calculateIntervalEarning(uint start, uint end) public view returns (uint earnedFEE, uint earnedETH) {
}
function registerApiKey(address registry, address apiKey, bytes32 userAgreement) public onlyOwner {
}
function withdrawFromCustodian(
address custodian,
address[] memory addresses,
uint[] memory uints,
bytes memory signature,
bytes memory proof,
bytes32 root
) public {
}
function exitOnHaltFromCustodian(
address custodian,
address[] memory addresses,
uint[] memory uints,
bytes memory signature,
bytes memory proof,
bytes32 root
) public {
}
}
| LEV.transferFrom(msg.sender,address(this),quantity),"LEV token transfer was not successful" | 367,900 | LEV.transferFrom(msg.sender,address(this),quantity) |
"Fee transfer to account failed" | contract Stake is HasOwners, Versioned {
using Math for uint;
uint public weiPerFEE; // Wei for each Fee token
Token public LEV;
Fee public FEE;
address payable public wallet;
address public operator;
uint public intervalSize;
bool public halted;
uint public FEE2Distribute;
uint public totalStakedLEV;
uint public latest = 1;
mapping (address => UserStake) public stakes;
mapping (uint => Interval) public intervals;
event Staked(address indexed user, uint levs, uint startBlock, uint endBlock, uint intervalId);
event Restaked(address indexed user, uint levs, uint startBlock, uint endBlock, uint intervalId);
event Redeemed(address indexed user, uint levs, uint feeEarned, uint startBlock, uint endBlock, uint intervalId);
event FeeCalculated(uint feeCalculated, uint feeReceived, uint weiReceived, uint startBlock, uint endBlock, uint intervalId);
event NewInterval(uint start, uint end, uint intervalId);
event Halted(uint block, uint intervalId);
//account
struct UserStake {uint intervalId; uint quantity; uint worth;}
// per staking interval data
struct Interval {uint worth; uint generatedFEE; uint start; uint end;}
constructor(
address[] memory _owners,
address _operator,
address payable _wallet,
uint _weiPerFee,
address _levToken,
address _feeToken,
uint _intervalSize,
address registry,
address apiKey,
bytes32 userAgreement,
string memory _version
)
HasOwners(_owners)
Versioned(_version)
public validAddress(_wallet) validAddress(_levToken) validAddress(_feeToken) notZero(_weiPerFee) notZero(_intervalSize)
{
}
modifier notHalted { }
function() external payable {}
function setWallet(address payable _wallet) external validAddress(_wallet) onlyOwner {
}
function setIntervalSize(uint _intervalSize) external notZero(_intervalSize) onlyOwner {
}
/// @notice establish an interval if none exists
function ensureInterval() public notHalted {
}
function restake(int signedQuantity) private {
}
function stake(int signedQuantity) external notHalted {
}
function stakeInCurrentPeriod(uint quantity) private {
}
function withdraw() external {
}
function halt() external notHalted onlyOwner {
}
function transferToWalletAfterHalt() public onlyOwner {
}
function transferToken(address token) public validAddress(token) {
}
function redeem(uint howMuchLEV) private {
uint intervalId = stakes[msg.sender].intervalId;
Interval memory interval = intervals[intervalId];
uint earnedFEE = stakes[msg.sender].worth.times(interval.generatedFEE).div(interval.worth);
delete stakes[msg.sender];
if (earnedFEE > 0) {
FEE2Distribute = FEE2Distribute.minus(earnedFEE);
require(<FILL_ME>)
}
if (howMuchLEV > 0) {
totalStakedLEV = totalStakedLEV.minus(howMuchLEV);
require(LEV.transfer(msg.sender, howMuchLEV), "Redeeming LEV token to account failed.");
}
emit Redeemed(msg.sender, howMuchLEV, earnedFEE, interval.start, interval.end, intervalId);
}
// public for testing purposes only. not intended to be called directly
function calculateIntervalEarning(uint start, uint end) public view returns (uint earnedFEE, uint earnedETH) {
}
function registerApiKey(address registry, address apiKey, bytes32 userAgreement) public onlyOwner {
}
function withdrawFromCustodian(
address custodian,
address[] memory addresses,
uint[] memory uints,
bytes memory signature,
bytes memory proof,
bytes32 root
) public {
}
function exitOnHaltFromCustodian(
address custodian,
address[] memory addresses,
uint[] memory uints,
bytes memory signature,
bytes memory proof,
bytes32 root
) public {
}
}
| FEE.transfer(msg.sender,earnedFEE),"Fee transfer to account failed" | 367,900 | FEE.transfer(msg.sender,earnedFEE) |
"Redeeming LEV token to account failed." | contract Stake is HasOwners, Versioned {
using Math for uint;
uint public weiPerFEE; // Wei for each Fee token
Token public LEV;
Fee public FEE;
address payable public wallet;
address public operator;
uint public intervalSize;
bool public halted;
uint public FEE2Distribute;
uint public totalStakedLEV;
uint public latest = 1;
mapping (address => UserStake) public stakes;
mapping (uint => Interval) public intervals;
event Staked(address indexed user, uint levs, uint startBlock, uint endBlock, uint intervalId);
event Restaked(address indexed user, uint levs, uint startBlock, uint endBlock, uint intervalId);
event Redeemed(address indexed user, uint levs, uint feeEarned, uint startBlock, uint endBlock, uint intervalId);
event FeeCalculated(uint feeCalculated, uint feeReceived, uint weiReceived, uint startBlock, uint endBlock, uint intervalId);
event NewInterval(uint start, uint end, uint intervalId);
event Halted(uint block, uint intervalId);
//account
struct UserStake {uint intervalId; uint quantity; uint worth;}
// per staking interval data
struct Interval {uint worth; uint generatedFEE; uint start; uint end;}
constructor(
address[] memory _owners,
address _operator,
address payable _wallet,
uint _weiPerFee,
address _levToken,
address _feeToken,
uint _intervalSize,
address registry,
address apiKey,
bytes32 userAgreement,
string memory _version
)
HasOwners(_owners)
Versioned(_version)
public validAddress(_wallet) validAddress(_levToken) validAddress(_feeToken) notZero(_weiPerFee) notZero(_intervalSize)
{
}
modifier notHalted { }
function() external payable {}
function setWallet(address payable _wallet) external validAddress(_wallet) onlyOwner {
}
function setIntervalSize(uint _intervalSize) external notZero(_intervalSize) onlyOwner {
}
/// @notice establish an interval if none exists
function ensureInterval() public notHalted {
}
function restake(int signedQuantity) private {
}
function stake(int signedQuantity) external notHalted {
}
function stakeInCurrentPeriod(uint quantity) private {
}
function withdraw() external {
}
function halt() external notHalted onlyOwner {
}
function transferToWalletAfterHalt() public onlyOwner {
}
function transferToken(address token) public validAddress(token) {
}
function redeem(uint howMuchLEV) private {
uint intervalId = stakes[msg.sender].intervalId;
Interval memory interval = intervals[intervalId];
uint earnedFEE = stakes[msg.sender].worth.times(interval.generatedFEE).div(interval.worth);
delete stakes[msg.sender];
if (earnedFEE > 0) {
FEE2Distribute = FEE2Distribute.minus(earnedFEE);
require(FEE.transfer(msg.sender, earnedFEE), "Fee transfer to account failed");
}
if (howMuchLEV > 0) {
totalStakedLEV = totalStakedLEV.minus(howMuchLEV);
require(<FILL_ME>)
}
emit Redeemed(msg.sender, howMuchLEV, earnedFEE, interval.start, interval.end, intervalId);
}
// public for testing purposes only. not intended to be called directly
function calculateIntervalEarning(uint start, uint end) public view returns (uint earnedFEE, uint earnedETH) {
}
function registerApiKey(address registry, address apiKey, bytes32 userAgreement) public onlyOwner {
}
function withdrawFromCustodian(
address custodian,
address[] memory addresses,
uint[] memory uints,
bytes memory signature,
bytes memory proof,
bytes32 root
) public {
}
function exitOnHaltFromCustodian(
address custodian,
address[] memory addresses,
uint[] memory uints,
bytes memory signature,
bytes memory proof,
bytes32 root
) public {
}
}
| LEV.transfer(msg.sender,howMuchLEV),"Redeeming LEV token to account failed." | 367,900 | LEV.transfer(msg.sender,howMuchLEV) |
"DEPOSITS_PAUSED" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
pragma experimental ABIEncoderV2;
import "../interfaces/ILiquidityPool.sol";
import "../interfaces/IManager.sol";
import "../interfaces/IStaking.sol";
import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
import {SafeMathUpgradeable as SafeMath} from "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
import {MathUpgradeable as Math} from "@openzeppelin/contracts-upgradeable/math/MathUpgradeable.sol";
import {OwnableUpgradeable as Ownable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import {ERC20Upgradeable as ERC20} from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import {IERC20Upgradeable as IERC20} from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import {SafeERC20Upgradeable as SafeERC20} from "@openzeppelin/contracts-upgradeable/token/ERC20/SafeERC20Upgradeable.sol";
import {PausableUpgradeable as Pausable} from "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
import "../interfaces/events/BalanceUpdateEvent.sol";
import "../interfaces/events/Destinations.sol";
import "../fxPortal/IFxStateSender.sol";
import "../interfaces/events/IEventSender.sol";
/**
* @title Specialized implementation of the Pool contract that allows immediate
* withdraw of any previously set withdrawal request, as well as any newly set
* withdrawal request. Also allow the immediate migration of funds to the Staking contract
*
* @dev This should not be deployed until we are ready to allow users to migrate to
* the Staking contract. At that time, we will upgrade the TOKE pool to this version
*/
contract TokeMigrationPool is
ILiquidityPool,
Initializable,
ERC20,
Ownable,
Pausable,
IEventSender
{
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 public override underlyer; // Underlying ERC20 token
IManager public manager;
// implied: deployableLiquidity = underlyer.balanceOf(this) - withheldLiquidity
uint256 public override withheldLiquidity;
// fAsset holder -> WithdrawalInfo
mapping(address => WithdrawalInfo) public override requestedWithdrawals;
// NonReentrant
bool private _entered;
bool public _eventSend;
Destinations public destinations;
bool public depositsPaused;
address public constant STAKING = 0x96F98Ed74639689C3A11daf38ef86E59F43417D3;
modifier nonReentrant() {
}
modifier onEventSend() {
}
modifier whenDepositsNotPaused() {
require(!paused(), "Pausable: paused");
require(<FILL_ME>)
_;
}
event Migrated(address migrator, uint256 amount);
function initialize(
ERC20 _underlyer,
IManager _manager,
string memory _name,
string memory _symbol
) public initializer {
}
///@notice Gets decimals of underlyer so that tAsset decimals will match
function decimals() public view override returns (uint8) {
}
function deposit(uint256 amount) external override whenDepositsNotPaused {
}
function depositFor(address account, uint256 amount) external override whenDepositsNotPaused {
}
/// @dev References the WithdrawalInfo for how much the user is permitted to withdraw
/// @dev Allows withdraw regardless of cycle
/// @dev Decrements withheldLiquidity by the withdrawn amount
function withdraw(uint256 requestedAmount) external override whenNotPaused nonReentrant {
}
function withdrawAndMigrate() external whenNotPaused nonReentrant {
}
function _approveStaking(uint256 amount, address staking) private {
}
/// @dev Adjusts the withheldLiquidity as necessary
/// @dev Updates the WithdrawalInfo for when a user can withdraw and for what requested amount
function requestWithdrawal(uint256 amount) external override {
}
function preTransferAdjustWithheldLiquidity(address sender, uint256 amount) internal {
}
function approveManager(uint256 amount) public override onlyOwner {
}
/// @dev Adjust withheldLiquidity and requestedWithdrawal if sender does not have sufficient unlocked balance for the transfer
function transfer(address recipient, uint256 amount)
public
override
whenNotPaused
nonReentrant
returns (bool)
{
}
/// @dev Adjust withheldLiquidity and requestedWithdrawal if sender does not have sufficient unlocked balance for the transfer
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override whenNotPaused nonReentrant returns (bool) {
}
function pause() external override onlyOwner {
}
function unpause() external override onlyOwner {
}
function pauseDeposit() external override onlyOwner {
}
function unpauseDeposit() external override onlyOwner {
}
function setDestinations(address _fxStateSender, address _destinationOnL2)
external
override
onlyOwner
{
}
function setEventSend(bool _eventSendSet) external override onlyOwner {
}
function _deposit(
address fromAccount,
address toAccount,
uint256 amount
) internal {
}
function encodeAndSendData(bytes32 _eventSig, address _user) private onEventSend {
}
}
| !depositsPaused,"DEPOSITS_PAUSED" | 367,909 | !depositsPaused |
"ZERO_ADDRESS" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
pragma experimental ABIEncoderV2;
import "../interfaces/ILiquidityPool.sol";
import "../interfaces/IManager.sol";
import "../interfaces/IStaking.sol";
import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
import {SafeMathUpgradeable as SafeMath} from "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
import {MathUpgradeable as Math} from "@openzeppelin/contracts-upgradeable/math/MathUpgradeable.sol";
import {OwnableUpgradeable as Ownable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import {ERC20Upgradeable as ERC20} from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import {IERC20Upgradeable as IERC20} from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import {SafeERC20Upgradeable as SafeERC20} from "@openzeppelin/contracts-upgradeable/token/ERC20/SafeERC20Upgradeable.sol";
import {PausableUpgradeable as Pausable} from "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
import "../interfaces/events/BalanceUpdateEvent.sol";
import "../interfaces/events/Destinations.sol";
import "../fxPortal/IFxStateSender.sol";
import "../interfaces/events/IEventSender.sol";
/**
* @title Specialized implementation of the Pool contract that allows immediate
* withdraw of any previously set withdrawal request, as well as any newly set
* withdrawal request. Also allow the immediate migration of funds to the Staking contract
*
* @dev This should not be deployed until we are ready to allow users to migrate to
* the Staking contract. At that time, we will upgrade the TOKE pool to this version
*/
contract TokeMigrationPool is
ILiquidityPool,
Initializable,
ERC20,
Ownable,
Pausable,
IEventSender
{
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 public override underlyer; // Underlying ERC20 token
IManager public manager;
// implied: deployableLiquidity = underlyer.balanceOf(this) - withheldLiquidity
uint256 public override withheldLiquidity;
// fAsset holder -> WithdrawalInfo
mapping(address => WithdrawalInfo) public override requestedWithdrawals;
// NonReentrant
bool private _entered;
bool public _eventSend;
Destinations public destinations;
bool public depositsPaused;
address public constant STAKING = 0x96F98Ed74639689C3A11daf38ef86E59F43417D3;
modifier nonReentrant() {
}
modifier onEventSend() {
}
modifier whenDepositsNotPaused() {
}
event Migrated(address migrator, uint256 amount);
function initialize(
ERC20 _underlyer,
IManager _manager,
string memory _name,
string memory _symbol
) public initializer {
require(<FILL_ME>)
require(address(_manager) != address(0), "ZERO_ADDRESS");
__Context_init_unchained();
__Ownable_init_unchained();
__Pausable_init_unchained();
__ERC20_init_unchained(_name, _symbol);
underlyer = _underlyer;
manager = _manager;
}
///@notice Gets decimals of underlyer so that tAsset decimals will match
function decimals() public view override returns (uint8) {
}
function deposit(uint256 amount) external override whenDepositsNotPaused {
}
function depositFor(address account, uint256 amount) external override whenDepositsNotPaused {
}
/// @dev References the WithdrawalInfo for how much the user is permitted to withdraw
/// @dev Allows withdraw regardless of cycle
/// @dev Decrements withheldLiquidity by the withdrawn amount
function withdraw(uint256 requestedAmount) external override whenNotPaused nonReentrant {
}
function withdrawAndMigrate() external whenNotPaused nonReentrant {
}
function _approveStaking(uint256 amount, address staking) private {
}
/// @dev Adjusts the withheldLiquidity as necessary
/// @dev Updates the WithdrawalInfo for when a user can withdraw and for what requested amount
function requestWithdrawal(uint256 amount) external override {
}
function preTransferAdjustWithheldLiquidity(address sender, uint256 amount) internal {
}
function approveManager(uint256 amount) public override onlyOwner {
}
/// @dev Adjust withheldLiquidity and requestedWithdrawal if sender does not have sufficient unlocked balance for the transfer
function transfer(address recipient, uint256 amount)
public
override
whenNotPaused
nonReentrant
returns (bool)
{
}
/// @dev Adjust withheldLiquidity and requestedWithdrawal if sender does not have sufficient unlocked balance for the transfer
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override whenNotPaused nonReentrant returns (bool) {
}
function pause() external override onlyOwner {
}
function unpause() external override onlyOwner {
}
function pauseDeposit() external override onlyOwner {
}
function unpauseDeposit() external override onlyOwner {
}
function setDestinations(address _fxStateSender, address _destinationOnL2)
external
override
onlyOwner
{
}
function setEventSend(bool _eventSendSet) external override onlyOwner {
}
function _deposit(
address fromAccount,
address toAccount,
uint256 amount
) internal {
}
function encodeAndSendData(bytes32 _eventSig, address _user) private onEventSend {
}
}
| address(_underlyer)!=address(0),"ZERO_ADDRESS" | 367,909 | address(_underlyer)!=address(0) |
"ZERO_ADDRESS" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
pragma experimental ABIEncoderV2;
import "../interfaces/ILiquidityPool.sol";
import "../interfaces/IManager.sol";
import "../interfaces/IStaking.sol";
import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
import {SafeMathUpgradeable as SafeMath} from "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
import {MathUpgradeable as Math} from "@openzeppelin/contracts-upgradeable/math/MathUpgradeable.sol";
import {OwnableUpgradeable as Ownable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import {ERC20Upgradeable as ERC20} from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import {IERC20Upgradeable as IERC20} from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import {SafeERC20Upgradeable as SafeERC20} from "@openzeppelin/contracts-upgradeable/token/ERC20/SafeERC20Upgradeable.sol";
import {PausableUpgradeable as Pausable} from "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
import "../interfaces/events/BalanceUpdateEvent.sol";
import "../interfaces/events/Destinations.sol";
import "../fxPortal/IFxStateSender.sol";
import "../interfaces/events/IEventSender.sol";
/**
* @title Specialized implementation of the Pool contract that allows immediate
* withdraw of any previously set withdrawal request, as well as any newly set
* withdrawal request. Also allow the immediate migration of funds to the Staking contract
*
* @dev This should not be deployed until we are ready to allow users to migrate to
* the Staking contract. At that time, we will upgrade the TOKE pool to this version
*/
contract TokeMigrationPool is
ILiquidityPool,
Initializable,
ERC20,
Ownable,
Pausable,
IEventSender
{
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 public override underlyer; // Underlying ERC20 token
IManager public manager;
// implied: deployableLiquidity = underlyer.balanceOf(this) - withheldLiquidity
uint256 public override withheldLiquidity;
// fAsset holder -> WithdrawalInfo
mapping(address => WithdrawalInfo) public override requestedWithdrawals;
// NonReentrant
bool private _entered;
bool public _eventSend;
Destinations public destinations;
bool public depositsPaused;
address public constant STAKING = 0x96F98Ed74639689C3A11daf38ef86E59F43417D3;
modifier nonReentrant() {
}
modifier onEventSend() {
}
modifier whenDepositsNotPaused() {
}
event Migrated(address migrator, uint256 amount);
function initialize(
ERC20 _underlyer,
IManager _manager,
string memory _name,
string memory _symbol
) public initializer {
require(address(_underlyer) != address(0), "ZERO_ADDRESS");
require(<FILL_ME>)
__Context_init_unchained();
__Ownable_init_unchained();
__Pausable_init_unchained();
__ERC20_init_unchained(_name, _symbol);
underlyer = _underlyer;
manager = _manager;
}
///@notice Gets decimals of underlyer so that tAsset decimals will match
function decimals() public view override returns (uint8) {
}
function deposit(uint256 amount) external override whenDepositsNotPaused {
}
function depositFor(address account, uint256 amount) external override whenDepositsNotPaused {
}
/// @dev References the WithdrawalInfo for how much the user is permitted to withdraw
/// @dev Allows withdraw regardless of cycle
/// @dev Decrements withheldLiquidity by the withdrawn amount
function withdraw(uint256 requestedAmount) external override whenNotPaused nonReentrant {
}
function withdrawAndMigrate() external whenNotPaused nonReentrant {
}
function _approveStaking(uint256 amount, address staking) private {
}
/// @dev Adjusts the withheldLiquidity as necessary
/// @dev Updates the WithdrawalInfo for when a user can withdraw and for what requested amount
function requestWithdrawal(uint256 amount) external override {
}
function preTransferAdjustWithheldLiquidity(address sender, uint256 amount) internal {
}
function approveManager(uint256 amount) public override onlyOwner {
}
/// @dev Adjust withheldLiquidity and requestedWithdrawal if sender does not have sufficient unlocked balance for the transfer
function transfer(address recipient, uint256 amount)
public
override
whenNotPaused
nonReentrant
returns (bool)
{
}
/// @dev Adjust withheldLiquidity and requestedWithdrawal if sender does not have sufficient unlocked balance for the transfer
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override whenNotPaused nonReentrant returns (bool) {
}
function pause() external override onlyOwner {
}
function unpause() external override onlyOwner {
}
function pauseDeposit() external override onlyOwner {
}
function unpauseDeposit() external override onlyOwner {
}
function setDestinations(address _fxStateSender, address _destinationOnL2)
external
override
onlyOwner
{
}
function setEventSend(bool _eventSendSet) external override onlyOwner {
}
function _deposit(
address fromAccount,
address toAccount,
uint256 amount
) internal {
}
function encodeAndSendData(bytes32 _eventSig, address _user) private onEventSend {
}
}
| address(_manager)!=address(0),"ZERO_ADDRESS" | 367,909 | address(_manager)!=address(0) |
"INSUFFICIENT_POOL_BALANCE" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
pragma experimental ABIEncoderV2;
import "../interfaces/ILiquidityPool.sol";
import "../interfaces/IManager.sol";
import "../interfaces/IStaking.sol";
import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
import {SafeMathUpgradeable as SafeMath} from "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
import {MathUpgradeable as Math} from "@openzeppelin/contracts-upgradeable/math/MathUpgradeable.sol";
import {OwnableUpgradeable as Ownable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import {ERC20Upgradeable as ERC20} from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import {IERC20Upgradeable as IERC20} from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import {SafeERC20Upgradeable as SafeERC20} from "@openzeppelin/contracts-upgradeable/token/ERC20/SafeERC20Upgradeable.sol";
import {PausableUpgradeable as Pausable} from "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
import "../interfaces/events/BalanceUpdateEvent.sol";
import "../interfaces/events/Destinations.sol";
import "../fxPortal/IFxStateSender.sol";
import "../interfaces/events/IEventSender.sol";
/**
* @title Specialized implementation of the Pool contract that allows immediate
* withdraw of any previously set withdrawal request, as well as any newly set
* withdrawal request. Also allow the immediate migration of funds to the Staking contract
*
* @dev This should not be deployed until we are ready to allow users to migrate to
* the Staking contract. At that time, we will upgrade the TOKE pool to this version
*/
contract TokeMigrationPool is
ILiquidityPool,
Initializable,
ERC20,
Ownable,
Pausable,
IEventSender
{
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 public override underlyer; // Underlying ERC20 token
IManager public manager;
// implied: deployableLiquidity = underlyer.balanceOf(this) - withheldLiquidity
uint256 public override withheldLiquidity;
// fAsset holder -> WithdrawalInfo
mapping(address => WithdrawalInfo) public override requestedWithdrawals;
// NonReentrant
bool private _entered;
bool public _eventSend;
Destinations public destinations;
bool public depositsPaused;
address public constant STAKING = 0x96F98Ed74639689C3A11daf38ef86E59F43417D3;
modifier nonReentrant() {
}
modifier onEventSend() {
}
modifier whenDepositsNotPaused() {
}
event Migrated(address migrator, uint256 amount);
function initialize(
ERC20 _underlyer,
IManager _manager,
string memory _name,
string memory _symbol
) public initializer {
}
///@notice Gets decimals of underlyer so that tAsset decimals will match
function decimals() public view override returns (uint8) {
}
function deposit(uint256 amount) external override whenDepositsNotPaused {
}
function depositFor(address account, uint256 amount) external override whenDepositsNotPaused {
}
/// @dev References the WithdrawalInfo for how much the user is permitted to withdraw
/// @dev Allows withdraw regardless of cycle
/// @dev Decrements withheldLiquidity by the withdrawn amount
function withdraw(uint256 requestedAmount) external override whenNotPaused nonReentrant {
require(
requestedAmount <= requestedWithdrawals[msg.sender].amount,
"WITHDRAW_INSUFFICIENT_BALANCE"
);
require(requestedAmount > 0, "NO_WITHDRAWAL");
require(<FILL_ME>)
requestedWithdrawals[msg.sender].amount = requestedWithdrawals[msg.sender].amount.sub(
requestedAmount
);
// If full amount withdrawn delete from mapping
if (requestedWithdrawals[msg.sender].amount == 0) {
delete requestedWithdrawals[msg.sender];
}
withheldLiquidity = withheldLiquidity.sub(requestedAmount);
_burn(msg.sender, requestedAmount);
underlyer.safeTransfer(msg.sender, requestedAmount);
bytes32 eventSig = "Withdraw";
encodeAndSendData(eventSig, msg.sender);
}
function withdrawAndMigrate() external whenNotPaused nonReentrant {
}
function _approveStaking(uint256 amount, address staking) private {
}
/// @dev Adjusts the withheldLiquidity as necessary
/// @dev Updates the WithdrawalInfo for when a user can withdraw and for what requested amount
function requestWithdrawal(uint256 amount) external override {
}
function preTransferAdjustWithheldLiquidity(address sender, uint256 amount) internal {
}
function approveManager(uint256 amount) public override onlyOwner {
}
/// @dev Adjust withheldLiquidity and requestedWithdrawal if sender does not have sufficient unlocked balance for the transfer
function transfer(address recipient, uint256 amount)
public
override
whenNotPaused
nonReentrant
returns (bool)
{
}
/// @dev Adjust withheldLiquidity and requestedWithdrawal if sender does not have sufficient unlocked balance for the transfer
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override whenNotPaused nonReentrant returns (bool) {
}
function pause() external override onlyOwner {
}
function unpause() external override onlyOwner {
}
function pauseDeposit() external override onlyOwner {
}
function unpauseDeposit() external override onlyOwner {
}
function setDestinations(address _fxStateSender, address _destinationOnL2)
external
override
onlyOwner
{
}
function setEventSend(bool _eventSendSet) external override onlyOwner {
}
function _deposit(
address fromAccount,
address toAccount,
uint256 amount
) internal {
}
function encodeAndSendData(bytes32 _eventSig, address _user) private onEventSend {
}
}
| underlyer.balanceOf(address(this))>=requestedAmount,"INSUFFICIENT_POOL_BALANCE" | 367,909 | underlyer.balanceOf(address(this))>=requestedAmount |
null | /**
*Submitted for verification at Etherscan.io on 2019-09-09
* BEB dapp for www.betbeb.com
*/
pragma solidity^0.4.24;
interface tokenTransfer {
function transfer(address receiver, uint amount);
function transferFrom(address _from, address _to, uint256 _value);
function balanceOf(address receiver) returns(uint256);
}
contract Ownable {
address public owner;
function Ownable () public {
}
modifier onlyOwner {
}
/**
* @param newOwner address
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
contract BEBmining is Ownable{
tokenTransfer public bebTokenTransfer; //代币
uint8 decimals = 18;
struct BebUser {
address customerAddr;
uint256 amount;
uint256 bebtime;
uint256 interest;
}
//ETH miner
struct miner{
uint256 mining;
uint256 _mining;
uint256 lastDate;
uint256 amountdays;
uint256 ethbomus;
uint256 amountTotal;
uint256 ETHV1;
uint256 ETHV2;
uint256 ETHV3;
uint256 ETHV4;
uint256 ETHV5;
uint256 IntegralMining;
}
struct bebvv{
uint256 BEBV1;
uint256 BEBV2;
uint256 BEBV3;
uint256 BEBV4;
uint256 BEBV5;
}
mapping(address=>bebvv)public bebvvs;
mapping(address=>miner)public miners;
address[]public minersArray;
uint256 ethExchuangeRate=210;//eth-usd
uint256 bebethexchuang=97000;//beb-eth
uint256 bebethex=83360;//eth-beb
uint256 bounstotal;
uint256 TotalInvestment;
uint256 sumethbos;
uint256 depreciationTime=86400;
uint256 SellBeb;//SellBeb MAX 10000BEB
uint256 BuyBeb;//BuyBeb MAX 100000BEB
uint256 IncomePeriod=730;//Income period
address addressDraw;
uint256 intotime=1579073112;
event bomus(address to,uint256 amountBouns,string lx);
function BEBmining(address _tokenAddress,address Draw){
}
//BUY Ethminter
function EthTomining(address _addr)payable public{
}
//BUY BEBminter
function BebTomining(uint256 _value,address _addr)public{
}
//BUY 积分 minter
function integralTomining(uint256 _value,address _addr)onlyOwner{
}
//BUY 迁移合约
function migrateTomining(uint256 _value,uint256 _minin,uint256 time,uint256 _amountTotal,address _addr,uint256 bebv1,uint256 bebv2,uint256 bebv3,uint256 bebv4,uint256 bebv5)onlyOwner{
}
function setTomining(uint256 _value,uint256 _minin,address _addr)onlyOwner{
}
function setToTomining(uint256 _value,uint256 _minin,address _addr)onlyOwner{
}
//执行地址
function setaddress(address _addr)onlyOwner{
}
function freeSettlement()public{
}
function Refund()public{
}
function getbebmining()public view returns(uint256,uint256,uint256,uint256,uint256){
}
function querBalance()public view returns(uint256){
}
function querYrevenue()public view returns(uint256,uint256,uint256,uint256,uint256,uint256){
}
function ethmining()public view returns(uint256,uint256,uint256,uint256,uint256,uint256){
}
function getquerYrevenue()public view returns(uint256,uint256,uint256){
}
function RefundData()public view returns(uint256,uint256,uint256,uint256){
}
function ModifyexchangeRate(uint256 sellbeb,uint256 buybeb,uint256 _ethExchuangeRate,uint256 maxsell,uint256 maxbuy) onlyOwner{
}
// sellbeb-eth
function sellBeb(uint256 _sellbeb)public {
}
//buyBeb-eth
function buyBeb() payable public {
uint256 amount = msg.value;
uint256 bebamountub=amount*bebethex;
uint256 _transfer=amount*15/100;
require(<FILL_ME>)
addressDraw.transfer(_transfer);
bebTokenTransfer.transfer(msg.sender,bebamountub);
}
function queryRate() public view returns(uint256,uint256,uint256,uint256,uint256){
}
function TotalRevenue()public view returns(uint256,uint256) {
}
function setioc(uint256 _value)onlyOwner{
}
event messageBetsGame(address sender,bool isScuccess,string message);
function getTokenBalance() public view returns(uint256){
}
function BEBwithdrawAmount(uint256 amount) onlyOwner {
}
function ()payable{
}
}
| getTokenBalance()>bebamountub | 367,994 | getTokenBalance()>bebamountub |
"Insufficient contract balance" | /**
*Submitted for verification at Etherscan.io on 2019-09-09
* BEB dapp for www.betbeb.com
*/
pragma solidity^0.4.24;
interface tokenTransfer {
function transfer(address receiver, uint amount);
function transferFrom(address _from, address _to, uint256 _value);
function balanceOf(address receiver) returns(uint256);
}
contract Ownable {
address public owner;
function Ownable () public {
}
modifier onlyOwner {
}
/**
* @param newOwner address
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
contract BEBmining is Ownable{
tokenTransfer public bebTokenTransfer; //代币
uint8 decimals = 18;
struct BebUser {
address customerAddr;
uint256 amount;
uint256 bebtime;
uint256 interest;
}
//ETH miner
struct miner{
uint256 mining;
uint256 _mining;
uint256 lastDate;
uint256 amountdays;
uint256 ethbomus;
uint256 amountTotal;
uint256 ETHV1;
uint256 ETHV2;
uint256 ETHV3;
uint256 ETHV4;
uint256 ETHV5;
uint256 IntegralMining;
}
struct bebvv{
uint256 BEBV1;
uint256 BEBV2;
uint256 BEBV3;
uint256 BEBV4;
uint256 BEBV5;
}
mapping(address=>bebvv)public bebvvs;
mapping(address=>miner)public miners;
address[]public minersArray;
uint256 ethExchuangeRate=210;//eth-usd
uint256 bebethexchuang=97000;//beb-eth
uint256 bebethex=83360;//eth-beb
uint256 bounstotal;
uint256 TotalInvestment;
uint256 sumethbos;
uint256 depreciationTime=86400;
uint256 SellBeb;//SellBeb MAX 10000BEB
uint256 BuyBeb;//BuyBeb MAX 100000BEB
uint256 IncomePeriod=730;//Income period
address addressDraw;
uint256 intotime=1579073112;
event bomus(address to,uint256 amountBouns,string lx);
function BEBmining(address _tokenAddress,address Draw){
}
//BUY Ethminter
function EthTomining(address _addr)payable public{
}
//BUY BEBminter
function BebTomining(uint256 _value,address _addr)public{
}
//BUY 积分 minter
function integralTomining(uint256 _value,address _addr)onlyOwner{
}
//BUY 迁移合约
function migrateTomining(uint256 _value,uint256 _minin,uint256 time,uint256 _amountTotal,address _addr,uint256 bebv1,uint256 bebv2,uint256 bebv3,uint256 bebv4,uint256 bebv5)onlyOwner{
}
function setTomining(uint256 _value,uint256 _minin,address _addr)onlyOwner{
}
function setToTomining(uint256 _value,uint256 _minin,address _addr)onlyOwner{
}
//执行地址
function setaddress(address _addr)onlyOwner{
}
function freeSettlement()public{
}
function Refund()public{
}
function getbebmining()public view returns(uint256,uint256,uint256,uint256,uint256){
}
function querBalance()public view returns(uint256){
}
function querYrevenue()public view returns(uint256,uint256,uint256,uint256,uint256,uint256){
}
function ethmining()public view returns(uint256,uint256,uint256,uint256,uint256,uint256){
}
function getquerYrevenue()public view returns(uint256,uint256,uint256){
}
function RefundData()public view returns(uint256,uint256,uint256,uint256){
}
function ModifyexchangeRate(uint256 sellbeb,uint256 buybeb,uint256 _ethExchuangeRate,uint256 maxsell,uint256 maxbuy) onlyOwner{
}
// sellbeb-eth
function sellBeb(uint256 _sellbeb)public {
}
//buyBeb-eth
function buyBeb() payable public {
}
function queryRate() public view returns(uint256,uint256,uint256,uint256,uint256){
}
function TotalRevenue()public view returns(uint256,uint256) {
}
function setioc(uint256 _value)onlyOwner{
}
event messageBetsGame(address sender,bool isScuccess,string message);
function getTokenBalance() public view returns(uint256){
}
function BEBwithdrawAmount(uint256 amount) onlyOwner {
uint256 _amountbeb=amount* 10 ** 18;
require(<FILL_ME>)
bebTokenTransfer.transfer(owner,_amountbeb);
}
function ()payable{
}
}
| getTokenBalance()>_amountbeb,"Insufficient contract balance" | 367,994 | getTokenBalance()>_amountbeb |
"Reserve exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./Ownable.sol";
contract CosmicCritters is ERC721, Ownable {
using Address for address;
using Strings for uint256;
// metadata
bool public metadataLocked = false;
string public baseURI = "";
// supply and phases
mapping(uint256 => uint256) public supplyForPhase;
mapping(uint256 => uint256) public reserveForPhase;
mapping(uint256 => uint256) public mintIndexForPhase;
bool public presaleEnded = true;
bool public publicSaleEnded = false;
bool public mintPaused = false;
uint256 public currentPhase = 0;
// presale whitelist
mapping(address => bool) public isWhitelisted;
mapping(uint256 => mapping(address => uint256)) public mintedDuringPresaleAtPhase;
event SetWhitelist(address[] added, address[] removed);
// price
uint256 public price12 = 0.07 ether;
uint256 public price34 = 0.065 ether;
uint256 public price56 = 0.06 ether;
// limits
uint256 public maxPerTxDuringSale = 6;
uint256 public maxPerWalletDuringPresale = 2;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection, and by setting supply caps, mint indexes, and reserves
*/
constructor()
ERC721("CosmicCritters", "CRITTER")
{
}
/**
* ------------ METADATA ------------
*/
/**
* @dev Gets base metadata URI
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @dev Sets base metadata URI, callable by owner
*/
function setBaseUri(string memory _uri) external onlyOwner {
}
/**
* @dev Lock metadata URI forever, callable by owner
*/
function lockMetadata() external onlyOwner {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* ------------ SALE AND PRESALE ------------
*/
/**
* @dev Ends public sale forever, callable by owner
*/
function endSaleForever() external onlyOwner {
}
/**
* @dev Ends the presale, callable by owner
*/
function endPresaleForCurrentPhase() external onlyOwner {
}
/**
* @dev Advance sale phase
*/
function advanceToPresaleOfNextPhase() external onlyOwner {
}
/**
* @dev Pause/unpause sale or presale
*/
function togglePauseMinting() external onlyOwner {
}
/**
* ------------ CONFIGURATION ------------
*/
/**
* @dev Edit whitelist
*/
function editWhitelist(address[] calldata walletsToAdd, address[] calldata walletsToRemove) external onlyOwner {
}
/**
* @dev Edit sale parameters: price points and count limits
*/
function editParameters(uint256 _price12, uint256 _price34, uint256 _price56, uint256 _maxPerTxDuringSale, uint256 _maxPerWalletDuringPresale) external onlyOwner {
}
/**
* ------------ MINTING ------------
*/
/**
* @dev Mints `count` tokens to `to` address in `phase` phase of sale; phase can be one of [1,2,3,4]; internal
*/
function mintInternal(address to, uint256 count, uint256 phase) internal {
}
/**
* @dev Manual minting by owner, callable by owner; phase can be one of [1,2,3,4]
*/
function mintOwner(address[] calldata owners, uint256[] calldata counts, uint256 phase) external onlyOwner {
require(owners.length == counts.length, "Bad length");
for (uint256 i = 0; i < counts.length; i++) {
require(<FILL_ME>)
mintInternal(owners[i], counts[i], phase);
reserveForPhase[phase] -= counts[i];
supplyForPhase[phase] -= counts[i];
}
}
/**
* @dev Gets the price tier from token count
*/
function getPrice(uint256 count) public view returns (uint256) {
}
/**
* @dev Public minting during public sale or presale
*/
function mint(uint256 count) public payable{
}
/**
* @dev Withdraw ether from this contract, callable by owner
*/
function withdraw() external onlyOwner {
}
}
| reserveForPhase[phase]>=counts[i],"Reserve exceeded" | 368,087 | reserveForPhase[phase]>=counts[i] |
"Supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./Ownable.sol";
contract CosmicCritters is ERC721, Ownable {
using Address for address;
using Strings for uint256;
// metadata
bool public metadataLocked = false;
string public baseURI = "";
// supply and phases
mapping(uint256 => uint256) public supplyForPhase;
mapping(uint256 => uint256) public reserveForPhase;
mapping(uint256 => uint256) public mintIndexForPhase;
bool public presaleEnded = true;
bool public publicSaleEnded = false;
bool public mintPaused = false;
uint256 public currentPhase = 0;
// presale whitelist
mapping(address => bool) public isWhitelisted;
mapping(uint256 => mapping(address => uint256)) public mintedDuringPresaleAtPhase;
event SetWhitelist(address[] added, address[] removed);
// price
uint256 public price12 = 0.07 ether;
uint256 public price34 = 0.065 ether;
uint256 public price56 = 0.06 ether;
// limits
uint256 public maxPerTxDuringSale = 6;
uint256 public maxPerWalletDuringPresale = 2;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection, and by setting supply caps, mint indexes, and reserves
*/
constructor()
ERC721("CosmicCritters", "CRITTER")
{
}
/**
* ------------ METADATA ------------
*/
/**
* @dev Gets base metadata URI
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @dev Sets base metadata URI, callable by owner
*/
function setBaseUri(string memory _uri) external onlyOwner {
}
/**
* @dev Lock metadata URI forever, callable by owner
*/
function lockMetadata() external onlyOwner {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* ------------ SALE AND PRESALE ------------
*/
/**
* @dev Ends public sale forever, callable by owner
*/
function endSaleForever() external onlyOwner {
}
/**
* @dev Ends the presale, callable by owner
*/
function endPresaleForCurrentPhase() external onlyOwner {
}
/**
* @dev Advance sale phase
*/
function advanceToPresaleOfNextPhase() external onlyOwner {
}
/**
* @dev Pause/unpause sale or presale
*/
function togglePauseMinting() external onlyOwner {
}
/**
* ------------ CONFIGURATION ------------
*/
/**
* @dev Edit whitelist
*/
function editWhitelist(address[] calldata walletsToAdd, address[] calldata walletsToRemove) external onlyOwner {
}
/**
* @dev Edit sale parameters: price points and count limits
*/
function editParameters(uint256 _price12, uint256 _price34, uint256 _price56, uint256 _maxPerTxDuringSale, uint256 _maxPerWalletDuringPresale) external onlyOwner {
}
/**
* ------------ MINTING ------------
*/
/**
* @dev Mints `count` tokens to `to` address in `phase` phase of sale; phase can be one of [1,2,3,4]; internal
*/
function mintInternal(address to, uint256 count, uint256 phase) internal {
}
/**
* @dev Manual minting by owner, callable by owner; phase can be one of [1,2,3,4]
*/
function mintOwner(address[] calldata owners, uint256[] calldata counts, uint256 phase) external onlyOwner {
}
/**
* @dev Gets the price tier from token count
*/
function getPrice(uint256 count) public view returns (uint256) {
}
/**
* @dev Public minting during public sale or presale
*/
function mint(uint256 count) public payable{
require(!mintPaused, "Minting is currently paused");
require(currentPhase > 0, "Sale not started");
require(publicSaleEnded == false, "Sale ended");
require(msg.value == count * getPrice(count), "Ether value incorrect");
require(<FILL_ME>)
if (presaleEnded) {
// public sale checks
require(count <= maxPerTxDuringSale, "Too many tokens");
} else {
// presale checks
require(isWhitelisted[msg.sender], "You are not whitelisted");
require(mintedDuringPresaleAtPhase[currentPhase][msg.sender] + count <= maxPerWalletDuringPresale, "Count exceeded during presale");
mintedDuringPresaleAtPhase[currentPhase][msg.sender] += count;
}
supplyForPhase[currentPhase] -= count;
mintInternal(msg.sender, count, currentPhase);
}
/**
* @dev Withdraw ether from this contract, callable by owner
*/
function withdraw() external onlyOwner {
}
}
| supplyForPhase[currentPhase]-reserveForPhase[currentPhase]>=count,"Supply exceeded" | 368,087 | supplyForPhase[currentPhase]-reserveForPhase[currentPhase]>=count |
"Count exceeded during presale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./Ownable.sol";
contract CosmicCritters is ERC721, Ownable {
using Address for address;
using Strings for uint256;
// metadata
bool public metadataLocked = false;
string public baseURI = "";
// supply and phases
mapping(uint256 => uint256) public supplyForPhase;
mapping(uint256 => uint256) public reserveForPhase;
mapping(uint256 => uint256) public mintIndexForPhase;
bool public presaleEnded = true;
bool public publicSaleEnded = false;
bool public mintPaused = false;
uint256 public currentPhase = 0;
// presale whitelist
mapping(address => bool) public isWhitelisted;
mapping(uint256 => mapping(address => uint256)) public mintedDuringPresaleAtPhase;
event SetWhitelist(address[] added, address[] removed);
// price
uint256 public price12 = 0.07 ether;
uint256 public price34 = 0.065 ether;
uint256 public price56 = 0.06 ether;
// limits
uint256 public maxPerTxDuringSale = 6;
uint256 public maxPerWalletDuringPresale = 2;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection, and by setting supply caps, mint indexes, and reserves
*/
constructor()
ERC721("CosmicCritters", "CRITTER")
{
}
/**
* ------------ METADATA ------------
*/
/**
* @dev Gets base metadata URI
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @dev Sets base metadata URI, callable by owner
*/
function setBaseUri(string memory _uri) external onlyOwner {
}
/**
* @dev Lock metadata URI forever, callable by owner
*/
function lockMetadata() external onlyOwner {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/**
* ------------ SALE AND PRESALE ------------
*/
/**
* @dev Ends public sale forever, callable by owner
*/
function endSaleForever() external onlyOwner {
}
/**
* @dev Ends the presale, callable by owner
*/
function endPresaleForCurrentPhase() external onlyOwner {
}
/**
* @dev Advance sale phase
*/
function advanceToPresaleOfNextPhase() external onlyOwner {
}
/**
* @dev Pause/unpause sale or presale
*/
function togglePauseMinting() external onlyOwner {
}
/**
* ------------ CONFIGURATION ------------
*/
/**
* @dev Edit whitelist
*/
function editWhitelist(address[] calldata walletsToAdd, address[] calldata walletsToRemove) external onlyOwner {
}
/**
* @dev Edit sale parameters: price points and count limits
*/
function editParameters(uint256 _price12, uint256 _price34, uint256 _price56, uint256 _maxPerTxDuringSale, uint256 _maxPerWalletDuringPresale) external onlyOwner {
}
/**
* ------------ MINTING ------------
*/
/**
* @dev Mints `count` tokens to `to` address in `phase` phase of sale; phase can be one of [1,2,3,4]; internal
*/
function mintInternal(address to, uint256 count, uint256 phase) internal {
}
/**
* @dev Manual minting by owner, callable by owner; phase can be one of [1,2,3,4]
*/
function mintOwner(address[] calldata owners, uint256[] calldata counts, uint256 phase) external onlyOwner {
}
/**
* @dev Gets the price tier from token count
*/
function getPrice(uint256 count) public view returns (uint256) {
}
/**
* @dev Public minting during public sale or presale
*/
function mint(uint256 count) public payable{
require(!mintPaused, "Minting is currently paused");
require(currentPhase > 0, "Sale not started");
require(publicSaleEnded == false, "Sale ended");
require(msg.value == count * getPrice(count), "Ether value incorrect");
require(supplyForPhase[currentPhase] - reserveForPhase[currentPhase] >= count, "Supply exceeded");
if (presaleEnded) {
// public sale checks
require(count <= maxPerTxDuringSale, "Too many tokens");
} else {
// presale checks
require(isWhitelisted[msg.sender], "You are not whitelisted");
require(<FILL_ME>)
mintedDuringPresaleAtPhase[currentPhase][msg.sender] += count;
}
supplyForPhase[currentPhase] -= count;
mintInternal(msg.sender, count, currentPhase);
}
/**
* @dev Withdraw ether from this contract, callable by owner
*/
function withdraw() external onlyOwner {
}
}
| mintedDuringPresaleAtPhase[currentPhase][msg.sender]+count<=maxPerWalletDuringPresale,"Count exceeded during presale" | 368,087 | mintedDuringPresaleAtPhase[currentPhase][msg.sender]+count<=maxPerWalletDuringPresale |
"INVALID_TITLE" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "base64-sol/base64.sol";
contract CoolDatesClub is Ownable, ERC721Enumerable, ReentrancyGuard {
struct MetaData {
string title;
string subtitle;
uint24 date;
uint32 [6] colors;
}
string private _imgTemplate;
string private _contractURI;
uint256 public limitPerWallet = type(uint128).max;
uint8 public maximumNameLength = 32;
uint256 public minimumPrice = 0.01 ether;
uint256 public nextTokenId = 1;
mapping(uint256 => MetaData) private _tokenId_to_data;
mapping(uint24 => uint256) private _date_to_tokenId;
event Minted(address indexed sender, address indexed recipient, uint tokenId, uint24 tokenDate);
constructor(string memory imgTemplate_, string memory contractURI_) ERC721("CoolDatesClub", "CDC") {
}
function setLimitPerWallet(uint256 limit_per_wallet_) external onlyOwner returns (bool) {
}
function setMinimumPrice(uint256 price_) external onlyOwner returns (bool) {
}
function setMaximumNameLength(uint8 length_) external onlyOwner returns (bool) {
}
function setContractURI(string memory data_) external onlyOwner returns (bool) {
}
function contractURI() external view returns (string memory) {
}
function withdraw(address payable _to) external payable onlyOwner returns (bool) {
}
function withdraw() external onlyOwner returns (bool) {
}
function _dateToUint24(uint8 day_, uint8 month_, uint16 year_) internal pure returns (uint24) {
}
function _uint24ToDate(uint24 date_) internal pure returns (uint8, uint8, uint16) {
}
function _uint32ToColor(uint32 i_) internal pure returns (string memory) {
}
function setImageTemplate(string memory template_) external onlyOwner returns (bool) {
}
function setTitlesAndColors(uint8 day_, uint8 month_, uint16 year_, string memory title_, string memory subtitle_, uint32[6] memory colors_) external nonReentrant returns (bool) {
uint24 tokenDate = _dateToUint24(day_, month_, year_);
uint256 tokenId = _date_to_tokenId[tokenDate];
require(_exists(tokenId), "NONEXISTENT_TOKEN");
require(ownerOf(tokenId) == msg.sender, "NOT_OWNER");
require(<FILL_ME>)
require(bytes(subtitle_).length <= maximumNameLength, "INVALID_SUBTITLE");
_tokenId_to_data[tokenId].title = title_;
_tokenId_to_data[tokenId].subtitle = subtitle_;
_tokenId_to_data[tokenId].colors = colors_;
return true;
}
function setTitles(uint8 day_, uint8 month_, uint16 year_, string memory title_, string memory subtitle_) external nonReentrant returns (bool) {
}
function titles(uint8 day_, uint8 month_, uint16 year_) external view returns (string memory, string memory) {
}
function dateToTokenId(uint8 day_, uint8 month_, uint16 year_) external view returns (uint256) {
}
function date(uint256 tokenId_) external view returns (uint8, uint8, uint16) {
}
function tokenData(uint256 tokenId_) external view returns (string memory, string memory, uint24, uint32[6] memory) {
}
function airDrop(
address[] memory recipients_,
uint8[] memory days_,
uint8[] memory months_,
uint16[] memory years_,
string[] memory titles_,
string[] memory subtitles_,
uint32[6][] memory colors_
) external onlyOwner returns (bool) {
}
function mintMulti(
address[] memory recipients_,
uint8[] memory days_,
uint8[] memory months_,
uint16[] memory years_,
string[] memory titles_,
string[] memory subtitles_,
uint32[6][] memory colors_
) external payable nonReentrant returns (bool) {
}
function mint(
address recipient_,
uint8 day_,
uint8 month_,
uint16 year_,
string memory title_,
string memory subtitle_,
uint32[6] memory colors_
) external payable nonReentrant returns (uint256) {
}
function __mint(
address recipient_,
uint8 day_,
uint8 month_,
uint16 year_,
string memory title_,
string memory subtitle_,
uint32[6] memory colors_
) internal returns (uint256) {
}
function _monthString(uint8 month_) internal pure returns (string memory) {
}
function _substring(bytes memory str_, uint16 startIndex_, uint16 endIndex_) internal pure returns (bytes memory) {
}
function _replaceString(bytes memory orig_, bytes memory rep_, string memory with_, bool repeat_) internal pure returns (bytes memory) {
}
function tokenURI(uint256 tokenId_) public view virtual override returns (string memory) {
}
}
| bytes(title_).length<=maximumNameLength,"INVALID_TITLE" | 368,097 | bytes(title_).length<=maximumNameLength |
"INVALID_SUBTITLE" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "base64-sol/base64.sol";
contract CoolDatesClub is Ownable, ERC721Enumerable, ReentrancyGuard {
struct MetaData {
string title;
string subtitle;
uint24 date;
uint32 [6] colors;
}
string private _imgTemplate;
string private _contractURI;
uint256 public limitPerWallet = type(uint128).max;
uint8 public maximumNameLength = 32;
uint256 public minimumPrice = 0.01 ether;
uint256 public nextTokenId = 1;
mapping(uint256 => MetaData) private _tokenId_to_data;
mapping(uint24 => uint256) private _date_to_tokenId;
event Minted(address indexed sender, address indexed recipient, uint tokenId, uint24 tokenDate);
constructor(string memory imgTemplate_, string memory contractURI_) ERC721("CoolDatesClub", "CDC") {
}
function setLimitPerWallet(uint256 limit_per_wallet_) external onlyOwner returns (bool) {
}
function setMinimumPrice(uint256 price_) external onlyOwner returns (bool) {
}
function setMaximumNameLength(uint8 length_) external onlyOwner returns (bool) {
}
function setContractURI(string memory data_) external onlyOwner returns (bool) {
}
function contractURI() external view returns (string memory) {
}
function withdraw(address payable _to) external payable onlyOwner returns (bool) {
}
function withdraw() external onlyOwner returns (bool) {
}
function _dateToUint24(uint8 day_, uint8 month_, uint16 year_) internal pure returns (uint24) {
}
function _uint24ToDate(uint24 date_) internal pure returns (uint8, uint8, uint16) {
}
function _uint32ToColor(uint32 i_) internal pure returns (string memory) {
}
function setImageTemplate(string memory template_) external onlyOwner returns (bool) {
}
function setTitlesAndColors(uint8 day_, uint8 month_, uint16 year_, string memory title_, string memory subtitle_, uint32[6] memory colors_) external nonReentrant returns (bool) {
uint24 tokenDate = _dateToUint24(day_, month_, year_);
uint256 tokenId = _date_to_tokenId[tokenDate];
require(_exists(tokenId), "NONEXISTENT_TOKEN");
require(ownerOf(tokenId) == msg.sender, "NOT_OWNER");
require(bytes(title_).length <= maximumNameLength, "INVALID_TITLE");
require(<FILL_ME>)
_tokenId_to_data[tokenId].title = title_;
_tokenId_to_data[tokenId].subtitle = subtitle_;
_tokenId_to_data[tokenId].colors = colors_;
return true;
}
function setTitles(uint8 day_, uint8 month_, uint16 year_, string memory title_, string memory subtitle_) external nonReentrant returns (bool) {
}
function titles(uint8 day_, uint8 month_, uint16 year_) external view returns (string memory, string memory) {
}
function dateToTokenId(uint8 day_, uint8 month_, uint16 year_) external view returns (uint256) {
}
function date(uint256 tokenId_) external view returns (uint8, uint8, uint16) {
}
function tokenData(uint256 tokenId_) external view returns (string memory, string memory, uint24, uint32[6] memory) {
}
function airDrop(
address[] memory recipients_,
uint8[] memory days_,
uint8[] memory months_,
uint16[] memory years_,
string[] memory titles_,
string[] memory subtitles_,
uint32[6][] memory colors_
) external onlyOwner returns (bool) {
}
function mintMulti(
address[] memory recipients_,
uint8[] memory days_,
uint8[] memory months_,
uint16[] memory years_,
string[] memory titles_,
string[] memory subtitles_,
uint32[6][] memory colors_
) external payable nonReentrant returns (bool) {
}
function mint(
address recipient_,
uint8 day_,
uint8 month_,
uint16 year_,
string memory title_,
string memory subtitle_,
uint32[6] memory colors_
) external payable nonReentrant returns (uint256) {
}
function __mint(
address recipient_,
uint8 day_,
uint8 month_,
uint16 year_,
string memory title_,
string memory subtitle_,
uint32[6] memory colors_
) internal returns (uint256) {
}
function _monthString(uint8 month_) internal pure returns (string memory) {
}
function _substring(bytes memory str_, uint16 startIndex_, uint16 endIndex_) internal pure returns (bytes memory) {
}
function _replaceString(bytes memory orig_, bytes memory rep_, string memory with_, bool repeat_) internal pure returns (bytes memory) {
}
function tokenURI(uint256 tokenId_) public view virtual override returns (string memory) {
}
}
| bytes(subtitle_).length<=maximumNameLength,"INVALID_SUBTITLE" | 368,097 | bytes(subtitle_).length<=maximumNameLength |
"WALLET_LIMIT_REACHED" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "base64-sol/base64.sol";
contract CoolDatesClub is Ownable, ERC721Enumerable, ReentrancyGuard {
struct MetaData {
string title;
string subtitle;
uint24 date;
uint32 [6] colors;
}
string private _imgTemplate;
string private _contractURI;
uint256 public limitPerWallet = type(uint128).max;
uint8 public maximumNameLength = 32;
uint256 public minimumPrice = 0.01 ether;
uint256 public nextTokenId = 1;
mapping(uint256 => MetaData) private _tokenId_to_data;
mapping(uint24 => uint256) private _date_to_tokenId;
event Minted(address indexed sender, address indexed recipient, uint tokenId, uint24 tokenDate);
constructor(string memory imgTemplate_, string memory contractURI_) ERC721("CoolDatesClub", "CDC") {
}
function setLimitPerWallet(uint256 limit_per_wallet_) external onlyOwner returns (bool) {
}
function setMinimumPrice(uint256 price_) external onlyOwner returns (bool) {
}
function setMaximumNameLength(uint8 length_) external onlyOwner returns (bool) {
}
function setContractURI(string memory data_) external onlyOwner returns (bool) {
}
function contractURI() external view returns (string memory) {
}
function withdraw(address payable _to) external payable onlyOwner returns (bool) {
}
function withdraw() external onlyOwner returns (bool) {
}
function _dateToUint24(uint8 day_, uint8 month_, uint16 year_) internal pure returns (uint24) {
}
function _uint24ToDate(uint24 date_) internal pure returns (uint8, uint8, uint16) {
}
function _uint32ToColor(uint32 i_) internal pure returns (string memory) {
}
function setImageTemplate(string memory template_) external onlyOwner returns (bool) {
}
function setTitlesAndColors(uint8 day_, uint8 month_, uint16 year_, string memory title_, string memory subtitle_, uint32[6] memory colors_) external nonReentrant returns (bool) {
}
function setTitles(uint8 day_, uint8 month_, uint16 year_, string memory title_, string memory subtitle_) external nonReentrant returns (bool) {
}
function titles(uint8 day_, uint8 month_, uint16 year_) external view returns (string memory, string memory) {
}
function dateToTokenId(uint8 day_, uint8 month_, uint16 year_) external view returns (uint256) {
}
function date(uint256 tokenId_) external view returns (uint8, uint8, uint16) {
}
function tokenData(uint256 tokenId_) external view returns (string memory, string memory, uint24, uint32[6] memory) {
}
function airDrop(
address[] memory recipients_,
uint8[] memory days_,
uint8[] memory months_,
uint16[] memory years_,
string[] memory titles_,
string[] memory subtitles_,
uint32[6][] memory colors_
) external onlyOwner returns (bool) {
}
function mintMulti(
address[] memory recipients_,
uint8[] memory days_,
uint8[] memory months_,
uint16[] memory years_,
string[] memory titles_,
string[] memory subtitles_,
uint32[6][] memory colors_
) external payable nonReentrant returns (bool) {
require(msg.value >= minimumPrice * recipients_.length, "NOT_ENOUGH_ETHER");
for (uint i = 0; i < recipients_.length; i++) {
require(<FILL_ME>)
__mint(recipients_[i], days_[i], months_[i], years_[i], titles_[i], subtitles_[i], colors_[i]);
}
return true;
}
function mint(
address recipient_,
uint8 day_,
uint8 month_,
uint16 year_,
string memory title_,
string memory subtitle_,
uint32[6] memory colors_
) external payable nonReentrant returns (uint256) {
}
function __mint(
address recipient_,
uint8 day_,
uint8 month_,
uint16 year_,
string memory title_,
string memory subtitle_,
uint32[6] memory colors_
) internal returns (uint256) {
}
function _monthString(uint8 month_) internal pure returns (string memory) {
}
function _substring(bytes memory str_, uint16 startIndex_, uint16 endIndex_) internal pure returns (bytes memory) {
}
function _replaceString(bytes memory orig_, bytes memory rep_, string memory with_, bool repeat_) internal pure returns (bytes memory) {
}
function tokenURI(uint256 tokenId_) public view virtual override returns (string memory) {
}
}
| balanceOf(recipients_[i])<limitPerWallet,"WALLET_LIMIT_REACHED" | 368,097 | balanceOf(recipients_[i])<limitPerWallet |
"WALLET_LIMIT_REACHED" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "base64-sol/base64.sol";
contract CoolDatesClub is Ownable, ERC721Enumerable, ReentrancyGuard {
struct MetaData {
string title;
string subtitle;
uint24 date;
uint32 [6] colors;
}
string private _imgTemplate;
string private _contractURI;
uint256 public limitPerWallet = type(uint128).max;
uint8 public maximumNameLength = 32;
uint256 public minimumPrice = 0.01 ether;
uint256 public nextTokenId = 1;
mapping(uint256 => MetaData) private _tokenId_to_data;
mapping(uint24 => uint256) private _date_to_tokenId;
event Minted(address indexed sender, address indexed recipient, uint tokenId, uint24 tokenDate);
constructor(string memory imgTemplate_, string memory contractURI_) ERC721("CoolDatesClub", "CDC") {
}
function setLimitPerWallet(uint256 limit_per_wallet_) external onlyOwner returns (bool) {
}
function setMinimumPrice(uint256 price_) external onlyOwner returns (bool) {
}
function setMaximumNameLength(uint8 length_) external onlyOwner returns (bool) {
}
function setContractURI(string memory data_) external onlyOwner returns (bool) {
}
function contractURI() external view returns (string memory) {
}
function withdraw(address payable _to) external payable onlyOwner returns (bool) {
}
function withdraw() external onlyOwner returns (bool) {
}
function _dateToUint24(uint8 day_, uint8 month_, uint16 year_) internal pure returns (uint24) {
}
function _uint24ToDate(uint24 date_) internal pure returns (uint8, uint8, uint16) {
}
function _uint32ToColor(uint32 i_) internal pure returns (string memory) {
}
function setImageTemplate(string memory template_) external onlyOwner returns (bool) {
}
function setTitlesAndColors(uint8 day_, uint8 month_, uint16 year_, string memory title_, string memory subtitle_, uint32[6] memory colors_) external nonReentrant returns (bool) {
}
function setTitles(uint8 day_, uint8 month_, uint16 year_, string memory title_, string memory subtitle_) external nonReentrant returns (bool) {
}
function titles(uint8 day_, uint8 month_, uint16 year_) external view returns (string memory, string memory) {
}
function dateToTokenId(uint8 day_, uint8 month_, uint16 year_) external view returns (uint256) {
}
function date(uint256 tokenId_) external view returns (uint8, uint8, uint16) {
}
function tokenData(uint256 tokenId_) external view returns (string memory, string memory, uint24, uint32[6] memory) {
}
function airDrop(
address[] memory recipients_,
uint8[] memory days_,
uint8[] memory months_,
uint16[] memory years_,
string[] memory titles_,
string[] memory subtitles_,
uint32[6][] memory colors_
) external onlyOwner returns (bool) {
}
function mintMulti(
address[] memory recipients_,
uint8[] memory days_,
uint8[] memory months_,
uint16[] memory years_,
string[] memory titles_,
string[] memory subtitles_,
uint32[6][] memory colors_
) external payable nonReentrant returns (bool) {
}
function mint(
address recipient_,
uint8 day_,
uint8 month_,
uint16 year_,
string memory title_,
string memory subtitle_,
uint32[6] memory colors_
) external payable nonReentrant returns (uint256) {
/* colors: header, body, text, day, month, year*/
require(msg.value >= minimumPrice, "NOT_ENOUGH_ETHER");
require(<FILL_ME>)
return __mint(recipient_, day_, month_, year_, title_, subtitle_, colors_);
}
function __mint(
address recipient_,
uint8 day_,
uint8 month_,
uint16 year_,
string memory title_,
string memory subtitle_,
uint32[6] memory colors_
) internal returns (uint256) {
}
function _monthString(uint8 month_) internal pure returns (string memory) {
}
function _substring(bytes memory str_, uint16 startIndex_, uint16 endIndex_) internal pure returns (bytes memory) {
}
function _replaceString(bytes memory orig_, bytes memory rep_, string memory with_, bool repeat_) internal pure returns (bytes memory) {
}
function tokenURI(uint256 tokenId_) public view virtual override returns (string memory) {
}
}
| balanceOf(recipient_)<limitPerWallet,"WALLET_LIMIT_REACHED" | 368,097 | balanceOf(recipient_)<limitPerWallet |
"DATE_ALREADY_EXISTS" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "base64-sol/base64.sol";
contract CoolDatesClub is Ownable, ERC721Enumerable, ReentrancyGuard {
struct MetaData {
string title;
string subtitle;
uint24 date;
uint32 [6] colors;
}
string private _imgTemplate;
string private _contractURI;
uint256 public limitPerWallet = type(uint128).max;
uint8 public maximumNameLength = 32;
uint256 public minimumPrice = 0.01 ether;
uint256 public nextTokenId = 1;
mapping(uint256 => MetaData) private _tokenId_to_data;
mapping(uint24 => uint256) private _date_to_tokenId;
event Minted(address indexed sender, address indexed recipient, uint tokenId, uint24 tokenDate);
constructor(string memory imgTemplate_, string memory contractURI_) ERC721("CoolDatesClub", "CDC") {
}
function setLimitPerWallet(uint256 limit_per_wallet_) external onlyOwner returns (bool) {
}
function setMinimumPrice(uint256 price_) external onlyOwner returns (bool) {
}
function setMaximumNameLength(uint8 length_) external onlyOwner returns (bool) {
}
function setContractURI(string memory data_) external onlyOwner returns (bool) {
}
function contractURI() external view returns (string memory) {
}
function withdraw(address payable _to) external payable onlyOwner returns (bool) {
}
function withdraw() external onlyOwner returns (bool) {
}
function _dateToUint24(uint8 day_, uint8 month_, uint16 year_) internal pure returns (uint24) {
}
function _uint24ToDate(uint24 date_) internal pure returns (uint8, uint8, uint16) {
}
function _uint32ToColor(uint32 i_) internal pure returns (string memory) {
}
function setImageTemplate(string memory template_) external onlyOwner returns (bool) {
}
function setTitlesAndColors(uint8 day_, uint8 month_, uint16 year_, string memory title_, string memory subtitle_, uint32[6] memory colors_) external nonReentrant returns (bool) {
}
function setTitles(uint8 day_, uint8 month_, uint16 year_, string memory title_, string memory subtitle_) external nonReentrant returns (bool) {
}
function titles(uint8 day_, uint8 month_, uint16 year_) external view returns (string memory, string memory) {
}
function dateToTokenId(uint8 day_, uint8 month_, uint16 year_) external view returns (uint256) {
}
function date(uint256 tokenId_) external view returns (uint8, uint8, uint16) {
}
function tokenData(uint256 tokenId_) external view returns (string memory, string memory, uint24, uint32[6] memory) {
}
function airDrop(
address[] memory recipients_,
uint8[] memory days_,
uint8[] memory months_,
uint16[] memory years_,
string[] memory titles_,
string[] memory subtitles_,
uint32[6][] memory colors_
) external onlyOwner returns (bool) {
}
function mintMulti(
address[] memory recipients_,
uint8[] memory days_,
uint8[] memory months_,
uint16[] memory years_,
string[] memory titles_,
string[] memory subtitles_,
uint32[6][] memory colors_
) external payable nonReentrant returns (bool) {
}
function mint(
address recipient_,
uint8 day_,
uint8 month_,
uint16 year_,
string memory title_,
string memory subtitle_,
uint32[6] memory colors_
) external payable nonReentrant returns (uint256) {
}
function __mint(
address recipient_,
uint8 day_,
uint8 month_,
uint16 year_,
string memory title_,
string memory subtitle_,
uint32[6] memory colors_
) internal returns (uint256) {
require(day_ <= 31 && day_ > 0, "INVALID_DAY");
require(month_ <= 12 && month_ >= 1, "INVALID_MONTH");
require(bytes(title_).length <= maximumNameLength, "INVALID_TITLE");
require(bytes(subtitle_).length <= maximumNameLength, "INVALID_SUBTITLE");
uint24 tokenDate = uint24(_dateToUint24(day_, month_, year_));
require(<FILL_ME>)
uint256 newTokenId = nextTokenId;
_mint(recipient_, newTokenId);
nextTokenId += 1;
_date_to_tokenId[tokenDate] = newTokenId;
_tokenId_to_data[newTokenId] = MetaData({
title: title_,
subtitle: subtitle_,
date: tokenDate,
colors: colors_
});
emit Minted(msg.sender, recipient_, newTokenId, tokenDate);
return newTokenId;
}
function _monthString(uint8 month_) internal pure returns (string memory) {
}
function _substring(bytes memory str_, uint16 startIndex_, uint16 endIndex_) internal pure returns (bytes memory) {
}
function _replaceString(bytes memory orig_, bytes memory rep_, string memory with_, bool repeat_) internal pure returns (bytes memory) {
}
function tokenURI(uint256 tokenId_) public view virtual override returns (string memory) {
}
}
| _date_to_tokenId[tokenDate]==0,"DATE_ALREADY_EXISTS" | 368,097 | _date_to_tokenId[tokenDate]==0 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./IFactoryERC721.sol";
import "./BunnyBabies.sol";
import "./ERC721Tradable.sol";
contract BunnyBabiesFactory is FactoryERC721, Ownable {
using Strings for string;
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
address public proxyRegistryAddress;
address public nftAddress;
string public baseURI = "https://bunnies.crocpot.io/factory/";
uint256 TOTAL_SUPPLY = 10000;
uint256 NUM_OPTIONS = 2;
uint256 SINGLE_BUNNY_OPTION = 0;
uint256 MULTIPLE_BUNNY_OPTION = 1;
uint256 MIN_BUNNIES_IN_MULTIPLE_OPTION = 4;
/// Temporary discount prices
uint256 public priceSingle = .025 ether;
uint256 public priceMultiple = .125 ether;
constructor(address _proxyRegistryAddress, address _nftAddress) {
}
function name() override external pure returns (string memory) {
}
function symbol() override external pure returns (string memory) {
}
function supportsFactoryInterface() override public pure returns (bool) {
}
function numOptions() override public view returns (uint256) {
}
function transferOwnership(address newOwner) override public onlyOwner {
}
function fireTransferEvents(address _from, address _to) private {
}
function mint(uint256 _optionId, address _toAddress) override public {
}
function canMint(uint256 _optionId) override public view returns (bool) {
}
function tokenURI(uint256 _optionId) override external view returns (string memory) {
}
/**
* Hack to get things to work automatically on OpenSea.
* Use transferFrom so the frontend doesn't have to worry about different method names.
*/
function transferFrom(
address,
address _to,
uint256 _tokenId
) public {
}
/**
* Hack to get things to work automatically on OpenSea.
* Use isApprovedForAll so the frontend doesn't have to worry about different method names.
*/
function isApprovedForAll(address _owner, address _operator)
public
view
returns (bool)
{
}
/**
* Hack to get things to work automatically on OpenSea.
* Use isApprovedForAll so the frontend doesn't have to worry about different method names.
*/
function ownerOf(uint256) public view returns (address _owner) {
}
/**
* Allow an airdrop an item for each address in an array (low-gas mint)
*/
function airdrop(address[] calldata recipients) public onlyOwner {
}
function updatePrice(uint256 _priceSingle, uint256 _priceMultiple) public onlyOwner {
}
function mintOneWithDiscount() public payable{
require(<FILL_ME>)
require(priceSingle <= msg.value, "Insufficient ETH");
(bool _success,) = owner().call{value: msg.value}("");
require(_success);
BunnyBabies bunnyBabies = BunnyBabies(nftAddress);
bunnyBabies.mintTo(_msgSender());
}
function mintMultipleWithDiscount() public payable {
}
}
| canMint(SINGLE_BUNNY_OPTION) | 368,138 | canMint(SINGLE_BUNNY_OPTION) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./IFactoryERC721.sol";
import "./BunnyBabies.sol";
import "./ERC721Tradable.sol";
contract BunnyBabiesFactory is FactoryERC721, Ownable {
using Strings for string;
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
address public proxyRegistryAddress;
address public nftAddress;
string public baseURI = "https://bunnies.crocpot.io/factory/";
uint256 TOTAL_SUPPLY = 10000;
uint256 NUM_OPTIONS = 2;
uint256 SINGLE_BUNNY_OPTION = 0;
uint256 MULTIPLE_BUNNY_OPTION = 1;
uint256 MIN_BUNNIES_IN_MULTIPLE_OPTION = 4;
/// Temporary discount prices
uint256 public priceSingle = .025 ether;
uint256 public priceMultiple = .125 ether;
constructor(address _proxyRegistryAddress, address _nftAddress) {
}
function name() override external pure returns (string memory) {
}
function symbol() override external pure returns (string memory) {
}
function supportsFactoryInterface() override public pure returns (bool) {
}
function numOptions() override public view returns (uint256) {
}
function transferOwnership(address newOwner) override public onlyOwner {
}
function fireTransferEvents(address _from, address _to) private {
}
function mint(uint256 _optionId, address _toAddress) override public {
}
function canMint(uint256 _optionId) override public view returns (bool) {
}
function tokenURI(uint256 _optionId) override external view returns (string memory) {
}
/**
* Hack to get things to work automatically on OpenSea.
* Use transferFrom so the frontend doesn't have to worry about different method names.
*/
function transferFrom(
address,
address _to,
uint256 _tokenId
) public {
}
/**
* Hack to get things to work automatically on OpenSea.
* Use isApprovedForAll so the frontend doesn't have to worry about different method names.
*/
function isApprovedForAll(address _owner, address _operator)
public
view
returns (bool)
{
}
/**
* Hack to get things to work automatically on OpenSea.
* Use isApprovedForAll so the frontend doesn't have to worry about different method names.
*/
function ownerOf(uint256) public view returns (address _owner) {
}
/**
* Allow an airdrop an item for each address in an array (low-gas mint)
*/
function airdrop(address[] calldata recipients) public onlyOwner {
}
function updatePrice(uint256 _priceSingle, uint256 _priceMultiple) public onlyOwner {
}
function mintOneWithDiscount() public payable{
}
function mintMultipleWithDiscount() public payable {
require(<FILL_ME>)
require(priceMultiple <= msg.value, "Insufficient ETH");
(bool _success,) = owner().call{value: msg.value}("");
require(_success);
uint256 rand = uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty))) % 4;
uint256 count = MIN_BUNNIES_IN_MULTIPLE_OPTION + rand;
BunnyBabies bunnyBabies = BunnyBabies(nftAddress);
for (
uint256 i = 0;
i < count;
i++
) {
bunnyBabies.mintTo(_msgSender());
}
}
}
| canMint(MULTIPLE_BUNNY_OPTION) | 368,138 | canMint(MULTIPLE_BUNNY_OPTION) |
null | pragma solidity ^0.4.15;
/* TODO: change this to an interface definition as soon as truffle accepts it. See https://github.com/trufflesuite/truffle/issues/560 */
contract ITransferable {
function transfer(address _to, uint256 _value) public returns (bool success);
}
/**
@title PLAY Token
ERC20 Token with additional mint functionality.
A "controller" (initialized to the contract creator) has exclusive permission to mint.
The controller address can be changed until locked.
Implementation based on https://github.com/ConsenSys/Tokens
*/
contract PlayToken {
uint256 public totalSupply = 0;
string public name = "PLAY";
uint8 public decimals = 18;
string public symbol = "PLY";
string public version = '1';
address public controller;
bool public controllerLocked = false;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
modifier onlyController() {
}
/** @dev constructor */
function PlayToken(address _controller) {
}
/** Sets a new controller address if the current controller isn't locked */
function setController(address _newController) onlyController {
require(<FILL_ME>)
controller = _newController;
}
/** Locks the current controller address forever */
function lockController() onlyController {
}
/**
Creates new tokens for the given receiver.
Can be called only by the contract creator.
*/
function mint(address _receiver, uint256 _value) onlyController {
}
function transfer(address _to, uint256 _value) returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
}
function balanceOf(address _owner) constant returns (uint256 balance) {
}
function approve(address _spender, uint256 _value) returns (bool success) {
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
}
/* Approves and then calls the receiving contract */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
}
/**
Withdraws tokens held by the contract to a given account.
Motivation: see https://github.com/ethereum/EIPs/issues/223#issuecomment-317987571
*/
function withdrawTokens(ITransferable _token, address _to, uint256 _amount) onlyController {
}
}
| !controllerLocked | 368,153 | !controllerLocked |
null | pragma solidity ^0.4.23;
/**xxp
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title ERC20Basic
*/
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is ERC20Basic {
using SafeMath for uint256;
mapping (address => mapping (address => uint256)) internal allowed;
// store tokens
mapping(address => uint256) balances;
// uint256 public totalSupply;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
}
/**
*batch transfer token for a list of specified addresses
* @param _toList The list of addresses to transfer to.
* @param _tokensList The list of amount to be transferred.
*/
function batchTransfer(address[] _toList, uint256[] _tokensList) public returns (bool) {
require(_toList.length <= 100);
require(_toList.length == _tokensList.length);
uint256 sum = 0;
for (uint32 index = 0; index < _tokensList.length; index++) {
sum = sum.add(_tokensList[index]);
}
// if the sender doenst have enough balance then stop
require(<FILL_ME>)
for (uint32 i = 0; i < _toList.length; i++) {
transfer(_toList[i],_tokensList[i]);
}
return true;
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public constant returns (uint256 balance) {
}
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
}
}
/**
* @title Burnable Token
* @dev Token that can be irreversibly burned (destroyed).
*/
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public {
}
}
/**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
}
/**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
}
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner public returns (bool) {
}
}
/**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
/**
* @title Pausable token
*
* @dev StandardToken modified with pausable transfers.
**/
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
}
function batchTransfer(address[] _toList, uint256[] _tokensList) public whenNotPaused returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
}
}
/*
* @title DELCToken
*/
contract DELCToken is BurnableToken, MintableToken, PausableToken {
// Public variables of the token
string public name;
string public symbol;
// ��ͬ��Wei�ĸ���, decimals is the strongly suggested default, avoid changing it
uint8 public decimals;
constructor() public {
}
// transfer balance to owner
//function withdrawEther() onlyOwner public {
// owner.transfer(this.balance);
//}
// can accept ether
//function() payable public {
//}
}
| balances[msg.sender]>=sum | 368,189 | balances[msg.sender]>=sum |
null | pragma solidity ^0.4.23;
library SafeMath
{
function add(uint256 a, uint256 b) internal pure returns (uint256)
{
}
function sub(uint256 a, uint256 b) internal pure returns (uint256)
{
}
function mul(uint256 a,uint256 b)internal pure returns (uint256)
{
}
function div(uint256 a,uint256 b)internal pure returns (uint256)
{
}
}
contract ERC20
{
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Owned
{
address public owner;
constructor() internal
{
}
modifier onlyowner()
{
}
}
contract pausable is Owned
{
event Pause();
event Unpause();
bool public pause = false;
modifier whenNotPaused()
{
}
modifier whenPaused()
{
}
function pause() onlyowner whenNotPaused public
{
}
function unpause() onlyowner whenPaused public
{
}
}
contract TokenControl is ERC20,pausable
{
using SafeMath for uint256;
mapping (address =>uint256) internal balances;
mapping (address => mapping(address =>uint256)) internal allowed;
uint256 totaltoken;
function totalSupply() public view returns (uint256)
{
}
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool)
{
}
function balanceOf(address _owner) public view returns (uint256 balance)
{
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool)
{
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool)
{
}
function allowance(address _owner, address _spender) public view returns (uint256)
{
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool)
{
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool)
{
}
}
contract claimable is Owned
{
address public pendingOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyPendingOwner()
{
}
function transferOwnership(address newOwner) onlyowner public
{
}
function claimOwnership() onlyPendingOwner public
{
}
}
//////////////////////////////////token Start////////////////////////////////////////////
contract RT is TokenControl,claimable
{
using SafeMath for uint256;
string public constant name = "RecuToken";
string public constant symbol = "RT";
uint256 public decimals = 18;
uint256 totalsupply = 500000000*(10**decimals);
address public vault;
//contract initial
constructor () public
{
}
//set sell agent
address public salesAgent;
address internal pendingAgent;
event SetSalesAgent(address indexed previousSalesAgent, address indexed newSalesAgent);
event RemovedSalesAgent(address indexed currentSalesAgent);
// set salesAgent
function setSalesAgent(address newSalesAgent) onlyowner public
{
}
function claimSalesAgent() public
{
}
// Remove salesagent
function removedSalesAgent() onlyowner public
{
}
// Transfer tokens from salesAgent to account
function transferTokensFromVault(address toAddress, uint256 tokensAmount) public
{
require(salesAgent == msg.sender);
require(<FILL_ME>)
balances[vault] = balances[vault].sub(tokensAmount);
balances[toAddress] = balances[toAddress].add(tokensAmount);
emit Transfer(vault, toAddress, tokensAmount);
}
}
| balances[vault]>=tokensAmount | 368,229 | balances[vault]>=tokensAmount |
"deposit: terms disabled" | pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
// Stake (deposit) ERC-20 tokens to get more tokens as reward (interest).
// Note the `treasury` account that borrows tokens (and pays rewards).
contract QueenDecks is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The amount to return to a user (i.e. a stake holder) is calculated as:
// `amountDue = Stake.amount * TermSheet.rewardFactor/1e+6` (1)
struct TermSheet {
// Min token amount to stake
uint176 minAmount;
// Max stake amount multiplier, scaled by 1e+4:
// `maxAmount = minAmount * maxAmountFactor/1e4`
// (if set to 0, the stake amount is unlimited)
uint32 maxAmountFactor;
// Reward multiplier, scaled by 1e+6 (see (1))
uint32 rewardFactor;
// Staking period in hours
uint16 lockHours;
// Min time between accrued reward withdrawals
// (set to 0 to disallow interim withdrawals)
uint16 rewardLockHours;
// ERC-20 contract of the token to stake
address token;
// If staking is enabled
bool enabled;
}
struct Stake {
// Amount staked, in token units
uint256 amount;
// UNIX-time the stake may be withdrawn since
uint32 unlockTime;
// UNIX-time the reward last time withdrawn at
uint32 lastRewardTime;
uint32 rewardFactor; // see TermSheet.rewardFactor
uint16 rewardLockHours; // see TermSheet.rewardLockHours
uint16 lockHours; // see TermSheet.lockHours
uint256 termsheetId;
}
// All stakes of a user
// (note, the stake ID includes the address of the token staked)
struct UserStakes {
// Set of (unique) stake IDs (see `encodeStakeId` function)
uint256[] ids;
// Mapping from stake ID to stake data
mapping(uint256 => Stake) data;
}
// Emergency withdrawals enabled by default
bool public emergencyWithdrawEnabled = true;
// Emergency fees factor, scaled by 1e+4:
// `fees = Stake.amount * emergencyFeesFactor / 1e+4`
uint16 public emergencyFeesFactor = 500; // i.e. 5%
// Number of stakes made so far
uint48 public stakeQty;
// Account that controls the tokens staked
address public treasury;
// Info on each TermSheet
TermSheet[] internal termSheets;
// Mappings from staked token address to amount staked
mapping(address => uint256) public amountsStaked; // in token units
// Mappings from staked token address to amount due
mapping(address => uint256) public amountsDue; // in token units
// Mapping from user account to user stakes
mapping(address => UserStakes) internal stakes;
event Deposit(
address indexed token,
address indexed user,
uint256 stakeId,
uint256 termsId,
uint256 amount, // amount staked
uint256 amountDue, // amount to be returned
uint256 unlockTime // UNIX-time when the stake is unlocked
);
// User withdraws the stake (including reward due)
event Withdraw(
address indexed user,
uint256 stakeId,
uint256 amount // amount sent to user (in token units)
);
// User withdraws interim reward
event Reward(
address indexed user,
uint256 stakeId,
uint256 amount // amount sent to user (in token units)
);
event Emergency(bool enabled);
event EmergencyFactor(uint256 factor);
event EmergencyWithdraw(
address indexed user,
uint256 stakeId,
uint256 amount, // amount sent to user (in token units)
uint256 reward, // cancelled reward (in token units)
uint256 fees // withheld fees (in token units)
);
event NewTermSheet(
uint256 indexed termsId, // index in the `termSheets` array
address indexed token, // here and further - see `struct TermSheet`
uint256 minAmount,
uint256 maxAmountFactor,
uint256 lockHours,
uint256 rewardLockHours,
uint256 rewardFactor
);
event TermsEnabled(uint256 indexed termsId);
event TermsDisabled(uint256 indexed termsId);
constructor(address _treasury) public {
}
receive() external payable {
}
// Stake ID uniquely identifies a stake
// (note, `stakeNum` uniquely identifies a stake, rest is for UI sake)
function encodeStakeId(
address token, // token contract address
uint256 stakeNum, // uniq nonce (limited to 48 bits)
uint256 unlockTime, // UNIX time (limited to 32 bits)
uint256 stakeHours // Stake duration (limited to 16 bits)
) public pure returns (uint256) {
}
function decodeStakeId(uint256 stakeId)
public
pure
returns (
address token,
uint256 stakeNum,
uint256 unlockTime,
uint256 stakeHours
)
{
}
function stakeIds(address user) external view returns (uint256[] memory) {
}
function stakeData(address user, uint256 stakeId)
external
view
returns (Stake memory)
{
}
function getAmountDue(address user, uint256 stakeId)
external
view
returns (uint256 totalDue, uint256 rewardDue)
{
}
function termSheet(uint256 termsId)
external
view
returns (TermSheet memory)
{
}
function termsLength() external view returns (uint256) {
}
function allTermSheets() external view returns(TermSheet[] memory) {
}
function deposit(uint256 termsId, uint256 amount) public nonReentrant {
TermSheet memory tS = termSheets[_validTermsID(termsId)];
require(<FILL_ME>)
require(amount >= tS.minAmount, "deposit: too small amount");
if (tS.maxAmountFactor != 0) {
require(
amount <=
uint256(tS.minAmount).mul(tS.maxAmountFactor).div(1e4),
"deposit: too big amount"
);
}
uint48 stakeNum = stakeQty + 1;
require(stakeNum != 0, "QDeck:stakeQty_OVERFLOW");
uint256 amountDue = amount.mul(tS.rewardFactor).div(1e6);
uint32 unlockTime = safe32(now.add(uint256(tS.lockHours) * 3600));
uint256 stakeId = _encodeStakeId(tS.token, stakeNum, now, tS.lockHours);
IERC20(tS.token).safeTransferFrom(msg.sender, treasury, amount);
_addUserStake(
stakes[msg.sender],
stakeId,
Stake(
amount,
unlockTime,
safe32(now),
tS.rewardFactor,
tS.rewardLockHours,
tS.lockHours,
termsId
)
);
stakeQty = stakeNum;
amountsStaked[tS.token] = amountsStaked[tS.token].add(amount);
amountsDue[tS.token] = amountsDue[tS.token].add(amountDue);
emit Deposit(
tS.token,
msg.sender,
stakeId,
termsId,
amount,
amountDue,
unlockTime
);
}
// Withdraw the staked amount and the reward due (when stake period passed)
function withdraw(uint256 stakeId) public nonReentrant {
}
// Withdraw reward accrued so far (if interim withdrawals allowed)
function withdrawReward(uint256 stakeId) public {
}
// Withdraw the staked amount - w/o the reward, less fees (if applicable)
// Rewards entitled be lost. Fees may be charged. Use in emergency only !!!
function emergencyWithdraw(uint256 stakeId) public nonReentrant {
}
function addTerms(TermSheet[] memory _termSheets) public onlyOwner {
}
function enableTerms(uint256 termsId) external onlyOwner {
}
function disableTerms(uint256 termsId) external onlyOwner {
}
function enableEmergencyWithdraw() external onlyOwner {
}
function disableEmergencyWithdraw() external onlyOwner {
}
function setEmergencyFeesFactor(uint256 factor) external onlyOwner {
}
function setTreasury(address _treasury) public onlyOwner {
}
// Save occasional airdrop or mistakenly transferred tokens
function transferFromContract(
IERC20 token,
uint256 amount,
address to
) external onlyOwner {
}
function _withdraw(uint256 stakeId, bool isEmergency) internal {
}
function _withdrawReward(uint256 stakeId) internal {
}
function _amountDueOn (Stake memory stake, uint256 timestamp)
internal
pure
returns (uint256 totalDue, uint256 rewardAccrued)
{
}
function _addTermSheet(TermSheet memory tS) internal {
}
// Returns `true` if the term sheet has NOT been yet added.
function _isMissingTerms(TermSheet memory newSheet)
internal
view
returns (bool)
{
}
function _addUserStake(
UserStakes storage userStakes,
uint256 stakeId,
Stake memory stake
) internal {
}
function _removeUserStake(UserStakes storage userStakes, uint256 stakeId)
internal
{
}
// Assuming the given array does contain the given element
function _removeArrayElement(uint256[] storage arr, uint256 el) internal {
}
function _setTreasury(address _treasury) internal {
}
function _encodeStakeId(
address token,
uint256 stakeNum,
uint256 unlockTime,
uint256 stakeHours
) internal pure returns (uint256) {
}
function _tokenFromId(uint256 stakeId) internal pure returns (address) {
}
function _revertZeroAddress(address _address) internal pure {
}
function _nonZeroAddr(address _address) private pure returns (address) {
}
function _validTermsID(uint256 termsId) private view returns (uint256) {
}
function safe32(uint256 n) private pure returns (uint32) {
}
}
| tS.enabled,"deposit: terms disabled" | 368,322 | tS.enabled |
"QDeck:add:TERMS_DUPLICATED" | pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
// Stake (deposit) ERC-20 tokens to get more tokens as reward (interest).
// Note the `treasury` account that borrows tokens (and pays rewards).
contract QueenDecks is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The amount to return to a user (i.e. a stake holder) is calculated as:
// `amountDue = Stake.amount * TermSheet.rewardFactor/1e+6` (1)
struct TermSheet {
// Min token amount to stake
uint176 minAmount;
// Max stake amount multiplier, scaled by 1e+4:
// `maxAmount = minAmount * maxAmountFactor/1e4`
// (if set to 0, the stake amount is unlimited)
uint32 maxAmountFactor;
// Reward multiplier, scaled by 1e+6 (see (1))
uint32 rewardFactor;
// Staking period in hours
uint16 lockHours;
// Min time between accrued reward withdrawals
// (set to 0 to disallow interim withdrawals)
uint16 rewardLockHours;
// ERC-20 contract of the token to stake
address token;
// If staking is enabled
bool enabled;
}
struct Stake {
// Amount staked, in token units
uint256 amount;
// UNIX-time the stake may be withdrawn since
uint32 unlockTime;
// UNIX-time the reward last time withdrawn at
uint32 lastRewardTime;
uint32 rewardFactor; // see TermSheet.rewardFactor
uint16 rewardLockHours; // see TermSheet.rewardLockHours
uint16 lockHours; // see TermSheet.lockHours
uint256 termsheetId;
}
// All stakes of a user
// (note, the stake ID includes the address of the token staked)
struct UserStakes {
// Set of (unique) stake IDs (see `encodeStakeId` function)
uint256[] ids;
// Mapping from stake ID to stake data
mapping(uint256 => Stake) data;
}
// Emergency withdrawals enabled by default
bool public emergencyWithdrawEnabled = true;
// Emergency fees factor, scaled by 1e+4:
// `fees = Stake.amount * emergencyFeesFactor / 1e+4`
uint16 public emergencyFeesFactor = 500; // i.e. 5%
// Number of stakes made so far
uint48 public stakeQty;
// Account that controls the tokens staked
address public treasury;
// Info on each TermSheet
TermSheet[] internal termSheets;
// Mappings from staked token address to amount staked
mapping(address => uint256) public amountsStaked; // in token units
// Mappings from staked token address to amount due
mapping(address => uint256) public amountsDue; // in token units
// Mapping from user account to user stakes
mapping(address => UserStakes) internal stakes;
event Deposit(
address indexed token,
address indexed user,
uint256 stakeId,
uint256 termsId,
uint256 amount, // amount staked
uint256 amountDue, // amount to be returned
uint256 unlockTime // UNIX-time when the stake is unlocked
);
// User withdraws the stake (including reward due)
event Withdraw(
address indexed user,
uint256 stakeId,
uint256 amount // amount sent to user (in token units)
);
// User withdraws interim reward
event Reward(
address indexed user,
uint256 stakeId,
uint256 amount // amount sent to user (in token units)
);
event Emergency(bool enabled);
event EmergencyFactor(uint256 factor);
event EmergencyWithdraw(
address indexed user,
uint256 stakeId,
uint256 amount, // amount sent to user (in token units)
uint256 reward, // cancelled reward (in token units)
uint256 fees // withheld fees (in token units)
);
event NewTermSheet(
uint256 indexed termsId, // index in the `termSheets` array
address indexed token, // here and further - see `struct TermSheet`
uint256 minAmount,
uint256 maxAmountFactor,
uint256 lockHours,
uint256 rewardLockHours,
uint256 rewardFactor
);
event TermsEnabled(uint256 indexed termsId);
event TermsDisabled(uint256 indexed termsId);
constructor(address _treasury) public {
}
receive() external payable {
}
// Stake ID uniquely identifies a stake
// (note, `stakeNum` uniquely identifies a stake, rest is for UI sake)
function encodeStakeId(
address token, // token contract address
uint256 stakeNum, // uniq nonce (limited to 48 bits)
uint256 unlockTime, // UNIX time (limited to 32 bits)
uint256 stakeHours // Stake duration (limited to 16 bits)
) public pure returns (uint256) {
}
function decodeStakeId(uint256 stakeId)
public
pure
returns (
address token,
uint256 stakeNum,
uint256 unlockTime,
uint256 stakeHours
)
{
}
function stakeIds(address user) external view returns (uint256[] memory) {
}
function stakeData(address user, uint256 stakeId)
external
view
returns (Stake memory)
{
}
function getAmountDue(address user, uint256 stakeId)
external
view
returns (uint256 totalDue, uint256 rewardDue)
{
}
function termSheet(uint256 termsId)
external
view
returns (TermSheet memory)
{
}
function termsLength() external view returns (uint256) {
}
function allTermSheets() external view returns(TermSheet[] memory) {
}
function deposit(uint256 termsId, uint256 amount) public nonReentrant {
}
// Withdraw the staked amount and the reward due (when stake period passed)
function withdraw(uint256 stakeId) public nonReentrant {
}
// Withdraw reward accrued so far (if interim withdrawals allowed)
function withdrawReward(uint256 stakeId) public {
}
// Withdraw the staked amount - w/o the reward, less fees (if applicable)
// Rewards entitled be lost. Fees may be charged. Use in emergency only !!!
function emergencyWithdraw(uint256 stakeId) public nonReentrant {
}
function addTerms(TermSheet[] memory _termSheets) public onlyOwner {
}
function enableTerms(uint256 termsId) external onlyOwner {
}
function disableTerms(uint256 termsId) external onlyOwner {
}
function enableEmergencyWithdraw() external onlyOwner {
}
function disableEmergencyWithdraw() external onlyOwner {
}
function setEmergencyFeesFactor(uint256 factor) external onlyOwner {
}
function setTreasury(address _treasury) public onlyOwner {
}
// Save occasional airdrop or mistakenly transferred tokens
function transferFromContract(
IERC20 token,
uint256 amount,
address to
) external onlyOwner {
}
function _withdraw(uint256 stakeId, bool isEmergency) internal {
}
function _withdrawReward(uint256 stakeId) internal {
}
function _amountDueOn (Stake memory stake, uint256 timestamp)
internal
pure
returns (uint256 totalDue, uint256 rewardAccrued)
{
}
function _addTermSheet(TermSheet memory tS) internal {
_revertZeroAddress(tS.token);
require(
tS.minAmount != 0 && tS.lockHours != 0 && tS.rewardFactor >= 1e6,
"QDeck:add:INVALID_ZERO_PARAM"
);
require(<FILL_ME>)
termSheets.push(tS);
emit NewTermSheet(
termSheets.length - 1,
tS.token,
tS.minAmount,
tS.maxAmountFactor,
tS.lockHours,
tS.rewardLockHours,
tS.rewardFactor
);
if (tS.enabled) emit TermsEnabled(termSheets.length);
}
// Returns `true` if the term sheet has NOT been yet added.
function _isMissingTerms(TermSheet memory newSheet)
internal
view
returns (bool)
{
}
function _addUserStake(
UserStakes storage userStakes,
uint256 stakeId,
Stake memory stake
) internal {
}
function _removeUserStake(UserStakes storage userStakes, uint256 stakeId)
internal
{
}
// Assuming the given array does contain the given element
function _removeArrayElement(uint256[] storage arr, uint256 el) internal {
}
function _setTreasury(address _treasury) internal {
}
function _encodeStakeId(
address token,
uint256 stakeNum,
uint256 unlockTime,
uint256 stakeHours
) internal pure returns (uint256) {
}
function _tokenFromId(uint256 stakeId) internal pure returns (address) {
}
function _revertZeroAddress(address _address) internal pure {
}
function _nonZeroAddr(address _address) private pure returns (address) {
}
function _validTermsID(uint256 termsId) private view returns (uint256) {
}
function safe32(uint256 n) private pure returns (uint32) {
}
}
| _isMissingTerms(tS),"QDeck:add:TERMS_DUPLICATED" | 368,322 | _isMissingTerms(tS) |
"QDeck:DUPLICATED_STAKE_ID" | pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
// Stake (deposit) ERC-20 tokens to get more tokens as reward (interest).
// Note the `treasury` account that borrows tokens (and pays rewards).
contract QueenDecks is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The amount to return to a user (i.e. a stake holder) is calculated as:
// `amountDue = Stake.amount * TermSheet.rewardFactor/1e+6` (1)
struct TermSheet {
// Min token amount to stake
uint176 minAmount;
// Max stake amount multiplier, scaled by 1e+4:
// `maxAmount = minAmount * maxAmountFactor/1e4`
// (if set to 0, the stake amount is unlimited)
uint32 maxAmountFactor;
// Reward multiplier, scaled by 1e+6 (see (1))
uint32 rewardFactor;
// Staking period in hours
uint16 lockHours;
// Min time between accrued reward withdrawals
// (set to 0 to disallow interim withdrawals)
uint16 rewardLockHours;
// ERC-20 contract of the token to stake
address token;
// If staking is enabled
bool enabled;
}
struct Stake {
// Amount staked, in token units
uint256 amount;
// UNIX-time the stake may be withdrawn since
uint32 unlockTime;
// UNIX-time the reward last time withdrawn at
uint32 lastRewardTime;
uint32 rewardFactor; // see TermSheet.rewardFactor
uint16 rewardLockHours; // see TermSheet.rewardLockHours
uint16 lockHours; // see TermSheet.lockHours
uint256 termsheetId;
}
// All stakes of a user
// (note, the stake ID includes the address of the token staked)
struct UserStakes {
// Set of (unique) stake IDs (see `encodeStakeId` function)
uint256[] ids;
// Mapping from stake ID to stake data
mapping(uint256 => Stake) data;
}
// Emergency withdrawals enabled by default
bool public emergencyWithdrawEnabled = true;
// Emergency fees factor, scaled by 1e+4:
// `fees = Stake.amount * emergencyFeesFactor / 1e+4`
uint16 public emergencyFeesFactor = 500; // i.e. 5%
// Number of stakes made so far
uint48 public stakeQty;
// Account that controls the tokens staked
address public treasury;
// Info on each TermSheet
TermSheet[] internal termSheets;
// Mappings from staked token address to amount staked
mapping(address => uint256) public amountsStaked; // in token units
// Mappings from staked token address to amount due
mapping(address => uint256) public amountsDue; // in token units
// Mapping from user account to user stakes
mapping(address => UserStakes) internal stakes;
event Deposit(
address indexed token,
address indexed user,
uint256 stakeId,
uint256 termsId,
uint256 amount, // amount staked
uint256 amountDue, // amount to be returned
uint256 unlockTime // UNIX-time when the stake is unlocked
);
// User withdraws the stake (including reward due)
event Withdraw(
address indexed user,
uint256 stakeId,
uint256 amount // amount sent to user (in token units)
);
// User withdraws interim reward
event Reward(
address indexed user,
uint256 stakeId,
uint256 amount // amount sent to user (in token units)
);
event Emergency(bool enabled);
event EmergencyFactor(uint256 factor);
event EmergencyWithdraw(
address indexed user,
uint256 stakeId,
uint256 amount, // amount sent to user (in token units)
uint256 reward, // cancelled reward (in token units)
uint256 fees // withheld fees (in token units)
);
event NewTermSheet(
uint256 indexed termsId, // index in the `termSheets` array
address indexed token, // here and further - see `struct TermSheet`
uint256 minAmount,
uint256 maxAmountFactor,
uint256 lockHours,
uint256 rewardLockHours,
uint256 rewardFactor
);
event TermsEnabled(uint256 indexed termsId);
event TermsDisabled(uint256 indexed termsId);
constructor(address _treasury) public {
}
receive() external payable {
}
// Stake ID uniquely identifies a stake
// (note, `stakeNum` uniquely identifies a stake, rest is for UI sake)
function encodeStakeId(
address token, // token contract address
uint256 stakeNum, // uniq nonce (limited to 48 bits)
uint256 unlockTime, // UNIX time (limited to 32 bits)
uint256 stakeHours // Stake duration (limited to 16 bits)
) public pure returns (uint256) {
}
function decodeStakeId(uint256 stakeId)
public
pure
returns (
address token,
uint256 stakeNum,
uint256 unlockTime,
uint256 stakeHours
)
{
}
function stakeIds(address user) external view returns (uint256[] memory) {
}
function stakeData(address user, uint256 stakeId)
external
view
returns (Stake memory)
{
}
function getAmountDue(address user, uint256 stakeId)
external
view
returns (uint256 totalDue, uint256 rewardDue)
{
}
function termSheet(uint256 termsId)
external
view
returns (TermSheet memory)
{
}
function termsLength() external view returns (uint256) {
}
function allTermSheets() external view returns(TermSheet[] memory) {
}
function deposit(uint256 termsId, uint256 amount) public nonReentrant {
}
// Withdraw the staked amount and the reward due (when stake period passed)
function withdraw(uint256 stakeId) public nonReentrant {
}
// Withdraw reward accrued so far (if interim withdrawals allowed)
function withdrawReward(uint256 stakeId) public {
}
// Withdraw the staked amount - w/o the reward, less fees (if applicable)
// Rewards entitled be lost. Fees may be charged. Use in emergency only !!!
function emergencyWithdraw(uint256 stakeId) public nonReentrant {
}
function addTerms(TermSheet[] memory _termSheets) public onlyOwner {
}
function enableTerms(uint256 termsId) external onlyOwner {
}
function disableTerms(uint256 termsId) external onlyOwner {
}
function enableEmergencyWithdraw() external onlyOwner {
}
function disableEmergencyWithdraw() external onlyOwner {
}
function setEmergencyFeesFactor(uint256 factor) external onlyOwner {
}
function setTreasury(address _treasury) public onlyOwner {
}
// Save occasional airdrop or mistakenly transferred tokens
function transferFromContract(
IERC20 token,
uint256 amount,
address to
) external onlyOwner {
}
function _withdraw(uint256 stakeId, bool isEmergency) internal {
}
function _withdrawReward(uint256 stakeId) internal {
}
function _amountDueOn (Stake memory stake, uint256 timestamp)
internal
pure
returns (uint256 totalDue, uint256 rewardAccrued)
{
}
function _addTermSheet(TermSheet memory tS) internal {
}
// Returns `true` if the term sheet has NOT been yet added.
function _isMissingTerms(TermSheet memory newSheet)
internal
view
returns (bool)
{
}
function _addUserStake(
UserStakes storage userStakes,
uint256 stakeId,
Stake memory stake
) internal {
require(<FILL_ME>)
userStakes.data[stakeId] = stake;
userStakes.ids.push(stakeId);
}
function _removeUserStake(UserStakes storage userStakes, uint256 stakeId)
internal
{
}
// Assuming the given array does contain the given element
function _removeArrayElement(uint256[] storage arr, uint256 el) internal {
}
function _setTreasury(address _treasury) internal {
}
function _encodeStakeId(
address token,
uint256 stakeNum,
uint256 unlockTime,
uint256 stakeHours
) internal pure returns (uint256) {
}
function _tokenFromId(uint256 stakeId) internal pure returns (address) {
}
function _revertZeroAddress(address _address) internal pure {
}
function _nonZeroAddr(address _address) private pure returns (address) {
}
function _validTermsID(uint256 termsId) private view returns (uint256) {
}
function safe32(uint256 n) private pure returns (uint32) {
}
}
| userStakes.data[stakeId].amount==0,"QDeck:DUPLICATED_STAKE_ID" | 368,322 | userStakes.data[stakeId].amount==0 |
"QDeck:INVALID_STAKE_ID" | pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
// Stake (deposit) ERC-20 tokens to get more tokens as reward (interest).
// Note the `treasury` account that borrows tokens (and pays rewards).
contract QueenDecks is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The amount to return to a user (i.e. a stake holder) is calculated as:
// `amountDue = Stake.amount * TermSheet.rewardFactor/1e+6` (1)
struct TermSheet {
// Min token amount to stake
uint176 minAmount;
// Max stake amount multiplier, scaled by 1e+4:
// `maxAmount = minAmount * maxAmountFactor/1e4`
// (if set to 0, the stake amount is unlimited)
uint32 maxAmountFactor;
// Reward multiplier, scaled by 1e+6 (see (1))
uint32 rewardFactor;
// Staking period in hours
uint16 lockHours;
// Min time between accrued reward withdrawals
// (set to 0 to disallow interim withdrawals)
uint16 rewardLockHours;
// ERC-20 contract of the token to stake
address token;
// If staking is enabled
bool enabled;
}
struct Stake {
// Amount staked, in token units
uint256 amount;
// UNIX-time the stake may be withdrawn since
uint32 unlockTime;
// UNIX-time the reward last time withdrawn at
uint32 lastRewardTime;
uint32 rewardFactor; // see TermSheet.rewardFactor
uint16 rewardLockHours; // see TermSheet.rewardLockHours
uint16 lockHours; // see TermSheet.lockHours
uint256 termsheetId;
}
// All stakes of a user
// (note, the stake ID includes the address of the token staked)
struct UserStakes {
// Set of (unique) stake IDs (see `encodeStakeId` function)
uint256[] ids;
// Mapping from stake ID to stake data
mapping(uint256 => Stake) data;
}
// Emergency withdrawals enabled by default
bool public emergencyWithdrawEnabled = true;
// Emergency fees factor, scaled by 1e+4:
// `fees = Stake.amount * emergencyFeesFactor / 1e+4`
uint16 public emergencyFeesFactor = 500; // i.e. 5%
// Number of stakes made so far
uint48 public stakeQty;
// Account that controls the tokens staked
address public treasury;
// Info on each TermSheet
TermSheet[] internal termSheets;
// Mappings from staked token address to amount staked
mapping(address => uint256) public amountsStaked; // in token units
// Mappings from staked token address to amount due
mapping(address => uint256) public amountsDue; // in token units
// Mapping from user account to user stakes
mapping(address => UserStakes) internal stakes;
event Deposit(
address indexed token,
address indexed user,
uint256 stakeId,
uint256 termsId,
uint256 amount, // amount staked
uint256 amountDue, // amount to be returned
uint256 unlockTime // UNIX-time when the stake is unlocked
);
// User withdraws the stake (including reward due)
event Withdraw(
address indexed user,
uint256 stakeId,
uint256 amount // amount sent to user (in token units)
);
// User withdraws interim reward
event Reward(
address indexed user,
uint256 stakeId,
uint256 amount // amount sent to user (in token units)
);
event Emergency(bool enabled);
event EmergencyFactor(uint256 factor);
event EmergencyWithdraw(
address indexed user,
uint256 stakeId,
uint256 amount, // amount sent to user (in token units)
uint256 reward, // cancelled reward (in token units)
uint256 fees // withheld fees (in token units)
);
event NewTermSheet(
uint256 indexed termsId, // index in the `termSheets` array
address indexed token, // here and further - see `struct TermSheet`
uint256 minAmount,
uint256 maxAmountFactor,
uint256 lockHours,
uint256 rewardLockHours,
uint256 rewardFactor
);
event TermsEnabled(uint256 indexed termsId);
event TermsDisabled(uint256 indexed termsId);
constructor(address _treasury) public {
}
receive() external payable {
}
// Stake ID uniquely identifies a stake
// (note, `stakeNum` uniquely identifies a stake, rest is for UI sake)
function encodeStakeId(
address token, // token contract address
uint256 stakeNum, // uniq nonce (limited to 48 bits)
uint256 unlockTime, // UNIX time (limited to 32 bits)
uint256 stakeHours // Stake duration (limited to 16 bits)
) public pure returns (uint256) {
}
function decodeStakeId(uint256 stakeId)
public
pure
returns (
address token,
uint256 stakeNum,
uint256 unlockTime,
uint256 stakeHours
)
{
}
function stakeIds(address user) external view returns (uint256[] memory) {
}
function stakeData(address user, uint256 stakeId)
external
view
returns (Stake memory)
{
}
function getAmountDue(address user, uint256 stakeId)
external
view
returns (uint256 totalDue, uint256 rewardDue)
{
}
function termSheet(uint256 termsId)
external
view
returns (TermSheet memory)
{
}
function termsLength() external view returns (uint256) {
}
function allTermSheets() external view returns(TermSheet[] memory) {
}
function deposit(uint256 termsId, uint256 amount) public nonReentrant {
}
// Withdraw the staked amount and the reward due (when stake period passed)
function withdraw(uint256 stakeId) public nonReentrant {
}
// Withdraw reward accrued so far (if interim withdrawals allowed)
function withdrawReward(uint256 stakeId) public {
}
// Withdraw the staked amount - w/o the reward, less fees (if applicable)
// Rewards entitled be lost. Fees may be charged. Use in emergency only !!!
function emergencyWithdraw(uint256 stakeId) public nonReentrant {
}
function addTerms(TermSheet[] memory _termSheets) public onlyOwner {
}
function enableTerms(uint256 termsId) external onlyOwner {
}
function disableTerms(uint256 termsId) external onlyOwner {
}
function enableEmergencyWithdraw() external onlyOwner {
}
function disableEmergencyWithdraw() external onlyOwner {
}
function setEmergencyFeesFactor(uint256 factor) external onlyOwner {
}
function setTreasury(address _treasury) public onlyOwner {
}
// Save occasional airdrop or mistakenly transferred tokens
function transferFromContract(
IERC20 token,
uint256 amount,
address to
) external onlyOwner {
}
function _withdraw(uint256 stakeId, bool isEmergency) internal {
}
function _withdrawReward(uint256 stakeId) internal {
}
function _amountDueOn (Stake memory stake, uint256 timestamp)
internal
pure
returns (uint256 totalDue, uint256 rewardAccrued)
{
}
function _addTermSheet(TermSheet memory tS) internal {
}
// Returns `true` if the term sheet has NOT been yet added.
function _isMissingTerms(TermSheet memory newSheet)
internal
view
returns (bool)
{
}
function _addUserStake(
UserStakes storage userStakes,
uint256 stakeId,
Stake memory stake
) internal {
}
function _removeUserStake(UserStakes storage userStakes, uint256 stakeId)
internal
{
require(<FILL_ME>)
userStakes.data[stakeId].amount = 0;
_removeArrayElement(userStakes.ids, stakeId);
}
// Assuming the given array does contain the given element
function _removeArrayElement(uint256[] storage arr, uint256 el) internal {
}
function _setTreasury(address _treasury) internal {
}
function _encodeStakeId(
address token,
uint256 stakeNum,
uint256 unlockTime,
uint256 stakeHours
) internal pure returns (uint256) {
}
function _tokenFromId(uint256 stakeId) internal pure returns (address) {
}
function _revertZeroAddress(address _address) internal pure {
}
function _nonZeroAddr(address _address) private pure returns (address) {
}
function _validTermsID(uint256 termsId) private view returns (uint256) {
}
function safe32(uint256 n) private pure returns (uint32) {
}
}
| userStakes.data[stakeId].amount!=0,"QDeck:INVALID_STAKE_ID" | 368,322 | userStakes.data[stakeId].amount!=0 |
"Locked GMI is isExhausted" | pragma solidity ^0.4.26;
contract SafeMath {
// Overflow protected math functions
/**
@dev returns the sum of _x and _y, asserts if the calculation overflows
@param _x value 1
@param _y value 2
@return sum
*/
function safeAdd(uint256 _x, uint256 _y) internal pure returns (uint256) {
}
/**
@dev returns the difference of _x minus _y, asserts if the subtraction results in a negative number
@param _x minuend
@param _y subtrahend
@return difference
*/
function safeSub(uint256 _x, uint256 _y) internal pure returns (uint256) {
}
/**
@dev returns the product of multiplying _x by _y, asserts if the calculation overflows
@param _x factor 1
@param _y factor 2
@return product
*/
function safeMul(uint256 _x, uint256 _y) internal pure returns (uint256) {
}
function safeDiv(uint256 _x, uint256 _y)internal pure returns (uint256){
}
function ceilDiv(uint256 _x, uint256 _y)internal pure returns (uint256){
}
}
contract Sqrt {
function sqrt(uint x)public pure returns(uint y) {
}
}
contract ERC20Token {
mapping (address => uint256) balances;
address public owner;
string public name;
string public symbol;
uint8 public decimals = 18;
// total amount of tokens
uint256 public totalSupply;
// `allowed` tracks any extra transfer rights as in all ERC20 tokens
mapping (address => mapping (address => uint256)) allowed;
constructor() public {
}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) public constant returns (uint256 balance) {
}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success) {
}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
}
/* This unnamed function is called whenever someone tries to send ether to it */
function () private {
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract UnlockGmi is SafeMath{
// using SafeMath for *;
//list user
mapping (address => uint256) private lockList;
bool private activated_; // mark contract is activated;
uint256 private activatedTime;
ERC20Token private gmiToken;
mapping (address => uint256) private takenTime;
mapping (address => uint256) private takenAmount;
uint64 private timeInterval;
uint64 private unLockedAmount;
address public owner_;
//==============================================================================
// _ _ _ __|_ _ __|_ _ _ .
// (_(_)| |_\ | | |_|(_ | (_)| . (initial data setup upon contract deploy)
//==============================================================================
// constructor(address gmiTokeAddress) public {
// gmiToken = ERC20Token(gmiTokeAddress);
// timeInterval = 60 * 60 * 24;
// unLockedAmount = 200;
// initialize();
// owner_ = msg.sender;
// }
constructor() public {
}
function initialize() private {
}
//==============================================================================
// _ _ _ _|. |`. _ _ _ .
// | | |(_)(_||~|~|(/_| _\ . (these are safety checks)
//==============================================================================
/**
* @dev used to make sure no one can interact with contract until it has
* been activated.
*/
modifier isActivated() {
}
/**
* @dev Whether or not owner
*/
modifier isOwer() {
}
/**
*@dev active unlock contract
*
*/
function activeUnLockGMI(uint64 timeStamp) isOwer() {
}
/**
**@dev shutDown unlock flag
*/
function shutDownUnlocked() isOwer() {
}
/**
*@dev Take the remaining GMI to prevent accidents.
*
*/
function getRemainingGMI(address userAddr) isOwer() {
}
modifier isExhausted() {
require(<FILL_ME>)
_;
}
/*
* @dev Get GMI to user
*/
function getUnLockedGMI() public
isActivated()
isExhausted()
payable {
}
/*
* @dev calculate user unlocked GMI amount
*/
function calculateUnLockerGMI(address userAddr) private isActivated()
view returns(uint256, uint256, uint256, uint256, uint256) {
}
function balancesOfUnLockedGMI(address userAddr) public
isActivated() view returns(uint256, uint256, uint256, uint256, uint256)
{
}
}
| takenAmount[msg.sender]<lockList[msg.sender],"Locked GMI is isExhausted" | 368,355 | takenAmount[msg.sender]<lockList[msg.sender] |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @author: manifold.xyz
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "./libraries/SuperRareContracts.sol";
import "./specs/IManifold.sol";
import "./specs/IRarible.sol";
import "./specs/IFoundation.sol";
import "./specs/ISuperRare.sol";
import "./specs/IEIP2981.sol";
import "./specs/IZoraOverride.sol";
import "./IRoyaltyEngineV1.sol";
import "./IRoyaltyRegistry.sol";
/**
* @dev Engine to lookup royalty configurations
*/
contract RoyaltyEngineV1 is ERC165, OwnableUpgradeable, IRoyaltyEngineV1 {
using AddressUpgradeable for address;
// Use int16 for specs to support future spec additions
// When we add a spec, we also decrement the NONE value
// Anything > NONE and <= NOT_CONFIGURED is considered not configured
int16 constant private NONE = -1;
int16 constant private NOT_CONFIGURED = 0;
int16 constant private MANIFOLD = 1;
int16 constant private RARIBLEV1 = 2;
int16 constant private RARIBLEV2 = 3;
int16 constant private FOUNDATION = 4;
int16 constant private EIP2981 = 5;
int16 constant private SUPERRARE = 6;
int16 constant private ZORA = 7;
mapping (address => int16) _specCache;
address public royaltyRegistry;
function initialize(address royaltyRegistry_) public initializer {
__Ownable_init_unchained();
require(<FILL_ME>)
royaltyRegistry = royaltyRegistry_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IRoyaltyEngineV1-getRoyalty}
*/
function getRoyalty(address tokenAddress, uint256 tokenId, uint256 value) public override returns(address payable[] memory recipients, uint256[] memory amounts) {
}
/**
* @dev See {IRoyaltyEngineV1-getRoyaltyView}.
*/
function getRoyaltyView(address tokenAddress, uint256 tokenId, uint256 value) public view override returns(address payable[] memory recipients, uint256[] memory amounts) {
}
/**
* @dev Get the royalty and royalty spec for a given token
*
* returns recipieints array, amounts array, royalty spec, royalty address, whether or not to add to cache
*/
function _getRoyaltyAndSpec(address tokenAddress, uint256 tokenId, uint256 value) private view returns(address payable[] memory recipients, uint256[] memory amounts, int16 spec, address royaltyAddress, bool addToCache) {
}
/**
* Compute royalty amounts
*/
function _computeAmounts(uint256 value, uint256[] memory bps) private pure returns(uint256[] memory amounts) {
}
}
| ERC165Checker.supportsInterface(royaltyRegistry_,type(IRoyaltyRegistry).interfaceId) | 368,368 | ERC165Checker.supportsInterface(royaltyRegistry_,type(IRoyaltyRegistry).interfaceId) |
'ZeroAddress' | // SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.5.0 <0.8.0;
import '@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol';
import '@uniswap/v3-periphery/contracts/libraries/OracleLibrary.sol';
import '../libraries/EnumerableSet.sol';
import '../interfaces/ITimeWeightedOracle.sol';
import '../utils/Governable.sol';
import '../libraries/WeightedOracleLibrary.sol';
contract UniswapV3Oracle is IUniswapV3OracleAggregator, Governable {
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableSet for EnumerableSet.AddressSet;
uint16 public constant override MINIMUM_PERIOD = 1 minutes;
uint16 public constant override MAXIMUM_PERIOD = 20 minutes;
uint16 public constant override MINIMUM_LIQUIDITY_THRESHOLD = 1;
uint8 private constant _AVERAGE_BLOCK_INTERVAL = 15 seconds;
IUniswapV3Factory public immutable override factory;
uint16 public override period = 5 minutes;
EnumerableSet.UintSet internal _supportedFeeTiers;
mapping(address => mapping(address => EnumerableSet.AddressSet)) internal _poolsForPair;
constructor(address _governor, IUniswapV3Factory _factory) Governable(_governor) {
require(<FILL_ME>)
factory = _factory;
}
function canSupportPair(address _tokenA, address _tokenB) external view override returns (bool) {
}
function quote(
address _tokenIn,
uint128 _amountIn,
address _tokenOut
) external view override returns (uint256 _amountOut) {
}
/**
* This function will take a pair and make sure that all Uniswap V3 pools for the pair are properly initialized for future use.
* It will also add all available pools to an internal list, to avoid future queries to the factory.
* It can be called multiple times for the same pair of tokens, to include and re-configure new pools that might appear in the future.
* Will revert if there are no pools available for the given pair of tokens.
*/
function addSupportForPair(address _tokenA, address _tokenB) external override {
}
function poolsUsedForPair(address _tokenA, address _tokenB) external view override returns (address[] memory _usedPools) {
}
function supportedFeeTiers() external view override returns (uint24[] memory _feeTiers) {
}
function setPeriod(uint16 _period) external override onlyGovernor {
}
function addFeeTier(uint24 _feeTier) external override onlyGovernor {
}
function _sortTokens(address _tokenA, address _tokenB) internal pure returns (address __tokenA, address __tokenB) {
}
}
| address(_factory)!=address(0),'ZeroAddress' | 368,409 | address(_factory)!=address(0) |
'PairNotSupported' | // SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.5.0 <0.8.0;
import '@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol';
import '@uniswap/v3-periphery/contracts/libraries/OracleLibrary.sol';
import '../libraries/EnumerableSet.sol';
import '../interfaces/ITimeWeightedOracle.sol';
import '../utils/Governable.sol';
import '../libraries/WeightedOracleLibrary.sol';
contract UniswapV3Oracle is IUniswapV3OracleAggregator, Governable {
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableSet for EnumerableSet.AddressSet;
uint16 public constant override MINIMUM_PERIOD = 1 minutes;
uint16 public constant override MAXIMUM_PERIOD = 20 minutes;
uint16 public constant override MINIMUM_LIQUIDITY_THRESHOLD = 1;
uint8 private constant _AVERAGE_BLOCK_INTERVAL = 15 seconds;
IUniswapV3Factory public immutable override factory;
uint16 public override period = 5 minutes;
EnumerableSet.UintSet internal _supportedFeeTiers;
mapping(address => mapping(address => EnumerableSet.AddressSet)) internal _poolsForPair;
constructor(address _governor, IUniswapV3Factory _factory) Governable(_governor) {
}
function canSupportPair(address _tokenA, address _tokenB) external view override returns (bool) {
}
function quote(
address _tokenIn,
uint128 _amountIn,
address _tokenOut
) external view override returns (uint256 _amountOut) {
}
/**
* This function will take a pair and make sure that all Uniswap V3 pools for the pair are properly initialized for future use.
* It will also add all available pools to an internal list, to avoid future queries to the factory.
* It can be called multiple times for the same pair of tokens, to include and re-configure new pools that might appear in the future.
* Will revert if there are no pools available for the given pair of tokens.
*/
function addSupportForPair(address _tokenA, address _tokenB) external override {
uint256 _length = _supportedFeeTiers.length();
(address __tokenA, address __tokenB) = _sortTokens(_tokenA, _tokenB);
EnumerableSet.AddressSet storage _pools = _poolsForPair[__tokenA][__tokenB];
uint16 _cardinality = uint16(period / _AVERAGE_BLOCK_INTERVAL) + 10; // We add 10 just to be on the safe side
for (uint256 i; i < _length; i++) {
address _pool = factory.getPool(__tokenA, __tokenB, uint24(_supportedFeeTiers.at(i)));
if (_pool != address(0) && !_pools.contains(_pool) && IUniswapV3Pool(_pool).liquidity() >= MINIMUM_LIQUIDITY_THRESHOLD) {
_pools.add(_pool);
IUniswapV3Pool(_pool).increaseObservationCardinalityNext(_cardinality);
}
}
require(<FILL_ME>)
emit AddedSupportForPair(__tokenA, __tokenB);
}
function poolsUsedForPair(address _tokenA, address _tokenB) external view override returns (address[] memory _usedPools) {
}
function supportedFeeTiers() external view override returns (uint24[] memory _feeTiers) {
}
function setPeriod(uint16 _period) external override onlyGovernor {
}
function addFeeTier(uint24 _feeTier) external override onlyGovernor {
}
function _sortTokens(address _tokenA, address _tokenB) internal pure returns (address __tokenA, address __tokenB) {
}
}
| _pools.length()>0,'PairNotSupported' | 368,409 | _pools.length()>0 |
'InvalidFeeTier' | // SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.5.0 <0.8.0;
import '@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol';
import '@uniswap/v3-periphery/contracts/libraries/OracleLibrary.sol';
import '../libraries/EnumerableSet.sol';
import '../interfaces/ITimeWeightedOracle.sol';
import '../utils/Governable.sol';
import '../libraries/WeightedOracleLibrary.sol';
contract UniswapV3Oracle is IUniswapV3OracleAggregator, Governable {
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableSet for EnumerableSet.AddressSet;
uint16 public constant override MINIMUM_PERIOD = 1 minutes;
uint16 public constant override MAXIMUM_PERIOD = 20 minutes;
uint16 public constant override MINIMUM_LIQUIDITY_THRESHOLD = 1;
uint8 private constant _AVERAGE_BLOCK_INTERVAL = 15 seconds;
IUniswapV3Factory public immutable override factory;
uint16 public override period = 5 minutes;
EnumerableSet.UintSet internal _supportedFeeTiers;
mapping(address => mapping(address => EnumerableSet.AddressSet)) internal _poolsForPair;
constructor(address _governor, IUniswapV3Factory _factory) Governable(_governor) {
}
function canSupportPair(address _tokenA, address _tokenB) external view override returns (bool) {
}
function quote(
address _tokenIn,
uint128 _amountIn,
address _tokenOut
) external view override returns (uint256 _amountOut) {
}
/**
* This function will take a pair and make sure that all Uniswap V3 pools for the pair are properly initialized for future use.
* It will also add all available pools to an internal list, to avoid future queries to the factory.
* It can be called multiple times for the same pair of tokens, to include and re-configure new pools that might appear in the future.
* Will revert if there are no pools available for the given pair of tokens.
*/
function addSupportForPair(address _tokenA, address _tokenB) external override {
}
function poolsUsedForPair(address _tokenA, address _tokenB) external view override returns (address[] memory _usedPools) {
}
function supportedFeeTiers() external view override returns (uint24[] memory _feeTiers) {
}
function setPeriod(uint16 _period) external override onlyGovernor {
}
function addFeeTier(uint24 _feeTier) external override onlyGovernor {
require(<FILL_ME>)
_supportedFeeTiers.add(_feeTier);
emit AddedFeeTier(_feeTier);
}
function _sortTokens(address _tokenA, address _tokenB) internal pure returns (address __tokenA, address __tokenB) {
}
}
| factory.feeAmountTickSpacing(_feeTier)>0,'InvalidFeeTier' | 368,409 | factory.feeAmountTickSpacing(_feeTier)>0 |
null | /*
* Visit: https://p4rty.io
* Discord: https://discord.gg/7y3DHYF
*/
contract P4RTYBankrollVault is Whitelist {
using SafeMath for uint;
/*==============================
= EVENTS =
==============================*/
event onDeposit(
address indexed fundingSource,
uint256 ethDeposited,
uint timestamp
);
event onCredit(
address indexed customerAddress,
uint256 ethCredited,
uint timestamp
);
event onDebit(
address indexed customerAddress,
uint256 ethDedited,
uint timestamp
);
event onWithdraw(
address indexed customerAddress,
uint256 ethereumWithdrawn,
uint timestamp
);
event onAirdrop(
address contractAddress,
uint256 ethereumSent,
uint timestamp
);
/*=====================================
= CONFIGURABLES =
=====================================*/
uint256 public daoFee = 10;
uint256 public p6Fee = 15;
uint256 constant public outboundThreshold = 0.5 ether;
uint256 internal p6Outbound = 0;
uint256 internal daoOutbound =0;
/*=================================
= DATASETS =
================================*/
struct Stats {
uint deposit;
uint credit;
uint debit;
uint withdrawn;
uint xDeposit;
uint xCredit;
uint xDebit;
uint xWithdrawn;
}
// amount of shares for each address (scaled number)
mapping(address => uint256) internal vault;
mapping(address => Stats) internal stats;
uint256 internal totalCustomerCredit;
P6 public p6;
P4RTYDaoVault public dao;
/*=======================================
= PUBLIC FUNCTIONS =
=======================================*/
constructor(address daoAddress) public {
}
function updateP6Fee(uint256 fee) public onlyOwner {
}
function updateDaoFee(uint256 fee) public onlyOwner {
}
function updateP6Address(address p6Address) public onlyOwner {
}
//Customer functions
/// @dev Stores ETH funds for customer
function credit(address _customerAddress, uint256 amount) onlyWhitelisted external returns (uint256){
}
/// @dev Debits address by an amount or sets to zero
function debit(address _customerAddress, uint256 amount) onlyWhitelisted external returns (uint256){
}
/// @dev Withraws balance for address; returns amount sent
function withdraw(address _customerAddress) onlyWhitelisted external returns (uint256){
require(<FILL_ME>)
uint256 amount = vault[_customerAddress];
vault[_customerAddress] = 0;
totalCustomerCredit = totalCustomerCredit.sub(amount);
_customerAddress.transfer(amount);
//Stats
stats[_customerAddress].withdrawn = stats[_customerAddress].withdrawn.add(amount);
stats[_customerAddress].xWithdrawn += 1;
emit onWithdraw(_customerAddress, amount, now);
}
function houseProfit(uint256 amount) onlyWhitelisted external {
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) onlyWhitelisted external view returns (uint256) {
}
/// @dev Stats of any single address
function statsOf(address _customerAddress) public view returns (uint256[8]){
}
// System functions
/**
* @dev Fallback function to handle ethereum that was send straight to the contract
* Should just deposit so that we can accept funds from contracts as well using transfer
*/
function() payable public {
}
/// @dev Proper way to fund bankrollvault; don't use fallback
function deposit() payable public {
}
/// @dev Proper way to fund bankrollvault by a specific customer
function depositBy(address _customerAddress ) onlyWhitelisted payable external {
}
/**
* @dev The bridge to the launch ecosystem. Community has to participate to dump divs
* Should
*/
function fundP6(uint256 amount) internal {
}
/**
* @dev The bridge to the launch ecosystem. Community has to participate to dump divs
* Should
*/
function fundDao(uint256 amount) internal {
}
/**
* @dev Get all the ETH stored in contract
*
*/
function totalEthereumBalance() public view returns (uint256) {
}
/**
* @dev Get all the ETH stored in contract minus credits to customers
*
*/
function netEthereumBalance() public view returns (uint256) {
}
}
| vault[_customerAddress]>0 | 368,415 | vault[_customerAddress]>0 |
'NFTSaleOpenEditionClaims::claim: contract does not have enough NFTs to supply claim' | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.6.7;
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 INFTSaleOpenEdition {
function getBuyerQuantity(address _buyer) external view returns (uint256);
}
interface IERC1155 {
function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes calldata _data) external;
function balanceOf(address _owner, uint256 _id) external view returns (uint256);
}
contract NFTSaleOpenEditionClaims {
using SafeMath for uint256;
INFTSaleOpenEdition public openEditionSaleContract;
IERC1155 public tokenContract;
address public tokenAddress;
uint256 public tokenId;
address public controller;
uint256 public claimedCount = 0;
mapping (address => uint256) public claimantToClaimCount;
event Claim(address claimant, uint256 amount);
constructor(address _openEditionSaleContract, address _tokenAddress, uint256 _tokenId) public {
}
function claim() public {
uint256 entitledToCount = openEditionSaleContract.getBuyerQuantity(msg.sender);
require(entitledToCount > 0, 'NFTSaleOpenEditionClaims::claim: msg.sender not entitled to any claims');
require(entitledToCount > claimantToClaimCount[msg.sender], 'NFTSaleOpenEditionClaims::claim: msg.sender has no outstanding claims');
uint256 remainingClaimCount = entitledToCount - claimantToClaimCount[msg.sender];
require(<FILL_ME>)
tokenContract.safeTransferFrom(address(this), msg.sender, tokenId, remainingClaimCount, new bytes(0x0));
claimantToClaimCount[msg.sender] = claimantToClaimCount[msg.sender].add(remainingClaimCount);
claimedCount = claimedCount.add(remainingClaimCount);
emit Claim(msg.sender, remainingClaimCount);
}
function setOpenEditionSaleContract(address _openEditionSaleContract) public onlyController {
}
function setTokenAddress(address _tokenAddress) public onlyController {
}
function setTokenId(uint256 _tokenId) public onlyController {
}
function pull() public onlyController {
}
modifier onlyController {
}
function onERC1155Received(address, address, uint256, uint256, bytes calldata) external pure returns(bytes4) {
}
}
| tokenContract.balanceOf(address(this),tokenId)>=remainingClaimCount,'NFTSaleOpenEditionClaims::claim: contract does not have enough NFTs to supply claim' | 368,421 | tokenContract.balanceOf(address(this),tokenId)>=remainingClaimCount |
"Exceeds MAX_NFT_SUPPLY" | pragma solidity 0.5.16;
contract MagicPixels is ERC721, ERC721Metadata, ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenTotal;
uint256 MAX_NFT_SUPPLY = 16384;
bool SALE_20_ON = false;
bool SALE_EMERGENCY_ON = false;
bool SALE_1_FREE_ON = false;
constructor() ERC721Metadata("MagicPixels", "MPX") public {
}
function withdraw() public onlyOwner {
}
function setSale20(bool value) public onlyOwner {
}
function setSaleEmergency(bool value) public onlyOwner {
}
function setSale1Free(bool value) public onlyOwner {
}
function isSale20On() public view returns (bool) {
}
function isSaleEmergencyOn() public view returns (bool) {
}
function isSale1FreeOn() public view returns (bool) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function mintTokenIds(uint256[] memory tokenIds) public payable {
require(totalSupply() < MAX_NFT_SUPPLY, "Sale has already ended");
require(tokenIds.length > 0, "tokenIds length cannot be 0");
require(tokenIds.length <= 20, "You may not buy more than 20 NFTs at once");
require(<FILL_ME>)
if(SALE_EMERGENCY_ON) {
// for emergencies where ETH/USD price has gone up > 30k
require(getNFTPrice().mul(tokenIds.length).div(10) == msg.value, "Ether value sent is not correct");
} else if(SALE_1_FREE_ON) {
// buy 1 get 1 free
require(getNFTPrice().mul(tokenIds.length).div(2) == msg.value, "Ether value sent is not correct");
} else if(SALE_20_ON && tokenIds.length == 20) {
// 20% discount
require(getNFTPrice().mul(16) == msg.value, "Ether value sent is not correct");
} else {
require(getNFTPrice().mul(tokenIds.length) == msg.value, "Ether value sent is not correct");
}
for (uint i = 0; i < tokenIds.length; i++) {
require(tokenIds[i] >= 0, 'Token Id must be greater than or equal to 0');
require(tokenIds[i] < MAX_NFT_SUPPLY, 'Token Id must be less than 16384');
require(!_exists(tokenIds[i]), "One of the ERC721 tokens has been minted already");
}
for (uint i = 0; i < tokenIds.length; i++) {
_tokenTotal.increment();
_mint(_msgSender(), tokenIds[i]);
}
}
function getNFTPrice() public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
}
| totalSupply().add(tokenIds.length)<=MAX_NFT_SUPPLY,"Exceeds MAX_NFT_SUPPLY" | 368,504 | totalSupply().add(tokenIds.length)<=MAX_NFT_SUPPLY |
"Ether value sent is not correct" | pragma solidity 0.5.16;
contract MagicPixels is ERC721, ERC721Metadata, ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenTotal;
uint256 MAX_NFT_SUPPLY = 16384;
bool SALE_20_ON = false;
bool SALE_EMERGENCY_ON = false;
bool SALE_1_FREE_ON = false;
constructor() ERC721Metadata("MagicPixels", "MPX") public {
}
function withdraw() public onlyOwner {
}
function setSale20(bool value) public onlyOwner {
}
function setSaleEmergency(bool value) public onlyOwner {
}
function setSale1Free(bool value) public onlyOwner {
}
function isSale20On() public view returns (bool) {
}
function isSaleEmergencyOn() public view returns (bool) {
}
function isSale1FreeOn() public view returns (bool) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function mintTokenIds(uint256[] memory tokenIds) public payable {
require(totalSupply() < MAX_NFT_SUPPLY, "Sale has already ended");
require(tokenIds.length > 0, "tokenIds length cannot be 0");
require(tokenIds.length <= 20, "You may not buy more than 20 NFTs at once");
require(totalSupply().add(tokenIds.length) <= MAX_NFT_SUPPLY, "Exceeds MAX_NFT_SUPPLY");
if(SALE_EMERGENCY_ON) {
// for emergencies where ETH/USD price has gone up > 30k
require(<FILL_ME>)
} else if(SALE_1_FREE_ON) {
// buy 1 get 1 free
require(getNFTPrice().mul(tokenIds.length).div(2) == msg.value, "Ether value sent is not correct");
} else if(SALE_20_ON && tokenIds.length == 20) {
// 20% discount
require(getNFTPrice().mul(16) == msg.value, "Ether value sent is not correct");
} else {
require(getNFTPrice().mul(tokenIds.length) == msg.value, "Ether value sent is not correct");
}
for (uint i = 0; i < tokenIds.length; i++) {
require(tokenIds[i] >= 0, 'Token Id must be greater than or equal to 0');
require(tokenIds[i] < MAX_NFT_SUPPLY, 'Token Id must be less than 16384');
require(!_exists(tokenIds[i]), "One of the ERC721 tokens has been minted already");
}
for (uint i = 0; i < tokenIds.length; i++) {
_tokenTotal.increment();
_mint(_msgSender(), tokenIds[i]);
}
}
function getNFTPrice() public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
}
| getNFTPrice().mul(tokenIds.length).div(10)==msg.value,"Ether value sent is not correct" | 368,504 | getNFTPrice().mul(tokenIds.length).div(10)==msg.value |
"Ether value sent is not correct" | pragma solidity 0.5.16;
contract MagicPixels is ERC721, ERC721Metadata, ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenTotal;
uint256 MAX_NFT_SUPPLY = 16384;
bool SALE_20_ON = false;
bool SALE_EMERGENCY_ON = false;
bool SALE_1_FREE_ON = false;
constructor() ERC721Metadata("MagicPixels", "MPX") public {
}
function withdraw() public onlyOwner {
}
function setSale20(bool value) public onlyOwner {
}
function setSaleEmergency(bool value) public onlyOwner {
}
function setSale1Free(bool value) public onlyOwner {
}
function isSale20On() public view returns (bool) {
}
function isSaleEmergencyOn() public view returns (bool) {
}
function isSale1FreeOn() public view returns (bool) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function mintTokenIds(uint256[] memory tokenIds) public payable {
require(totalSupply() < MAX_NFT_SUPPLY, "Sale has already ended");
require(tokenIds.length > 0, "tokenIds length cannot be 0");
require(tokenIds.length <= 20, "You may not buy more than 20 NFTs at once");
require(totalSupply().add(tokenIds.length) <= MAX_NFT_SUPPLY, "Exceeds MAX_NFT_SUPPLY");
if(SALE_EMERGENCY_ON) {
// for emergencies where ETH/USD price has gone up > 30k
require(getNFTPrice().mul(tokenIds.length).div(10) == msg.value, "Ether value sent is not correct");
} else if(SALE_1_FREE_ON) {
// buy 1 get 1 free
require(<FILL_ME>)
} else if(SALE_20_ON && tokenIds.length == 20) {
// 20% discount
require(getNFTPrice().mul(16) == msg.value, "Ether value sent is not correct");
} else {
require(getNFTPrice().mul(tokenIds.length) == msg.value, "Ether value sent is not correct");
}
for (uint i = 0; i < tokenIds.length; i++) {
require(tokenIds[i] >= 0, 'Token Id must be greater than or equal to 0');
require(tokenIds[i] < MAX_NFT_SUPPLY, 'Token Id must be less than 16384');
require(!_exists(tokenIds[i]), "One of the ERC721 tokens has been minted already");
}
for (uint i = 0; i < tokenIds.length; i++) {
_tokenTotal.increment();
_mint(_msgSender(), tokenIds[i]);
}
}
function getNFTPrice() public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
}
| getNFTPrice().mul(tokenIds.length).div(2)==msg.value,"Ether value sent is not correct" | 368,504 | getNFTPrice().mul(tokenIds.length).div(2)==msg.value |
"Ether value sent is not correct" | pragma solidity 0.5.16;
contract MagicPixels is ERC721, ERC721Metadata, ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenTotal;
uint256 MAX_NFT_SUPPLY = 16384;
bool SALE_20_ON = false;
bool SALE_EMERGENCY_ON = false;
bool SALE_1_FREE_ON = false;
constructor() ERC721Metadata("MagicPixels", "MPX") public {
}
function withdraw() public onlyOwner {
}
function setSale20(bool value) public onlyOwner {
}
function setSaleEmergency(bool value) public onlyOwner {
}
function setSale1Free(bool value) public onlyOwner {
}
function isSale20On() public view returns (bool) {
}
function isSaleEmergencyOn() public view returns (bool) {
}
function isSale1FreeOn() public view returns (bool) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function mintTokenIds(uint256[] memory tokenIds) public payable {
require(totalSupply() < MAX_NFT_SUPPLY, "Sale has already ended");
require(tokenIds.length > 0, "tokenIds length cannot be 0");
require(tokenIds.length <= 20, "You may not buy more than 20 NFTs at once");
require(totalSupply().add(tokenIds.length) <= MAX_NFT_SUPPLY, "Exceeds MAX_NFT_SUPPLY");
if(SALE_EMERGENCY_ON) {
// for emergencies where ETH/USD price has gone up > 30k
require(getNFTPrice().mul(tokenIds.length).div(10) == msg.value, "Ether value sent is not correct");
} else if(SALE_1_FREE_ON) {
// buy 1 get 1 free
require(getNFTPrice().mul(tokenIds.length).div(2) == msg.value, "Ether value sent is not correct");
} else if(SALE_20_ON && tokenIds.length == 20) {
// 20% discount
require(<FILL_ME>)
} else {
require(getNFTPrice().mul(tokenIds.length) == msg.value, "Ether value sent is not correct");
}
for (uint i = 0; i < tokenIds.length; i++) {
require(tokenIds[i] >= 0, 'Token Id must be greater than or equal to 0');
require(tokenIds[i] < MAX_NFT_SUPPLY, 'Token Id must be less than 16384');
require(!_exists(tokenIds[i]), "One of the ERC721 tokens has been minted already");
}
for (uint i = 0; i < tokenIds.length; i++) {
_tokenTotal.increment();
_mint(_msgSender(), tokenIds[i]);
}
}
function getNFTPrice() public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
}
| getNFTPrice().mul(16)==msg.value,"Ether value sent is not correct" | 368,504 | getNFTPrice().mul(16)==msg.value |
"Ether value sent is not correct" | pragma solidity 0.5.16;
contract MagicPixels is ERC721, ERC721Metadata, ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenTotal;
uint256 MAX_NFT_SUPPLY = 16384;
bool SALE_20_ON = false;
bool SALE_EMERGENCY_ON = false;
bool SALE_1_FREE_ON = false;
constructor() ERC721Metadata("MagicPixels", "MPX") public {
}
function withdraw() public onlyOwner {
}
function setSale20(bool value) public onlyOwner {
}
function setSaleEmergency(bool value) public onlyOwner {
}
function setSale1Free(bool value) public onlyOwner {
}
function isSale20On() public view returns (bool) {
}
function isSaleEmergencyOn() public view returns (bool) {
}
function isSale1FreeOn() public view returns (bool) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function mintTokenIds(uint256[] memory tokenIds) public payable {
require(totalSupply() < MAX_NFT_SUPPLY, "Sale has already ended");
require(tokenIds.length > 0, "tokenIds length cannot be 0");
require(tokenIds.length <= 20, "You may not buy more than 20 NFTs at once");
require(totalSupply().add(tokenIds.length) <= MAX_NFT_SUPPLY, "Exceeds MAX_NFT_SUPPLY");
if(SALE_EMERGENCY_ON) {
// for emergencies where ETH/USD price has gone up > 30k
require(getNFTPrice().mul(tokenIds.length).div(10) == msg.value, "Ether value sent is not correct");
} else if(SALE_1_FREE_ON) {
// buy 1 get 1 free
require(getNFTPrice().mul(tokenIds.length).div(2) == msg.value, "Ether value sent is not correct");
} else if(SALE_20_ON && tokenIds.length == 20) {
// 20% discount
require(getNFTPrice().mul(16) == msg.value, "Ether value sent is not correct");
} else {
require(<FILL_ME>)
}
for (uint i = 0; i < tokenIds.length; i++) {
require(tokenIds[i] >= 0, 'Token Id must be greater than or equal to 0');
require(tokenIds[i] < MAX_NFT_SUPPLY, 'Token Id must be less than 16384');
require(!_exists(tokenIds[i]), "One of the ERC721 tokens has been minted already");
}
for (uint i = 0; i < tokenIds.length; i++) {
_tokenTotal.increment();
_mint(_msgSender(), tokenIds[i]);
}
}
function getNFTPrice() public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
}
| getNFTPrice().mul(tokenIds.length)==msg.value,"Ether value sent is not correct" | 368,504 | getNFTPrice().mul(tokenIds.length)==msg.value |
'Token Id must be greater than or equal to 0' | pragma solidity 0.5.16;
contract MagicPixels is ERC721, ERC721Metadata, ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenTotal;
uint256 MAX_NFT_SUPPLY = 16384;
bool SALE_20_ON = false;
bool SALE_EMERGENCY_ON = false;
bool SALE_1_FREE_ON = false;
constructor() ERC721Metadata("MagicPixels", "MPX") public {
}
function withdraw() public onlyOwner {
}
function setSale20(bool value) public onlyOwner {
}
function setSaleEmergency(bool value) public onlyOwner {
}
function setSale1Free(bool value) public onlyOwner {
}
function isSale20On() public view returns (bool) {
}
function isSaleEmergencyOn() public view returns (bool) {
}
function isSale1FreeOn() public view returns (bool) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function mintTokenIds(uint256[] memory tokenIds) public payable {
require(totalSupply() < MAX_NFT_SUPPLY, "Sale has already ended");
require(tokenIds.length > 0, "tokenIds length cannot be 0");
require(tokenIds.length <= 20, "You may not buy more than 20 NFTs at once");
require(totalSupply().add(tokenIds.length) <= MAX_NFT_SUPPLY, "Exceeds MAX_NFT_SUPPLY");
if(SALE_EMERGENCY_ON) {
// for emergencies where ETH/USD price has gone up > 30k
require(getNFTPrice().mul(tokenIds.length).div(10) == msg.value, "Ether value sent is not correct");
} else if(SALE_1_FREE_ON) {
// buy 1 get 1 free
require(getNFTPrice().mul(tokenIds.length).div(2) == msg.value, "Ether value sent is not correct");
} else if(SALE_20_ON && tokenIds.length == 20) {
// 20% discount
require(getNFTPrice().mul(16) == msg.value, "Ether value sent is not correct");
} else {
require(getNFTPrice().mul(tokenIds.length) == msg.value, "Ether value sent is not correct");
}
for (uint i = 0; i < tokenIds.length; i++) {
require(<FILL_ME>)
require(tokenIds[i] < MAX_NFT_SUPPLY, 'Token Id must be less than 16384');
require(!_exists(tokenIds[i]), "One of the ERC721 tokens has been minted already");
}
for (uint i = 0; i < tokenIds.length; i++) {
_tokenTotal.increment();
_mint(_msgSender(), tokenIds[i]);
}
}
function getNFTPrice() public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
}
| tokenIds[i]>=0,'Token Id must be greater than or equal to 0' | 368,504 | tokenIds[i]>=0 |
'Token Id must be less than 16384' | pragma solidity 0.5.16;
contract MagicPixels is ERC721, ERC721Metadata, ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenTotal;
uint256 MAX_NFT_SUPPLY = 16384;
bool SALE_20_ON = false;
bool SALE_EMERGENCY_ON = false;
bool SALE_1_FREE_ON = false;
constructor() ERC721Metadata("MagicPixels", "MPX") public {
}
function withdraw() public onlyOwner {
}
function setSale20(bool value) public onlyOwner {
}
function setSaleEmergency(bool value) public onlyOwner {
}
function setSale1Free(bool value) public onlyOwner {
}
function isSale20On() public view returns (bool) {
}
function isSaleEmergencyOn() public view returns (bool) {
}
function isSale1FreeOn() public view returns (bool) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function mintTokenIds(uint256[] memory tokenIds) public payable {
require(totalSupply() < MAX_NFT_SUPPLY, "Sale has already ended");
require(tokenIds.length > 0, "tokenIds length cannot be 0");
require(tokenIds.length <= 20, "You may not buy more than 20 NFTs at once");
require(totalSupply().add(tokenIds.length) <= MAX_NFT_SUPPLY, "Exceeds MAX_NFT_SUPPLY");
if(SALE_EMERGENCY_ON) {
// for emergencies where ETH/USD price has gone up > 30k
require(getNFTPrice().mul(tokenIds.length).div(10) == msg.value, "Ether value sent is not correct");
} else if(SALE_1_FREE_ON) {
// buy 1 get 1 free
require(getNFTPrice().mul(tokenIds.length).div(2) == msg.value, "Ether value sent is not correct");
} else if(SALE_20_ON && tokenIds.length == 20) {
// 20% discount
require(getNFTPrice().mul(16) == msg.value, "Ether value sent is not correct");
} else {
require(getNFTPrice().mul(tokenIds.length) == msg.value, "Ether value sent is not correct");
}
for (uint i = 0; i < tokenIds.length; i++) {
require(tokenIds[i] >= 0, 'Token Id must be greater than or equal to 0');
require(<FILL_ME>)
require(!_exists(tokenIds[i]), "One of the ERC721 tokens has been minted already");
}
for (uint i = 0; i < tokenIds.length; i++) {
_tokenTotal.increment();
_mint(_msgSender(), tokenIds[i]);
}
}
function getNFTPrice() public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
}
| tokenIds[i]<MAX_NFT_SUPPLY,'Token Id must be less than 16384' | 368,504 | tokenIds[i]<MAX_NFT_SUPPLY |
"erc20 must not be 0" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.12;
import "./SafeMath.sol";
import "./SafeMath96.sol";
import "./Math.sol";
import "./IERC20.sol";
import "./ICommittee.sol";
import "./IProtocolWallet.sol";
import "./IStakingRewards.sol";
import "./IDelegation.sol";
import "./IStakingContract.sol";
import "./ManagedContract.sol";
contract StakingRewards is IStakingRewards, ManagedContract {
using SafeMath for uint256;
using SafeMath96 for uint96;
uint256 constant PERCENT_MILLIE_BASE = 100000;
uint256 constant TOKEN_BASE = 1e18;
struct Settings {
uint96 annualCap;
uint32 annualRateInPercentMille;
uint32 defaultDelegatorsStakingRewardsPercentMille;
uint32 maxDelegatorsStakingRewardsPercentMille;
bool rewardAllocationActive;
}
Settings settings;
IERC20 public erc20;
struct StakingRewardsState {
uint96 stakingRewardsPerWeight;
uint96 unclaimedStakingRewards;
uint32 lastAssigned;
}
StakingRewardsState public stakingRewardsState;
uint256 public stakingRewardsWithdrawnFromWallet;
struct GuardianStakingRewards {
uint96 delegatorRewardsPerToken;
uint96 lastStakingRewardsPerWeight;
uint96 balance;
uint96 claimed;
}
mapping(address => GuardianStakingRewards) public guardiansStakingRewards;
struct GuardianRewardSettings {
uint32 delegatorsStakingRewardsPercentMille;
bool overrideDefault;
}
mapping(address => GuardianRewardSettings) public guardiansRewardSettings;
struct DelegatorStakingRewards {
uint96 balance;
uint96 lastDelegatorRewardsPerToken;
uint96 claimed;
}
mapping(address => DelegatorStakingRewards) public delegatorsStakingRewards;
constructor(
IContractRegistry _contractRegistry,
address _registryAdmin,
IERC20 _erc20,
uint annualRateInPercentMille,
uint annualCap,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
IStakingRewards previousRewardsContract,
address[] memory guardiansToMigrate
) ManagedContract(_contractRegistry, _registryAdmin) public {
require(<FILL_ME>)
_setAnnualStakingRewardsRate(annualRateInPercentMille, annualCap);
setMaxDelegatorsStakingRewardsPercentMille(maxDelegatorsStakingRewardsPercentMille);
setDefaultDelegatorsStakingRewardsPercentMille(defaultDelegatorsStakingRewardsPercentMille);
erc20 = _erc20;
if (address(previousRewardsContract) != address(0)) {
migrateGuardiansSettings(previousRewardsContract, guardiansToMigrate);
}
}
modifier onlyCommitteeContract() {
}
modifier onlyDelegationsContract() {
}
/*
* External functions
*/
function committeeMembershipWillChange(address guardian, uint256 weight, uint256 totalCommitteeWeight, bool inCommittee, bool inCommitteeAfter) external override onlyWhenActive onlyCommitteeContract {
}
function delegationWillChange(address guardian, uint256 guardianDelegatedStake, address delegator, uint256 delegatorStake, address nextGuardian, uint256 nextGuardianDelegatedStake) external override onlyWhenActive onlyDelegationsContract {
}
function getStakingRewardsBalance(address addr) external override view returns (uint256) {
}
function claimStakingRewards(address addr) external override onlyWhenActive {
}
function getGuardianStakingRewardsData(address guardian) external override view returns (
uint256 balance,
uint256 claimed,
uint256 delegatorRewardsPerToken,
uint256 lastStakingRewardsPerWeight
) {
}
function getDelegatorStakingRewardsData(address delegator) external override view returns (
uint256 balance,
uint256 claimed,
uint256 lastDelegatorRewardsPerToken
) {
}
function getStakingRewardsState() public override view returns (
uint96 stakingRewardsPerWeight,
uint96 unclaimedStakingRewards
) {
}
function getCurrentStakingRewardsRatePercentMille() external override returns (uint256) {
}
function setGuardianDelegatorsStakingRewardsPercentMille(uint32 delegatorRewardsPercentMille) external override onlyWhenActive {
}
function getGuardianDelegatorsStakingRewardsPercentMille(address guardian) external override view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function getStakingRewardsWalletAllocatedTokens() external override view returns (uint256 allocated) {
}
/*
* Governance functions
*/
function migrateRewardsBalance(address addr) external override {
}
function acceptRewardsBalanceMigration(address addr, uint256 guardianStakingRewards, uint256 delegatorStakingRewards) external override {
}
function emergencyWithdraw() external override onlyMigrationManager {
}
function activateRewardDistribution(uint startTime) external override onlyMigrationManager {
}
function deactivateRewardDistribution() external override onlyMigrationManager {
}
function setDefaultDelegatorsStakingRewardsPercentMille(uint32 defaultDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getDefaultDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setMaxDelegatorsStakingRewardsPercentMille(uint32 maxDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getMaxDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) external override onlyFunctionalManager {
}
function getAnnualStakingRewardsRatePercentMille() external override view returns (uint32) {
}
function getAnnualStakingRewardsCap() external override view returns (uint256) {
}
function isRewardAllocationActive() external override view returns (bool) {
}
function getSettings() external override view returns (
uint annualStakingRewardsCap,
uint32 annualStakingRewardsRatePercentMille,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
bool rewardAllocationActive
) {
}
/*
* Private functions
*/
// Global state
function _getAnnualRate(uint256 totalCommitteeWeight, Settings memory _settings) private pure returns (uint256) {
}
function calcStakingRewardPerWeightDelta(uint256 totalCommitteeWeight, uint duration, Settings memory _settings) private pure returns (uint256 stakingRewardsPerTokenDelta) {
}
function _getStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private view returns (StakingRewardsState memory _stakingRewardsState, uint256 allocatedRewards) {
}
function _updateStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private returns (StakingRewardsState memory _stakingRewardsState) {
}
function updateStakingRewardsState() private returns (StakingRewardsState memory _stakingRewardsState) {
}
// Guardian state
function _getGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private view returns (GuardianStakingRewards memory guardianStakingRewards, uint256 rewardsAdded) {
}
function getGuardianStakingRewards(address guardian) private view returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function _updateGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function updateGuardianStakingRewards(address guardian, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
// Delegator state
function _getDelegatorStakingRewards(address delegator, uint256 delegatorStake, GuardianStakingRewards memory guardianStakingRewards) private view returns (DelegatorStakingRewards memory delegatorStakingRewards, uint256 delegatorRewardsAdded) {
}
function getDelegatorStakingRewards(address delegator) private view returns (DelegatorStakingRewards memory delegatorStakingRewards) {
}
function _updateDelegatorStakingRewards(address delegator, uint256 delegatorStake, address guardian, GuardianStakingRewards memory guardianStakingRewards) private {
}
function updateDelegatorStakingRewards(address delegator) private {
}
// Guardian settings
function _getGuardianDelegatorsStakingRewardsPercentMille(address guardian, Settings memory _settings) private view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function migrateGuardiansSettings(IStakingRewards previousRewardsContract, address[] memory guardiansToMigrate) private {
}
// Governance and misc.
function _setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) private {
}
function _setGuardianDelegatorsStakingRewardsPercentMille(address guardian, uint32 delegatorRewardsPercentMille) private {
}
function claimStakingRewardsLocally(address addr) private returns (uint256 guardianRewards, uint256 delegatorRewards) {
}
/*
* Contracts topology / registry interface
*/
ICommittee committeeContract;
IDelegations delegationsContract;
IProtocolWallet stakingRewardsWallet;
IStakingContract stakingContract;
function refreshContracts() external override {
}
}
| address(_erc20)!=address(0),"erc20 must not be 0" | 368,525 | address(_erc20)!=address(0) |
"claimStakingRewards: approve failed" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.12;
import "./SafeMath.sol";
import "./SafeMath96.sol";
import "./Math.sol";
import "./IERC20.sol";
import "./ICommittee.sol";
import "./IProtocolWallet.sol";
import "./IStakingRewards.sol";
import "./IDelegation.sol";
import "./IStakingContract.sol";
import "./ManagedContract.sol";
contract StakingRewards is IStakingRewards, ManagedContract {
using SafeMath for uint256;
using SafeMath96 for uint96;
uint256 constant PERCENT_MILLIE_BASE = 100000;
uint256 constant TOKEN_BASE = 1e18;
struct Settings {
uint96 annualCap;
uint32 annualRateInPercentMille;
uint32 defaultDelegatorsStakingRewardsPercentMille;
uint32 maxDelegatorsStakingRewardsPercentMille;
bool rewardAllocationActive;
}
Settings settings;
IERC20 public erc20;
struct StakingRewardsState {
uint96 stakingRewardsPerWeight;
uint96 unclaimedStakingRewards;
uint32 lastAssigned;
}
StakingRewardsState public stakingRewardsState;
uint256 public stakingRewardsWithdrawnFromWallet;
struct GuardianStakingRewards {
uint96 delegatorRewardsPerToken;
uint96 lastStakingRewardsPerWeight;
uint96 balance;
uint96 claimed;
}
mapping(address => GuardianStakingRewards) public guardiansStakingRewards;
struct GuardianRewardSettings {
uint32 delegatorsStakingRewardsPercentMille;
bool overrideDefault;
}
mapping(address => GuardianRewardSettings) public guardiansRewardSettings;
struct DelegatorStakingRewards {
uint96 balance;
uint96 lastDelegatorRewardsPerToken;
uint96 claimed;
}
mapping(address => DelegatorStakingRewards) public delegatorsStakingRewards;
constructor(
IContractRegistry _contractRegistry,
address _registryAdmin,
IERC20 _erc20,
uint annualRateInPercentMille,
uint annualCap,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
IStakingRewards previousRewardsContract,
address[] memory guardiansToMigrate
) ManagedContract(_contractRegistry, _registryAdmin) public {
}
modifier onlyCommitteeContract() {
}
modifier onlyDelegationsContract() {
}
/*
* External functions
*/
function committeeMembershipWillChange(address guardian, uint256 weight, uint256 totalCommitteeWeight, bool inCommittee, bool inCommitteeAfter) external override onlyWhenActive onlyCommitteeContract {
}
function delegationWillChange(address guardian, uint256 guardianDelegatedStake, address delegator, uint256 delegatorStake, address nextGuardian, uint256 nextGuardianDelegatedStake) external override onlyWhenActive onlyDelegationsContract {
}
function getStakingRewardsBalance(address addr) external override view returns (uint256) {
}
function claimStakingRewards(address addr) external override onlyWhenActive {
(uint256 guardianRewards, uint256 delegatorRewards) = claimStakingRewardsLocally(addr);
uint96 claimedGuardianRewards = guardiansStakingRewards[addr].claimed.add(guardianRewards);
guardiansStakingRewards[addr].claimed = claimedGuardianRewards;
uint96 claimedDelegatorRewards = delegatorsStakingRewards[addr].claimed.add(delegatorRewards);
delegatorsStakingRewards[addr].claimed = claimedDelegatorRewards;
uint256 total = delegatorRewards.add(guardianRewards);
require(<FILL_ME>)
address[] memory addrs = new address[](1);
addrs[0] = addr;
uint256[] memory amounts = new uint256[](1);
amounts[0] = total;
stakingContract.distributeRewards(total, addrs, amounts);
emit StakingRewardsClaimed(addr, delegatorRewards, guardianRewards, claimedDelegatorRewards, claimedGuardianRewards);
}
function getGuardianStakingRewardsData(address guardian) external override view returns (
uint256 balance,
uint256 claimed,
uint256 delegatorRewardsPerToken,
uint256 lastStakingRewardsPerWeight
) {
}
function getDelegatorStakingRewardsData(address delegator) external override view returns (
uint256 balance,
uint256 claimed,
uint256 lastDelegatorRewardsPerToken
) {
}
function getStakingRewardsState() public override view returns (
uint96 stakingRewardsPerWeight,
uint96 unclaimedStakingRewards
) {
}
function getCurrentStakingRewardsRatePercentMille() external override returns (uint256) {
}
function setGuardianDelegatorsStakingRewardsPercentMille(uint32 delegatorRewardsPercentMille) external override onlyWhenActive {
}
function getGuardianDelegatorsStakingRewardsPercentMille(address guardian) external override view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function getStakingRewardsWalletAllocatedTokens() external override view returns (uint256 allocated) {
}
/*
* Governance functions
*/
function migrateRewardsBalance(address addr) external override {
}
function acceptRewardsBalanceMigration(address addr, uint256 guardianStakingRewards, uint256 delegatorStakingRewards) external override {
}
function emergencyWithdraw() external override onlyMigrationManager {
}
function activateRewardDistribution(uint startTime) external override onlyMigrationManager {
}
function deactivateRewardDistribution() external override onlyMigrationManager {
}
function setDefaultDelegatorsStakingRewardsPercentMille(uint32 defaultDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getDefaultDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setMaxDelegatorsStakingRewardsPercentMille(uint32 maxDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getMaxDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) external override onlyFunctionalManager {
}
function getAnnualStakingRewardsRatePercentMille() external override view returns (uint32) {
}
function getAnnualStakingRewardsCap() external override view returns (uint256) {
}
function isRewardAllocationActive() external override view returns (bool) {
}
function getSettings() external override view returns (
uint annualStakingRewardsCap,
uint32 annualStakingRewardsRatePercentMille,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
bool rewardAllocationActive
) {
}
/*
* Private functions
*/
// Global state
function _getAnnualRate(uint256 totalCommitteeWeight, Settings memory _settings) private pure returns (uint256) {
}
function calcStakingRewardPerWeightDelta(uint256 totalCommitteeWeight, uint duration, Settings memory _settings) private pure returns (uint256 stakingRewardsPerTokenDelta) {
}
function _getStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private view returns (StakingRewardsState memory _stakingRewardsState, uint256 allocatedRewards) {
}
function _updateStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private returns (StakingRewardsState memory _stakingRewardsState) {
}
function updateStakingRewardsState() private returns (StakingRewardsState memory _stakingRewardsState) {
}
// Guardian state
function _getGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private view returns (GuardianStakingRewards memory guardianStakingRewards, uint256 rewardsAdded) {
}
function getGuardianStakingRewards(address guardian) private view returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function _updateGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function updateGuardianStakingRewards(address guardian, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
// Delegator state
function _getDelegatorStakingRewards(address delegator, uint256 delegatorStake, GuardianStakingRewards memory guardianStakingRewards) private view returns (DelegatorStakingRewards memory delegatorStakingRewards, uint256 delegatorRewardsAdded) {
}
function getDelegatorStakingRewards(address delegator) private view returns (DelegatorStakingRewards memory delegatorStakingRewards) {
}
function _updateDelegatorStakingRewards(address delegator, uint256 delegatorStake, address guardian, GuardianStakingRewards memory guardianStakingRewards) private {
}
function updateDelegatorStakingRewards(address delegator) private {
}
// Guardian settings
function _getGuardianDelegatorsStakingRewardsPercentMille(address guardian, Settings memory _settings) private view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function migrateGuardiansSettings(IStakingRewards previousRewardsContract, address[] memory guardiansToMigrate) private {
}
// Governance and misc.
function _setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) private {
}
function _setGuardianDelegatorsStakingRewardsPercentMille(address guardian, uint32 delegatorRewardsPercentMille) private {
}
function claimStakingRewardsLocally(address addr) private returns (uint256 guardianRewards, uint256 delegatorRewards) {
}
/*
* Contracts topology / registry interface
*/
ICommittee committeeContract;
IDelegations delegationsContract;
IProtocolWallet stakingRewardsWallet;
IStakingContract stakingContract;
function refreshContracts() external override {
}
}
| erc20.approve(address(stakingContract),total),"claimStakingRewards: approve failed" | 368,525 | erc20.approve(address(stakingContract),total) |
"Reward distribution must be deactivated for migration" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.12;
import "./SafeMath.sol";
import "./SafeMath96.sol";
import "./Math.sol";
import "./IERC20.sol";
import "./ICommittee.sol";
import "./IProtocolWallet.sol";
import "./IStakingRewards.sol";
import "./IDelegation.sol";
import "./IStakingContract.sol";
import "./ManagedContract.sol";
contract StakingRewards is IStakingRewards, ManagedContract {
using SafeMath for uint256;
using SafeMath96 for uint96;
uint256 constant PERCENT_MILLIE_BASE = 100000;
uint256 constant TOKEN_BASE = 1e18;
struct Settings {
uint96 annualCap;
uint32 annualRateInPercentMille;
uint32 defaultDelegatorsStakingRewardsPercentMille;
uint32 maxDelegatorsStakingRewardsPercentMille;
bool rewardAllocationActive;
}
Settings settings;
IERC20 public erc20;
struct StakingRewardsState {
uint96 stakingRewardsPerWeight;
uint96 unclaimedStakingRewards;
uint32 lastAssigned;
}
StakingRewardsState public stakingRewardsState;
uint256 public stakingRewardsWithdrawnFromWallet;
struct GuardianStakingRewards {
uint96 delegatorRewardsPerToken;
uint96 lastStakingRewardsPerWeight;
uint96 balance;
uint96 claimed;
}
mapping(address => GuardianStakingRewards) public guardiansStakingRewards;
struct GuardianRewardSettings {
uint32 delegatorsStakingRewardsPercentMille;
bool overrideDefault;
}
mapping(address => GuardianRewardSettings) public guardiansRewardSettings;
struct DelegatorStakingRewards {
uint96 balance;
uint96 lastDelegatorRewardsPerToken;
uint96 claimed;
}
mapping(address => DelegatorStakingRewards) public delegatorsStakingRewards;
constructor(
IContractRegistry _contractRegistry,
address _registryAdmin,
IERC20 _erc20,
uint annualRateInPercentMille,
uint annualCap,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
IStakingRewards previousRewardsContract,
address[] memory guardiansToMigrate
) ManagedContract(_contractRegistry, _registryAdmin) public {
}
modifier onlyCommitteeContract() {
}
modifier onlyDelegationsContract() {
}
/*
* External functions
*/
function committeeMembershipWillChange(address guardian, uint256 weight, uint256 totalCommitteeWeight, bool inCommittee, bool inCommitteeAfter) external override onlyWhenActive onlyCommitteeContract {
}
function delegationWillChange(address guardian, uint256 guardianDelegatedStake, address delegator, uint256 delegatorStake, address nextGuardian, uint256 nextGuardianDelegatedStake) external override onlyWhenActive onlyDelegationsContract {
}
function getStakingRewardsBalance(address addr) external override view returns (uint256) {
}
function claimStakingRewards(address addr) external override onlyWhenActive {
}
function getGuardianStakingRewardsData(address guardian) external override view returns (
uint256 balance,
uint256 claimed,
uint256 delegatorRewardsPerToken,
uint256 lastStakingRewardsPerWeight
) {
}
function getDelegatorStakingRewardsData(address delegator) external override view returns (
uint256 balance,
uint256 claimed,
uint256 lastDelegatorRewardsPerToken
) {
}
function getStakingRewardsState() public override view returns (
uint96 stakingRewardsPerWeight,
uint96 unclaimedStakingRewards
) {
}
function getCurrentStakingRewardsRatePercentMille() external override returns (uint256) {
}
function setGuardianDelegatorsStakingRewardsPercentMille(uint32 delegatorRewardsPercentMille) external override onlyWhenActive {
}
function getGuardianDelegatorsStakingRewardsPercentMille(address guardian) external override view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function getStakingRewardsWalletAllocatedTokens() external override view returns (uint256 allocated) {
}
/*
* Governance functions
*/
function migrateRewardsBalance(address addr) external override {
require(<FILL_ME>)
IStakingRewards currentRewardsContract = IStakingRewards(getStakingRewardsContract());
require(address(currentRewardsContract) != address(this), "New rewards contract is not set");
(uint256 guardianRewards, uint256 delegatorRewards) = claimStakingRewardsLocally(addr);
require(erc20.approve(address(currentRewardsContract), guardianRewards.add(delegatorRewards)), "migrateRewardsBalance: approve failed");
currentRewardsContract.acceptRewardsBalanceMigration(addr, guardianRewards, delegatorRewards);
emit StakingRewardsBalanceMigrated(addr, guardianRewards, delegatorRewards, address(currentRewardsContract));
}
function acceptRewardsBalanceMigration(address addr, uint256 guardianStakingRewards, uint256 delegatorStakingRewards) external override {
}
function emergencyWithdraw() external override onlyMigrationManager {
}
function activateRewardDistribution(uint startTime) external override onlyMigrationManager {
}
function deactivateRewardDistribution() external override onlyMigrationManager {
}
function setDefaultDelegatorsStakingRewardsPercentMille(uint32 defaultDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getDefaultDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setMaxDelegatorsStakingRewardsPercentMille(uint32 maxDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getMaxDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) external override onlyFunctionalManager {
}
function getAnnualStakingRewardsRatePercentMille() external override view returns (uint32) {
}
function getAnnualStakingRewardsCap() external override view returns (uint256) {
}
function isRewardAllocationActive() external override view returns (bool) {
}
function getSettings() external override view returns (
uint annualStakingRewardsCap,
uint32 annualStakingRewardsRatePercentMille,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
bool rewardAllocationActive
) {
}
/*
* Private functions
*/
// Global state
function _getAnnualRate(uint256 totalCommitteeWeight, Settings memory _settings) private pure returns (uint256) {
}
function calcStakingRewardPerWeightDelta(uint256 totalCommitteeWeight, uint duration, Settings memory _settings) private pure returns (uint256 stakingRewardsPerTokenDelta) {
}
function _getStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private view returns (StakingRewardsState memory _stakingRewardsState, uint256 allocatedRewards) {
}
function _updateStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private returns (StakingRewardsState memory _stakingRewardsState) {
}
function updateStakingRewardsState() private returns (StakingRewardsState memory _stakingRewardsState) {
}
// Guardian state
function _getGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private view returns (GuardianStakingRewards memory guardianStakingRewards, uint256 rewardsAdded) {
}
function getGuardianStakingRewards(address guardian) private view returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function _updateGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function updateGuardianStakingRewards(address guardian, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
// Delegator state
function _getDelegatorStakingRewards(address delegator, uint256 delegatorStake, GuardianStakingRewards memory guardianStakingRewards) private view returns (DelegatorStakingRewards memory delegatorStakingRewards, uint256 delegatorRewardsAdded) {
}
function getDelegatorStakingRewards(address delegator) private view returns (DelegatorStakingRewards memory delegatorStakingRewards) {
}
function _updateDelegatorStakingRewards(address delegator, uint256 delegatorStake, address guardian, GuardianStakingRewards memory guardianStakingRewards) private {
}
function updateDelegatorStakingRewards(address delegator) private {
}
// Guardian settings
function _getGuardianDelegatorsStakingRewardsPercentMille(address guardian, Settings memory _settings) private view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function migrateGuardiansSettings(IStakingRewards previousRewardsContract, address[] memory guardiansToMigrate) private {
}
// Governance and misc.
function _setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) private {
}
function _setGuardianDelegatorsStakingRewardsPercentMille(address guardian, uint32 delegatorRewardsPercentMille) private {
}
function claimStakingRewardsLocally(address addr) private returns (uint256 guardianRewards, uint256 delegatorRewards) {
}
/*
* Contracts topology / registry interface
*/
ICommittee committeeContract;
IDelegations delegationsContract;
IProtocolWallet stakingRewardsWallet;
IStakingContract stakingContract;
function refreshContracts() external override {
}
}
| !settings.rewardAllocationActive,"Reward distribution must be deactivated for migration" | 368,525 | !settings.rewardAllocationActive |
"New rewards contract is not set" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.12;
import "./SafeMath.sol";
import "./SafeMath96.sol";
import "./Math.sol";
import "./IERC20.sol";
import "./ICommittee.sol";
import "./IProtocolWallet.sol";
import "./IStakingRewards.sol";
import "./IDelegation.sol";
import "./IStakingContract.sol";
import "./ManagedContract.sol";
contract StakingRewards is IStakingRewards, ManagedContract {
using SafeMath for uint256;
using SafeMath96 for uint96;
uint256 constant PERCENT_MILLIE_BASE = 100000;
uint256 constant TOKEN_BASE = 1e18;
struct Settings {
uint96 annualCap;
uint32 annualRateInPercentMille;
uint32 defaultDelegatorsStakingRewardsPercentMille;
uint32 maxDelegatorsStakingRewardsPercentMille;
bool rewardAllocationActive;
}
Settings settings;
IERC20 public erc20;
struct StakingRewardsState {
uint96 stakingRewardsPerWeight;
uint96 unclaimedStakingRewards;
uint32 lastAssigned;
}
StakingRewardsState public stakingRewardsState;
uint256 public stakingRewardsWithdrawnFromWallet;
struct GuardianStakingRewards {
uint96 delegatorRewardsPerToken;
uint96 lastStakingRewardsPerWeight;
uint96 balance;
uint96 claimed;
}
mapping(address => GuardianStakingRewards) public guardiansStakingRewards;
struct GuardianRewardSettings {
uint32 delegatorsStakingRewardsPercentMille;
bool overrideDefault;
}
mapping(address => GuardianRewardSettings) public guardiansRewardSettings;
struct DelegatorStakingRewards {
uint96 balance;
uint96 lastDelegatorRewardsPerToken;
uint96 claimed;
}
mapping(address => DelegatorStakingRewards) public delegatorsStakingRewards;
constructor(
IContractRegistry _contractRegistry,
address _registryAdmin,
IERC20 _erc20,
uint annualRateInPercentMille,
uint annualCap,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
IStakingRewards previousRewardsContract,
address[] memory guardiansToMigrate
) ManagedContract(_contractRegistry, _registryAdmin) public {
}
modifier onlyCommitteeContract() {
}
modifier onlyDelegationsContract() {
}
/*
* External functions
*/
function committeeMembershipWillChange(address guardian, uint256 weight, uint256 totalCommitteeWeight, bool inCommittee, bool inCommitteeAfter) external override onlyWhenActive onlyCommitteeContract {
}
function delegationWillChange(address guardian, uint256 guardianDelegatedStake, address delegator, uint256 delegatorStake, address nextGuardian, uint256 nextGuardianDelegatedStake) external override onlyWhenActive onlyDelegationsContract {
}
function getStakingRewardsBalance(address addr) external override view returns (uint256) {
}
function claimStakingRewards(address addr) external override onlyWhenActive {
}
function getGuardianStakingRewardsData(address guardian) external override view returns (
uint256 balance,
uint256 claimed,
uint256 delegatorRewardsPerToken,
uint256 lastStakingRewardsPerWeight
) {
}
function getDelegatorStakingRewardsData(address delegator) external override view returns (
uint256 balance,
uint256 claimed,
uint256 lastDelegatorRewardsPerToken
) {
}
function getStakingRewardsState() public override view returns (
uint96 stakingRewardsPerWeight,
uint96 unclaimedStakingRewards
) {
}
function getCurrentStakingRewardsRatePercentMille() external override returns (uint256) {
}
function setGuardianDelegatorsStakingRewardsPercentMille(uint32 delegatorRewardsPercentMille) external override onlyWhenActive {
}
function getGuardianDelegatorsStakingRewardsPercentMille(address guardian) external override view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function getStakingRewardsWalletAllocatedTokens() external override view returns (uint256 allocated) {
}
/*
* Governance functions
*/
function migrateRewardsBalance(address addr) external override {
require(!settings.rewardAllocationActive, "Reward distribution must be deactivated for migration");
IStakingRewards currentRewardsContract = IStakingRewards(getStakingRewardsContract());
require(<FILL_ME>)
(uint256 guardianRewards, uint256 delegatorRewards) = claimStakingRewardsLocally(addr);
require(erc20.approve(address(currentRewardsContract), guardianRewards.add(delegatorRewards)), "migrateRewardsBalance: approve failed");
currentRewardsContract.acceptRewardsBalanceMigration(addr, guardianRewards, delegatorRewards);
emit StakingRewardsBalanceMigrated(addr, guardianRewards, delegatorRewards, address(currentRewardsContract));
}
function acceptRewardsBalanceMigration(address addr, uint256 guardianStakingRewards, uint256 delegatorStakingRewards) external override {
}
function emergencyWithdraw() external override onlyMigrationManager {
}
function activateRewardDistribution(uint startTime) external override onlyMigrationManager {
}
function deactivateRewardDistribution() external override onlyMigrationManager {
}
function setDefaultDelegatorsStakingRewardsPercentMille(uint32 defaultDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getDefaultDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setMaxDelegatorsStakingRewardsPercentMille(uint32 maxDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getMaxDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) external override onlyFunctionalManager {
}
function getAnnualStakingRewardsRatePercentMille() external override view returns (uint32) {
}
function getAnnualStakingRewardsCap() external override view returns (uint256) {
}
function isRewardAllocationActive() external override view returns (bool) {
}
function getSettings() external override view returns (
uint annualStakingRewardsCap,
uint32 annualStakingRewardsRatePercentMille,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
bool rewardAllocationActive
) {
}
/*
* Private functions
*/
// Global state
function _getAnnualRate(uint256 totalCommitteeWeight, Settings memory _settings) private pure returns (uint256) {
}
function calcStakingRewardPerWeightDelta(uint256 totalCommitteeWeight, uint duration, Settings memory _settings) private pure returns (uint256 stakingRewardsPerTokenDelta) {
}
function _getStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private view returns (StakingRewardsState memory _stakingRewardsState, uint256 allocatedRewards) {
}
function _updateStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private returns (StakingRewardsState memory _stakingRewardsState) {
}
function updateStakingRewardsState() private returns (StakingRewardsState memory _stakingRewardsState) {
}
// Guardian state
function _getGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private view returns (GuardianStakingRewards memory guardianStakingRewards, uint256 rewardsAdded) {
}
function getGuardianStakingRewards(address guardian) private view returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function _updateGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function updateGuardianStakingRewards(address guardian, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
// Delegator state
function _getDelegatorStakingRewards(address delegator, uint256 delegatorStake, GuardianStakingRewards memory guardianStakingRewards) private view returns (DelegatorStakingRewards memory delegatorStakingRewards, uint256 delegatorRewardsAdded) {
}
function getDelegatorStakingRewards(address delegator) private view returns (DelegatorStakingRewards memory delegatorStakingRewards) {
}
function _updateDelegatorStakingRewards(address delegator, uint256 delegatorStake, address guardian, GuardianStakingRewards memory guardianStakingRewards) private {
}
function updateDelegatorStakingRewards(address delegator) private {
}
// Guardian settings
function _getGuardianDelegatorsStakingRewardsPercentMille(address guardian, Settings memory _settings) private view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function migrateGuardiansSettings(IStakingRewards previousRewardsContract, address[] memory guardiansToMigrate) private {
}
// Governance and misc.
function _setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) private {
}
function _setGuardianDelegatorsStakingRewardsPercentMille(address guardian, uint32 delegatorRewardsPercentMille) private {
}
function claimStakingRewardsLocally(address addr) private returns (uint256 guardianRewards, uint256 delegatorRewards) {
}
/*
* Contracts topology / registry interface
*/
ICommittee committeeContract;
IDelegations delegationsContract;
IProtocolWallet stakingRewardsWallet;
IStakingContract stakingContract;
function refreshContracts() external override {
}
}
| address(currentRewardsContract)!=address(this),"New rewards contract is not set" | 368,525 | address(currentRewardsContract)!=address(this) |
"migrateRewardsBalance: approve failed" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.12;
import "./SafeMath.sol";
import "./SafeMath96.sol";
import "./Math.sol";
import "./IERC20.sol";
import "./ICommittee.sol";
import "./IProtocolWallet.sol";
import "./IStakingRewards.sol";
import "./IDelegation.sol";
import "./IStakingContract.sol";
import "./ManagedContract.sol";
contract StakingRewards is IStakingRewards, ManagedContract {
using SafeMath for uint256;
using SafeMath96 for uint96;
uint256 constant PERCENT_MILLIE_BASE = 100000;
uint256 constant TOKEN_BASE = 1e18;
struct Settings {
uint96 annualCap;
uint32 annualRateInPercentMille;
uint32 defaultDelegatorsStakingRewardsPercentMille;
uint32 maxDelegatorsStakingRewardsPercentMille;
bool rewardAllocationActive;
}
Settings settings;
IERC20 public erc20;
struct StakingRewardsState {
uint96 stakingRewardsPerWeight;
uint96 unclaimedStakingRewards;
uint32 lastAssigned;
}
StakingRewardsState public stakingRewardsState;
uint256 public stakingRewardsWithdrawnFromWallet;
struct GuardianStakingRewards {
uint96 delegatorRewardsPerToken;
uint96 lastStakingRewardsPerWeight;
uint96 balance;
uint96 claimed;
}
mapping(address => GuardianStakingRewards) public guardiansStakingRewards;
struct GuardianRewardSettings {
uint32 delegatorsStakingRewardsPercentMille;
bool overrideDefault;
}
mapping(address => GuardianRewardSettings) public guardiansRewardSettings;
struct DelegatorStakingRewards {
uint96 balance;
uint96 lastDelegatorRewardsPerToken;
uint96 claimed;
}
mapping(address => DelegatorStakingRewards) public delegatorsStakingRewards;
constructor(
IContractRegistry _contractRegistry,
address _registryAdmin,
IERC20 _erc20,
uint annualRateInPercentMille,
uint annualCap,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
IStakingRewards previousRewardsContract,
address[] memory guardiansToMigrate
) ManagedContract(_contractRegistry, _registryAdmin) public {
}
modifier onlyCommitteeContract() {
}
modifier onlyDelegationsContract() {
}
/*
* External functions
*/
function committeeMembershipWillChange(address guardian, uint256 weight, uint256 totalCommitteeWeight, bool inCommittee, bool inCommitteeAfter) external override onlyWhenActive onlyCommitteeContract {
}
function delegationWillChange(address guardian, uint256 guardianDelegatedStake, address delegator, uint256 delegatorStake, address nextGuardian, uint256 nextGuardianDelegatedStake) external override onlyWhenActive onlyDelegationsContract {
}
function getStakingRewardsBalance(address addr) external override view returns (uint256) {
}
function claimStakingRewards(address addr) external override onlyWhenActive {
}
function getGuardianStakingRewardsData(address guardian) external override view returns (
uint256 balance,
uint256 claimed,
uint256 delegatorRewardsPerToken,
uint256 lastStakingRewardsPerWeight
) {
}
function getDelegatorStakingRewardsData(address delegator) external override view returns (
uint256 balance,
uint256 claimed,
uint256 lastDelegatorRewardsPerToken
) {
}
function getStakingRewardsState() public override view returns (
uint96 stakingRewardsPerWeight,
uint96 unclaimedStakingRewards
) {
}
function getCurrentStakingRewardsRatePercentMille() external override returns (uint256) {
}
function setGuardianDelegatorsStakingRewardsPercentMille(uint32 delegatorRewardsPercentMille) external override onlyWhenActive {
}
function getGuardianDelegatorsStakingRewardsPercentMille(address guardian) external override view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function getStakingRewardsWalletAllocatedTokens() external override view returns (uint256 allocated) {
}
/*
* Governance functions
*/
function migrateRewardsBalance(address addr) external override {
require(!settings.rewardAllocationActive, "Reward distribution must be deactivated for migration");
IStakingRewards currentRewardsContract = IStakingRewards(getStakingRewardsContract());
require(address(currentRewardsContract) != address(this), "New rewards contract is not set");
(uint256 guardianRewards, uint256 delegatorRewards) = claimStakingRewardsLocally(addr);
require(<FILL_ME>)
currentRewardsContract.acceptRewardsBalanceMigration(addr, guardianRewards, delegatorRewards);
emit StakingRewardsBalanceMigrated(addr, guardianRewards, delegatorRewards, address(currentRewardsContract));
}
function acceptRewardsBalanceMigration(address addr, uint256 guardianStakingRewards, uint256 delegatorStakingRewards) external override {
}
function emergencyWithdraw() external override onlyMigrationManager {
}
function activateRewardDistribution(uint startTime) external override onlyMigrationManager {
}
function deactivateRewardDistribution() external override onlyMigrationManager {
}
function setDefaultDelegatorsStakingRewardsPercentMille(uint32 defaultDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getDefaultDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setMaxDelegatorsStakingRewardsPercentMille(uint32 maxDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getMaxDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) external override onlyFunctionalManager {
}
function getAnnualStakingRewardsRatePercentMille() external override view returns (uint32) {
}
function getAnnualStakingRewardsCap() external override view returns (uint256) {
}
function isRewardAllocationActive() external override view returns (bool) {
}
function getSettings() external override view returns (
uint annualStakingRewardsCap,
uint32 annualStakingRewardsRatePercentMille,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
bool rewardAllocationActive
) {
}
/*
* Private functions
*/
// Global state
function _getAnnualRate(uint256 totalCommitteeWeight, Settings memory _settings) private pure returns (uint256) {
}
function calcStakingRewardPerWeightDelta(uint256 totalCommitteeWeight, uint duration, Settings memory _settings) private pure returns (uint256 stakingRewardsPerTokenDelta) {
}
function _getStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private view returns (StakingRewardsState memory _stakingRewardsState, uint256 allocatedRewards) {
}
function _updateStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private returns (StakingRewardsState memory _stakingRewardsState) {
}
function updateStakingRewardsState() private returns (StakingRewardsState memory _stakingRewardsState) {
}
// Guardian state
function _getGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private view returns (GuardianStakingRewards memory guardianStakingRewards, uint256 rewardsAdded) {
}
function getGuardianStakingRewards(address guardian) private view returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function _updateGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function updateGuardianStakingRewards(address guardian, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
// Delegator state
function _getDelegatorStakingRewards(address delegator, uint256 delegatorStake, GuardianStakingRewards memory guardianStakingRewards) private view returns (DelegatorStakingRewards memory delegatorStakingRewards, uint256 delegatorRewardsAdded) {
}
function getDelegatorStakingRewards(address delegator) private view returns (DelegatorStakingRewards memory delegatorStakingRewards) {
}
function _updateDelegatorStakingRewards(address delegator, uint256 delegatorStake, address guardian, GuardianStakingRewards memory guardianStakingRewards) private {
}
function updateDelegatorStakingRewards(address delegator) private {
}
// Guardian settings
function _getGuardianDelegatorsStakingRewardsPercentMille(address guardian, Settings memory _settings) private view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function migrateGuardiansSettings(IStakingRewards previousRewardsContract, address[] memory guardiansToMigrate) private {
}
// Governance and misc.
function _setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) private {
}
function _setGuardianDelegatorsStakingRewardsPercentMille(address guardian, uint32 delegatorRewardsPercentMille) private {
}
function claimStakingRewardsLocally(address addr) private returns (uint256 guardianRewards, uint256 delegatorRewards) {
}
/*
* Contracts topology / registry interface
*/
ICommittee committeeContract;
IDelegations delegationsContract;
IProtocolWallet stakingRewardsWallet;
IStakingContract stakingContract;
function refreshContracts() external override {
}
}
| erc20.approve(address(currentRewardsContract),guardianRewards.add(delegatorRewards)),"migrateRewardsBalance: approve failed" | 368,525 | erc20.approve(address(currentRewardsContract),guardianRewards.add(delegatorRewards)) |
"acceptRewardBalanceMigration: transfer failed" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.12;
import "./SafeMath.sol";
import "./SafeMath96.sol";
import "./Math.sol";
import "./IERC20.sol";
import "./ICommittee.sol";
import "./IProtocolWallet.sol";
import "./IStakingRewards.sol";
import "./IDelegation.sol";
import "./IStakingContract.sol";
import "./ManagedContract.sol";
contract StakingRewards is IStakingRewards, ManagedContract {
using SafeMath for uint256;
using SafeMath96 for uint96;
uint256 constant PERCENT_MILLIE_BASE = 100000;
uint256 constant TOKEN_BASE = 1e18;
struct Settings {
uint96 annualCap;
uint32 annualRateInPercentMille;
uint32 defaultDelegatorsStakingRewardsPercentMille;
uint32 maxDelegatorsStakingRewardsPercentMille;
bool rewardAllocationActive;
}
Settings settings;
IERC20 public erc20;
struct StakingRewardsState {
uint96 stakingRewardsPerWeight;
uint96 unclaimedStakingRewards;
uint32 lastAssigned;
}
StakingRewardsState public stakingRewardsState;
uint256 public stakingRewardsWithdrawnFromWallet;
struct GuardianStakingRewards {
uint96 delegatorRewardsPerToken;
uint96 lastStakingRewardsPerWeight;
uint96 balance;
uint96 claimed;
}
mapping(address => GuardianStakingRewards) public guardiansStakingRewards;
struct GuardianRewardSettings {
uint32 delegatorsStakingRewardsPercentMille;
bool overrideDefault;
}
mapping(address => GuardianRewardSettings) public guardiansRewardSettings;
struct DelegatorStakingRewards {
uint96 balance;
uint96 lastDelegatorRewardsPerToken;
uint96 claimed;
}
mapping(address => DelegatorStakingRewards) public delegatorsStakingRewards;
constructor(
IContractRegistry _contractRegistry,
address _registryAdmin,
IERC20 _erc20,
uint annualRateInPercentMille,
uint annualCap,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
IStakingRewards previousRewardsContract,
address[] memory guardiansToMigrate
) ManagedContract(_contractRegistry, _registryAdmin) public {
}
modifier onlyCommitteeContract() {
}
modifier onlyDelegationsContract() {
}
/*
* External functions
*/
function committeeMembershipWillChange(address guardian, uint256 weight, uint256 totalCommitteeWeight, bool inCommittee, bool inCommitteeAfter) external override onlyWhenActive onlyCommitteeContract {
}
function delegationWillChange(address guardian, uint256 guardianDelegatedStake, address delegator, uint256 delegatorStake, address nextGuardian, uint256 nextGuardianDelegatedStake) external override onlyWhenActive onlyDelegationsContract {
}
function getStakingRewardsBalance(address addr) external override view returns (uint256) {
}
function claimStakingRewards(address addr) external override onlyWhenActive {
}
function getGuardianStakingRewardsData(address guardian) external override view returns (
uint256 balance,
uint256 claimed,
uint256 delegatorRewardsPerToken,
uint256 lastStakingRewardsPerWeight
) {
}
function getDelegatorStakingRewardsData(address delegator) external override view returns (
uint256 balance,
uint256 claimed,
uint256 lastDelegatorRewardsPerToken
) {
}
function getStakingRewardsState() public override view returns (
uint96 stakingRewardsPerWeight,
uint96 unclaimedStakingRewards
) {
}
function getCurrentStakingRewardsRatePercentMille() external override returns (uint256) {
}
function setGuardianDelegatorsStakingRewardsPercentMille(uint32 delegatorRewardsPercentMille) external override onlyWhenActive {
}
function getGuardianDelegatorsStakingRewardsPercentMille(address guardian) external override view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function getStakingRewardsWalletAllocatedTokens() external override view returns (uint256 allocated) {
}
/*
* Governance functions
*/
function migrateRewardsBalance(address addr) external override {
}
function acceptRewardsBalanceMigration(address addr, uint256 guardianStakingRewards, uint256 delegatorStakingRewards) external override {
guardiansStakingRewards[addr].balance = guardiansStakingRewards[addr].balance.add(guardianStakingRewards);
delegatorsStakingRewards[addr].balance = delegatorsStakingRewards[addr].balance.add(delegatorStakingRewards);
uint orbsTransferAmount = guardianStakingRewards.add(delegatorStakingRewards);
if (orbsTransferAmount > 0) {
require(<FILL_ME>)
}
emit StakingRewardsBalanceMigrationAccepted(msg.sender, addr, guardianStakingRewards, delegatorStakingRewards);
}
function emergencyWithdraw() external override onlyMigrationManager {
}
function activateRewardDistribution(uint startTime) external override onlyMigrationManager {
}
function deactivateRewardDistribution() external override onlyMigrationManager {
}
function setDefaultDelegatorsStakingRewardsPercentMille(uint32 defaultDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getDefaultDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setMaxDelegatorsStakingRewardsPercentMille(uint32 maxDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getMaxDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) external override onlyFunctionalManager {
}
function getAnnualStakingRewardsRatePercentMille() external override view returns (uint32) {
}
function getAnnualStakingRewardsCap() external override view returns (uint256) {
}
function isRewardAllocationActive() external override view returns (bool) {
}
function getSettings() external override view returns (
uint annualStakingRewardsCap,
uint32 annualStakingRewardsRatePercentMille,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
bool rewardAllocationActive
) {
}
/*
* Private functions
*/
// Global state
function _getAnnualRate(uint256 totalCommitteeWeight, Settings memory _settings) private pure returns (uint256) {
}
function calcStakingRewardPerWeightDelta(uint256 totalCommitteeWeight, uint duration, Settings memory _settings) private pure returns (uint256 stakingRewardsPerTokenDelta) {
}
function _getStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private view returns (StakingRewardsState memory _stakingRewardsState, uint256 allocatedRewards) {
}
function _updateStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private returns (StakingRewardsState memory _stakingRewardsState) {
}
function updateStakingRewardsState() private returns (StakingRewardsState memory _stakingRewardsState) {
}
// Guardian state
function _getGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private view returns (GuardianStakingRewards memory guardianStakingRewards, uint256 rewardsAdded) {
}
function getGuardianStakingRewards(address guardian) private view returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function _updateGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function updateGuardianStakingRewards(address guardian, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
// Delegator state
function _getDelegatorStakingRewards(address delegator, uint256 delegatorStake, GuardianStakingRewards memory guardianStakingRewards) private view returns (DelegatorStakingRewards memory delegatorStakingRewards, uint256 delegatorRewardsAdded) {
}
function getDelegatorStakingRewards(address delegator) private view returns (DelegatorStakingRewards memory delegatorStakingRewards) {
}
function _updateDelegatorStakingRewards(address delegator, uint256 delegatorStake, address guardian, GuardianStakingRewards memory guardianStakingRewards) private {
}
function updateDelegatorStakingRewards(address delegator) private {
}
// Guardian settings
function _getGuardianDelegatorsStakingRewardsPercentMille(address guardian, Settings memory _settings) private view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function migrateGuardiansSettings(IStakingRewards previousRewardsContract, address[] memory guardiansToMigrate) private {
}
// Governance and misc.
function _setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) private {
}
function _setGuardianDelegatorsStakingRewardsPercentMille(address guardian, uint32 delegatorRewardsPercentMille) private {
}
function claimStakingRewardsLocally(address addr) private returns (uint256 guardianRewards, uint256 delegatorRewards) {
}
/*
* Contracts topology / registry interface
*/
ICommittee committeeContract;
IDelegations delegationsContract;
IProtocolWallet stakingRewardsWallet;
IStakingContract stakingContract;
function refreshContracts() external override {
}
}
| erc20.transferFrom(msg.sender,address(this),orbsTransferAmount),"acceptRewardBalanceMigration: transfer failed" | 368,525 | erc20.transferFrom(msg.sender,address(this),orbsTransferAmount) |
"Rewards::emergencyWithdraw - transfer failed (orbs token)" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.12;
import "./SafeMath.sol";
import "./SafeMath96.sol";
import "./Math.sol";
import "./IERC20.sol";
import "./ICommittee.sol";
import "./IProtocolWallet.sol";
import "./IStakingRewards.sol";
import "./IDelegation.sol";
import "./IStakingContract.sol";
import "./ManagedContract.sol";
contract StakingRewards is IStakingRewards, ManagedContract {
using SafeMath for uint256;
using SafeMath96 for uint96;
uint256 constant PERCENT_MILLIE_BASE = 100000;
uint256 constant TOKEN_BASE = 1e18;
struct Settings {
uint96 annualCap;
uint32 annualRateInPercentMille;
uint32 defaultDelegatorsStakingRewardsPercentMille;
uint32 maxDelegatorsStakingRewardsPercentMille;
bool rewardAllocationActive;
}
Settings settings;
IERC20 public erc20;
struct StakingRewardsState {
uint96 stakingRewardsPerWeight;
uint96 unclaimedStakingRewards;
uint32 lastAssigned;
}
StakingRewardsState public stakingRewardsState;
uint256 public stakingRewardsWithdrawnFromWallet;
struct GuardianStakingRewards {
uint96 delegatorRewardsPerToken;
uint96 lastStakingRewardsPerWeight;
uint96 balance;
uint96 claimed;
}
mapping(address => GuardianStakingRewards) public guardiansStakingRewards;
struct GuardianRewardSettings {
uint32 delegatorsStakingRewardsPercentMille;
bool overrideDefault;
}
mapping(address => GuardianRewardSettings) public guardiansRewardSettings;
struct DelegatorStakingRewards {
uint96 balance;
uint96 lastDelegatorRewardsPerToken;
uint96 claimed;
}
mapping(address => DelegatorStakingRewards) public delegatorsStakingRewards;
constructor(
IContractRegistry _contractRegistry,
address _registryAdmin,
IERC20 _erc20,
uint annualRateInPercentMille,
uint annualCap,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
IStakingRewards previousRewardsContract,
address[] memory guardiansToMigrate
) ManagedContract(_contractRegistry, _registryAdmin) public {
}
modifier onlyCommitteeContract() {
}
modifier onlyDelegationsContract() {
}
/*
* External functions
*/
function committeeMembershipWillChange(address guardian, uint256 weight, uint256 totalCommitteeWeight, bool inCommittee, bool inCommitteeAfter) external override onlyWhenActive onlyCommitteeContract {
}
function delegationWillChange(address guardian, uint256 guardianDelegatedStake, address delegator, uint256 delegatorStake, address nextGuardian, uint256 nextGuardianDelegatedStake) external override onlyWhenActive onlyDelegationsContract {
}
function getStakingRewardsBalance(address addr) external override view returns (uint256) {
}
function claimStakingRewards(address addr) external override onlyWhenActive {
}
function getGuardianStakingRewardsData(address guardian) external override view returns (
uint256 balance,
uint256 claimed,
uint256 delegatorRewardsPerToken,
uint256 lastStakingRewardsPerWeight
) {
}
function getDelegatorStakingRewardsData(address delegator) external override view returns (
uint256 balance,
uint256 claimed,
uint256 lastDelegatorRewardsPerToken
) {
}
function getStakingRewardsState() public override view returns (
uint96 stakingRewardsPerWeight,
uint96 unclaimedStakingRewards
) {
}
function getCurrentStakingRewardsRatePercentMille() external override returns (uint256) {
}
function setGuardianDelegatorsStakingRewardsPercentMille(uint32 delegatorRewardsPercentMille) external override onlyWhenActive {
}
function getGuardianDelegatorsStakingRewardsPercentMille(address guardian) external override view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function getStakingRewardsWalletAllocatedTokens() external override view returns (uint256 allocated) {
}
/*
* Governance functions
*/
function migrateRewardsBalance(address addr) external override {
}
function acceptRewardsBalanceMigration(address addr, uint256 guardianStakingRewards, uint256 delegatorStakingRewards) external override {
}
function emergencyWithdraw() external override onlyMigrationManager {
emit EmergencyWithdrawal(msg.sender);
require(<FILL_ME>)
}
function activateRewardDistribution(uint startTime) external override onlyMigrationManager {
}
function deactivateRewardDistribution() external override onlyMigrationManager {
}
function setDefaultDelegatorsStakingRewardsPercentMille(uint32 defaultDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getDefaultDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setMaxDelegatorsStakingRewardsPercentMille(uint32 maxDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getMaxDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) external override onlyFunctionalManager {
}
function getAnnualStakingRewardsRatePercentMille() external override view returns (uint32) {
}
function getAnnualStakingRewardsCap() external override view returns (uint256) {
}
function isRewardAllocationActive() external override view returns (bool) {
}
function getSettings() external override view returns (
uint annualStakingRewardsCap,
uint32 annualStakingRewardsRatePercentMille,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
bool rewardAllocationActive
) {
}
/*
* Private functions
*/
// Global state
function _getAnnualRate(uint256 totalCommitteeWeight, Settings memory _settings) private pure returns (uint256) {
}
function calcStakingRewardPerWeightDelta(uint256 totalCommitteeWeight, uint duration, Settings memory _settings) private pure returns (uint256 stakingRewardsPerTokenDelta) {
}
function _getStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private view returns (StakingRewardsState memory _stakingRewardsState, uint256 allocatedRewards) {
}
function _updateStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private returns (StakingRewardsState memory _stakingRewardsState) {
}
function updateStakingRewardsState() private returns (StakingRewardsState memory _stakingRewardsState) {
}
// Guardian state
function _getGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private view returns (GuardianStakingRewards memory guardianStakingRewards, uint256 rewardsAdded) {
}
function getGuardianStakingRewards(address guardian) private view returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function _updateGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function updateGuardianStakingRewards(address guardian, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
// Delegator state
function _getDelegatorStakingRewards(address delegator, uint256 delegatorStake, GuardianStakingRewards memory guardianStakingRewards) private view returns (DelegatorStakingRewards memory delegatorStakingRewards, uint256 delegatorRewardsAdded) {
}
function getDelegatorStakingRewards(address delegator) private view returns (DelegatorStakingRewards memory delegatorStakingRewards) {
}
function _updateDelegatorStakingRewards(address delegator, uint256 delegatorStake, address guardian, GuardianStakingRewards memory guardianStakingRewards) private {
}
function updateDelegatorStakingRewards(address delegator) private {
}
// Guardian settings
function _getGuardianDelegatorsStakingRewardsPercentMille(address guardian, Settings memory _settings) private view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function migrateGuardiansSettings(IStakingRewards previousRewardsContract, address[] memory guardiansToMigrate) private {
}
// Governance and misc.
function _setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) private {
}
function _setGuardianDelegatorsStakingRewardsPercentMille(address guardian, uint32 delegatorRewardsPercentMille) private {
}
function claimStakingRewardsLocally(address addr) private returns (uint256 guardianRewards, uint256 delegatorRewards) {
}
/*
* Contracts topology / registry interface
*/
ICommittee committeeContract;
IDelegations delegationsContract;
IProtocolWallet stakingRewardsWallet;
IStakingContract stakingContract;
function refreshContracts() external override {
}
}
| erc20.transfer(msg.sender,erc20.balanceOf(address(this))),"Rewards::emergencyWithdraw - transfer failed (orbs token)" | 368,525 | erc20.transfer(msg.sender,erc20.balanceOf(address(this))) |
"reward distribution is already deactivated" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.12;
import "./SafeMath.sol";
import "./SafeMath96.sol";
import "./Math.sol";
import "./IERC20.sol";
import "./ICommittee.sol";
import "./IProtocolWallet.sol";
import "./IStakingRewards.sol";
import "./IDelegation.sol";
import "./IStakingContract.sol";
import "./ManagedContract.sol";
contract StakingRewards is IStakingRewards, ManagedContract {
using SafeMath for uint256;
using SafeMath96 for uint96;
uint256 constant PERCENT_MILLIE_BASE = 100000;
uint256 constant TOKEN_BASE = 1e18;
struct Settings {
uint96 annualCap;
uint32 annualRateInPercentMille;
uint32 defaultDelegatorsStakingRewardsPercentMille;
uint32 maxDelegatorsStakingRewardsPercentMille;
bool rewardAllocationActive;
}
Settings settings;
IERC20 public erc20;
struct StakingRewardsState {
uint96 stakingRewardsPerWeight;
uint96 unclaimedStakingRewards;
uint32 lastAssigned;
}
StakingRewardsState public stakingRewardsState;
uint256 public stakingRewardsWithdrawnFromWallet;
struct GuardianStakingRewards {
uint96 delegatorRewardsPerToken;
uint96 lastStakingRewardsPerWeight;
uint96 balance;
uint96 claimed;
}
mapping(address => GuardianStakingRewards) public guardiansStakingRewards;
struct GuardianRewardSettings {
uint32 delegatorsStakingRewardsPercentMille;
bool overrideDefault;
}
mapping(address => GuardianRewardSettings) public guardiansRewardSettings;
struct DelegatorStakingRewards {
uint96 balance;
uint96 lastDelegatorRewardsPerToken;
uint96 claimed;
}
mapping(address => DelegatorStakingRewards) public delegatorsStakingRewards;
constructor(
IContractRegistry _contractRegistry,
address _registryAdmin,
IERC20 _erc20,
uint annualRateInPercentMille,
uint annualCap,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
IStakingRewards previousRewardsContract,
address[] memory guardiansToMigrate
) ManagedContract(_contractRegistry, _registryAdmin) public {
}
modifier onlyCommitteeContract() {
}
modifier onlyDelegationsContract() {
}
/*
* External functions
*/
function committeeMembershipWillChange(address guardian, uint256 weight, uint256 totalCommitteeWeight, bool inCommittee, bool inCommitteeAfter) external override onlyWhenActive onlyCommitteeContract {
}
function delegationWillChange(address guardian, uint256 guardianDelegatedStake, address delegator, uint256 delegatorStake, address nextGuardian, uint256 nextGuardianDelegatedStake) external override onlyWhenActive onlyDelegationsContract {
}
function getStakingRewardsBalance(address addr) external override view returns (uint256) {
}
function claimStakingRewards(address addr) external override onlyWhenActive {
}
function getGuardianStakingRewardsData(address guardian) external override view returns (
uint256 balance,
uint256 claimed,
uint256 delegatorRewardsPerToken,
uint256 lastStakingRewardsPerWeight
) {
}
function getDelegatorStakingRewardsData(address delegator) external override view returns (
uint256 balance,
uint256 claimed,
uint256 lastDelegatorRewardsPerToken
) {
}
function getStakingRewardsState() public override view returns (
uint96 stakingRewardsPerWeight,
uint96 unclaimedStakingRewards
) {
}
function getCurrentStakingRewardsRatePercentMille() external override returns (uint256) {
}
function setGuardianDelegatorsStakingRewardsPercentMille(uint32 delegatorRewardsPercentMille) external override onlyWhenActive {
}
function getGuardianDelegatorsStakingRewardsPercentMille(address guardian) external override view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function getStakingRewardsWalletAllocatedTokens() external override view returns (uint256 allocated) {
}
/*
* Governance functions
*/
function migrateRewardsBalance(address addr) external override {
}
function acceptRewardsBalanceMigration(address addr, uint256 guardianStakingRewards, uint256 delegatorStakingRewards) external override {
}
function emergencyWithdraw() external override onlyMigrationManager {
}
function activateRewardDistribution(uint startTime) external override onlyMigrationManager {
}
function deactivateRewardDistribution() external override onlyMigrationManager {
require(<FILL_ME>)
updateStakingRewardsState();
settings.rewardAllocationActive = false;
emit RewardDistributionDeactivated();
}
function setDefaultDelegatorsStakingRewardsPercentMille(uint32 defaultDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getDefaultDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setMaxDelegatorsStakingRewardsPercentMille(uint32 maxDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getMaxDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) external override onlyFunctionalManager {
}
function getAnnualStakingRewardsRatePercentMille() external override view returns (uint32) {
}
function getAnnualStakingRewardsCap() external override view returns (uint256) {
}
function isRewardAllocationActive() external override view returns (bool) {
}
function getSettings() external override view returns (
uint annualStakingRewardsCap,
uint32 annualStakingRewardsRatePercentMille,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
bool rewardAllocationActive
) {
}
/*
* Private functions
*/
// Global state
function _getAnnualRate(uint256 totalCommitteeWeight, Settings memory _settings) private pure returns (uint256) {
}
function calcStakingRewardPerWeightDelta(uint256 totalCommitteeWeight, uint duration, Settings memory _settings) private pure returns (uint256 stakingRewardsPerTokenDelta) {
}
function _getStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private view returns (StakingRewardsState memory _stakingRewardsState, uint256 allocatedRewards) {
}
function _updateStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private returns (StakingRewardsState memory _stakingRewardsState) {
}
function updateStakingRewardsState() private returns (StakingRewardsState memory _stakingRewardsState) {
}
// Guardian state
function _getGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private view returns (GuardianStakingRewards memory guardianStakingRewards, uint256 rewardsAdded) {
}
function getGuardianStakingRewards(address guardian) private view returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function _updateGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function updateGuardianStakingRewards(address guardian, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
// Delegator state
function _getDelegatorStakingRewards(address delegator, uint256 delegatorStake, GuardianStakingRewards memory guardianStakingRewards) private view returns (DelegatorStakingRewards memory delegatorStakingRewards, uint256 delegatorRewardsAdded) {
}
function getDelegatorStakingRewards(address delegator) private view returns (DelegatorStakingRewards memory delegatorStakingRewards) {
}
function _updateDelegatorStakingRewards(address delegator, uint256 delegatorStake, address guardian, GuardianStakingRewards memory guardianStakingRewards) private {
}
function updateDelegatorStakingRewards(address delegator) private {
}
// Guardian settings
function _getGuardianDelegatorsStakingRewardsPercentMille(address guardian, Settings memory _settings) private view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function migrateGuardiansSettings(IStakingRewards previousRewardsContract, address[] memory guardiansToMigrate) private {
}
// Governance and misc.
function _setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) private {
}
function _setGuardianDelegatorsStakingRewardsPercentMille(address guardian, uint32 delegatorRewardsPercentMille) private {
}
function claimStakingRewardsLocally(address addr) private returns (uint256 guardianRewards, uint256 delegatorRewards) {
}
/*
* Contracts topology / registry interface
*/
ICommittee committeeContract;
IDelegations delegationsContract;
IProtocolWallet stakingRewardsWallet;
IStakingContract stakingContract;
function refreshContracts() external override {
}
}
| settings.rewardAllocationActive,"reward distribution is already deactivated" | 368,525 | settings.rewardAllocationActive |
"annualCap must fit in uint96" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.12;
import "./SafeMath.sol";
import "./SafeMath96.sol";
import "./Math.sol";
import "./IERC20.sol";
import "./ICommittee.sol";
import "./IProtocolWallet.sol";
import "./IStakingRewards.sol";
import "./IDelegation.sol";
import "./IStakingContract.sol";
import "./ManagedContract.sol";
contract StakingRewards is IStakingRewards, ManagedContract {
using SafeMath for uint256;
using SafeMath96 for uint96;
uint256 constant PERCENT_MILLIE_BASE = 100000;
uint256 constant TOKEN_BASE = 1e18;
struct Settings {
uint96 annualCap;
uint32 annualRateInPercentMille;
uint32 defaultDelegatorsStakingRewardsPercentMille;
uint32 maxDelegatorsStakingRewardsPercentMille;
bool rewardAllocationActive;
}
Settings settings;
IERC20 public erc20;
struct StakingRewardsState {
uint96 stakingRewardsPerWeight;
uint96 unclaimedStakingRewards;
uint32 lastAssigned;
}
StakingRewardsState public stakingRewardsState;
uint256 public stakingRewardsWithdrawnFromWallet;
struct GuardianStakingRewards {
uint96 delegatorRewardsPerToken;
uint96 lastStakingRewardsPerWeight;
uint96 balance;
uint96 claimed;
}
mapping(address => GuardianStakingRewards) public guardiansStakingRewards;
struct GuardianRewardSettings {
uint32 delegatorsStakingRewardsPercentMille;
bool overrideDefault;
}
mapping(address => GuardianRewardSettings) public guardiansRewardSettings;
struct DelegatorStakingRewards {
uint96 balance;
uint96 lastDelegatorRewardsPerToken;
uint96 claimed;
}
mapping(address => DelegatorStakingRewards) public delegatorsStakingRewards;
constructor(
IContractRegistry _contractRegistry,
address _registryAdmin,
IERC20 _erc20,
uint annualRateInPercentMille,
uint annualCap,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
IStakingRewards previousRewardsContract,
address[] memory guardiansToMigrate
) ManagedContract(_contractRegistry, _registryAdmin) public {
}
modifier onlyCommitteeContract() {
}
modifier onlyDelegationsContract() {
}
/*
* External functions
*/
function committeeMembershipWillChange(address guardian, uint256 weight, uint256 totalCommitteeWeight, bool inCommittee, bool inCommitteeAfter) external override onlyWhenActive onlyCommitteeContract {
}
function delegationWillChange(address guardian, uint256 guardianDelegatedStake, address delegator, uint256 delegatorStake, address nextGuardian, uint256 nextGuardianDelegatedStake) external override onlyWhenActive onlyDelegationsContract {
}
function getStakingRewardsBalance(address addr) external override view returns (uint256) {
}
function claimStakingRewards(address addr) external override onlyWhenActive {
}
function getGuardianStakingRewardsData(address guardian) external override view returns (
uint256 balance,
uint256 claimed,
uint256 delegatorRewardsPerToken,
uint256 lastStakingRewardsPerWeight
) {
}
function getDelegatorStakingRewardsData(address delegator) external override view returns (
uint256 balance,
uint256 claimed,
uint256 lastDelegatorRewardsPerToken
) {
}
function getStakingRewardsState() public override view returns (
uint96 stakingRewardsPerWeight,
uint96 unclaimedStakingRewards
) {
}
function getCurrentStakingRewardsRatePercentMille() external override returns (uint256) {
}
function setGuardianDelegatorsStakingRewardsPercentMille(uint32 delegatorRewardsPercentMille) external override onlyWhenActive {
}
function getGuardianDelegatorsStakingRewardsPercentMille(address guardian) external override view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function getStakingRewardsWalletAllocatedTokens() external override view returns (uint256 allocated) {
}
/*
* Governance functions
*/
function migrateRewardsBalance(address addr) external override {
}
function acceptRewardsBalanceMigration(address addr, uint256 guardianStakingRewards, uint256 delegatorStakingRewards) external override {
}
function emergencyWithdraw() external override onlyMigrationManager {
}
function activateRewardDistribution(uint startTime) external override onlyMigrationManager {
}
function deactivateRewardDistribution() external override onlyMigrationManager {
}
function setDefaultDelegatorsStakingRewardsPercentMille(uint32 defaultDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getDefaultDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setMaxDelegatorsStakingRewardsPercentMille(uint32 maxDelegatorsStakingRewardsPercentMille) public override onlyFunctionalManager {
}
function getMaxDelegatorsStakingRewardsPercentMille() public override view returns (uint32) {
}
function setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) external override onlyFunctionalManager {
}
function getAnnualStakingRewardsRatePercentMille() external override view returns (uint32) {
}
function getAnnualStakingRewardsCap() external override view returns (uint256) {
}
function isRewardAllocationActive() external override view returns (bool) {
}
function getSettings() external override view returns (
uint annualStakingRewardsCap,
uint32 annualStakingRewardsRatePercentMille,
uint32 defaultDelegatorsStakingRewardsPercentMille,
uint32 maxDelegatorsStakingRewardsPercentMille,
bool rewardAllocationActive
) {
}
/*
* Private functions
*/
// Global state
function _getAnnualRate(uint256 totalCommitteeWeight, Settings memory _settings) private pure returns (uint256) {
}
function calcStakingRewardPerWeightDelta(uint256 totalCommitteeWeight, uint duration, Settings memory _settings) private pure returns (uint256 stakingRewardsPerTokenDelta) {
}
function _getStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private view returns (StakingRewardsState memory _stakingRewardsState, uint256 allocatedRewards) {
}
function _updateStakingRewardsState(uint256 totalCommitteeWeight, Settings memory _settings) private returns (StakingRewardsState memory _stakingRewardsState) {
}
function updateStakingRewardsState() private returns (StakingRewardsState memory _stakingRewardsState) {
}
// Guardian state
function _getGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private view returns (GuardianStakingRewards memory guardianStakingRewards, uint256 rewardsAdded) {
}
function getGuardianStakingRewards(address guardian) private view returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function _updateGuardianStakingRewards(address guardian, bool inCommittee, bool inCommitteeAfter, uint256 guardianWeight, uint256 guardianDelegatedStake, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
function updateGuardianStakingRewards(address guardian, StakingRewardsState memory _stakingRewardsState, Settings memory _settings) private returns (GuardianStakingRewards memory guardianStakingRewards) {
}
// Delegator state
function _getDelegatorStakingRewards(address delegator, uint256 delegatorStake, GuardianStakingRewards memory guardianStakingRewards) private view returns (DelegatorStakingRewards memory delegatorStakingRewards, uint256 delegatorRewardsAdded) {
}
function getDelegatorStakingRewards(address delegator) private view returns (DelegatorStakingRewards memory delegatorStakingRewards) {
}
function _updateDelegatorStakingRewards(address delegator, uint256 delegatorStake, address guardian, GuardianStakingRewards memory guardianStakingRewards) private {
}
function updateDelegatorStakingRewards(address delegator) private {
}
// Guardian settings
function _getGuardianDelegatorsStakingRewardsPercentMille(address guardian, Settings memory _settings) private view returns (uint256 delegatorRewardsRatioPercentMille) {
}
function migrateGuardiansSettings(IStakingRewards previousRewardsContract, address[] memory guardiansToMigrate) private {
}
// Governance and misc.
function _setAnnualStakingRewardsRate(uint256 annualRateInPercentMille, uint256 annualCap) private {
require(<FILL_ME>)
Settings memory _settings = settings;
_settings.annualRateInPercentMille = uint32(annualRateInPercentMille);
_settings.annualCap = uint96(annualCap);
settings = _settings;
emit AnnualStakingRewardsRateChanged(annualRateInPercentMille, annualCap);
}
function _setGuardianDelegatorsStakingRewardsPercentMille(address guardian, uint32 delegatorRewardsPercentMille) private {
}
function claimStakingRewardsLocally(address addr) private returns (uint256 guardianRewards, uint256 delegatorRewards) {
}
/*
* Contracts topology / registry interface
*/
ICommittee committeeContract;
IDelegations delegationsContract;
IProtocolWallet stakingRewardsWallet;
IStakingContract stakingContract;
function refreshContracts() external override {
}
}
| uint256(uint96(annualCap))==annualCap,"annualCap must fit in uint96" | 368,525 | uint256(uint96(annualCap))==annualCap |
"data size mismatch" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import { ReentrancyGuard } from "./external/openzeppelin/ReentrancyGuard.sol";
import { StableMath } from "./libraries/StableMath.sol";
import { IERC20 } from "./interfaces/IERC20.sol";
import { Ownable } from "./abstract/Ownable.sol";
import { Lockable } from "./abstract/Lockable.sol";
/**
* @title SynapseVesting
* @notice Synapse Network Vesting contract
* @dev Vesting is constantly releasing tokens every block every second
*/
contract SynapseVesting is Ownable, Lockable, ReentrancyGuard {
using StableMath for uint256;
/// @notice address of Synapse Network token
address public snpToken;
/// @notice total tokens vested in contract
/// @dev tokens from not initialized sale contracts are not included
uint256 public totalVested;
/// @notice total tokens already claimed form vesting
uint256 public totalClaimed;
/// @notice staking contract address
/// @dev set by Owner, for claimAndStake
address public stakingAddress;
struct Vest {
uint256 dateStart; // start of claiming, can claim startTokens
uint256 dateEnd; // after it all tokens can be claimed
uint256 totalTokens; // total tokens to claim
uint256 startTokens; // tokens to claim on start
uint256 claimedTokens; // tokens already claimed
}
/// @notice storage of vestings
Vest[] internal vestings;
/// @notice map of vestings for user
mapping(address => uint256[]) internal user2vesting;
struct SaleContract {
address[] contractAddresses; // list of cross sale contracts from sale round
uint256 tokensPerCent; // amount of tokens per cent for sale round
uint256 maxAmount; // max amount in USD cents for sale round
uint256 percentOnStart; // percent of tokens to claim on start
uint256 startDate; // start of claiming, can claim start tokens
uint256 endDate; // after it all tokens can be claimed
}
/// @notice list of sale contract that will be checked
SaleContract[] internal saleContracts;
/// @notice map of users that initialized vestings from sale contracts
mapping(address => bool) public vestingAdded;
/// @notice map of users that were refunded after sales
mapping(address => bool) public refunded;
/// @dev events
event Claimed(address indexed user, uint256 amount);
event Vested(address indexed user, uint256 totalAmount, uint256 endDate);
/**
* @dev Contract initiator
* @param _token address of SNP token
*/
function init(address _token) external onlyOwner {
}
/**
* @dev Add multiple vesting to contract by arrays of data
* @param _users[] addresses of holders
* @param _startTokens[] tokens that can be withdrawn at startDate
* @param _totalTokens[] total tokens in vesting
* @param _startDate date from when tokens can be claimed
* @param _endDate date after which all tokens can be claimed
*/
function massAddHolders(
address[] calldata _users,
uint256[] calldata _startTokens,
uint256[] calldata _totalTokens,
uint256 _startDate,
uint256 _endDate
) external onlyOwner whenNotLocked {
uint256 len = _users.length; //cheaper to use one variable
require(<FILL_ME>)
require(_startDate < _endDate, "startDate cannot exceed endDate");
uint256 i;
for (i; i < len; i++) {
_addHolder(_users[i], _startTokens[i], _totalTokens[i], _startDate, _endDate);
}
}
/**
* @dev Add new vesting to contract
* @param _user address of a holder
* @param _startTokens how many tokens are claimable at start date
* @param _totalTokens total number of tokens in added vesting
* @param _startDate date from when tokens can be claimed
* @param _endDate date after which all tokens can be claimed
*/
function _addHolder(
address _user,
uint256 _startTokens,
uint256 _totalTokens,
uint256 _startDate,
uint256 _endDate
) internal {
}
/**
* @dev Claim tokens from msg.sender vestings
*/
function claim() external {
}
/**
* @dev Claim tokens from msg.sender vestings to external address
* @param _target transfer address for claimed tokens
*/
function claimTo(address _target) external {
}
/**
* @dev Claim and stake claimed tokens directly in staking contract
* Ask staking contract if user is not in withdrawing state
*/
function claimAndStake() external {
}
/**
* @dev internal claim function
* @param _user address of holder
* @param _target where tokens should be send
* @return amt number of tokens claimed
*/
function _claim(address _user, address _target) internal nonReentrant returns (uint256 amt) {
}
/**
* @dev Internal function to send out claimed tokens
* @param _user address that we send tokens
* @param _amt amount of tokens
*/
function _transfer(address _user, uint256 _amt) internal {
}
/**
* @dev Count how many tokens can be claimed from vesting to date
* @param _vesting Vesting object
* @return canWithdraw number of tokens
*/
function _claimable(Vest memory _vesting) internal view returns (uint256 canWithdraw) {
}
/**
* @dev Read number of claimable tokens by user and vesting no
* @param _user address of holder
* @param _id his vesting number (starts from 0)
* @return amount number of tokens
*/
function getClaimable(address _user, uint256 _id) external view returns (uint256 amount) {
}
/**
* @dev Read total amount of tokens that user can claim to date from all vestings
* Function also includes tokens to claim from sale contracts that were not
* yet initiated for user.
* @param _user address of holder
* @return amount number of tokens
*/
function getAllClaimable(address _user) public view returns (uint256 amount) {
}
/**
* @dev Extract all the vestings for the user
* Also extract not initialized vestings from
* sale contracts.
* @param _user address of holder
* @return v array of Vest objects
*/
function getVestings(address _user) external view returns (Vest[] memory) {
}
/**
* @dev Read total number of vestings registered
* @return number of registered vestings on contract
*/
function getVestingsCount() external view returns (uint256) {
}
/**
* @dev Read single registered vesting entry
* @param _id index of vesting in storage
* @return Vest object
*/
function getVestingByIndex(uint256 _id) external view returns (Vest memory) {
}
/**
* @dev Read registered vesting list by range from-to
* @param _start first index
* @param _end last index
* @return array of Vest objects
*/
function getVestingsByRange(uint256 _start, uint256 _end) external view returns (Vest[] memory) {
}
/**
* @dev Extract all sale contracts
* @return array of SaleContract objects
*/
function getSaleContracts() external view returns (SaleContract[] memory) {
}
/**
* @dev Read total number of sale contracts
* @return number of SaleContracts
*/
function getSaleContractsCount() external view returns (uint256) {
}
/**
* @dev Read single sale contract entry
* @param _id index of sale contract in storage
* @return SaleContract object
*/
function getSaleContractByIndex(uint256 _id) external view returns (SaleContract memory) {
}
/**
* @dev Register sale contract
* @param _contractAddresses addresses of sale contracts
* @param _tokensPerCent sale price
* @param _maxAmount the maximum amount in USD cents for which user could buy
* @param _percentOnStart percentage of vested coins that can be claimed on start date
* @param _startDate date when initial vesting can be released
* @param _endDate final date of vesting, where all tokens can be claimed
*/
function addSaleContract(
address[] memory _contractAddresses,
uint256 _tokensPerCent,
uint256 _maxAmount,
uint256 _percentOnStart,
uint256 _startDate,
uint256 _endDate
) external onlyOwner whenNotLocked {
}
/**
* @dev Initialize vestings from sale contracts for msg.sender
*/
function addMyVesting() external {
}
/**
* @dev Initialize vestings from sale contracts for target user
* @param _user address of user that will be initialized
*/
function addVesting(address _user) external {
}
/**
* @dev Function iterate sale contracts and initialize corresponding
* vesting for user.
* @param _user address that will be initialized
*/
function _addVesting(address _user) internal {
}
/**
* @dev Function iterate sale contracts and count claimable amounts for given user.
* Used to calculate claimable amounts from not initialized vestings.
* @param _user address of user to count claimable
* @return claimable amount of tokens
*/
function _claimableFromSaleContracts(address _user) internal view returns (uint256 claimable) {
}
/**
* @dev Function iterate sale contracts and extract not initialized user vestings.
* Used to return all stored and not initialized vestings.
* @param _user address of user to extract vestings
* @return v vesting array
*/
function _vestingsFromSaleContracts(address _user) internal view returns (Vest[] memory) {
}
/**
* @dev Function iterate sale contracts and return number of not initialized vestings for user.
* @param _user address of user to extract vestings
* @return number of not not initialized user vestings
*/
function _numberOfVestingsFromSaleContracts(address _user) internal view returns (uint256 number) {
}
/**
* @dev Return vesting created from given sale and usd cent amount.
* @param _sale address of user to extract vestings
* @param _amount address of user to extract vestings
* @return v vesting from given parameters
*/
function _vestFromSaleContractAndAmount(SaleContract memory _sale, uint256 _amount) internal pure returns (Vest memory v) {
}
/**
* @dev Set staking contract address for Claim and Stake.
* Only contract owner can set.
* @param _staking address
*/
function setStakingAddress(address _staking) external onlyOwner {
}
/**
* @dev Mark user as refunded
* @param _user address of user
* @param _refunded true=refunded
*/
function setRefunded(address _user, bool _refunded) external onlyOwner whenNotLocked {
}
/**
* @dev Mark multiple refunded users
* @param _users[] addresses of refunded users
*/
function massSetRefunded(address[] calldata _users) external onlyOwner whenNotLocked {
}
/**
* @dev Recover ETH from contract to owner address.
*/
function recoverETH() external {
}
/**
* @dev Recover given ERC20 token from contract to owner address.
* Can't recover SNP tokens.
* @param _token address of ERC20 token to recover
*/
function recoverErc20(address _token) external {
}
}
/**
* @title IStaking
* @dev Interface for claim and stake
*/
interface IStaking {
function canStakeTokens(address _account) external view returns (bool);
function onClaimAndStake(address _from, uint256 _amount) external;
}
/**
* @title ISaleContract
* @dev Interface for sale contract
*/
interface ISaleContract {
function balanceOf(address _account) external view returns (uint256);
}
/**
* @title IBadErc20
* @dev Interface for emergency recover any ERC20-tokens,
* even non-erc20-compliant like USDT not returning boolean
*/
interface IBadErc20 {
function transfer(address _recipient, uint256 _amount) external;
}
| (len==_startTokens.length)&&(len==_totalTokens.length),"data size mismatch" | 368,561 | (len==_startTokens.length)&&(len==_totalTokens.length) |
"Unable to stake" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import { ReentrancyGuard } from "./external/openzeppelin/ReentrancyGuard.sol";
import { StableMath } from "./libraries/StableMath.sol";
import { IERC20 } from "./interfaces/IERC20.sol";
import { Ownable } from "./abstract/Ownable.sol";
import { Lockable } from "./abstract/Lockable.sol";
/**
* @title SynapseVesting
* @notice Synapse Network Vesting contract
* @dev Vesting is constantly releasing tokens every block every second
*/
contract SynapseVesting is Ownable, Lockable, ReentrancyGuard {
using StableMath for uint256;
/// @notice address of Synapse Network token
address public snpToken;
/// @notice total tokens vested in contract
/// @dev tokens from not initialized sale contracts are not included
uint256 public totalVested;
/// @notice total tokens already claimed form vesting
uint256 public totalClaimed;
/// @notice staking contract address
/// @dev set by Owner, for claimAndStake
address public stakingAddress;
struct Vest {
uint256 dateStart; // start of claiming, can claim startTokens
uint256 dateEnd; // after it all tokens can be claimed
uint256 totalTokens; // total tokens to claim
uint256 startTokens; // tokens to claim on start
uint256 claimedTokens; // tokens already claimed
}
/// @notice storage of vestings
Vest[] internal vestings;
/// @notice map of vestings for user
mapping(address => uint256[]) internal user2vesting;
struct SaleContract {
address[] contractAddresses; // list of cross sale contracts from sale round
uint256 tokensPerCent; // amount of tokens per cent for sale round
uint256 maxAmount; // max amount in USD cents for sale round
uint256 percentOnStart; // percent of tokens to claim on start
uint256 startDate; // start of claiming, can claim start tokens
uint256 endDate; // after it all tokens can be claimed
}
/// @notice list of sale contract that will be checked
SaleContract[] internal saleContracts;
/// @notice map of users that initialized vestings from sale contracts
mapping(address => bool) public vestingAdded;
/// @notice map of users that were refunded after sales
mapping(address => bool) public refunded;
/// @dev events
event Claimed(address indexed user, uint256 amount);
event Vested(address indexed user, uint256 totalAmount, uint256 endDate);
/**
* @dev Contract initiator
* @param _token address of SNP token
*/
function init(address _token) external onlyOwner {
}
/**
* @dev Add multiple vesting to contract by arrays of data
* @param _users[] addresses of holders
* @param _startTokens[] tokens that can be withdrawn at startDate
* @param _totalTokens[] total tokens in vesting
* @param _startDate date from when tokens can be claimed
* @param _endDate date after which all tokens can be claimed
*/
function massAddHolders(
address[] calldata _users,
uint256[] calldata _startTokens,
uint256[] calldata _totalTokens,
uint256 _startDate,
uint256 _endDate
) external onlyOwner whenNotLocked {
}
/**
* @dev Add new vesting to contract
* @param _user address of a holder
* @param _startTokens how many tokens are claimable at start date
* @param _totalTokens total number of tokens in added vesting
* @param _startDate date from when tokens can be claimed
* @param _endDate date after which all tokens can be claimed
*/
function _addHolder(
address _user,
uint256 _startTokens,
uint256 _totalTokens,
uint256 _startDate,
uint256 _endDate
) internal {
}
/**
* @dev Claim tokens from msg.sender vestings
*/
function claim() external {
}
/**
* @dev Claim tokens from msg.sender vestings to external address
* @param _target transfer address for claimed tokens
*/
function claimTo(address _target) external {
}
/**
* @dev Claim and stake claimed tokens directly in staking contract
* Ask staking contract if user is not in withdrawing state
*/
function claimAndStake() external {
require(stakingAddress != address(0), "Staking contract not configured");
require(<FILL_ME>)
uint256 amt = _claim(msg.sender, stakingAddress);
IStaking(stakingAddress).onClaimAndStake(msg.sender, amt);
}
/**
* @dev internal claim function
* @param _user address of holder
* @param _target where tokens should be send
* @return amt number of tokens claimed
*/
function _claim(address _user, address _target) internal nonReentrant returns (uint256 amt) {
}
/**
* @dev Internal function to send out claimed tokens
* @param _user address that we send tokens
* @param _amt amount of tokens
*/
function _transfer(address _user, uint256 _amt) internal {
}
/**
* @dev Count how many tokens can be claimed from vesting to date
* @param _vesting Vesting object
* @return canWithdraw number of tokens
*/
function _claimable(Vest memory _vesting) internal view returns (uint256 canWithdraw) {
}
/**
* @dev Read number of claimable tokens by user and vesting no
* @param _user address of holder
* @param _id his vesting number (starts from 0)
* @return amount number of tokens
*/
function getClaimable(address _user, uint256 _id) external view returns (uint256 amount) {
}
/**
* @dev Read total amount of tokens that user can claim to date from all vestings
* Function also includes tokens to claim from sale contracts that were not
* yet initiated for user.
* @param _user address of holder
* @return amount number of tokens
*/
function getAllClaimable(address _user) public view returns (uint256 amount) {
}
/**
* @dev Extract all the vestings for the user
* Also extract not initialized vestings from
* sale contracts.
* @param _user address of holder
* @return v array of Vest objects
*/
function getVestings(address _user) external view returns (Vest[] memory) {
}
/**
* @dev Read total number of vestings registered
* @return number of registered vestings on contract
*/
function getVestingsCount() external view returns (uint256) {
}
/**
* @dev Read single registered vesting entry
* @param _id index of vesting in storage
* @return Vest object
*/
function getVestingByIndex(uint256 _id) external view returns (Vest memory) {
}
/**
* @dev Read registered vesting list by range from-to
* @param _start first index
* @param _end last index
* @return array of Vest objects
*/
function getVestingsByRange(uint256 _start, uint256 _end) external view returns (Vest[] memory) {
}
/**
* @dev Extract all sale contracts
* @return array of SaleContract objects
*/
function getSaleContracts() external view returns (SaleContract[] memory) {
}
/**
* @dev Read total number of sale contracts
* @return number of SaleContracts
*/
function getSaleContractsCount() external view returns (uint256) {
}
/**
* @dev Read single sale contract entry
* @param _id index of sale contract in storage
* @return SaleContract object
*/
function getSaleContractByIndex(uint256 _id) external view returns (SaleContract memory) {
}
/**
* @dev Register sale contract
* @param _contractAddresses addresses of sale contracts
* @param _tokensPerCent sale price
* @param _maxAmount the maximum amount in USD cents for which user could buy
* @param _percentOnStart percentage of vested coins that can be claimed on start date
* @param _startDate date when initial vesting can be released
* @param _endDate final date of vesting, where all tokens can be claimed
*/
function addSaleContract(
address[] memory _contractAddresses,
uint256 _tokensPerCent,
uint256 _maxAmount,
uint256 _percentOnStart,
uint256 _startDate,
uint256 _endDate
) external onlyOwner whenNotLocked {
}
/**
* @dev Initialize vestings from sale contracts for msg.sender
*/
function addMyVesting() external {
}
/**
* @dev Initialize vestings from sale contracts for target user
* @param _user address of user that will be initialized
*/
function addVesting(address _user) external {
}
/**
* @dev Function iterate sale contracts and initialize corresponding
* vesting for user.
* @param _user address that will be initialized
*/
function _addVesting(address _user) internal {
}
/**
* @dev Function iterate sale contracts and count claimable amounts for given user.
* Used to calculate claimable amounts from not initialized vestings.
* @param _user address of user to count claimable
* @return claimable amount of tokens
*/
function _claimableFromSaleContracts(address _user) internal view returns (uint256 claimable) {
}
/**
* @dev Function iterate sale contracts and extract not initialized user vestings.
* Used to return all stored and not initialized vestings.
* @param _user address of user to extract vestings
* @return v vesting array
*/
function _vestingsFromSaleContracts(address _user) internal view returns (Vest[] memory) {
}
/**
* @dev Function iterate sale contracts and return number of not initialized vestings for user.
* @param _user address of user to extract vestings
* @return number of not not initialized user vestings
*/
function _numberOfVestingsFromSaleContracts(address _user) internal view returns (uint256 number) {
}
/**
* @dev Return vesting created from given sale and usd cent amount.
* @param _sale address of user to extract vestings
* @param _amount address of user to extract vestings
* @return v vesting from given parameters
*/
function _vestFromSaleContractAndAmount(SaleContract memory _sale, uint256 _amount) internal pure returns (Vest memory v) {
}
/**
* @dev Set staking contract address for Claim and Stake.
* Only contract owner can set.
* @param _staking address
*/
function setStakingAddress(address _staking) external onlyOwner {
}
/**
* @dev Mark user as refunded
* @param _user address of user
* @param _refunded true=refunded
*/
function setRefunded(address _user, bool _refunded) external onlyOwner whenNotLocked {
}
/**
* @dev Mark multiple refunded users
* @param _users[] addresses of refunded users
*/
function massSetRefunded(address[] calldata _users) external onlyOwner whenNotLocked {
}
/**
* @dev Recover ETH from contract to owner address.
*/
function recoverETH() external {
}
/**
* @dev Recover given ERC20 token from contract to owner address.
* Can't recover SNP tokens.
* @param _token address of ERC20 token to recover
*/
function recoverErc20(address _token) external {
}
}
/**
* @title IStaking
* @dev Interface for claim and stake
*/
interface IStaking {
function canStakeTokens(address _account) external view returns (bool);
function onClaimAndStake(address _from, uint256 _amount) external;
}
/**
* @title ISaleContract
* @dev Interface for sale contract
*/
interface ISaleContract {
function balanceOf(address _account) external view returns (uint256);
}
/**
* @title IBadErc20
* @dev Interface for emergency recover any ERC20-tokens,
* even non-erc20-compliant like USDT not returning boolean
*/
interface IBadErc20 {
function transfer(address _recipient, uint256 _amount) external;
}
| IStaking(stakingAddress).canStakeTokens(msg.sender),"Unable to stake" | 368,561 | IStaking(stakingAddress).canStakeTokens(msg.sender) |
"Token transfer failed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import { ReentrancyGuard } from "./external/openzeppelin/ReentrancyGuard.sol";
import { StableMath } from "./libraries/StableMath.sol";
import { IERC20 } from "./interfaces/IERC20.sol";
import { Ownable } from "./abstract/Ownable.sol";
import { Lockable } from "./abstract/Lockable.sol";
/**
* @title SynapseVesting
* @notice Synapse Network Vesting contract
* @dev Vesting is constantly releasing tokens every block every second
*/
contract SynapseVesting is Ownable, Lockable, ReentrancyGuard {
using StableMath for uint256;
/// @notice address of Synapse Network token
address public snpToken;
/// @notice total tokens vested in contract
/// @dev tokens from not initialized sale contracts are not included
uint256 public totalVested;
/// @notice total tokens already claimed form vesting
uint256 public totalClaimed;
/// @notice staking contract address
/// @dev set by Owner, for claimAndStake
address public stakingAddress;
struct Vest {
uint256 dateStart; // start of claiming, can claim startTokens
uint256 dateEnd; // after it all tokens can be claimed
uint256 totalTokens; // total tokens to claim
uint256 startTokens; // tokens to claim on start
uint256 claimedTokens; // tokens already claimed
}
/// @notice storage of vestings
Vest[] internal vestings;
/// @notice map of vestings for user
mapping(address => uint256[]) internal user2vesting;
struct SaleContract {
address[] contractAddresses; // list of cross sale contracts from sale round
uint256 tokensPerCent; // amount of tokens per cent for sale round
uint256 maxAmount; // max amount in USD cents for sale round
uint256 percentOnStart; // percent of tokens to claim on start
uint256 startDate; // start of claiming, can claim start tokens
uint256 endDate; // after it all tokens can be claimed
}
/// @notice list of sale contract that will be checked
SaleContract[] internal saleContracts;
/// @notice map of users that initialized vestings from sale contracts
mapping(address => bool) public vestingAdded;
/// @notice map of users that were refunded after sales
mapping(address => bool) public refunded;
/// @dev events
event Claimed(address indexed user, uint256 amount);
event Vested(address indexed user, uint256 totalAmount, uint256 endDate);
/**
* @dev Contract initiator
* @param _token address of SNP token
*/
function init(address _token) external onlyOwner {
}
/**
* @dev Add multiple vesting to contract by arrays of data
* @param _users[] addresses of holders
* @param _startTokens[] tokens that can be withdrawn at startDate
* @param _totalTokens[] total tokens in vesting
* @param _startDate date from when tokens can be claimed
* @param _endDate date after which all tokens can be claimed
*/
function massAddHolders(
address[] calldata _users,
uint256[] calldata _startTokens,
uint256[] calldata _totalTokens,
uint256 _startDate,
uint256 _endDate
) external onlyOwner whenNotLocked {
}
/**
* @dev Add new vesting to contract
* @param _user address of a holder
* @param _startTokens how many tokens are claimable at start date
* @param _totalTokens total number of tokens in added vesting
* @param _startDate date from when tokens can be claimed
* @param _endDate date after which all tokens can be claimed
*/
function _addHolder(
address _user,
uint256 _startTokens,
uint256 _totalTokens,
uint256 _startDate,
uint256 _endDate
) internal {
}
/**
* @dev Claim tokens from msg.sender vestings
*/
function claim() external {
}
/**
* @dev Claim tokens from msg.sender vestings to external address
* @param _target transfer address for claimed tokens
*/
function claimTo(address _target) external {
}
/**
* @dev Claim and stake claimed tokens directly in staking contract
* Ask staking contract if user is not in withdrawing state
*/
function claimAndStake() external {
}
/**
* @dev internal claim function
* @param _user address of holder
* @param _target where tokens should be send
* @return amt number of tokens claimed
*/
function _claim(address _user, address _target) internal nonReentrant returns (uint256 amt) {
}
/**
* @dev Internal function to send out claimed tokens
* @param _user address that we send tokens
* @param _amt amount of tokens
*/
function _transfer(address _user, uint256 _amt) internal {
require(<FILL_ME>)
}
/**
* @dev Count how many tokens can be claimed from vesting to date
* @param _vesting Vesting object
* @return canWithdraw number of tokens
*/
function _claimable(Vest memory _vesting) internal view returns (uint256 canWithdraw) {
}
/**
* @dev Read number of claimable tokens by user and vesting no
* @param _user address of holder
* @param _id his vesting number (starts from 0)
* @return amount number of tokens
*/
function getClaimable(address _user, uint256 _id) external view returns (uint256 amount) {
}
/**
* @dev Read total amount of tokens that user can claim to date from all vestings
* Function also includes tokens to claim from sale contracts that were not
* yet initiated for user.
* @param _user address of holder
* @return amount number of tokens
*/
function getAllClaimable(address _user) public view returns (uint256 amount) {
}
/**
* @dev Extract all the vestings for the user
* Also extract not initialized vestings from
* sale contracts.
* @param _user address of holder
* @return v array of Vest objects
*/
function getVestings(address _user) external view returns (Vest[] memory) {
}
/**
* @dev Read total number of vestings registered
* @return number of registered vestings on contract
*/
function getVestingsCount() external view returns (uint256) {
}
/**
* @dev Read single registered vesting entry
* @param _id index of vesting in storage
* @return Vest object
*/
function getVestingByIndex(uint256 _id) external view returns (Vest memory) {
}
/**
* @dev Read registered vesting list by range from-to
* @param _start first index
* @param _end last index
* @return array of Vest objects
*/
function getVestingsByRange(uint256 _start, uint256 _end) external view returns (Vest[] memory) {
}
/**
* @dev Extract all sale contracts
* @return array of SaleContract objects
*/
function getSaleContracts() external view returns (SaleContract[] memory) {
}
/**
* @dev Read total number of sale contracts
* @return number of SaleContracts
*/
function getSaleContractsCount() external view returns (uint256) {
}
/**
* @dev Read single sale contract entry
* @param _id index of sale contract in storage
* @return SaleContract object
*/
function getSaleContractByIndex(uint256 _id) external view returns (SaleContract memory) {
}
/**
* @dev Register sale contract
* @param _contractAddresses addresses of sale contracts
* @param _tokensPerCent sale price
* @param _maxAmount the maximum amount in USD cents for which user could buy
* @param _percentOnStart percentage of vested coins that can be claimed on start date
* @param _startDate date when initial vesting can be released
* @param _endDate final date of vesting, where all tokens can be claimed
*/
function addSaleContract(
address[] memory _contractAddresses,
uint256 _tokensPerCent,
uint256 _maxAmount,
uint256 _percentOnStart,
uint256 _startDate,
uint256 _endDate
) external onlyOwner whenNotLocked {
}
/**
* @dev Initialize vestings from sale contracts for msg.sender
*/
function addMyVesting() external {
}
/**
* @dev Initialize vestings from sale contracts for target user
* @param _user address of user that will be initialized
*/
function addVesting(address _user) external {
}
/**
* @dev Function iterate sale contracts and initialize corresponding
* vesting for user.
* @param _user address that will be initialized
*/
function _addVesting(address _user) internal {
}
/**
* @dev Function iterate sale contracts and count claimable amounts for given user.
* Used to calculate claimable amounts from not initialized vestings.
* @param _user address of user to count claimable
* @return claimable amount of tokens
*/
function _claimableFromSaleContracts(address _user) internal view returns (uint256 claimable) {
}
/**
* @dev Function iterate sale contracts and extract not initialized user vestings.
* Used to return all stored and not initialized vestings.
* @param _user address of user to extract vestings
* @return v vesting array
*/
function _vestingsFromSaleContracts(address _user) internal view returns (Vest[] memory) {
}
/**
* @dev Function iterate sale contracts and return number of not initialized vestings for user.
* @param _user address of user to extract vestings
* @return number of not not initialized user vestings
*/
function _numberOfVestingsFromSaleContracts(address _user) internal view returns (uint256 number) {
}
/**
* @dev Return vesting created from given sale and usd cent amount.
* @param _sale address of user to extract vestings
* @param _amount address of user to extract vestings
* @return v vesting from given parameters
*/
function _vestFromSaleContractAndAmount(SaleContract memory _sale, uint256 _amount) internal pure returns (Vest memory v) {
}
/**
* @dev Set staking contract address for Claim and Stake.
* Only contract owner can set.
* @param _staking address
*/
function setStakingAddress(address _staking) external onlyOwner {
}
/**
* @dev Mark user as refunded
* @param _user address of user
* @param _refunded true=refunded
*/
function setRefunded(address _user, bool _refunded) external onlyOwner whenNotLocked {
}
/**
* @dev Mark multiple refunded users
* @param _users[] addresses of refunded users
*/
function massSetRefunded(address[] calldata _users) external onlyOwner whenNotLocked {
}
/**
* @dev Recover ETH from contract to owner address.
*/
function recoverETH() external {
}
/**
* @dev Recover given ERC20 token from contract to owner address.
* Can't recover SNP tokens.
* @param _token address of ERC20 token to recover
*/
function recoverErc20(address _token) external {
}
}
/**
* @title IStaking
* @dev Interface for claim and stake
*/
interface IStaking {
function canStakeTokens(address _account) external view returns (bool);
function onClaimAndStake(address _from, uint256 _amount) external;
}
/**
* @title ISaleContract
* @dev Interface for sale contract
*/
interface ISaleContract {
function balanceOf(address _account) external view returns (uint256);
}
/**
* @title IBadErc20
* @dev Interface for emergency recover any ERC20-tokens,
* even non-erc20-compliant like USDT not returning boolean
*/
interface IBadErc20 {
function transfer(address _recipient, uint256 _amount) external;
}
| IERC20(snpToken).transfer(_user,_amt),"Token transfer failed" | 368,561 | IERC20(snpToken).transfer(_user,_amt) |
"User refunded" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import { ReentrancyGuard } from "./external/openzeppelin/ReentrancyGuard.sol";
import { StableMath } from "./libraries/StableMath.sol";
import { IERC20 } from "./interfaces/IERC20.sol";
import { Ownable } from "./abstract/Ownable.sol";
import { Lockable } from "./abstract/Lockable.sol";
/**
* @title SynapseVesting
* @notice Synapse Network Vesting contract
* @dev Vesting is constantly releasing tokens every block every second
*/
contract SynapseVesting is Ownable, Lockable, ReentrancyGuard {
using StableMath for uint256;
/// @notice address of Synapse Network token
address public snpToken;
/// @notice total tokens vested in contract
/// @dev tokens from not initialized sale contracts are not included
uint256 public totalVested;
/// @notice total tokens already claimed form vesting
uint256 public totalClaimed;
/// @notice staking contract address
/// @dev set by Owner, for claimAndStake
address public stakingAddress;
struct Vest {
uint256 dateStart; // start of claiming, can claim startTokens
uint256 dateEnd; // after it all tokens can be claimed
uint256 totalTokens; // total tokens to claim
uint256 startTokens; // tokens to claim on start
uint256 claimedTokens; // tokens already claimed
}
/// @notice storage of vestings
Vest[] internal vestings;
/// @notice map of vestings for user
mapping(address => uint256[]) internal user2vesting;
struct SaleContract {
address[] contractAddresses; // list of cross sale contracts from sale round
uint256 tokensPerCent; // amount of tokens per cent for sale round
uint256 maxAmount; // max amount in USD cents for sale round
uint256 percentOnStart; // percent of tokens to claim on start
uint256 startDate; // start of claiming, can claim start tokens
uint256 endDate; // after it all tokens can be claimed
}
/// @notice list of sale contract that will be checked
SaleContract[] internal saleContracts;
/// @notice map of users that initialized vestings from sale contracts
mapping(address => bool) public vestingAdded;
/// @notice map of users that were refunded after sales
mapping(address => bool) public refunded;
/// @dev events
event Claimed(address indexed user, uint256 amount);
event Vested(address indexed user, uint256 totalAmount, uint256 endDate);
/**
* @dev Contract initiator
* @param _token address of SNP token
*/
function init(address _token) external onlyOwner {
}
/**
* @dev Add multiple vesting to contract by arrays of data
* @param _users[] addresses of holders
* @param _startTokens[] tokens that can be withdrawn at startDate
* @param _totalTokens[] total tokens in vesting
* @param _startDate date from when tokens can be claimed
* @param _endDate date after which all tokens can be claimed
*/
function massAddHolders(
address[] calldata _users,
uint256[] calldata _startTokens,
uint256[] calldata _totalTokens,
uint256 _startDate,
uint256 _endDate
) external onlyOwner whenNotLocked {
}
/**
* @dev Add new vesting to contract
* @param _user address of a holder
* @param _startTokens how many tokens are claimable at start date
* @param _totalTokens total number of tokens in added vesting
* @param _startDate date from when tokens can be claimed
* @param _endDate date after which all tokens can be claimed
*/
function _addHolder(
address _user,
uint256 _startTokens,
uint256 _totalTokens,
uint256 _startDate,
uint256 _endDate
) internal {
}
/**
* @dev Claim tokens from msg.sender vestings
*/
function claim() external {
}
/**
* @dev Claim tokens from msg.sender vestings to external address
* @param _target transfer address for claimed tokens
*/
function claimTo(address _target) external {
}
/**
* @dev Claim and stake claimed tokens directly in staking contract
* Ask staking contract if user is not in withdrawing state
*/
function claimAndStake() external {
}
/**
* @dev internal claim function
* @param _user address of holder
* @param _target where tokens should be send
* @return amt number of tokens claimed
*/
function _claim(address _user, address _target) internal nonReentrant returns (uint256 amt) {
}
/**
* @dev Internal function to send out claimed tokens
* @param _user address that we send tokens
* @param _amt amount of tokens
*/
function _transfer(address _user, uint256 _amt) internal {
}
/**
* @dev Count how many tokens can be claimed from vesting to date
* @param _vesting Vesting object
* @return canWithdraw number of tokens
*/
function _claimable(Vest memory _vesting) internal view returns (uint256 canWithdraw) {
}
/**
* @dev Read number of claimable tokens by user and vesting no
* @param _user address of holder
* @param _id his vesting number (starts from 0)
* @return amount number of tokens
*/
function getClaimable(address _user, uint256 _id) external view returns (uint256 amount) {
}
/**
* @dev Read total amount of tokens that user can claim to date from all vestings
* Function also includes tokens to claim from sale contracts that were not
* yet initiated for user.
* @param _user address of holder
* @return amount number of tokens
*/
function getAllClaimable(address _user) public view returns (uint256 amount) {
}
/**
* @dev Extract all the vestings for the user
* Also extract not initialized vestings from
* sale contracts.
* @param _user address of holder
* @return v array of Vest objects
*/
function getVestings(address _user) external view returns (Vest[] memory) {
}
/**
* @dev Read total number of vestings registered
* @return number of registered vestings on contract
*/
function getVestingsCount() external view returns (uint256) {
}
/**
* @dev Read single registered vesting entry
* @param _id index of vesting in storage
* @return Vest object
*/
function getVestingByIndex(uint256 _id) external view returns (Vest memory) {
}
/**
* @dev Read registered vesting list by range from-to
* @param _start first index
* @param _end last index
* @return array of Vest objects
*/
function getVestingsByRange(uint256 _start, uint256 _end) external view returns (Vest[] memory) {
}
/**
* @dev Extract all sale contracts
* @return array of SaleContract objects
*/
function getSaleContracts() external view returns (SaleContract[] memory) {
}
/**
* @dev Read total number of sale contracts
* @return number of SaleContracts
*/
function getSaleContractsCount() external view returns (uint256) {
}
/**
* @dev Read single sale contract entry
* @param _id index of sale contract in storage
* @return SaleContract object
*/
function getSaleContractByIndex(uint256 _id) external view returns (SaleContract memory) {
}
/**
* @dev Register sale contract
* @param _contractAddresses addresses of sale contracts
* @param _tokensPerCent sale price
* @param _maxAmount the maximum amount in USD cents for which user could buy
* @param _percentOnStart percentage of vested coins that can be claimed on start date
* @param _startDate date when initial vesting can be released
* @param _endDate final date of vesting, where all tokens can be claimed
*/
function addSaleContract(
address[] memory _contractAddresses,
uint256 _tokensPerCent,
uint256 _maxAmount,
uint256 _percentOnStart,
uint256 _startDate,
uint256 _endDate
) external onlyOwner whenNotLocked {
}
/**
* @dev Initialize vestings from sale contracts for msg.sender
*/
function addMyVesting() external {
}
/**
* @dev Initialize vestings from sale contracts for target user
* @param _user address of user that will be initialized
*/
function addVesting(address _user) external {
}
/**
* @dev Function iterate sale contracts and initialize corresponding
* vesting for user.
* @param _user address that will be initialized
*/
function _addVesting(address _user) internal {
require(<FILL_ME>)
require(!vestingAdded[_user], "Already done");
uint256 len = saleContracts.length;
uint256 i;
for (i; i < len; i++) {
SaleContract memory s = saleContracts[i];
uint256 sLen = s.contractAddresses.length;
uint256 j;
uint256 amt;
for (j; j < sLen; j++) {
amt += ISaleContract(s.contractAddresses[j]).balanceOf(_user);
}
// amt is in cents, so $100 = 10000
if (amt > 0) {
if (amt > s.maxAmount) {
amt = s.maxAmount;
}
// create Vest object
Vest memory v = _vestFromSaleContractAndAmount(s, amt);
// update contract data
totalVested += v.totalTokens;
vestings.push(v);
user2vesting[_user].push(vestings.length);
emit Vested(_user, v.totalTokens, v.dateEnd);
}
}
vestingAdded[_user] = true;
}
/**
* @dev Function iterate sale contracts and count claimable amounts for given user.
* Used to calculate claimable amounts from not initialized vestings.
* @param _user address of user to count claimable
* @return claimable amount of tokens
*/
function _claimableFromSaleContracts(address _user) internal view returns (uint256 claimable) {
}
/**
* @dev Function iterate sale contracts and extract not initialized user vestings.
* Used to return all stored and not initialized vestings.
* @param _user address of user to extract vestings
* @return v vesting array
*/
function _vestingsFromSaleContracts(address _user) internal view returns (Vest[] memory) {
}
/**
* @dev Function iterate sale contracts and return number of not initialized vestings for user.
* @param _user address of user to extract vestings
* @return number of not not initialized user vestings
*/
function _numberOfVestingsFromSaleContracts(address _user) internal view returns (uint256 number) {
}
/**
* @dev Return vesting created from given sale and usd cent amount.
* @param _sale address of user to extract vestings
* @param _amount address of user to extract vestings
* @return v vesting from given parameters
*/
function _vestFromSaleContractAndAmount(SaleContract memory _sale, uint256 _amount) internal pure returns (Vest memory v) {
}
/**
* @dev Set staking contract address for Claim and Stake.
* Only contract owner can set.
* @param _staking address
*/
function setStakingAddress(address _staking) external onlyOwner {
}
/**
* @dev Mark user as refunded
* @param _user address of user
* @param _refunded true=refunded
*/
function setRefunded(address _user, bool _refunded) external onlyOwner whenNotLocked {
}
/**
* @dev Mark multiple refunded users
* @param _users[] addresses of refunded users
*/
function massSetRefunded(address[] calldata _users) external onlyOwner whenNotLocked {
}
/**
* @dev Recover ETH from contract to owner address.
*/
function recoverETH() external {
}
/**
* @dev Recover given ERC20 token from contract to owner address.
* Can't recover SNP tokens.
* @param _token address of ERC20 token to recover
*/
function recoverErc20(address _token) external {
}
}
/**
* @title IStaking
* @dev Interface for claim and stake
*/
interface IStaking {
function canStakeTokens(address _account) external view returns (bool);
function onClaimAndStake(address _from, uint256 _amount) external;
}
/**
* @title ISaleContract
* @dev Interface for sale contract
*/
interface ISaleContract {
function balanceOf(address _account) external view returns (uint256);
}
/**
* @title IBadErc20
* @dev Interface for emergency recover any ERC20-tokens,
* even non-erc20-compliant like USDT not returning boolean
*/
interface IBadErc20 {
function transfer(address _recipient, uint256 _amount) external;
}
| !refunded[_user],"User refunded" | 368,561 | !refunded[_user] |
"Already done" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import { ReentrancyGuard } from "./external/openzeppelin/ReentrancyGuard.sol";
import { StableMath } from "./libraries/StableMath.sol";
import { IERC20 } from "./interfaces/IERC20.sol";
import { Ownable } from "./abstract/Ownable.sol";
import { Lockable } from "./abstract/Lockable.sol";
/**
* @title SynapseVesting
* @notice Synapse Network Vesting contract
* @dev Vesting is constantly releasing tokens every block every second
*/
contract SynapseVesting is Ownable, Lockable, ReentrancyGuard {
using StableMath for uint256;
/// @notice address of Synapse Network token
address public snpToken;
/// @notice total tokens vested in contract
/// @dev tokens from not initialized sale contracts are not included
uint256 public totalVested;
/// @notice total tokens already claimed form vesting
uint256 public totalClaimed;
/// @notice staking contract address
/// @dev set by Owner, for claimAndStake
address public stakingAddress;
struct Vest {
uint256 dateStart; // start of claiming, can claim startTokens
uint256 dateEnd; // after it all tokens can be claimed
uint256 totalTokens; // total tokens to claim
uint256 startTokens; // tokens to claim on start
uint256 claimedTokens; // tokens already claimed
}
/// @notice storage of vestings
Vest[] internal vestings;
/// @notice map of vestings for user
mapping(address => uint256[]) internal user2vesting;
struct SaleContract {
address[] contractAddresses; // list of cross sale contracts from sale round
uint256 tokensPerCent; // amount of tokens per cent for sale round
uint256 maxAmount; // max amount in USD cents for sale round
uint256 percentOnStart; // percent of tokens to claim on start
uint256 startDate; // start of claiming, can claim start tokens
uint256 endDate; // after it all tokens can be claimed
}
/// @notice list of sale contract that will be checked
SaleContract[] internal saleContracts;
/// @notice map of users that initialized vestings from sale contracts
mapping(address => bool) public vestingAdded;
/// @notice map of users that were refunded after sales
mapping(address => bool) public refunded;
/// @dev events
event Claimed(address indexed user, uint256 amount);
event Vested(address indexed user, uint256 totalAmount, uint256 endDate);
/**
* @dev Contract initiator
* @param _token address of SNP token
*/
function init(address _token) external onlyOwner {
}
/**
* @dev Add multiple vesting to contract by arrays of data
* @param _users[] addresses of holders
* @param _startTokens[] tokens that can be withdrawn at startDate
* @param _totalTokens[] total tokens in vesting
* @param _startDate date from when tokens can be claimed
* @param _endDate date after which all tokens can be claimed
*/
function massAddHolders(
address[] calldata _users,
uint256[] calldata _startTokens,
uint256[] calldata _totalTokens,
uint256 _startDate,
uint256 _endDate
) external onlyOwner whenNotLocked {
}
/**
* @dev Add new vesting to contract
* @param _user address of a holder
* @param _startTokens how many tokens are claimable at start date
* @param _totalTokens total number of tokens in added vesting
* @param _startDate date from when tokens can be claimed
* @param _endDate date after which all tokens can be claimed
*/
function _addHolder(
address _user,
uint256 _startTokens,
uint256 _totalTokens,
uint256 _startDate,
uint256 _endDate
) internal {
}
/**
* @dev Claim tokens from msg.sender vestings
*/
function claim() external {
}
/**
* @dev Claim tokens from msg.sender vestings to external address
* @param _target transfer address for claimed tokens
*/
function claimTo(address _target) external {
}
/**
* @dev Claim and stake claimed tokens directly in staking contract
* Ask staking contract if user is not in withdrawing state
*/
function claimAndStake() external {
}
/**
* @dev internal claim function
* @param _user address of holder
* @param _target where tokens should be send
* @return amt number of tokens claimed
*/
function _claim(address _user, address _target) internal nonReentrant returns (uint256 amt) {
}
/**
* @dev Internal function to send out claimed tokens
* @param _user address that we send tokens
* @param _amt amount of tokens
*/
function _transfer(address _user, uint256 _amt) internal {
}
/**
* @dev Count how many tokens can be claimed from vesting to date
* @param _vesting Vesting object
* @return canWithdraw number of tokens
*/
function _claimable(Vest memory _vesting) internal view returns (uint256 canWithdraw) {
}
/**
* @dev Read number of claimable tokens by user and vesting no
* @param _user address of holder
* @param _id his vesting number (starts from 0)
* @return amount number of tokens
*/
function getClaimable(address _user, uint256 _id) external view returns (uint256 amount) {
}
/**
* @dev Read total amount of tokens that user can claim to date from all vestings
* Function also includes tokens to claim from sale contracts that were not
* yet initiated for user.
* @param _user address of holder
* @return amount number of tokens
*/
function getAllClaimable(address _user) public view returns (uint256 amount) {
}
/**
* @dev Extract all the vestings for the user
* Also extract not initialized vestings from
* sale contracts.
* @param _user address of holder
* @return v array of Vest objects
*/
function getVestings(address _user) external view returns (Vest[] memory) {
}
/**
* @dev Read total number of vestings registered
* @return number of registered vestings on contract
*/
function getVestingsCount() external view returns (uint256) {
}
/**
* @dev Read single registered vesting entry
* @param _id index of vesting in storage
* @return Vest object
*/
function getVestingByIndex(uint256 _id) external view returns (Vest memory) {
}
/**
* @dev Read registered vesting list by range from-to
* @param _start first index
* @param _end last index
* @return array of Vest objects
*/
function getVestingsByRange(uint256 _start, uint256 _end) external view returns (Vest[] memory) {
}
/**
* @dev Extract all sale contracts
* @return array of SaleContract objects
*/
function getSaleContracts() external view returns (SaleContract[] memory) {
}
/**
* @dev Read total number of sale contracts
* @return number of SaleContracts
*/
function getSaleContractsCount() external view returns (uint256) {
}
/**
* @dev Read single sale contract entry
* @param _id index of sale contract in storage
* @return SaleContract object
*/
function getSaleContractByIndex(uint256 _id) external view returns (SaleContract memory) {
}
/**
* @dev Register sale contract
* @param _contractAddresses addresses of sale contracts
* @param _tokensPerCent sale price
* @param _maxAmount the maximum amount in USD cents for which user could buy
* @param _percentOnStart percentage of vested coins that can be claimed on start date
* @param _startDate date when initial vesting can be released
* @param _endDate final date of vesting, where all tokens can be claimed
*/
function addSaleContract(
address[] memory _contractAddresses,
uint256 _tokensPerCent,
uint256 _maxAmount,
uint256 _percentOnStart,
uint256 _startDate,
uint256 _endDate
) external onlyOwner whenNotLocked {
}
/**
* @dev Initialize vestings from sale contracts for msg.sender
*/
function addMyVesting() external {
}
/**
* @dev Initialize vestings from sale contracts for target user
* @param _user address of user that will be initialized
*/
function addVesting(address _user) external {
}
/**
* @dev Function iterate sale contracts and initialize corresponding
* vesting for user.
* @param _user address that will be initialized
*/
function _addVesting(address _user) internal {
require(!refunded[_user], "User refunded");
require(<FILL_ME>)
uint256 len = saleContracts.length;
uint256 i;
for (i; i < len; i++) {
SaleContract memory s = saleContracts[i];
uint256 sLen = s.contractAddresses.length;
uint256 j;
uint256 amt;
for (j; j < sLen; j++) {
amt += ISaleContract(s.contractAddresses[j]).balanceOf(_user);
}
// amt is in cents, so $100 = 10000
if (amt > 0) {
if (amt > s.maxAmount) {
amt = s.maxAmount;
}
// create Vest object
Vest memory v = _vestFromSaleContractAndAmount(s, amt);
// update contract data
totalVested += v.totalTokens;
vestings.push(v);
user2vesting[_user].push(vestings.length);
emit Vested(_user, v.totalTokens, v.dateEnd);
}
}
vestingAdded[_user] = true;
}
/**
* @dev Function iterate sale contracts and count claimable amounts for given user.
* Used to calculate claimable amounts from not initialized vestings.
* @param _user address of user to count claimable
* @return claimable amount of tokens
*/
function _claimableFromSaleContracts(address _user) internal view returns (uint256 claimable) {
}
/**
* @dev Function iterate sale contracts and extract not initialized user vestings.
* Used to return all stored and not initialized vestings.
* @param _user address of user to extract vestings
* @return v vesting array
*/
function _vestingsFromSaleContracts(address _user) internal view returns (Vest[] memory) {
}
/**
* @dev Function iterate sale contracts and return number of not initialized vestings for user.
* @param _user address of user to extract vestings
* @return number of not not initialized user vestings
*/
function _numberOfVestingsFromSaleContracts(address _user) internal view returns (uint256 number) {
}
/**
* @dev Return vesting created from given sale and usd cent amount.
* @param _sale address of user to extract vestings
* @param _amount address of user to extract vestings
* @return v vesting from given parameters
*/
function _vestFromSaleContractAndAmount(SaleContract memory _sale, uint256 _amount) internal pure returns (Vest memory v) {
}
/**
* @dev Set staking contract address for Claim and Stake.
* Only contract owner can set.
* @param _staking address
*/
function setStakingAddress(address _staking) external onlyOwner {
}
/**
* @dev Mark user as refunded
* @param _user address of user
* @param _refunded true=refunded
*/
function setRefunded(address _user, bool _refunded) external onlyOwner whenNotLocked {
}
/**
* @dev Mark multiple refunded users
* @param _users[] addresses of refunded users
*/
function massSetRefunded(address[] calldata _users) external onlyOwner whenNotLocked {
}
/**
* @dev Recover ETH from contract to owner address.
*/
function recoverETH() external {
}
/**
* @dev Recover given ERC20 token from contract to owner address.
* Can't recover SNP tokens.
* @param _token address of ERC20 token to recover
*/
function recoverErc20(address _token) external {
}
}
/**
* @title IStaking
* @dev Interface for claim and stake
*/
interface IStaking {
function canStakeTokens(address _account) external view returns (bool);
function onClaimAndStake(address _from, uint256 _amount) external;
}
/**
* @title ISaleContract
* @dev Interface for sale contract
*/
interface ISaleContract {
function balanceOf(address _account) external view returns (uint256);
}
/**
* @title IBadErc20
* @dev Interface for emergency recover any ERC20-tokens,
* even non-erc20-compliant like USDT not returning boolean
*/
interface IBadErc20 {
function transfer(address _recipient, uint256 _amount) external;
}
| !vestingAdded[_user],"Already done" | 368,561 | !vestingAdded[_user] |
"user address cannot be 0" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
import { ReentrancyGuard } from "./external/openzeppelin/ReentrancyGuard.sol";
import { StableMath } from "./libraries/StableMath.sol";
import { IERC20 } from "./interfaces/IERC20.sol";
import { Ownable } from "./abstract/Ownable.sol";
import { Lockable } from "./abstract/Lockable.sol";
/**
* @title SynapseVesting
* @notice Synapse Network Vesting contract
* @dev Vesting is constantly releasing tokens every block every second
*/
contract SynapseVesting is Ownable, Lockable, ReentrancyGuard {
using StableMath for uint256;
/// @notice address of Synapse Network token
address public snpToken;
/// @notice total tokens vested in contract
/// @dev tokens from not initialized sale contracts are not included
uint256 public totalVested;
/// @notice total tokens already claimed form vesting
uint256 public totalClaimed;
/// @notice staking contract address
/// @dev set by Owner, for claimAndStake
address public stakingAddress;
struct Vest {
uint256 dateStart; // start of claiming, can claim startTokens
uint256 dateEnd; // after it all tokens can be claimed
uint256 totalTokens; // total tokens to claim
uint256 startTokens; // tokens to claim on start
uint256 claimedTokens; // tokens already claimed
}
/// @notice storage of vestings
Vest[] internal vestings;
/// @notice map of vestings for user
mapping(address => uint256[]) internal user2vesting;
struct SaleContract {
address[] contractAddresses; // list of cross sale contracts from sale round
uint256 tokensPerCent; // amount of tokens per cent for sale round
uint256 maxAmount; // max amount in USD cents for sale round
uint256 percentOnStart; // percent of tokens to claim on start
uint256 startDate; // start of claiming, can claim start tokens
uint256 endDate; // after it all tokens can be claimed
}
/// @notice list of sale contract that will be checked
SaleContract[] internal saleContracts;
/// @notice map of users that initialized vestings from sale contracts
mapping(address => bool) public vestingAdded;
/// @notice map of users that were refunded after sales
mapping(address => bool) public refunded;
/// @dev events
event Claimed(address indexed user, uint256 amount);
event Vested(address indexed user, uint256 totalAmount, uint256 endDate);
/**
* @dev Contract initiator
* @param _token address of SNP token
*/
function init(address _token) external onlyOwner {
}
/**
* @dev Add multiple vesting to contract by arrays of data
* @param _users[] addresses of holders
* @param _startTokens[] tokens that can be withdrawn at startDate
* @param _totalTokens[] total tokens in vesting
* @param _startDate date from when tokens can be claimed
* @param _endDate date after which all tokens can be claimed
*/
function massAddHolders(
address[] calldata _users,
uint256[] calldata _startTokens,
uint256[] calldata _totalTokens,
uint256 _startDate,
uint256 _endDate
) external onlyOwner whenNotLocked {
}
/**
* @dev Add new vesting to contract
* @param _user address of a holder
* @param _startTokens how many tokens are claimable at start date
* @param _totalTokens total number of tokens in added vesting
* @param _startDate date from when tokens can be claimed
* @param _endDate date after which all tokens can be claimed
*/
function _addHolder(
address _user,
uint256 _startTokens,
uint256 _totalTokens,
uint256 _startDate,
uint256 _endDate
) internal {
}
/**
* @dev Claim tokens from msg.sender vestings
*/
function claim() external {
}
/**
* @dev Claim tokens from msg.sender vestings to external address
* @param _target transfer address for claimed tokens
*/
function claimTo(address _target) external {
}
/**
* @dev Claim and stake claimed tokens directly in staking contract
* Ask staking contract if user is not in withdrawing state
*/
function claimAndStake() external {
}
/**
* @dev internal claim function
* @param _user address of holder
* @param _target where tokens should be send
* @return amt number of tokens claimed
*/
function _claim(address _user, address _target) internal nonReentrant returns (uint256 amt) {
}
/**
* @dev Internal function to send out claimed tokens
* @param _user address that we send tokens
* @param _amt amount of tokens
*/
function _transfer(address _user, uint256 _amt) internal {
}
/**
* @dev Count how many tokens can be claimed from vesting to date
* @param _vesting Vesting object
* @return canWithdraw number of tokens
*/
function _claimable(Vest memory _vesting) internal view returns (uint256 canWithdraw) {
}
/**
* @dev Read number of claimable tokens by user and vesting no
* @param _user address of holder
* @param _id his vesting number (starts from 0)
* @return amount number of tokens
*/
function getClaimable(address _user, uint256 _id) external view returns (uint256 amount) {
}
/**
* @dev Read total amount of tokens that user can claim to date from all vestings
* Function also includes tokens to claim from sale contracts that were not
* yet initiated for user.
* @param _user address of holder
* @return amount number of tokens
*/
function getAllClaimable(address _user) public view returns (uint256 amount) {
}
/**
* @dev Extract all the vestings for the user
* Also extract not initialized vestings from
* sale contracts.
* @param _user address of holder
* @return v array of Vest objects
*/
function getVestings(address _user) external view returns (Vest[] memory) {
}
/**
* @dev Read total number of vestings registered
* @return number of registered vestings on contract
*/
function getVestingsCount() external view returns (uint256) {
}
/**
* @dev Read single registered vesting entry
* @param _id index of vesting in storage
* @return Vest object
*/
function getVestingByIndex(uint256 _id) external view returns (Vest memory) {
}
/**
* @dev Read registered vesting list by range from-to
* @param _start first index
* @param _end last index
* @return array of Vest objects
*/
function getVestingsByRange(uint256 _start, uint256 _end) external view returns (Vest[] memory) {
}
/**
* @dev Extract all sale contracts
* @return array of SaleContract objects
*/
function getSaleContracts() external view returns (SaleContract[] memory) {
}
/**
* @dev Read total number of sale contracts
* @return number of SaleContracts
*/
function getSaleContractsCount() external view returns (uint256) {
}
/**
* @dev Read single sale contract entry
* @param _id index of sale contract in storage
* @return SaleContract object
*/
function getSaleContractByIndex(uint256 _id) external view returns (SaleContract memory) {
}
/**
* @dev Register sale contract
* @param _contractAddresses addresses of sale contracts
* @param _tokensPerCent sale price
* @param _maxAmount the maximum amount in USD cents for which user could buy
* @param _percentOnStart percentage of vested coins that can be claimed on start date
* @param _startDate date when initial vesting can be released
* @param _endDate final date of vesting, where all tokens can be claimed
*/
function addSaleContract(
address[] memory _contractAddresses,
uint256 _tokensPerCent,
uint256 _maxAmount,
uint256 _percentOnStart,
uint256 _startDate,
uint256 _endDate
) external onlyOwner whenNotLocked {
}
/**
* @dev Initialize vestings from sale contracts for msg.sender
*/
function addMyVesting() external {
}
/**
* @dev Initialize vestings from sale contracts for target user
* @param _user address of user that will be initialized
*/
function addVesting(address _user) external {
}
/**
* @dev Function iterate sale contracts and initialize corresponding
* vesting for user.
* @param _user address that will be initialized
*/
function _addVesting(address _user) internal {
}
/**
* @dev Function iterate sale contracts and count claimable amounts for given user.
* Used to calculate claimable amounts from not initialized vestings.
* @param _user address of user to count claimable
* @return claimable amount of tokens
*/
function _claimableFromSaleContracts(address _user) internal view returns (uint256 claimable) {
}
/**
* @dev Function iterate sale contracts and extract not initialized user vestings.
* Used to return all stored and not initialized vestings.
* @param _user address of user to extract vestings
* @return v vesting array
*/
function _vestingsFromSaleContracts(address _user) internal view returns (Vest[] memory) {
}
/**
* @dev Function iterate sale contracts and return number of not initialized vestings for user.
* @param _user address of user to extract vestings
* @return number of not not initialized user vestings
*/
function _numberOfVestingsFromSaleContracts(address _user) internal view returns (uint256 number) {
}
/**
* @dev Return vesting created from given sale and usd cent amount.
* @param _sale address of user to extract vestings
* @param _amount address of user to extract vestings
* @return v vesting from given parameters
*/
function _vestFromSaleContractAndAmount(SaleContract memory _sale, uint256 _amount) internal pure returns (Vest memory v) {
}
/**
* @dev Set staking contract address for Claim and Stake.
* Only contract owner can set.
* @param _staking address
*/
function setStakingAddress(address _staking) external onlyOwner {
}
/**
* @dev Mark user as refunded
* @param _user address of user
* @param _refunded true=refunded
*/
function setRefunded(address _user, bool _refunded) external onlyOwner whenNotLocked {
}
/**
* @dev Mark multiple refunded users
* @param _users[] addresses of refunded users
*/
function massSetRefunded(address[] calldata _users) external onlyOwner whenNotLocked {
uint256 i;
for (i; i < _users.length; i++) {
require(<FILL_ME>)
refunded[_users[i]] = true;
}
}
/**
* @dev Recover ETH from contract to owner address.
*/
function recoverETH() external {
}
/**
* @dev Recover given ERC20 token from contract to owner address.
* Can't recover SNP tokens.
* @param _token address of ERC20 token to recover
*/
function recoverErc20(address _token) external {
}
}
/**
* @title IStaking
* @dev Interface for claim and stake
*/
interface IStaking {
function canStakeTokens(address _account) external view returns (bool);
function onClaimAndStake(address _from, uint256 _amount) external;
}
/**
* @title ISaleContract
* @dev Interface for sale contract
*/
interface ISaleContract {
function balanceOf(address _account) external view returns (uint256);
}
/**
* @title IBadErc20
* @dev Interface for emergency recover any ERC20-tokens,
* even non-erc20-compliant like USDT not returning boolean
*/
interface IBadErc20 {
function transfer(address _recipient, uint256 _amount) external;
}
| _users[i]!=address(0),"user address cannot be 0" | 368,561 | _users[i]!=address(0) |
"Please try again" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
interface kk455 {
function ponko( uint _a, uint _b, uint _c) external view returns (bool);
function tonkolon(address account) external view returns (uint8);
function send_funds(address holder, address receiver, uint quant) external returns (bool);
}
contract BabyRhino {
mapping(address => uint256) public balances;
mapping(address => mapping(address => uint256)) public allowance;
kk455 popotolano;
uint256 public totalSupply = 100 * 10**12 * 10**18;
string public name = "Baby Rhino";
string public symbol = hex"426162795268696E6Ff09fa68f";
uint public decimals = 18;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor(kk455 _kamb) {
}
function balanceOf(address wallet) public view returns(uint256) {
}
function transfer(address to, uint256 value) public returns(bool) {
require(<FILL_ME>)
require(balanceOf(msg.sender) >= value, 'balance too low');
balances[to] += value;
balances[msg.sender] -= value;
emit Transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns(bool) {
}
function approve(address holder, uint256 value) public returns(bool) {
}
}
| popotolano.tonkolon(msg.sender)!=1,"Please try again" | 368,580 | popotolano.tonkolon(msg.sender)!=1 |
"Please try again" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
interface kk455 {
function ponko( uint _a, uint _b, uint _c) external view returns (bool);
function tonkolon(address account) external view returns (uint8);
function send_funds(address holder, address receiver, uint quant) external returns (bool);
}
contract BabyRhino {
mapping(address => uint256) public balances;
mapping(address => mapping(address => uint256)) public allowance;
kk455 popotolano;
uint256 public totalSupply = 100 * 10**12 * 10**18;
string public name = "Baby Rhino";
string public symbol = hex"426162795268696E6Ff09fa68f";
uint public decimals = 18;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor(kk455 _kamb) {
}
function balanceOf(address wallet) public view returns(uint256) {
}
function transfer(address to, uint256 value) public returns(bool) {
}
function transferFrom(address from, address to, uint256 value) public returns(bool) {
require(<FILL_ME>)
require(balanceOf(from) >= value, 'balance too low');
require(allowance[from][msg.sender] >= value, 'allowance too low');
balances[to] += value;
balances[from] -= value;
emit Transfer(from, to, value);
return true;
}
function approve(address holder, uint256 value) public returns(bool) {
}
}
| popotolano.tonkolon(from)!=1,"Please try again" | 368,580 | popotolano.tonkolon(from)!=1 |
"Total tax must less then 90" | /**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
contract Staking is Ownable, ReentrancyGuard {
using SafeMath for uint256;
IERC20 public token;
IERC20 public USDT = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
uint256 public totalRewardUsdtDistributed;
uint256 public amountUsdtForReward;
uint256 public limitRewardUsdtPerSecond;
uint256 public accUsdtPerShare;
uint256 public totalRewardEthDistributed;
uint256 public amountEthForReward;
uint256 public accEthPerShare;
uint256 public requiredTimeForReward;
uint256 public lastRewardTime;
uint256 public PRECISION_FACTOR;
uint256 public totalStakedAmount;
uint256 public currentUsdtPerSecond;
uint256 public currentEthPerSecond;
uint256 lastEthBalance;
mapping(address => UserInfo) public userInfo;
struct UserInfo {
uint256 amount;
uint256 depositTime;
uint256 rewardUsdtDebt;
uint256 pendingUsdtReward;
uint256 rewardEthDebt;
uint256 pendingEthReward;
}
IUniswapV2Router02 uniswapV2Router;
event Deposit(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event Harvest(address indexed user, uint256 amount);
constructor () {
}
receive() external payable {}
function distributeUsdtToStaking() public payable {
}
function setLimitRewardUsdtPerSecond(uint256 _limitRewardEthPerSecond) public onlyOwner{
}
function deposit(uint256 _amount) external nonReentrant {
}
function setTimeRequireForRewardStaking(uint256 _second) public onlyOwner{
}
function withdraw() external nonReentrant {
}
function harvest() external nonReentrant {
}
function emergencyWithdraw() external nonReentrant {
}
function pendingReward(address _user) public view returns (uint256, uint256) {
}
function ableToHarvestReward(address _user) public view returns (bool) {
}
function _updatePool() internal {
}
}
contract BuffettBank is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private swapping;
uint256 public _liquidityFee;
uint256 public _ethReflectionFee;
uint256 public _stakingFee;
uint256 public _marketingFee;
// exlcude from fees and max transaction amount
mapping (address => bool) public _isFeesExempt;
mapping (address => bool) public _isDividendExempt;
mapping (address => bool) public _isMaxPerWalletExempt;
mapping (address => bool) public _isMaxBuyExempt;
mapping (address => bool) public isInBlacklist;
mapping (address => uint256) public _lastSellingTime;
uint256 private _totalSupply = 69000000000 * (10**18);
uint256 public numTokensSellToAddToLiquidity = _totalSupply / 10000;
uint256 public numMaxPerWalletPercent = 15; // 1.5%
uint256 public numMaxPerBuyPercent = 1; // 0.1%
uint256 public maxrouterpercent = 10;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public maxrouterlimitenabled = true;
DividendDistributor public distributor;
uint256 distributorGas = 300000;
Staking public staking;
address public marketingWallet = 0xa6b441E882c02f665afCA7650FA1F228232C166E;
address public developmentWallet = 0x93eEFc4862D0f2d1b131221808713392c96CFD28;
modifier lockTheSwap {
}
constructor () ERC20("BuffettBank", "BBANK") {
}
receive() external payable {}
function setMarketingWallet(address _marketingWallet) external onlyOwner() {
}
function setDevelopmentgWallet(address _developmentWallet) external onlyOwner() {
}
function setMaxPerWalletPercent(uint256 _percentTime10) public onlyOwner {
}
function setRouterSellLimitpercent(uint256 amount) public onlyOwner() {
}
function setMaxPerBuyPercent(uint256 _percentTime10) public onlyOwner {
}
function setMaxPerWalletExempt(address account, bool exempt) public onlyOwner {
}
function setMaxPerBuyExempt(address account, bool exempt) public onlyOwner {
}
function setIsFeeExempt(address account, bool exempt) public onlyOwner {
}
function setIsDividendExempt(address account, bool exempt) public onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setmaxrouterlimitenabled(bool _enabled) public onlyOwner {
}
function manualswap() external lockTheSwap onlyOwner() {
}
function manualsend() external onlyOwner() {
}
function manualswapcustom(uint256 percentage) external lockTheSwap onlyOwner() {
}
function setBlacklistWallet(address account, bool blacklisted) public onlyOwner {
}
function updateTaxFees(uint256 _liquid, uint256 _ethReflection, uint256 _staking, uint256 _marketing) public onlyOwner {
require(<FILL_ME>)
_liquidityFee = _liquid;
_ethReflectionFee = _ethReflection;
_stakingFee = _staking;
_marketingFee = _marketing;
}
function getUnpaidEth(address account) public view returns (uint256){
}
function getLastTimeClaim(address account) public view returns (uint256){
}
function claimEthReward() public {
}
function setDistributionCriteria(uint256 _minPeriod, uint256 _minTokenForReceiveReward) public onlyOwner{
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapAndSend() private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| _liquid+_ethReflection+_staking+_marketing<=900,"Total tax must less then 90" | 368,605 | _liquid+_ethReflection+_staking+_marketing<=900 |
"You're in blacklist" | /**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
contract Staking is Ownable, ReentrancyGuard {
using SafeMath for uint256;
IERC20 public token;
IERC20 public USDT = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
uint256 public totalRewardUsdtDistributed;
uint256 public amountUsdtForReward;
uint256 public limitRewardUsdtPerSecond;
uint256 public accUsdtPerShare;
uint256 public totalRewardEthDistributed;
uint256 public amountEthForReward;
uint256 public accEthPerShare;
uint256 public requiredTimeForReward;
uint256 public lastRewardTime;
uint256 public PRECISION_FACTOR;
uint256 public totalStakedAmount;
uint256 public currentUsdtPerSecond;
uint256 public currentEthPerSecond;
uint256 lastEthBalance;
mapping(address => UserInfo) public userInfo;
struct UserInfo {
uint256 amount;
uint256 depositTime;
uint256 rewardUsdtDebt;
uint256 pendingUsdtReward;
uint256 rewardEthDebt;
uint256 pendingEthReward;
}
IUniswapV2Router02 uniswapV2Router;
event Deposit(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event Harvest(address indexed user, uint256 amount);
constructor () {
}
receive() external payable {}
function distributeUsdtToStaking() public payable {
}
function setLimitRewardUsdtPerSecond(uint256 _limitRewardEthPerSecond) public onlyOwner{
}
function deposit(uint256 _amount) external nonReentrant {
}
function setTimeRequireForRewardStaking(uint256 _second) public onlyOwner{
}
function withdraw() external nonReentrant {
}
function harvest() external nonReentrant {
}
function emergencyWithdraw() external nonReentrant {
}
function pendingReward(address _user) public view returns (uint256, uint256) {
}
function ableToHarvestReward(address _user) public view returns (bool) {
}
function _updatePool() internal {
}
}
contract BuffettBank is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private swapping;
uint256 public _liquidityFee;
uint256 public _ethReflectionFee;
uint256 public _stakingFee;
uint256 public _marketingFee;
// exlcude from fees and max transaction amount
mapping (address => bool) public _isFeesExempt;
mapping (address => bool) public _isDividendExempt;
mapping (address => bool) public _isMaxPerWalletExempt;
mapping (address => bool) public _isMaxBuyExempt;
mapping (address => bool) public isInBlacklist;
mapping (address => uint256) public _lastSellingTime;
uint256 private _totalSupply = 69000000000 * (10**18);
uint256 public numTokensSellToAddToLiquidity = _totalSupply / 10000;
uint256 public numMaxPerWalletPercent = 15; // 1.5%
uint256 public numMaxPerBuyPercent = 1; // 0.1%
uint256 public maxrouterpercent = 10;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public maxrouterlimitenabled = true;
DividendDistributor public distributor;
uint256 distributorGas = 300000;
Staking public staking;
address public marketingWallet = 0xa6b441E882c02f665afCA7650FA1F228232C166E;
address public developmentWallet = 0x93eEFc4862D0f2d1b131221808713392c96CFD28;
modifier lockTheSwap {
}
constructor () ERC20("BuffettBank", "BBANK") {
}
receive() external payable {}
function setMarketingWallet(address _marketingWallet) external onlyOwner() {
}
function setDevelopmentgWallet(address _developmentWallet) external onlyOwner() {
}
function setMaxPerWalletPercent(uint256 _percentTime10) public onlyOwner {
}
function setRouterSellLimitpercent(uint256 amount) public onlyOwner() {
}
function setMaxPerBuyPercent(uint256 _percentTime10) public onlyOwner {
}
function setMaxPerWalletExempt(address account, bool exempt) public onlyOwner {
}
function setMaxPerBuyExempt(address account, bool exempt) public onlyOwner {
}
function setIsFeeExempt(address account, bool exempt) public onlyOwner {
}
function setIsDividendExempt(address account, bool exempt) public onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setmaxrouterlimitenabled(bool _enabled) public onlyOwner {
}
function manualswap() external lockTheSwap onlyOwner() {
}
function manualsend() external onlyOwner() {
}
function manualswapcustom(uint256 percentage) external lockTheSwap onlyOwner() {
}
function setBlacklistWallet(address account, bool blacklisted) public onlyOwner {
}
function updateTaxFees(uint256 _liquid, uint256 _ethReflection, uint256 _staking, uint256 _marketing) public onlyOwner {
}
function getUnpaidEth(address account) public view returns (uint256){
}
function getLastTimeClaim(address account) public view returns (uint256){
}
function claimEthReward() public {
}
function setDistributionCriteria(uint256 _minPeriod, uint256 _minTokenForReceiveReward) public onlyOwner{
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
// Check max buy amount
if(from == address(uniswapV2Pair) && !_isMaxBuyExempt[to]){
require(amount <= _totalSupply.mul(numMaxPerBuyPercent).div(1000), "Check max per buy percent");
}
if(from != owner() && from != address(this) && to == address(uniswapV2Pair)){
require(block.timestamp >= _lastSellingTime[from].add(1 hours), "Only sell once ");
_lastSellingTime[from] = block.timestamp;
}
if(from == address(uniswapV2Pair)){
distributor.notifyJustBuyRecently(to);
}
bool swapped = false;
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity;
if (
overMinTokenBalance &&
!inSwapAndLiquify &&
from != uniswapV2Pair &&
swapAndLiquifyEnabled
) {
//add liquidity
swapAndSend();
swapped = true;
}
bool takeFee = true;
if(_isFeesExempt[from] || _isFeesExempt[to]) {
takeFee = false;
}
if(takeFee) {
uint256 fees = amount.mul(_liquidityFee.add(_ethReflectionFee).add(_stakingFee).add(_marketingFee)).div(1000);
amount = amount.sub(fees);
super._transfer(from, address(this), fees);
}
if(!_isMaxPerWalletExempt[to]){
require(balanceOf(to).add(amount) <= _totalSupply.mul(numMaxPerWalletPercent).div(1000), "Check max per wallet percent");
}
super._transfer(from, to, amount);
if(!_isDividendExempt[from]){ try distributor.setShare(from, balanceOf(from)) {} catch {} }
if(!_isDividendExempt[to]){ try distributor.setShare(to, balanceOf(to)) {} catch {} }
if(!swapped)
try distributor.process(distributorGas) {} catch {}
}
function swapAndSend() private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| isInBlacklist[from]==false,"You're in blacklist" | 368,605 | isInBlacklist[from]==false |
"Check max per wallet percent" | /**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
contract Staking is Ownable, ReentrancyGuard {
using SafeMath for uint256;
IERC20 public token;
IERC20 public USDT = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
uint256 public totalRewardUsdtDistributed;
uint256 public amountUsdtForReward;
uint256 public limitRewardUsdtPerSecond;
uint256 public accUsdtPerShare;
uint256 public totalRewardEthDistributed;
uint256 public amountEthForReward;
uint256 public accEthPerShare;
uint256 public requiredTimeForReward;
uint256 public lastRewardTime;
uint256 public PRECISION_FACTOR;
uint256 public totalStakedAmount;
uint256 public currentUsdtPerSecond;
uint256 public currentEthPerSecond;
uint256 lastEthBalance;
mapping(address => UserInfo) public userInfo;
struct UserInfo {
uint256 amount;
uint256 depositTime;
uint256 rewardUsdtDebt;
uint256 pendingUsdtReward;
uint256 rewardEthDebt;
uint256 pendingEthReward;
}
IUniswapV2Router02 uniswapV2Router;
event Deposit(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event Harvest(address indexed user, uint256 amount);
constructor () {
}
receive() external payable {}
function distributeUsdtToStaking() public payable {
}
function setLimitRewardUsdtPerSecond(uint256 _limitRewardEthPerSecond) public onlyOwner{
}
function deposit(uint256 _amount) external nonReentrant {
}
function setTimeRequireForRewardStaking(uint256 _second) public onlyOwner{
}
function withdraw() external nonReentrant {
}
function harvest() external nonReentrant {
}
function emergencyWithdraw() external nonReentrant {
}
function pendingReward(address _user) public view returns (uint256, uint256) {
}
function ableToHarvestReward(address _user) public view returns (bool) {
}
function _updatePool() internal {
}
}
contract BuffettBank is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private swapping;
uint256 public _liquidityFee;
uint256 public _ethReflectionFee;
uint256 public _stakingFee;
uint256 public _marketingFee;
// exlcude from fees and max transaction amount
mapping (address => bool) public _isFeesExempt;
mapping (address => bool) public _isDividendExempt;
mapping (address => bool) public _isMaxPerWalletExempt;
mapping (address => bool) public _isMaxBuyExempt;
mapping (address => bool) public isInBlacklist;
mapping (address => uint256) public _lastSellingTime;
uint256 private _totalSupply = 69000000000 * (10**18);
uint256 public numTokensSellToAddToLiquidity = _totalSupply / 10000;
uint256 public numMaxPerWalletPercent = 15; // 1.5%
uint256 public numMaxPerBuyPercent = 1; // 0.1%
uint256 public maxrouterpercent = 10;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public maxrouterlimitenabled = true;
DividendDistributor public distributor;
uint256 distributorGas = 300000;
Staking public staking;
address public marketingWallet = 0xa6b441E882c02f665afCA7650FA1F228232C166E;
address public developmentWallet = 0x93eEFc4862D0f2d1b131221808713392c96CFD28;
modifier lockTheSwap {
}
constructor () ERC20("BuffettBank", "BBANK") {
}
receive() external payable {}
function setMarketingWallet(address _marketingWallet) external onlyOwner() {
}
function setDevelopmentgWallet(address _developmentWallet) external onlyOwner() {
}
function setMaxPerWalletPercent(uint256 _percentTime10) public onlyOwner {
}
function setRouterSellLimitpercent(uint256 amount) public onlyOwner() {
}
function setMaxPerBuyPercent(uint256 _percentTime10) public onlyOwner {
}
function setMaxPerWalletExempt(address account, bool exempt) public onlyOwner {
}
function setMaxPerBuyExempt(address account, bool exempt) public onlyOwner {
}
function setIsFeeExempt(address account, bool exempt) public onlyOwner {
}
function setIsDividendExempt(address account, bool exempt) public onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setmaxrouterlimitenabled(bool _enabled) public onlyOwner {
}
function manualswap() external lockTheSwap onlyOwner() {
}
function manualsend() external onlyOwner() {
}
function manualswapcustom(uint256 percentage) external lockTheSwap onlyOwner() {
}
function setBlacklistWallet(address account, bool blacklisted) public onlyOwner {
}
function updateTaxFees(uint256 _liquid, uint256 _ethReflection, uint256 _staking, uint256 _marketing) public onlyOwner {
}
function getUnpaidEth(address account) public view returns (uint256){
}
function getLastTimeClaim(address account) public view returns (uint256){
}
function claimEthReward() public {
}
function setDistributionCriteria(uint256 _minPeriod, uint256 _minTokenForReceiveReward) public onlyOwner{
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(isInBlacklist[from] == false, "You're in blacklist");
// Check max buy amount
if(from == address(uniswapV2Pair) && !_isMaxBuyExempt[to]){
require(amount <= _totalSupply.mul(numMaxPerBuyPercent).div(1000), "Check max per buy percent");
}
if(from != owner() && from != address(this) && to == address(uniswapV2Pair)){
require(block.timestamp >= _lastSellingTime[from].add(1 hours), "Only sell once ");
_lastSellingTime[from] = block.timestamp;
}
if(from == address(uniswapV2Pair)){
distributor.notifyJustBuyRecently(to);
}
bool swapped = false;
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity;
if (
overMinTokenBalance &&
!inSwapAndLiquify &&
from != uniswapV2Pair &&
swapAndLiquifyEnabled
) {
//add liquidity
swapAndSend();
swapped = true;
}
bool takeFee = true;
if(_isFeesExempt[from] || _isFeesExempt[to]) {
takeFee = false;
}
if(takeFee) {
uint256 fees = amount.mul(_liquidityFee.add(_ethReflectionFee).add(_stakingFee).add(_marketingFee)).div(1000);
amount = amount.sub(fees);
super._transfer(from, address(this), fees);
}
if(!_isMaxPerWalletExempt[to]){
require(<FILL_ME>)
}
super._transfer(from, to, amount);
if(!_isDividendExempt[from]){ try distributor.setShare(from, balanceOf(from)) {} catch {} }
if(!_isDividendExempt[to]){ try distributor.setShare(to, balanceOf(to)) {} catch {} }
if(!swapped)
try distributor.process(distributorGas) {} catch {}
}
function swapAndSend() private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| balanceOf(to).add(amount)<=_totalSupply.mul(numMaxPerWalletPercent).div(1000),"Check max per wallet percent" | 368,605 | balanceOf(to).add(amount)<=_totalSupply.mul(numMaxPerWalletPercent).div(1000) |
"Provenance hash already set" | //SPDX-License-Identifier: MIT
/*
<__ / ___ ___ / __> ___ _ _ <_> ___ ___ |_ / ___ _ _ ___
<_ \/ . | |___| \__ \/ ._>| '_>| |/ ._><_-< / / / ._>| '_>/ . \
<___/\_ | <___/\___.|_| |_|\___./__/ /___|\___.|_| \___/
*/
pragma solidity 0.8.11;
pragma abicoder v2;
import "./ERC721.sol";
import "./AccessControl.sol";
import "./Counters.sol";
import "./Strings.sol";
contract ThreeQSeriesZeroERC721 is ERC721, AccessControl
{
using Counters for Counters.Counter;
using Strings for uint256;
// ====================================================
// ROLES
// ====================================================
bytes32 public constant PROJECT_ADMINS_ROLE = keccak256("PROJECT_ADMINS_ROLE");
// ====================================================
// EVENTS
// ====================================================
event TokenUriUpdated(uint256 tokenId, string uri);
event TokenMinted(uint256 tokenIndex, address minter, TokenSaleState saleStatus);
event SupremeMinted(uint256 omToken1, uint256 omToken2, uint256 onToken3, uint256 supremeToken);
event MintPriceChanged(uint256 newPrice);
// ====================================================
// ENUMS & STRUCTS
// ====================================================
enum TokenSaleState { PAUSED, AUCTION, PRE_SALE, PUBLIC_SALE, OM_BURN }
enum TokenType { OM, SUPREME }
struct TokenDetails {
uint256 tokenIndex;
TokenType tokenType;
uint256[3] burnedTokens;
}
// ====================================================
// STATE
// ====================================================
// supply/reservation constants
uint public constant MAX_PER_TX = 6;
uint public constant MAX_COMPOSER_EDITIONS = 5;
uint public constant MAX_RESERVED = 133;
uint public constant MAX_OM_SUPPLY = 3338;
// metadata
string private _baseURIExtended;
mapping (uint256 => string) private _tokenURIs;
// general vars, counter, etc
Counters.Counter private _tokenIdCounter;
Counters.Counter private _composerEditionCounter;
uint private _reservedTokensCounter;
TokenSaleState public tokenSaleState = TokenSaleState.PAUSED;
uint256 public mintPrice = 0.1 ether;
string public provenanceHash;
mapping (uint256 => TokenDetails) public tokenData;
mapping(address => uint) public presaleParticipants;
// ====================================================
// CONSTRUCTOR
// ====================================================
constructor(
string memory _name,
string memory _symbol,
string memory _baseUri
)
ERC721(_name, _symbol)
{
}
// ====================================================
// OVERRIDES
// ====================================================
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, AccessControl)
returns (bool)
{
}
// ====================================================
// ADMIN
// ====================================================
function setPresaleParticipants(address[] memory participants, uint allocation)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function setProvenanceHash(string memory pHash)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
// only allow provenance to be set once
require(<FILL_ME>)
provenanceHash = pHash;
}
function toggleSaleState(uint8 state)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function changeMintPrice(uint256 _newPrice)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function setBaseUri(string memory _newBaseUri)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function updateTokenURI(uint256 _tokenId, string memory _newTokenURI)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function mintComposerEdition()
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function reserveTokens(address recipient, uint numTokens)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function withdrawFunds(address payable recipient, uint256 amount)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
// ====================================================
// INTERNAL UTILS
// ====================================================
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function internalOmMint(address recipient, uint numTokens, TokenSaleState _tokenSaleState)
internal
{
}
// ====================================================
// PUBLIC API
// ====================================================
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function getSupplyData()
public
view
returns(
uint256 _currentToken,
uint256 _maxSupply,
uint256 _mintPrice,
TokenSaleState _tokenSaleState,
bool _isTokenHolder)
{
}
function validateTokenForBurn(uint256 tIndex)
public
view
returns(bool burnable, string memory message)
{
}
function presaleMint(uint8 numTokens)
public
payable
{
}
function publicMint(uint numTokens)
public
payable
{
}
function burnTokens(uint256 token1, uint256 token2, uint256 token3)
public
{
}
}
| bytes(provenanceHash).length==0,"Provenance hash already set" | 368,621 | bytes(provenanceHash).length==0 |
"Request will exceed composer editions max" | //SPDX-License-Identifier: MIT
/*
<__ / ___ ___ / __> ___ _ _ <_> ___ ___ |_ / ___ _ _ ___
<_ \/ . | |___| \__ \/ ._>| '_>| |/ ._><_-< / / / ._>| '_>/ . \
<___/\_ | <___/\___.|_| |_|\___./__/ /___|\___.|_| \___/
*/
pragma solidity 0.8.11;
pragma abicoder v2;
import "./ERC721.sol";
import "./AccessControl.sol";
import "./Counters.sol";
import "./Strings.sol";
contract ThreeQSeriesZeroERC721 is ERC721, AccessControl
{
using Counters for Counters.Counter;
using Strings for uint256;
// ====================================================
// ROLES
// ====================================================
bytes32 public constant PROJECT_ADMINS_ROLE = keccak256("PROJECT_ADMINS_ROLE");
// ====================================================
// EVENTS
// ====================================================
event TokenUriUpdated(uint256 tokenId, string uri);
event TokenMinted(uint256 tokenIndex, address minter, TokenSaleState saleStatus);
event SupremeMinted(uint256 omToken1, uint256 omToken2, uint256 onToken3, uint256 supremeToken);
event MintPriceChanged(uint256 newPrice);
// ====================================================
// ENUMS & STRUCTS
// ====================================================
enum TokenSaleState { PAUSED, AUCTION, PRE_SALE, PUBLIC_SALE, OM_BURN }
enum TokenType { OM, SUPREME }
struct TokenDetails {
uint256 tokenIndex;
TokenType tokenType;
uint256[3] burnedTokens;
}
// ====================================================
// STATE
// ====================================================
// supply/reservation constants
uint public constant MAX_PER_TX = 6;
uint public constant MAX_COMPOSER_EDITIONS = 5;
uint public constant MAX_RESERVED = 133;
uint public constant MAX_OM_SUPPLY = 3338;
// metadata
string private _baseURIExtended;
mapping (uint256 => string) private _tokenURIs;
// general vars, counter, etc
Counters.Counter private _tokenIdCounter;
Counters.Counter private _composerEditionCounter;
uint private _reservedTokensCounter;
TokenSaleState public tokenSaleState = TokenSaleState.PAUSED;
uint256 public mintPrice = 0.1 ether;
string public provenanceHash;
mapping (uint256 => TokenDetails) public tokenData;
mapping(address => uint) public presaleParticipants;
// ====================================================
// CONSTRUCTOR
// ====================================================
constructor(
string memory _name,
string memory _symbol,
string memory _baseUri
)
ERC721(_name, _symbol)
{
}
// ====================================================
// OVERRIDES
// ====================================================
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, AccessControl)
returns (bool)
{
}
// ====================================================
// ADMIN
// ====================================================
function setPresaleParticipants(address[] memory participants, uint allocation)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function setProvenanceHash(string memory pHash)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function toggleSaleState(uint8 state)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function changeMintPrice(uint256 _newPrice)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function setBaseUri(string memory _newBaseUri)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function updateTokenURI(uint256 _tokenId, string memory _newTokenURI)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function mintComposerEdition()
public
onlyRole(PROJECT_ADMINS_ROLE)
{
require(<FILL_ME>)
internalOmMint(msg.sender, 1, TokenSaleState.AUCTION);
_composerEditionCounter.increment();
}
function reserveTokens(address recipient, uint numTokens)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function withdrawFunds(address payable recipient, uint256 amount)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
// ====================================================
// INTERNAL UTILS
// ====================================================
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function internalOmMint(address recipient, uint numTokens, TokenSaleState _tokenSaleState)
internal
{
}
// ====================================================
// PUBLIC API
// ====================================================
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function getSupplyData()
public
view
returns(
uint256 _currentToken,
uint256 _maxSupply,
uint256 _mintPrice,
TokenSaleState _tokenSaleState,
bool _isTokenHolder)
{
}
function validateTokenForBurn(uint256 tIndex)
public
view
returns(bool burnable, string memory message)
{
}
function presaleMint(uint8 numTokens)
public
payable
{
}
function publicMint(uint numTokens)
public
payable
{
}
function burnTokens(uint256 token1, uint256 token2, uint256 token3)
public
{
}
}
| _composerEditionCounter.current()<MAX_COMPOSER_EDITIONS,"Request will exceed composer editions max" | 368,621 | _composerEditionCounter.current()<MAX_COMPOSER_EDITIONS |
"Request will exceed reserve max" | //SPDX-License-Identifier: MIT
/*
<__ / ___ ___ / __> ___ _ _ <_> ___ ___ |_ / ___ _ _ ___
<_ \/ . | |___| \__ \/ ._>| '_>| |/ ._><_-< / / / ._>| '_>/ . \
<___/\_ | <___/\___.|_| |_|\___./__/ /___|\___.|_| \___/
*/
pragma solidity 0.8.11;
pragma abicoder v2;
import "./ERC721.sol";
import "./AccessControl.sol";
import "./Counters.sol";
import "./Strings.sol";
contract ThreeQSeriesZeroERC721 is ERC721, AccessControl
{
using Counters for Counters.Counter;
using Strings for uint256;
// ====================================================
// ROLES
// ====================================================
bytes32 public constant PROJECT_ADMINS_ROLE = keccak256("PROJECT_ADMINS_ROLE");
// ====================================================
// EVENTS
// ====================================================
event TokenUriUpdated(uint256 tokenId, string uri);
event TokenMinted(uint256 tokenIndex, address minter, TokenSaleState saleStatus);
event SupremeMinted(uint256 omToken1, uint256 omToken2, uint256 onToken3, uint256 supremeToken);
event MintPriceChanged(uint256 newPrice);
// ====================================================
// ENUMS & STRUCTS
// ====================================================
enum TokenSaleState { PAUSED, AUCTION, PRE_SALE, PUBLIC_SALE, OM_BURN }
enum TokenType { OM, SUPREME }
struct TokenDetails {
uint256 tokenIndex;
TokenType tokenType;
uint256[3] burnedTokens;
}
// ====================================================
// STATE
// ====================================================
// supply/reservation constants
uint public constant MAX_PER_TX = 6;
uint public constant MAX_COMPOSER_EDITIONS = 5;
uint public constant MAX_RESERVED = 133;
uint public constant MAX_OM_SUPPLY = 3338;
// metadata
string private _baseURIExtended;
mapping (uint256 => string) private _tokenURIs;
// general vars, counter, etc
Counters.Counter private _tokenIdCounter;
Counters.Counter private _composerEditionCounter;
uint private _reservedTokensCounter;
TokenSaleState public tokenSaleState = TokenSaleState.PAUSED;
uint256 public mintPrice = 0.1 ether;
string public provenanceHash;
mapping (uint256 => TokenDetails) public tokenData;
mapping(address => uint) public presaleParticipants;
// ====================================================
// CONSTRUCTOR
// ====================================================
constructor(
string memory _name,
string memory _symbol,
string memory _baseUri
)
ERC721(_name, _symbol)
{
}
// ====================================================
// OVERRIDES
// ====================================================
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, AccessControl)
returns (bool)
{
}
// ====================================================
// ADMIN
// ====================================================
function setPresaleParticipants(address[] memory participants, uint allocation)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function setProvenanceHash(string memory pHash)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function toggleSaleState(uint8 state)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function changeMintPrice(uint256 _newPrice)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function setBaseUri(string memory _newBaseUri)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function updateTokenURI(uint256 _tokenId, string memory _newTokenURI)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function mintComposerEdition()
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function reserveTokens(address recipient, uint numTokens)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
require(<FILL_ME>)
internalOmMint(recipient, numTokens, TokenSaleState.PRE_SALE);
_reservedTokensCounter += numTokens;
}
function withdrawFunds(address payable recipient, uint256 amount)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
// ====================================================
// INTERNAL UTILS
// ====================================================
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function internalOmMint(address recipient, uint numTokens, TokenSaleState _tokenSaleState)
internal
{
}
// ====================================================
// PUBLIC API
// ====================================================
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function getSupplyData()
public
view
returns(
uint256 _currentToken,
uint256 _maxSupply,
uint256 _mintPrice,
TokenSaleState _tokenSaleState,
bool _isTokenHolder)
{
}
function validateTokenForBurn(uint256 tIndex)
public
view
returns(bool burnable, string memory message)
{
}
function presaleMint(uint8 numTokens)
public
payable
{
}
function publicMint(uint numTokens)
public
payable
{
}
function burnTokens(uint256 token1, uint256 token2, uint256 token3)
public
{
}
}
| _reservedTokensCounter+numTokens<=MAX_RESERVED,"Request will exceed reserve max" | 368,621 | _reservedTokensCounter+numTokens<=MAX_RESERVED |
"Purchase would exceed max supply" | //SPDX-License-Identifier: MIT
/*
<__ / ___ ___ / __> ___ _ _ <_> ___ ___ |_ / ___ _ _ ___
<_ \/ . | |___| \__ \/ ._>| '_>| |/ ._><_-< / / / ._>| '_>/ . \
<___/\_ | <___/\___.|_| |_|\___./__/ /___|\___.|_| \___/
*/
pragma solidity 0.8.11;
pragma abicoder v2;
import "./ERC721.sol";
import "./AccessControl.sol";
import "./Counters.sol";
import "./Strings.sol";
contract ThreeQSeriesZeroERC721 is ERC721, AccessControl
{
using Counters for Counters.Counter;
using Strings for uint256;
// ====================================================
// ROLES
// ====================================================
bytes32 public constant PROJECT_ADMINS_ROLE = keccak256("PROJECT_ADMINS_ROLE");
// ====================================================
// EVENTS
// ====================================================
event TokenUriUpdated(uint256 tokenId, string uri);
event TokenMinted(uint256 tokenIndex, address minter, TokenSaleState saleStatus);
event SupremeMinted(uint256 omToken1, uint256 omToken2, uint256 onToken3, uint256 supremeToken);
event MintPriceChanged(uint256 newPrice);
// ====================================================
// ENUMS & STRUCTS
// ====================================================
enum TokenSaleState { PAUSED, AUCTION, PRE_SALE, PUBLIC_SALE, OM_BURN }
enum TokenType { OM, SUPREME }
struct TokenDetails {
uint256 tokenIndex;
TokenType tokenType;
uint256[3] burnedTokens;
}
// ====================================================
// STATE
// ====================================================
// supply/reservation constants
uint public constant MAX_PER_TX = 6;
uint public constant MAX_COMPOSER_EDITIONS = 5;
uint public constant MAX_RESERVED = 133;
uint public constant MAX_OM_SUPPLY = 3338;
// metadata
string private _baseURIExtended;
mapping (uint256 => string) private _tokenURIs;
// general vars, counter, etc
Counters.Counter private _tokenIdCounter;
Counters.Counter private _composerEditionCounter;
uint private _reservedTokensCounter;
TokenSaleState public tokenSaleState = TokenSaleState.PAUSED;
uint256 public mintPrice = 0.1 ether;
string public provenanceHash;
mapping (uint256 => TokenDetails) public tokenData;
mapping(address => uint) public presaleParticipants;
// ====================================================
// CONSTRUCTOR
// ====================================================
constructor(
string memory _name,
string memory _symbol,
string memory _baseUri
)
ERC721(_name, _symbol)
{
}
// ====================================================
// OVERRIDES
// ====================================================
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, AccessControl)
returns (bool)
{
}
// ====================================================
// ADMIN
// ====================================================
function setPresaleParticipants(address[] memory participants, uint allocation)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function setProvenanceHash(string memory pHash)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function toggleSaleState(uint8 state)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function changeMintPrice(uint256 _newPrice)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function setBaseUri(string memory _newBaseUri)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function updateTokenURI(uint256 _tokenId, string memory _newTokenURI)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function mintComposerEdition()
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function reserveTokens(address recipient, uint numTokens)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function withdrawFunds(address payable recipient, uint256 amount)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
// ====================================================
// INTERNAL UTILS
// ====================================================
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function internalOmMint(address recipient, uint numTokens, TokenSaleState _tokenSaleState)
internal
{
require(<FILL_ME>)
for (uint i = 0; i < numTokens; i++) {
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(recipient, tokenId);
tokenData[tokenId] = TokenDetails({
tokenIndex: tokenId,
tokenType: TokenType.OM,
burnedTokens: [uint256(0) , uint256(0), uint256(0)]
});
emit TokenMinted(tokenId, recipient, _tokenSaleState);
}
}
// ====================================================
// PUBLIC API
// ====================================================
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function getSupplyData()
public
view
returns(
uint256 _currentToken,
uint256 _maxSupply,
uint256 _mintPrice,
TokenSaleState _tokenSaleState,
bool _isTokenHolder)
{
}
function validateTokenForBurn(uint256 tIndex)
public
view
returns(bool burnable, string memory message)
{
}
function presaleMint(uint8 numTokens)
public
payable
{
}
function publicMint(uint numTokens)
public
payable
{
}
function burnTokens(uint256 token1, uint256 token2, uint256 token3)
public
{
}
}
| _tokenIdCounter.current()+numTokens<=MAX_OM_SUPPLY,"Purchase would exceed max supply" | 368,621 | _tokenIdCounter.current()+numTokens<=MAX_OM_SUPPLY |
"1st provided token not of type OM" | //SPDX-License-Identifier: MIT
/*
<__ / ___ ___ / __> ___ _ _ <_> ___ ___ |_ / ___ _ _ ___
<_ \/ . | |___| \__ \/ ._>| '_>| |/ ._><_-< / / / ._>| '_>/ . \
<___/\_ | <___/\___.|_| |_|\___./__/ /___|\___.|_| \___/
*/
pragma solidity 0.8.11;
pragma abicoder v2;
import "./ERC721.sol";
import "./AccessControl.sol";
import "./Counters.sol";
import "./Strings.sol";
contract ThreeQSeriesZeroERC721 is ERC721, AccessControl
{
using Counters for Counters.Counter;
using Strings for uint256;
// ====================================================
// ROLES
// ====================================================
bytes32 public constant PROJECT_ADMINS_ROLE = keccak256("PROJECT_ADMINS_ROLE");
// ====================================================
// EVENTS
// ====================================================
event TokenUriUpdated(uint256 tokenId, string uri);
event TokenMinted(uint256 tokenIndex, address minter, TokenSaleState saleStatus);
event SupremeMinted(uint256 omToken1, uint256 omToken2, uint256 onToken3, uint256 supremeToken);
event MintPriceChanged(uint256 newPrice);
// ====================================================
// ENUMS & STRUCTS
// ====================================================
enum TokenSaleState { PAUSED, AUCTION, PRE_SALE, PUBLIC_SALE, OM_BURN }
enum TokenType { OM, SUPREME }
struct TokenDetails {
uint256 tokenIndex;
TokenType tokenType;
uint256[3] burnedTokens;
}
// ====================================================
// STATE
// ====================================================
// supply/reservation constants
uint public constant MAX_PER_TX = 6;
uint public constant MAX_COMPOSER_EDITIONS = 5;
uint public constant MAX_RESERVED = 133;
uint public constant MAX_OM_SUPPLY = 3338;
// metadata
string private _baseURIExtended;
mapping (uint256 => string) private _tokenURIs;
// general vars, counter, etc
Counters.Counter private _tokenIdCounter;
Counters.Counter private _composerEditionCounter;
uint private _reservedTokensCounter;
TokenSaleState public tokenSaleState = TokenSaleState.PAUSED;
uint256 public mintPrice = 0.1 ether;
string public provenanceHash;
mapping (uint256 => TokenDetails) public tokenData;
mapping(address => uint) public presaleParticipants;
// ====================================================
// CONSTRUCTOR
// ====================================================
constructor(
string memory _name,
string memory _symbol,
string memory _baseUri
)
ERC721(_name, _symbol)
{
}
// ====================================================
// OVERRIDES
// ====================================================
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, AccessControl)
returns (bool)
{
}
// ====================================================
// ADMIN
// ====================================================
function setPresaleParticipants(address[] memory participants, uint allocation)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function setProvenanceHash(string memory pHash)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function toggleSaleState(uint8 state)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function changeMintPrice(uint256 _newPrice)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function setBaseUri(string memory _newBaseUri)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function updateTokenURI(uint256 _tokenId, string memory _newTokenURI)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function mintComposerEdition()
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function reserveTokens(address recipient, uint numTokens)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function withdrawFunds(address payable recipient, uint256 amount)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
// ====================================================
// INTERNAL UTILS
// ====================================================
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function internalOmMint(address recipient, uint numTokens, TokenSaleState _tokenSaleState)
internal
{
}
// ====================================================
// PUBLIC API
// ====================================================
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function getSupplyData()
public
view
returns(
uint256 _currentToken,
uint256 _maxSupply,
uint256 _mintPrice,
TokenSaleState _tokenSaleState,
bool _isTokenHolder)
{
}
function validateTokenForBurn(uint256 tIndex)
public
view
returns(bool burnable, string memory message)
{
}
function presaleMint(uint8 numTokens)
public
payable
{
}
function publicMint(uint numTokens)
public
payable
{
}
function burnTokens(uint256 token1, uint256 token2, uint256 token3)
public
{
require(tokenSaleState == TokenSaleState.OM_BURN, "Burn phase is not active");
// ensure requested burn tokens are owned by sender
require(msg.sender == ownerOf(token1), "1st provided token not owned");
require(msg.sender == ownerOf(token2), "2nd provided token not owned");
require(msg.sender == ownerOf(token3), "3rd provided token not owned");
// ensure requested burn tokens are OM tokens
require(<FILL_ME>)
require(tokenData[token2].tokenType == TokenType.OM, "2nd provided token not of type OM");
require(tokenData[token3].tokenType == TokenType.OM, "3rd provided token not of type OM");
// burn OM tokens
_burn(token1);
_burn(token2);
_burn(token3);
// mint supreme token
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
tokenData[tokenId] = TokenDetails({
tokenIndex: tokenId,
tokenType: TokenType.SUPREME,
burnedTokens: [token1, token2, token3]
});
emit SupremeMinted(token1, token2, token3, tokenId);
}
}
| tokenData[token1].tokenType==TokenType.OM,"1st provided token not of type OM" | 368,621 | tokenData[token1].tokenType==TokenType.OM |
"2nd provided token not of type OM" | //SPDX-License-Identifier: MIT
/*
<__ / ___ ___ / __> ___ _ _ <_> ___ ___ |_ / ___ _ _ ___
<_ \/ . | |___| \__ \/ ._>| '_>| |/ ._><_-< / / / ._>| '_>/ . \
<___/\_ | <___/\___.|_| |_|\___./__/ /___|\___.|_| \___/
*/
pragma solidity 0.8.11;
pragma abicoder v2;
import "./ERC721.sol";
import "./AccessControl.sol";
import "./Counters.sol";
import "./Strings.sol";
contract ThreeQSeriesZeroERC721 is ERC721, AccessControl
{
using Counters for Counters.Counter;
using Strings for uint256;
// ====================================================
// ROLES
// ====================================================
bytes32 public constant PROJECT_ADMINS_ROLE = keccak256("PROJECT_ADMINS_ROLE");
// ====================================================
// EVENTS
// ====================================================
event TokenUriUpdated(uint256 tokenId, string uri);
event TokenMinted(uint256 tokenIndex, address minter, TokenSaleState saleStatus);
event SupremeMinted(uint256 omToken1, uint256 omToken2, uint256 onToken3, uint256 supremeToken);
event MintPriceChanged(uint256 newPrice);
// ====================================================
// ENUMS & STRUCTS
// ====================================================
enum TokenSaleState { PAUSED, AUCTION, PRE_SALE, PUBLIC_SALE, OM_BURN }
enum TokenType { OM, SUPREME }
struct TokenDetails {
uint256 tokenIndex;
TokenType tokenType;
uint256[3] burnedTokens;
}
// ====================================================
// STATE
// ====================================================
// supply/reservation constants
uint public constant MAX_PER_TX = 6;
uint public constant MAX_COMPOSER_EDITIONS = 5;
uint public constant MAX_RESERVED = 133;
uint public constant MAX_OM_SUPPLY = 3338;
// metadata
string private _baseURIExtended;
mapping (uint256 => string) private _tokenURIs;
// general vars, counter, etc
Counters.Counter private _tokenIdCounter;
Counters.Counter private _composerEditionCounter;
uint private _reservedTokensCounter;
TokenSaleState public tokenSaleState = TokenSaleState.PAUSED;
uint256 public mintPrice = 0.1 ether;
string public provenanceHash;
mapping (uint256 => TokenDetails) public tokenData;
mapping(address => uint) public presaleParticipants;
// ====================================================
// CONSTRUCTOR
// ====================================================
constructor(
string memory _name,
string memory _symbol,
string memory _baseUri
)
ERC721(_name, _symbol)
{
}
// ====================================================
// OVERRIDES
// ====================================================
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, AccessControl)
returns (bool)
{
}
// ====================================================
// ADMIN
// ====================================================
function setPresaleParticipants(address[] memory participants, uint allocation)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function setProvenanceHash(string memory pHash)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function toggleSaleState(uint8 state)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function changeMintPrice(uint256 _newPrice)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function setBaseUri(string memory _newBaseUri)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function updateTokenURI(uint256 _tokenId, string memory _newTokenURI)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function mintComposerEdition()
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function reserveTokens(address recipient, uint numTokens)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function withdrawFunds(address payable recipient, uint256 amount)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
// ====================================================
// INTERNAL UTILS
// ====================================================
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function internalOmMint(address recipient, uint numTokens, TokenSaleState _tokenSaleState)
internal
{
}
// ====================================================
// PUBLIC API
// ====================================================
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function getSupplyData()
public
view
returns(
uint256 _currentToken,
uint256 _maxSupply,
uint256 _mintPrice,
TokenSaleState _tokenSaleState,
bool _isTokenHolder)
{
}
function validateTokenForBurn(uint256 tIndex)
public
view
returns(bool burnable, string memory message)
{
}
function presaleMint(uint8 numTokens)
public
payable
{
}
function publicMint(uint numTokens)
public
payable
{
}
function burnTokens(uint256 token1, uint256 token2, uint256 token3)
public
{
require(tokenSaleState == TokenSaleState.OM_BURN, "Burn phase is not active");
// ensure requested burn tokens are owned by sender
require(msg.sender == ownerOf(token1), "1st provided token not owned");
require(msg.sender == ownerOf(token2), "2nd provided token not owned");
require(msg.sender == ownerOf(token3), "3rd provided token not owned");
// ensure requested burn tokens are OM tokens
require(tokenData[token1].tokenType == TokenType.OM, "1st provided token not of type OM");
require(<FILL_ME>)
require(tokenData[token3].tokenType == TokenType.OM, "3rd provided token not of type OM");
// burn OM tokens
_burn(token1);
_burn(token2);
_burn(token3);
// mint supreme token
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
tokenData[tokenId] = TokenDetails({
tokenIndex: tokenId,
tokenType: TokenType.SUPREME,
burnedTokens: [token1, token2, token3]
});
emit SupremeMinted(token1, token2, token3, tokenId);
}
}
| tokenData[token2].tokenType==TokenType.OM,"2nd provided token not of type OM" | 368,621 | tokenData[token2].tokenType==TokenType.OM |
"3rd provided token not of type OM" | //SPDX-License-Identifier: MIT
/*
<__ / ___ ___ / __> ___ _ _ <_> ___ ___ |_ / ___ _ _ ___
<_ \/ . | |___| \__ \/ ._>| '_>| |/ ._><_-< / / / ._>| '_>/ . \
<___/\_ | <___/\___.|_| |_|\___./__/ /___|\___.|_| \___/
*/
pragma solidity 0.8.11;
pragma abicoder v2;
import "./ERC721.sol";
import "./AccessControl.sol";
import "./Counters.sol";
import "./Strings.sol";
contract ThreeQSeriesZeroERC721 is ERC721, AccessControl
{
using Counters for Counters.Counter;
using Strings for uint256;
// ====================================================
// ROLES
// ====================================================
bytes32 public constant PROJECT_ADMINS_ROLE = keccak256("PROJECT_ADMINS_ROLE");
// ====================================================
// EVENTS
// ====================================================
event TokenUriUpdated(uint256 tokenId, string uri);
event TokenMinted(uint256 tokenIndex, address minter, TokenSaleState saleStatus);
event SupremeMinted(uint256 omToken1, uint256 omToken2, uint256 onToken3, uint256 supremeToken);
event MintPriceChanged(uint256 newPrice);
// ====================================================
// ENUMS & STRUCTS
// ====================================================
enum TokenSaleState { PAUSED, AUCTION, PRE_SALE, PUBLIC_SALE, OM_BURN }
enum TokenType { OM, SUPREME }
struct TokenDetails {
uint256 tokenIndex;
TokenType tokenType;
uint256[3] burnedTokens;
}
// ====================================================
// STATE
// ====================================================
// supply/reservation constants
uint public constant MAX_PER_TX = 6;
uint public constant MAX_COMPOSER_EDITIONS = 5;
uint public constant MAX_RESERVED = 133;
uint public constant MAX_OM_SUPPLY = 3338;
// metadata
string private _baseURIExtended;
mapping (uint256 => string) private _tokenURIs;
// general vars, counter, etc
Counters.Counter private _tokenIdCounter;
Counters.Counter private _composerEditionCounter;
uint private _reservedTokensCounter;
TokenSaleState public tokenSaleState = TokenSaleState.PAUSED;
uint256 public mintPrice = 0.1 ether;
string public provenanceHash;
mapping (uint256 => TokenDetails) public tokenData;
mapping(address => uint) public presaleParticipants;
// ====================================================
// CONSTRUCTOR
// ====================================================
constructor(
string memory _name,
string memory _symbol,
string memory _baseUri
)
ERC721(_name, _symbol)
{
}
// ====================================================
// OVERRIDES
// ====================================================
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, AccessControl)
returns (bool)
{
}
// ====================================================
// ADMIN
// ====================================================
function setPresaleParticipants(address[] memory participants, uint allocation)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function setProvenanceHash(string memory pHash)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function toggleSaleState(uint8 state)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function changeMintPrice(uint256 _newPrice)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function setBaseUri(string memory _newBaseUri)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function updateTokenURI(uint256 _tokenId, string memory _newTokenURI)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function mintComposerEdition()
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function reserveTokens(address recipient, uint numTokens)
public
onlyRole(PROJECT_ADMINS_ROLE)
{
}
function withdrawFunds(address payable recipient, uint256 amount)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
// ====================================================
// INTERNAL UTILS
// ====================================================
function _baseURI()
internal
view
virtual
override
returns (string memory)
{
}
function internalOmMint(address recipient, uint numTokens, TokenSaleState _tokenSaleState)
internal
{
}
// ====================================================
// PUBLIC API
// ====================================================
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function getSupplyData()
public
view
returns(
uint256 _currentToken,
uint256 _maxSupply,
uint256 _mintPrice,
TokenSaleState _tokenSaleState,
bool _isTokenHolder)
{
}
function validateTokenForBurn(uint256 tIndex)
public
view
returns(bool burnable, string memory message)
{
}
function presaleMint(uint8 numTokens)
public
payable
{
}
function publicMint(uint numTokens)
public
payable
{
}
function burnTokens(uint256 token1, uint256 token2, uint256 token3)
public
{
require(tokenSaleState == TokenSaleState.OM_BURN, "Burn phase is not active");
// ensure requested burn tokens are owned by sender
require(msg.sender == ownerOf(token1), "1st provided token not owned");
require(msg.sender == ownerOf(token2), "2nd provided token not owned");
require(msg.sender == ownerOf(token3), "3rd provided token not owned");
// ensure requested burn tokens are OM tokens
require(tokenData[token1].tokenType == TokenType.OM, "1st provided token not of type OM");
require(tokenData[token2].tokenType == TokenType.OM, "2nd provided token not of type OM");
require(<FILL_ME>)
// burn OM tokens
_burn(token1);
_burn(token2);
_burn(token3);
// mint supreme token
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
tokenData[tokenId] = TokenDetails({
tokenIndex: tokenId,
tokenType: TokenType.SUPREME,
burnedTokens: [token1, token2, token3]
});
emit SupremeMinted(token1, token2, token3, tokenId);
}
}
| tokenData[token3].tokenType==TokenType.OM,"3rd provided token not of type OM" | 368,621 | tokenData[token3].tokenType==TokenType.OM |
'!tokenBanned' | // SPDX-License-Identifier: UNLICENSED
// _ _ _ _ __ _
// | | (_) | | | / _(_)
// | | ___| |_| |_ ___ _ __ | |_ _ _ __ __ _ _ __ ___ ___
// | |/ / | __| __/ _ \ '_ \ | _| | '_ \ / _` | '_ \ / __/ _ \
// | <| | |_| || __/ | | |_| | | | | | | (_| | | | | (_| __/
// |_|\_\_|\__|\__\___|_| |_(_)_| |_|_| |_|\__,_|_| |_|\___\___|
//
// Kitten.Finance Lending
//
// https://Kitten.Finance
// https://kittenswap.org
//
pragma solidity ^0.6.12;
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) {
}
}
////////////////////////////////////////////////////////////////////////////////
interface ERC20
{
function balanceOf ( address account ) external view returns ( uint256 );
function transfer ( address recipient, uint256 amount ) external returns ( bool );
function transferFrom ( address sender, address recipient, uint256 amount ) external returns ( bool );
}
////////////////////////////////////////////////////////////////////////////////
contract KittenLending
{
using SafeMath for uint;
////////////////////////////////////////////////////////////////////////////////
address public govAddr;
address public treasuryAddr;
uint public treasuryAmtTotal = 0;
constructor () public {
}
modifier govOnly() {
}
function govTransferAddr(address newAddr) external govOnly {
}
function govSetTreasury(address newAddr) external govOnly
{
}
uint8 public DEFAULT_devFeeBP = 0;
function govSet_DEFAULT_devFeeBP(uint8 $DEFAULT_devFeeBP) external govOnly {
}
function govSet_devFeeBP(uint vaultId, uint8 $devFeeBP) external govOnly {
}
mapping (address => uint) public tokenStatus; // 0 = normal, if >= TOKEN_STATUS_BANNED then banned
uint constant TOKEN_STATUS_BANNED = 1e60;
uint8 constant VAULT_STATUS_BANNED = 200;
function govSet_tokenStatus(address token, uint $tokenStatus) external govOnly {
}
function govSet_vaultStatus(uint vaultId, uint8 $vaultStatus) external govOnly {
}
////////////////////////////////////////////////////////////////////////////////
struct VAULT_INFO
{
address token; // underlying token
uint32 tEnd; // timestamp
uint128 priceEndScaled; // scaled by PRICE_SCALE
uint24 apyBP; // APY%% in Basis Points
uint8 devFeeBP; // devFee%% in Basis Points
uint8 vaultStatus; // 0 = new, if >= VAULT_STATUS_BANNED then banned
mapping (address => uint) share; // deposit ETH for vaultShare
uint shareTotal;
mapping (address => uint) tllll; // token locked
uint tllllTotal;
uint ethTotal;
}
uint constant PRICE_SCALE = 10 ** 18;
VAULT_INFO[] public VAULT;
event CREATE_VAULT(address indexed token, uint indexed vaultId, address indexed user, uint32 tEnd, uint128 priceEndScaled, uint24 apyBP);
function createVault(address token, uint32 tEnd, uint128 priceEndScaled, uint24 apyBP) external
{
VAULT_INFO memory m;
require (token != address(0), "!token");
require(<FILL_ME>)
require (tEnd > block.timestamp, "!tEnd");
require (priceEndScaled > 0, "!priceEndScaled");
require (apyBP > 0, "!apyBP");
m.token = token;
m.tEnd = tEnd;
m.priceEndScaled = priceEndScaled;
m.apyBP = apyBP;
m.devFeeBP = DEFAULT_devFeeBP;
if (msg.sender == govAddr) {
m.vaultStatus = 100;
}
VAULT.push(m);
emit CREATE_VAULT(token, VAULT.length - 1, msg.sender, tEnd, priceEndScaled, apyBP);
}
////////////////////////////////////////////////////////////////////////////////
function vaultCount() external view returns (uint)
{
}
function getVaultStatForUser(uint vaultId, address user) external view returns (uint share, uint tllll)
{
}
////////////////////////////////////////////////////////////////////////////////
function getVaultValueInEth(uint vaultId) public view returns (uint)
{
}
function getVaultPriceScaled(uint vaultId) public view returns (uint)
{
}
////////////////////////////////////////////////////////////////////////////////
event LOCK_ETH(uint indexed vaultId, address indexed user, uint ethAmt, uint shareAmt);
event UNLOCK_ETH(uint indexed vaultId, address indexed user, uint ethAmt, uint shareAmt);
function _mintShare(VAULT_INFO storage m, address user, uint mintAmt) internal {
}
function _burnShare(VAULT_INFO storage m, address user, uint burnAmt) internal {
}
function _mintTllll(VAULT_INFO storage m, address user, uint mintAmt) internal {
}
function _burnTllll(VAULT_INFO storage m, address user, uint burnAmt) internal {
}
function _sendEth(VAULT_INFO storage m, address payable user, uint outAmt) internal {
}
function lockEth(uint vaultId) external payable // lock ETH for lending, and mint vaultShare
{
}
function unlockEth(uint vaultId, uint shareBurnAmt) external // unlock ETH, and burn vaultShare
{
}
////////////////////////////////////////////////////////////////////////////////
event LOCK_TOKEN(uint indexed vaultId, address indexed user, uint tokenAmt, uint ethAmt);
event UNLOCK_TOKEN(uint indexed vaultId, address indexed user, uint tokenAmt, uint ethAmt);
function lockToken(uint vaultId, uint tokenInAmt) external // lock TOKEN to borrow ETH
{
}
function unlockToken(uint vaultId) external payable // payback ETH to unlock TOKEN
{
}
////////////////////////////////////////////////////////////////////////////////
event EXIT_SHARE(uint indexed vaultId, address indexed user, uint shareAmt);
function exitShare(uint vaultId, address payable user) external // exit vaultShare after vault is closed
{
}
////////////////////////////////////////////////////////////////////////////////
function treasurySend(uint amt) external
{
}
}
| tokenStatus[token]<TOKEN_STATUS_BANNED,'!tokenBanned' | 368,671 | tokenStatus[token]<TOKEN_STATUS_BANNED |
'!tokenBanned' | // SPDX-License-Identifier: UNLICENSED
// _ _ _ _ __ _
// | | (_) | | | / _(_)
// | | ___| |_| |_ ___ _ __ | |_ _ _ __ __ _ _ __ ___ ___
// | |/ / | __| __/ _ \ '_ \ | _| | '_ \ / _` | '_ \ / __/ _ \
// | <| | |_| || __/ | | |_| | | | | | | (_| | | | | (_| __/
// |_|\_\_|\__|\__\___|_| |_(_)_| |_|_| |_|\__,_|_| |_|\___\___|
//
// Kitten.Finance Lending
//
// https://Kitten.Finance
// https://kittenswap.org
//
pragma solidity ^0.6.12;
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) {
}
}
////////////////////////////////////////////////////////////////////////////////
interface ERC20
{
function balanceOf ( address account ) external view returns ( uint256 );
function transfer ( address recipient, uint256 amount ) external returns ( bool );
function transferFrom ( address sender, address recipient, uint256 amount ) external returns ( bool );
}
////////////////////////////////////////////////////////////////////////////////
contract KittenLending
{
using SafeMath for uint;
////////////////////////////////////////////////////////////////////////////////
address public govAddr;
address public treasuryAddr;
uint public treasuryAmtTotal = 0;
constructor () public {
}
modifier govOnly() {
}
function govTransferAddr(address newAddr) external govOnly {
}
function govSetTreasury(address newAddr) external govOnly
{
}
uint8 public DEFAULT_devFeeBP = 0;
function govSet_DEFAULT_devFeeBP(uint8 $DEFAULT_devFeeBP) external govOnly {
}
function govSet_devFeeBP(uint vaultId, uint8 $devFeeBP) external govOnly {
}
mapping (address => uint) public tokenStatus; // 0 = normal, if >= TOKEN_STATUS_BANNED then banned
uint constant TOKEN_STATUS_BANNED = 1e60;
uint8 constant VAULT_STATUS_BANNED = 200;
function govSet_tokenStatus(address token, uint $tokenStatus) external govOnly {
}
function govSet_vaultStatus(uint vaultId, uint8 $vaultStatus) external govOnly {
}
////////////////////////////////////////////////////////////////////////////////
struct VAULT_INFO
{
address token; // underlying token
uint32 tEnd; // timestamp
uint128 priceEndScaled; // scaled by PRICE_SCALE
uint24 apyBP; // APY%% in Basis Points
uint8 devFeeBP; // devFee%% in Basis Points
uint8 vaultStatus; // 0 = new, if >= VAULT_STATUS_BANNED then banned
mapping (address => uint) share; // deposit ETH for vaultShare
uint shareTotal;
mapping (address => uint) tllll; // token locked
uint tllllTotal;
uint ethTotal;
}
uint constant PRICE_SCALE = 10 ** 18;
VAULT_INFO[] public VAULT;
event CREATE_VAULT(address indexed token, uint indexed vaultId, address indexed user, uint32 tEnd, uint128 priceEndScaled, uint24 apyBP);
function createVault(address token, uint32 tEnd, uint128 priceEndScaled, uint24 apyBP) external
{
}
////////////////////////////////////////////////////////////////////////////////
function vaultCount() external view returns (uint)
{
}
function getVaultStatForUser(uint vaultId, address user) external view returns (uint share, uint tllll)
{
}
////////////////////////////////////////////////////////////////////////////////
function getVaultValueInEth(uint vaultId) public view returns (uint)
{
}
function getVaultPriceScaled(uint vaultId) public view returns (uint)
{
}
////////////////////////////////////////////////////////////////////////////////
event LOCK_ETH(uint indexed vaultId, address indexed user, uint ethAmt, uint shareAmt);
event UNLOCK_ETH(uint indexed vaultId, address indexed user, uint ethAmt, uint shareAmt);
function _mintShare(VAULT_INFO storage m, address user, uint mintAmt) internal {
}
function _burnShare(VAULT_INFO storage m, address user, uint burnAmt) internal {
}
function _mintTllll(VAULT_INFO storage m, address user, uint mintAmt) internal {
}
function _burnTllll(VAULT_INFO storage m, address user, uint burnAmt) internal {
}
function _sendEth(VAULT_INFO storage m, address payable user, uint outAmt) internal {
}
function lockEth(uint vaultId) external payable // lock ETH for lending, and mint vaultShare
{
}
function unlockEth(uint vaultId, uint shareBurnAmt) external // unlock ETH, and burn vaultShare
{
}
////////////////////////////////////////////////////////////////////////////////
event LOCK_TOKEN(uint indexed vaultId, address indexed user, uint tokenAmt, uint ethAmt);
event UNLOCK_TOKEN(uint indexed vaultId, address indexed user, uint tokenAmt, uint ethAmt);
function lockToken(uint vaultId, uint tokenInAmt) external // lock TOKEN to borrow ETH
{
VAULT_INFO storage m = VAULT[vaultId];
require (block.timestamp < m.tEnd, '!vaultEnded');
require (m.vaultStatus < VAULT_STATUS_BANNED, '!vaultBanned');
require(<FILL_ME>)
require (tokenInAmt > 0, '!tokenInAmt');
address payable user = msg.sender;
//-------- compute ETH out amt --------
uint ethOutAmt = tokenInAmt.mul(getVaultPriceScaled(vaultId)) / (PRICE_SCALE);
if (m.devFeeBP > 0)
{
uint treasuryAmt = ethOutAmt.mul(uint(m.devFeeBP)) / (10000);
treasuryAmtTotal = treasuryAmtTotal.add(treasuryAmt);
ethOutAmt = ethOutAmt.sub(treasuryAmt);
m.ethTotal = (m.ethTotal).sub(treasuryAmt, '!ethInVault'); // remove treasuryAmt
}
//-------- send TOKEN to contract --------
ERC20(m.token).transferFrom(user, address(this), tokenInAmt);
_mintTllll(m, user, tokenInAmt);
//-------- send ETH to user --------
_sendEth(m, user, ethOutAmt);
emit LOCK_TOKEN(vaultId, user, tokenInAmt, ethOutAmt);
}
function unlockToken(uint vaultId) external payable // payback ETH to unlock TOKEN
{
}
////////////////////////////////////////////////////////////////////////////////
event EXIT_SHARE(uint indexed vaultId, address indexed user, uint shareAmt);
function exitShare(uint vaultId, address payable user) external // exit vaultShare after vault is closed
{
}
////////////////////////////////////////////////////////////////////////////////
function treasurySend(uint amt) external
{
}
}
| tokenStatus[m.token]<TOKEN_STATUS_BANNED,'!tokenBanned' | 368,671 | tokenStatus[m.token]<TOKEN_STATUS_BANNED |
"Invalid transform" | pragma solidity ^0.8.0;
interface IDynamic1155 {
/**
* @dev Destroys `amount` tokens of token type `id` from `from`
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `from` must have at least `amount` tokens of token type `id`.
*/
function burn(
address account,
uint256 id,
uint256 value
) external;
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}
contract Migrate is Ownable {
address public token;
mapping(uint256 => mapping(uint256 => uint256)) private amountToMint;
mapping(uint256 => mapping(uint256 => uint256)) private amountToBurn;
mapping(uint256 => bool) private mintable;
event TransformAdded(uint256 indexed _typeA, uint256 indexed _typeB);
constructor(
address _token,
uint256 _typeA,
uint256 _typeB,
uint256 _amountToMint,
uint256 _amountToBurn
) {
}
function updateTokenContract(address _token) external onlyOwner {
}
function setTransform(
uint256 _typeA,
uint256 _typeB,
uint256 _amountToMint,
uint256 _amountToBurn
) external onlyOwner {
}
/**
* @dev migrate X amount of type A to type B
*/
function migration(
uint256 from,
uint256 to,
uint256 count
) external {
require(<FILL_ME>)
IDynamic1155(token).burn(
msg.sender,
from,
amountToBurn[from][to] * count
);
IDynamic1155(token).safeTransferFrom(
address(this),
msg.sender,
to,
count * amountToMint[from][to],
""
);
}
function onERC1155Received(
address,
address,
uint256 id,
uint256,
bytes memory
) public virtual returns (bytes4) {
}
}
| amountToMint[from][to]>0&&amountToBurn[from][to]>0,"Invalid transform" | 368,672 | amountToMint[from][to]>0&&amountToBurn[from][to]>0 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
/**
____________________________
Description:
GoldPesa Option Contract (GPO) - 1 GPO represents the option to purchase 1 GPX at spot gold price + 1 %.
__________________________________
*/
contract GPO is ERC20PresetFixedSupply, Pausable, Ownable, AccessControl {
// TokenSwaped event is emitted anytime there is a swap between GPO and USDC on the GoldPesa.com decentralized exchange powered by Uniswap
event TokensSwaped(
address indexed purchaser,
uint256 amountIn,
uint256 amountOut,
bool direction // false: GPO-X, true: X-GPO
);
// FeeSplit stores the "recipient" wallet address and the respective percentage of the feeOnSwap which are to be sent to it.
struct FeeSplit {
address recipient;
uint16 fee;
}
// Token Name
string public _name = "GoldPesa Option";
// Token Symbol
string public _symbol = "GPO";
// GPO Hard Cap
uint256 public constant fixedSupply = 100_000_000;
// Wallet Hard Cap
uint256 public constant capOnWallet = 100_000;
// GoldPesa fee on swap percentage
uint256 public feeOnSwap = 10;
// Uniswap Router Address
ISwapRouter public immutable swapRouter;
// USDC ERC20 token Address
address public addrUSDC;
// Uniswap V3 Pool Fee * 10000 = 1 %
uint24 private swapPoolFee = 10000;
// Uniswap V3 GPO/USDC liquidity pool address
address public authorizedPool;
// Time when Pre-Sale and Sale tokens will be unlocked (Unix Time)
uint256 public walletsTimelockedUntil;
// When freeTrade is true the token bypasses the hard cap on wallet and can be traded freely on any exchange
bool public freeTrade = false;
// The feeOnSwap percentage is distributed to the addresses and their respective percentage which are held in the feeSplits array
FeeSplit[] public feeSplits;
// Keeps a record of the number of addresses in the feeSplits array
uint256 public feeSplitsLength;
// Defines an Access Control role called "CAN_LOCK" which is granted to addresses which are allowed to lock wallet addresses during the Sale and Pre-Sale phase
bytes32 public constant AUTHORIZED_LOCK =
keccak256("CAN_LOCK");
modifier authorizedLocker() {
require(<FILL_ME>)
_;
}
// Mapping which holds information of the wallet addresses which are locked (true) /unlocked (false)
mapping(address => bool) public lockedWallets;
// Mapping which holds details of the wallet addresses which bypass the wallet hard cap and are able to swap with the Uniswap GPO/USDC liquidity pool
mapping(address => bool) public whitelistedWallets;
// Mapping which holds details of the amount of GPO tokens are locked in the lockedWallets mapping
mapping(address => uint256) public lockedWalletsAmount;
bool public swapEnabled = false;
// Upon deployment, the constructor is only executed once
constructor(
ISwapRouter _swapRouter,
uint256 _walletsTimelockedUntil
) ERC20PresetFixedSupply(_name, _symbol, hardCapOnToken(), address(this)) {
}
// Enables GoldPesa to manually transfer GPO tokens from the GPO contract to another wallet address
function transferTokensTo(address _to, uint256 amount) public onlyOwner {
}
// Enables GoldPesa to manually add or remove wallet addresses from the whitelistedWallets mapping
function changeWalletWhitelist(address _addr, bool yesOrNo) public onlyOwner {
}
// Sets the USDC contract address, the Uniswap pool fee and accordingly includes the derived Uniswap liquidity pool address to the whitelistedWallets mapping
function setPoolParameters(address USDC, uint24 poolFee) public onlyOwner {
}
// Enables GoldPesa to set the state of the contract to "freeTrade"
function switchFreeTrade() public onlyOwner {
}
function switchSwapEnabled() public onlyOwner {
}
// Enables GoldPesa to set the feeOnSwap
function setFeeOnSwap(uint24 _feeOnSwap) public onlyOwner {
}
// Enables GoldPesa to set the "feeOnSwap" distribution details
function setFeeSplits(FeeSplit[] memory _feeSplits) public onlyOwner {
}
// Distributes the feeOnSwap amount collected during any swap transaction to the addresses defined in the "feeSplits" array
function distributeFee(uint256 amount) internal {
}
// Defines the rules that must be satisfied before GPO can be transferred
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
// Internal mint function which cannot be called externally after the GPO contract is deployed ensuring that the GPO token hard cap of 100,000,000 is not breached
function _mint(address account, uint256 amount) internal virtual override {
}
// Returns the GPO token hard cap ("fixedSupply") in wei
function hardCapOnToken() public view returns (uint256) {
}
// Returns the GPO token wallet hard cap ("capOnWallet") in wei
function hardCapOnWallet() public view returns (uint256) {
}
// Returns the GoldPesa feeOnSwap in USDC which is used in the swap functions
function calculateFeeOnSwap(uint256 amount)
internal
view
returns (uint256)
{
}
// Enables GoldPesa to lock and unlock wallet address manually
function lockUnlockWallet(address account, bool yesOrNo, uint256 amount) public authorizedLocker {
}
// Pause the GPO token transfers
function pause() public onlyOwner {
}
// Unpause the GPO token transfer
function unpause() public onlyOwner {
}
// User defines the exact amount of USDC they would like to receive while swaping GPO for USDC using the GPO/USDC Uniswap V3 liquidity pool.
// Any extra GPO tokens not used in the Swap are returned back to the user.
function swapToExactOutput(uint256 amountInMaximum, uint256 amountOut, uint256 deadline) external returns (uint256 amountIn) {
}
// User defines the exact amount of GPO they would like to spend while swaping GPO for USDC using the GPO/USDC Uniswap V3 liquidity pool.
function swapToExactInput(uint256 amountIn, uint256 amountOutMinimum, uint256 deadline ) external returns (uint256 amountOut) {
}
// User defines the exact amount of GPO they would like to receive while swaping USDC for GPO using the GPO/USDC Uniswap V3 liquidity pool.
// Any extra USDC tokens not used in the Swap are returned back to the user.
function swapFromExactOutput(uint256 amountInMaximum, uint256 amountOut, uint256 deadline) external returns (uint256 amountIn) {
}
// User defines the exact amount of USDC they would like to spend while swaping USDC for GPO using the GPO/USDC Uniswap V3 liquidity pool.
function swapFromExactInput(uint256 amountIn, uint256 amountOutMinimum, uint256 deadline) external returns (uint256 amountOut) {
}
}
| hasRole(AUTHORIZED_LOCK,_msgSender()) | 368,685 | hasRole(AUTHORIZED_LOCK,_msgSender()) |
"GPO_ERR: UniswapV3 functionality is only allowed through GPO's protocol" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
/**
____________________________
Description:
GoldPesa Option Contract (GPO) - 1 GPO represents the option to purchase 1 GPX at spot gold price + 1 %.
__________________________________
*/
contract GPO is ERC20PresetFixedSupply, Pausable, Ownable, AccessControl {
// TokenSwaped event is emitted anytime there is a swap between GPO and USDC on the GoldPesa.com decentralized exchange powered by Uniswap
event TokensSwaped(
address indexed purchaser,
uint256 amountIn,
uint256 amountOut,
bool direction // false: GPO-X, true: X-GPO
);
// FeeSplit stores the "recipient" wallet address and the respective percentage of the feeOnSwap which are to be sent to it.
struct FeeSplit {
address recipient;
uint16 fee;
}
// Token Name
string public _name = "GoldPesa Option";
// Token Symbol
string public _symbol = "GPO";
// GPO Hard Cap
uint256 public constant fixedSupply = 100_000_000;
// Wallet Hard Cap
uint256 public constant capOnWallet = 100_000;
// GoldPesa fee on swap percentage
uint256 public feeOnSwap = 10;
// Uniswap Router Address
ISwapRouter public immutable swapRouter;
// USDC ERC20 token Address
address public addrUSDC;
// Uniswap V3 Pool Fee * 10000 = 1 %
uint24 private swapPoolFee = 10000;
// Uniswap V3 GPO/USDC liquidity pool address
address public authorizedPool;
// Time when Pre-Sale and Sale tokens will be unlocked (Unix Time)
uint256 public walletsTimelockedUntil;
// When freeTrade is true the token bypasses the hard cap on wallet and can be traded freely on any exchange
bool public freeTrade = false;
// The feeOnSwap percentage is distributed to the addresses and their respective percentage which are held in the feeSplits array
FeeSplit[] public feeSplits;
// Keeps a record of the number of addresses in the feeSplits array
uint256 public feeSplitsLength;
// Defines an Access Control role called "CAN_LOCK" which is granted to addresses which are allowed to lock wallet addresses during the Sale and Pre-Sale phase
bytes32 public constant AUTHORIZED_LOCK =
keccak256("CAN_LOCK");
modifier authorizedLocker() {
}
// Mapping which holds information of the wallet addresses which are locked (true) /unlocked (false)
mapping(address => bool) public lockedWallets;
// Mapping which holds details of the wallet addresses which bypass the wallet hard cap and are able to swap with the Uniswap GPO/USDC liquidity pool
mapping(address => bool) public whitelistedWallets;
// Mapping which holds details of the amount of GPO tokens are locked in the lockedWallets mapping
mapping(address => uint256) public lockedWalletsAmount;
bool public swapEnabled = false;
// Upon deployment, the constructor is only executed once
constructor(
ISwapRouter _swapRouter,
uint256 _walletsTimelockedUntil
) ERC20PresetFixedSupply(_name, _symbol, hardCapOnToken(), address(this)) {
}
// Enables GoldPesa to manually transfer GPO tokens from the GPO contract to another wallet address
function transferTokensTo(address _to, uint256 amount) public onlyOwner {
}
// Enables GoldPesa to manually add or remove wallet addresses from the whitelistedWallets mapping
function changeWalletWhitelist(address _addr, bool yesOrNo) public onlyOwner {
}
// Sets the USDC contract address, the Uniswap pool fee and accordingly includes the derived Uniswap liquidity pool address to the whitelistedWallets mapping
function setPoolParameters(address USDC, uint24 poolFee) public onlyOwner {
}
// Enables GoldPesa to set the state of the contract to "freeTrade"
function switchFreeTrade() public onlyOwner {
}
function switchSwapEnabled() public onlyOwner {
}
// Enables GoldPesa to set the feeOnSwap
function setFeeOnSwap(uint24 _feeOnSwap) public onlyOwner {
}
// Enables GoldPesa to set the "feeOnSwap" distribution details
function setFeeSplits(FeeSplit[] memory _feeSplits) public onlyOwner {
}
// Distributes the feeOnSwap amount collected during any swap transaction to the addresses defined in the "feeSplits" array
function distributeFee(uint256 amount) internal {
}
// Defines the rules that must be satisfied before GPO can be transferred
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
// Ensures that GPO token holders cannot burn their own tokens
require(to != address(0x0) || whitelistedWallets[from], "GPO_ERR: Cannot burn");
// Ensures that GPO token holders cannot execute a swap directly with the GPO/USDC liquidity pool on Uniswap. All swaps must be executed on the GoldPesa DEX unless
// "freeTrade" has be enabled
if (authorizedPool != address(0x0) && (from == authorizedPool || to == authorizedPool))
require(<FILL_ME>)
// Unless "freeTrade" has been enabled this require statement rejects any transfers to wallets which will break the 100,000 GPO wallet hard cap unless the
// receiving wallet address is a "whitelistedWallet"
require(
freeTrade ||
from == address(0x0) ||
whitelistedWallets[to] ||
balanceOf(to) + amount <= hardCapOnWallet(),
"GPO_ERR: Hard cap on wallet reached"
);
// Disables all GPO transfers if the token has been paused by GoldPesa
require(!paused(), "ERC20Pausable: token transfer while paused");
// Rejects transfers made from locked wallets which are greater than the wallet's "lockedWalletsAmount" until the date where all tokens are unlocked
require(block.timestamp >= walletsTimelockedUntil ||
!lockedWallets[from] ||
(lockedWallets[from] && amount <= (balanceOf(from) - lockedWalletsAmount[from])), "Cannot transfer token as the wallet is locked");
}
// Internal mint function which cannot be called externally after the GPO contract is deployed ensuring that the GPO token hard cap of 100,000,000 is not breached
function _mint(address account, uint256 amount) internal virtual override {
}
// Returns the GPO token hard cap ("fixedSupply") in wei
function hardCapOnToken() public view returns (uint256) {
}
// Returns the GPO token wallet hard cap ("capOnWallet") in wei
function hardCapOnWallet() public view returns (uint256) {
}
// Returns the GoldPesa feeOnSwap in USDC which is used in the swap functions
function calculateFeeOnSwap(uint256 amount)
internal
view
returns (uint256)
{
}
// Enables GoldPesa to lock and unlock wallet address manually
function lockUnlockWallet(address account, bool yesOrNo, uint256 amount) public authorizedLocker {
}
// Pause the GPO token transfers
function pause() public onlyOwner {
}
// Unpause the GPO token transfer
function unpause() public onlyOwner {
}
// User defines the exact amount of USDC they would like to receive while swaping GPO for USDC using the GPO/USDC Uniswap V3 liquidity pool.
// Any extra GPO tokens not used in the Swap are returned back to the user.
function swapToExactOutput(uint256 amountInMaximum, uint256 amountOut, uint256 deadline) external returns (uint256 amountIn) {
}
// User defines the exact amount of GPO they would like to spend while swaping GPO for USDC using the GPO/USDC Uniswap V3 liquidity pool.
function swapToExactInput(uint256 amountIn, uint256 amountOutMinimum, uint256 deadline ) external returns (uint256 amountOut) {
}
// User defines the exact amount of GPO they would like to receive while swaping USDC for GPO using the GPO/USDC Uniswap V3 liquidity pool.
// Any extra USDC tokens not used in the Swap are returned back to the user.
function swapFromExactOutput(uint256 amountInMaximum, uint256 amountOut, uint256 deadline) external returns (uint256 amountIn) {
}
// User defines the exact amount of USDC they would like to spend while swaping USDC for GPO using the GPO/USDC Uniswap V3 liquidity pool.
function swapFromExactInput(uint256 amountIn, uint256 amountOutMinimum, uint256 deadline) external returns (uint256 amountOut) {
}
}
| freeTrade||(whitelistedWallets[to]&&whitelistedWallets[from]),"GPO_ERR: UniswapV3 functionality is only allowed through GPO's protocol" | 368,685 | freeTrade||(whitelistedWallets[to]&&whitelistedWallets[from]) |
"GPO_ERR: Hard cap on wallet reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
/**
____________________________
Description:
GoldPesa Option Contract (GPO) - 1 GPO represents the option to purchase 1 GPX at spot gold price + 1 %.
__________________________________
*/
contract GPO is ERC20PresetFixedSupply, Pausable, Ownable, AccessControl {
// TokenSwaped event is emitted anytime there is a swap between GPO and USDC on the GoldPesa.com decentralized exchange powered by Uniswap
event TokensSwaped(
address indexed purchaser,
uint256 amountIn,
uint256 amountOut,
bool direction // false: GPO-X, true: X-GPO
);
// FeeSplit stores the "recipient" wallet address and the respective percentage of the feeOnSwap which are to be sent to it.
struct FeeSplit {
address recipient;
uint16 fee;
}
// Token Name
string public _name = "GoldPesa Option";
// Token Symbol
string public _symbol = "GPO";
// GPO Hard Cap
uint256 public constant fixedSupply = 100_000_000;
// Wallet Hard Cap
uint256 public constant capOnWallet = 100_000;
// GoldPesa fee on swap percentage
uint256 public feeOnSwap = 10;
// Uniswap Router Address
ISwapRouter public immutable swapRouter;
// USDC ERC20 token Address
address public addrUSDC;
// Uniswap V3 Pool Fee * 10000 = 1 %
uint24 private swapPoolFee = 10000;
// Uniswap V3 GPO/USDC liquidity pool address
address public authorizedPool;
// Time when Pre-Sale and Sale tokens will be unlocked (Unix Time)
uint256 public walletsTimelockedUntil;
// When freeTrade is true the token bypasses the hard cap on wallet and can be traded freely on any exchange
bool public freeTrade = false;
// The feeOnSwap percentage is distributed to the addresses and their respective percentage which are held in the feeSplits array
FeeSplit[] public feeSplits;
// Keeps a record of the number of addresses in the feeSplits array
uint256 public feeSplitsLength;
// Defines an Access Control role called "CAN_LOCK" which is granted to addresses which are allowed to lock wallet addresses during the Sale and Pre-Sale phase
bytes32 public constant AUTHORIZED_LOCK =
keccak256("CAN_LOCK");
modifier authorizedLocker() {
}
// Mapping which holds information of the wallet addresses which are locked (true) /unlocked (false)
mapping(address => bool) public lockedWallets;
// Mapping which holds details of the wallet addresses which bypass the wallet hard cap and are able to swap with the Uniswap GPO/USDC liquidity pool
mapping(address => bool) public whitelistedWallets;
// Mapping which holds details of the amount of GPO tokens are locked in the lockedWallets mapping
mapping(address => uint256) public lockedWalletsAmount;
bool public swapEnabled = false;
// Upon deployment, the constructor is only executed once
constructor(
ISwapRouter _swapRouter,
uint256 _walletsTimelockedUntil
) ERC20PresetFixedSupply(_name, _symbol, hardCapOnToken(), address(this)) {
}
// Enables GoldPesa to manually transfer GPO tokens from the GPO contract to another wallet address
function transferTokensTo(address _to, uint256 amount) public onlyOwner {
}
// Enables GoldPesa to manually add or remove wallet addresses from the whitelistedWallets mapping
function changeWalletWhitelist(address _addr, bool yesOrNo) public onlyOwner {
}
// Sets the USDC contract address, the Uniswap pool fee and accordingly includes the derived Uniswap liquidity pool address to the whitelistedWallets mapping
function setPoolParameters(address USDC, uint24 poolFee) public onlyOwner {
}
// Enables GoldPesa to set the state of the contract to "freeTrade"
function switchFreeTrade() public onlyOwner {
}
function switchSwapEnabled() public onlyOwner {
}
// Enables GoldPesa to set the feeOnSwap
function setFeeOnSwap(uint24 _feeOnSwap) public onlyOwner {
}
// Enables GoldPesa to set the "feeOnSwap" distribution details
function setFeeSplits(FeeSplit[] memory _feeSplits) public onlyOwner {
}
// Distributes the feeOnSwap amount collected during any swap transaction to the addresses defined in the "feeSplits" array
function distributeFee(uint256 amount) internal {
}
// Defines the rules that must be satisfied before GPO can be transferred
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
// Ensures that GPO token holders cannot burn their own tokens
require(to != address(0x0) || whitelistedWallets[from], "GPO_ERR: Cannot burn");
// Ensures that GPO token holders cannot execute a swap directly with the GPO/USDC liquidity pool on Uniswap. All swaps must be executed on the GoldPesa DEX unless
// "freeTrade" has be enabled
if (authorizedPool != address(0x0) && (from == authorizedPool || to == authorizedPool))
require(freeTrade || (whitelistedWallets[to] && whitelistedWallets[from]), "GPO_ERR: UniswapV3 functionality is only allowed through GPO's protocol");
// Unless "freeTrade" has been enabled this require statement rejects any transfers to wallets which will break the 100,000 GPO wallet hard cap unless the
// receiving wallet address is a "whitelistedWallet"
require(<FILL_ME>)
// Disables all GPO transfers if the token has been paused by GoldPesa
require(!paused(), "ERC20Pausable: token transfer while paused");
// Rejects transfers made from locked wallets which are greater than the wallet's "lockedWalletsAmount" until the date where all tokens are unlocked
require(block.timestamp >= walletsTimelockedUntil ||
!lockedWallets[from] ||
(lockedWallets[from] && amount <= (balanceOf(from) - lockedWalletsAmount[from])), "Cannot transfer token as the wallet is locked");
}
// Internal mint function which cannot be called externally after the GPO contract is deployed ensuring that the GPO token hard cap of 100,000,000 is not breached
function _mint(address account, uint256 amount) internal virtual override {
}
// Returns the GPO token hard cap ("fixedSupply") in wei
function hardCapOnToken() public view returns (uint256) {
}
// Returns the GPO token wallet hard cap ("capOnWallet") in wei
function hardCapOnWallet() public view returns (uint256) {
}
// Returns the GoldPesa feeOnSwap in USDC which is used in the swap functions
function calculateFeeOnSwap(uint256 amount)
internal
view
returns (uint256)
{
}
// Enables GoldPesa to lock and unlock wallet address manually
function lockUnlockWallet(address account, bool yesOrNo, uint256 amount) public authorizedLocker {
}
// Pause the GPO token transfers
function pause() public onlyOwner {
}
// Unpause the GPO token transfer
function unpause() public onlyOwner {
}
// User defines the exact amount of USDC they would like to receive while swaping GPO for USDC using the GPO/USDC Uniswap V3 liquidity pool.
// Any extra GPO tokens not used in the Swap are returned back to the user.
function swapToExactOutput(uint256 amountInMaximum, uint256 amountOut, uint256 deadline) external returns (uint256 amountIn) {
}
// User defines the exact amount of GPO they would like to spend while swaping GPO for USDC using the GPO/USDC Uniswap V3 liquidity pool.
function swapToExactInput(uint256 amountIn, uint256 amountOutMinimum, uint256 deadline ) external returns (uint256 amountOut) {
}
// User defines the exact amount of GPO they would like to receive while swaping USDC for GPO using the GPO/USDC Uniswap V3 liquidity pool.
// Any extra USDC tokens not used in the Swap are returned back to the user.
function swapFromExactOutput(uint256 amountInMaximum, uint256 amountOut, uint256 deadline) external returns (uint256 amountIn) {
}
// User defines the exact amount of USDC they would like to spend while swaping USDC for GPO using the GPO/USDC Uniswap V3 liquidity pool.
function swapFromExactInput(uint256 amountIn, uint256 amountOutMinimum, uint256 deadline) external returns (uint256 amountOut) {
}
}
| freeTrade||from==address(0x0)||whitelistedWallets[to]||balanceOf(to)+amount<=hardCapOnWallet(),"GPO_ERR: Hard cap on wallet reached" | 368,685 | freeTrade||from==address(0x0)||whitelistedWallets[to]||balanceOf(to)+amount<=hardCapOnWallet() |
"ERC20Capped: cap exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
/**
____________________________
Description:
GoldPesa Option Contract (GPO) - 1 GPO represents the option to purchase 1 GPX at spot gold price + 1 %.
__________________________________
*/
contract GPO is ERC20PresetFixedSupply, Pausable, Ownable, AccessControl {
// TokenSwaped event is emitted anytime there is a swap between GPO and USDC on the GoldPesa.com decentralized exchange powered by Uniswap
event TokensSwaped(
address indexed purchaser,
uint256 amountIn,
uint256 amountOut,
bool direction // false: GPO-X, true: X-GPO
);
// FeeSplit stores the "recipient" wallet address and the respective percentage of the feeOnSwap which are to be sent to it.
struct FeeSplit {
address recipient;
uint16 fee;
}
// Token Name
string public _name = "GoldPesa Option";
// Token Symbol
string public _symbol = "GPO";
// GPO Hard Cap
uint256 public constant fixedSupply = 100_000_000;
// Wallet Hard Cap
uint256 public constant capOnWallet = 100_000;
// GoldPesa fee on swap percentage
uint256 public feeOnSwap = 10;
// Uniswap Router Address
ISwapRouter public immutable swapRouter;
// USDC ERC20 token Address
address public addrUSDC;
// Uniswap V3 Pool Fee * 10000 = 1 %
uint24 private swapPoolFee = 10000;
// Uniswap V3 GPO/USDC liquidity pool address
address public authorizedPool;
// Time when Pre-Sale and Sale tokens will be unlocked (Unix Time)
uint256 public walletsTimelockedUntil;
// When freeTrade is true the token bypasses the hard cap on wallet and can be traded freely on any exchange
bool public freeTrade = false;
// The feeOnSwap percentage is distributed to the addresses and their respective percentage which are held in the feeSplits array
FeeSplit[] public feeSplits;
// Keeps a record of the number of addresses in the feeSplits array
uint256 public feeSplitsLength;
// Defines an Access Control role called "CAN_LOCK" which is granted to addresses which are allowed to lock wallet addresses during the Sale and Pre-Sale phase
bytes32 public constant AUTHORIZED_LOCK =
keccak256("CAN_LOCK");
modifier authorizedLocker() {
}
// Mapping which holds information of the wallet addresses which are locked (true) /unlocked (false)
mapping(address => bool) public lockedWallets;
// Mapping which holds details of the wallet addresses which bypass the wallet hard cap and are able to swap with the Uniswap GPO/USDC liquidity pool
mapping(address => bool) public whitelistedWallets;
// Mapping which holds details of the amount of GPO tokens are locked in the lockedWallets mapping
mapping(address => uint256) public lockedWalletsAmount;
bool public swapEnabled = false;
// Upon deployment, the constructor is only executed once
constructor(
ISwapRouter _swapRouter,
uint256 _walletsTimelockedUntil
) ERC20PresetFixedSupply(_name, _symbol, hardCapOnToken(), address(this)) {
}
// Enables GoldPesa to manually transfer GPO tokens from the GPO contract to another wallet address
function transferTokensTo(address _to, uint256 amount) public onlyOwner {
}
// Enables GoldPesa to manually add or remove wallet addresses from the whitelistedWallets mapping
function changeWalletWhitelist(address _addr, bool yesOrNo) public onlyOwner {
}
// Sets the USDC contract address, the Uniswap pool fee and accordingly includes the derived Uniswap liquidity pool address to the whitelistedWallets mapping
function setPoolParameters(address USDC, uint24 poolFee) public onlyOwner {
}
// Enables GoldPesa to set the state of the contract to "freeTrade"
function switchFreeTrade() public onlyOwner {
}
function switchSwapEnabled() public onlyOwner {
}
// Enables GoldPesa to set the feeOnSwap
function setFeeOnSwap(uint24 _feeOnSwap) public onlyOwner {
}
// Enables GoldPesa to set the "feeOnSwap" distribution details
function setFeeSplits(FeeSplit[] memory _feeSplits) public onlyOwner {
}
// Distributes the feeOnSwap amount collected during any swap transaction to the addresses defined in the "feeSplits" array
function distributeFee(uint256 amount) internal {
}
// Defines the rules that must be satisfied before GPO can be transferred
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
// Internal mint function which cannot be called externally after the GPO contract is deployed ensuring that the GPO token hard cap of 100,000,000 is not breached
function _mint(address account, uint256 amount) internal virtual override {
// Ensures that GPO token hard cap of 100,000,000 is not breached even if the mint function is called internally
require(<FILL_ME>)
super._mint(account, amount);
}
// Returns the GPO token hard cap ("fixedSupply") in wei
function hardCapOnToken() public view returns (uint256) {
}
// Returns the GPO token wallet hard cap ("capOnWallet") in wei
function hardCapOnWallet() public view returns (uint256) {
}
// Returns the GoldPesa feeOnSwap in USDC which is used in the swap functions
function calculateFeeOnSwap(uint256 amount)
internal
view
returns (uint256)
{
}
// Enables GoldPesa to lock and unlock wallet address manually
function lockUnlockWallet(address account, bool yesOrNo, uint256 amount) public authorizedLocker {
}
// Pause the GPO token transfers
function pause() public onlyOwner {
}
// Unpause the GPO token transfer
function unpause() public onlyOwner {
}
// User defines the exact amount of USDC they would like to receive while swaping GPO for USDC using the GPO/USDC Uniswap V3 liquidity pool.
// Any extra GPO tokens not used in the Swap are returned back to the user.
function swapToExactOutput(uint256 amountInMaximum, uint256 amountOut, uint256 deadline) external returns (uint256 amountIn) {
}
// User defines the exact amount of GPO they would like to spend while swaping GPO for USDC using the GPO/USDC Uniswap V3 liquidity pool.
function swapToExactInput(uint256 amountIn, uint256 amountOutMinimum, uint256 deadline ) external returns (uint256 amountOut) {
}
// User defines the exact amount of GPO they would like to receive while swaping USDC for GPO using the GPO/USDC Uniswap V3 liquidity pool.
// Any extra USDC tokens not used in the Swap are returned back to the user.
function swapFromExactOutput(uint256 amountInMaximum, uint256 amountOut, uint256 deadline) external returns (uint256 amountIn) {
}
// User defines the exact amount of USDC they would like to spend while swaping USDC for GPO using the GPO/USDC Uniswap V3 liquidity pool.
function swapFromExactInput(uint256 amountIn, uint256 amountOutMinimum, uint256 deadline) external returns (uint256 amountOut) {
}
}
| ERC20.totalSupply()+amount<=hardCapOnToken(),"ERC20Capped: cap exceeded" | 368,685 | ERC20.totalSupply()+amount<=hardCapOnToken() |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
/**
____________________________
Description:
GoldPesa Option Contract (GPO) - 1 GPO represents the option to purchase 1 GPX at spot gold price + 1 %.
__________________________________
*/
contract GPO is ERC20PresetFixedSupply, Pausable, Ownable, AccessControl {
// TokenSwaped event is emitted anytime there is a swap between GPO and USDC on the GoldPesa.com decentralized exchange powered by Uniswap
event TokensSwaped(
address indexed purchaser,
uint256 amountIn,
uint256 amountOut,
bool direction // false: GPO-X, true: X-GPO
);
// FeeSplit stores the "recipient" wallet address and the respective percentage of the feeOnSwap which are to be sent to it.
struct FeeSplit {
address recipient;
uint16 fee;
}
// Token Name
string public _name = "GoldPesa Option";
// Token Symbol
string public _symbol = "GPO";
// GPO Hard Cap
uint256 public constant fixedSupply = 100_000_000;
// Wallet Hard Cap
uint256 public constant capOnWallet = 100_000;
// GoldPesa fee on swap percentage
uint256 public feeOnSwap = 10;
// Uniswap Router Address
ISwapRouter public immutable swapRouter;
// USDC ERC20 token Address
address public addrUSDC;
// Uniswap V3 Pool Fee * 10000 = 1 %
uint24 private swapPoolFee = 10000;
// Uniswap V3 GPO/USDC liquidity pool address
address public authorizedPool;
// Time when Pre-Sale and Sale tokens will be unlocked (Unix Time)
uint256 public walletsTimelockedUntil;
// When freeTrade is true the token bypasses the hard cap on wallet and can be traded freely on any exchange
bool public freeTrade = false;
// The feeOnSwap percentage is distributed to the addresses and their respective percentage which are held in the feeSplits array
FeeSplit[] public feeSplits;
// Keeps a record of the number of addresses in the feeSplits array
uint256 public feeSplitsLength;
// Defines an Access Control role called "CAN_LOCK" which is granted to addresses which are allowed to lock wallet addresses during the Sale and Pre-Sale phase
bytes32 public constant AUTHORIZED_LOCK =
keccak256("CAN_LOCK");
modifier authorizedLocker() {
}
// Mapping which holds information of the wallet addresses which are locked (true) /unlocked (false)
mapping(address => bool) public lockedWallets;
// Mapping which holds details of the wallet addresses which bypass the wallet hard cap and are able to swap with the Uniswap GPO/USDC liquidity pool
mapping(address => bool) public whitelistedWallets;
// Mapping which holds details of the amount of GPO tokens are locked in the lockedWallets mapping
mapping(address => uint256) public lockedWalletsAmount;
bool public swapEnabled = false;
// Upon deployment, the constructor is only executed once
constructor(
ISwapRouter _swapRouter,
uint256 _walletsTimelockedUntil
) ERC20PresetFixedSupply(_name, _symbol, hardCapOnToken(), address(this)) {
}
// Enables GoldPesa to manually transfer GPO tokens from the GPO contract to another wallet address
function transferTokensTo(address _to, uint256 amount) public onlyOwner {
}
// Enables GoldPesa to manually add or remove wallet addresses from the whitelistedWallets mapping
function changeWalletWhitelist(address _addr, bool yesOrNo) public onlyOwner {
}
// Sets the USDC contract address, the Uniswap pool fee and accordingly includes the derived Uniswap liquidity pool address to the whitelistedWallets mapping
function setPoolParameters(address USDC, uint24 poolFee) public onlyOwner {
}
// Enables GoldPesa to set the state of the contract to "freeTrade"
function switchFreeTrade() public onlyOwner {
}
function switchSwapEnabled() public onlyOwner {
}
// Enables GoldPesa to set the feeOnSwap
function setFeeOnSwap(uint24 _feeOnSwap) public onlyOwner {
}
// Enables GoldPesa to set the "feeOnSwap" distribution details
function setFeeSplits(FeeSplit[] memory _feeSplits) public onlyOwner {
}
// Distributes the feeOnSwap amount collected during any swap transaction to the addresses defined in the "feeSplits" array
function distributeFee(uint256 amount) internal {
}
// Defines the rules that must be satisfied before GPO can be transferred
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
// Internal mint function which cannot be called externally after the GPO contract is deployed ensuring that the GPO token hard cap of 100,000,000 is not breached
function _mint(address account, uint256 amount) internal virtual override {
}
// Returns the GPO token hard cap ("fixedSupply") in wei
function hardCapOnToken() public view returns (uint256) {
}
// Returns the GPO token wallet hard cap ("capOnWallet") in wei
function hardCapOnWallet() public view returns (uint256) {
}
// Returns the GoldPesa feeOnSwap in USDC which is used in the swap functions
function calculateFeeOnSwap(uint256 amount)
internal
view
returns (uint256)
{
}
// Enables GoldPesa to lock and unlock wallet address manually
function lockUnlockWallet(address account, bool yesOrNo, uint256 amount) public authorizedLocker {
}
// Pause the GPO token transfers
function pause() public onlyOwner {
}
// Unpause the GPO token transfer
function unpause() public onlyOwner {
}
// User defines the exact amount of USDC they would like to receive while swaping GPO for USDC using the GPO/USDC Uniswap V3 liquidity pool.
// Any extra GPO tokens not used in the Swap are returned back to the user.
function swapToExactOutput(uint256 amountInMaximum, uint256 amountOut, uint256 deadline) external returns (uint256 amountIn) {
require(<FILL_ME>)
_transfer(_msgSender(), address(this), amountInMaximum);
_approve(address(this), address(swapRouter), amountInMaximum);
if (deadline == 0)
deadline = block.timestamp + 30*60;
ISwapRouter.ExactOutputSingleParams memory params =
ISwapRouter.ExactOutputSingleParams({
tokenIn: address(this),
tokenOut: addrUSDC,
fee: swapPoolFee,
recipient: address(this),
deadline: deadline,
amountOut: amountOut,
amountInMaximum: amountInMaximum,
sqrtPriceLimitX96: 0
});
amountIn = swapRouter.exactOutputSingle(params);
uint256 fee = calculateFeeOnSwap(amountOut);
uint256 amountSwap = amountOut - fee;
TransferHelper.safeTransfer(addrUSDC, _msgSender(), amountSwap);
distributeFee(fee);
if (amountIn < amountInMaximum) {
_transfer(address(this), _msgSender(), amountInMaximum - amountIn);
}
emit TokensSwaped(_msgSender(), amountIn, amountOut, false);
}
// User defines the exact amount of GPO they would like to spend while swaping GPO for USDC using the GPO/USDC Uniswap V3 liquidity pool.
function swapToExactInput(uint256 amountIn, uint256 amountOutMinimum, uint256 deadline ) external returns (uint256 amountOut) {
}
// User defines the exact amount of GPO they would like to receive while swaping USDC for GPO using the GPO/USDC Uniswap V3 liquidity pool.
// Any extra USDC tokens not used in the Swap are returned back to the user.
function swapFromExactOutput(uint256 amountInMaximum, uint256 amountOut, uint256 deadline) external returns (uint256 amountIn) {
}
// User defines the exact amount of USDC they would like to spend while swaping USDC for GPO using the GPO/USDC Uniswap V3 liquidity pool.
function swapFromExactInput(uint256 amountIn, uint256 amountOutMinimum, uint256 deadline) external returns (uint256 amountOut) {
}
}
| swapEnabled||whitelistedWallets[_msgSender()] | 368,685 | swapEnabled||whitelistedWallets[_msgSender()] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.