comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Refund::refund: pToken is not allowed" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "./Services/ERC20.sol";
import "./Services/Blacklist.sol";
import "./Services/Service.sol";
contract Refund is Service, BlackList {
uint public startTimestamp;
uint public endTimestamp;
mapping(address => Base) public pTokens;
address[] pTokensList;
struct Base {
address baseToken;
uint course;
}
mapping(address => mapping(address => uint)) public pTokenAmounts;
mapping(address => address) public baseTokens;
address[] baseTokenList;
struct Balance {
uint amount;
uint out;
}
mapping(address => mapping(address => Balance)) public balances;
mapping(address => uint[]) public checkpoints;
mapping(address => uint) public totalAmount;
address public calcPoolPrice;
constructor(
uint startTimestamp_,
uint endTimestamp_,
address controller_,
address pETH_,
address calcPoolPrice_
) Service(controller_, pETH_) {
}
function addRefundPair(address pToken, address baseToken_, uint course_) public onlyOwner returns (bool) {
}
function addTokensAndCheckpoint(address baseToken, uint baseTokenAmount) public onlyOwner returns (bool) {
}
function removeUnused(address token, uint amount) public onlyOwner returns (bool) {
}
function refund(address pToken, uint pTokenAmount) public returns (bool) {
require(getBlockTimestamp() < startTimestamp, "Refund::refund: you can convert pTokens before start timestamp only");
require(checkBorrowBalance(msg.sender), "Refund::refund: sumBorrow must be less than $1");
require(<FILL_ME>)
uint pTokenAmountIn = doTransferIn(msg.sender, pToken, pTokenAmount);
pTokenAmounts[msg.sender][pToken] += pTokenAmountIn;
address baseToken = baseTokens[pToken];
uint baseTokenAmount = calcRefundAmount(pToken, pTokenAmountIn);
balances[msg.sender][baseToken].amount += baseTokenAmount;
totalAmount[baseToken] += baseTokenAmount;
return true;
}
function calcRefundAmount(address pToken, uint amount) public view returns (uint) {
}
function claimToken(address pToken) public returns (bool) {
}
function calcClaimAmount(address user, address pToken) public view returns (uint) {
}
function getCheckpointsLength(address baseToken_) public view returns (uint) {
}
function getPTokenList() public view returns (address[] memory) {
}
function getPTokenListLength() public view returns (uint) {
}
function getAllTotalAmount() public view returns (uint) {
}
function getUserUsdAmount(address user) public view returns (uint) {
}
function pTokensIsAllowed(address pToken_) public view returns (bool) {
}
function getAvailableLiquidity() public view returns (uint) {
}
function getBlockTimestamp() public view virtual returns (uint) {
}
}
| pTokensIsAllowed(pToken),"Refund::refund: pToken is not allowed" | 16,499 | pTokensIsAllowed(pToken) |
"Refund::claimToken: bad timing for the request" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "./Services/ERC20.sol";
import "./Services/Blacklist.sol";
import "./Services/Service.sol";
contract Refund is Service, BlackList {
uint public startTimestamp;
uint public endTimestamp;
mapping(address => Base) public pTokens;
address[] pTokensList;
struct Base {
address baseToken;
uint course;
}
mapping(address => mapping(address => uint)) public pTokenAmounts;
mapping(address => address) public baseTokens;
address[] baseTokenList;
struct Balance {
uint amount;
uint out;
}
mapping(address => mapping(address => Balance)) public balances;
mapping(address => uint[]) public checkpoints;
mapping(address => uint) public totalAmount;
address public calcPoolPrice;
constructor(
uint startTimestamp_,
uint endTimestamp_,
address controller_,
address pETH_,
address calcPoolPrice_
) Service(controller_, pETH_) {
}
function addRefundPair(address pToken, address baseToken_, uint course_) public onlyOwner returns (bool) {
}
function addTokensAndCheckpoint(address baseToken, uint baseTokenAmount) public onlyOwner returns (bool) {
}
function removeUnused(address token, uint amount) public onlyOwner returns (bool) {
}
function refund(address pToken, uint pTokenAmount) public returns (bool) {
}
function calcRefundAmount(address pToken, uint amount) public view returns (uint) {
}
function claimToken(address pToken) public returns (bool) {
require(<FILL_ME>)
require(!isBlackListed[msg.sender], "Refund::claimToken: user in black list");
uint amount = calcClaimAmount(msg.sender, pToken);
address baseToken = baseTokens[pToken];
balances[msg.sender][baseToken].out += amount;
doTransferOut(baseToken, msg.sender, amount);
return true;
}
function calcClaimAmount(address user, address pToken) public view returns (uint) {
}
function getCheckpointsLength(address baseToken_) public view returns (uint) {
}
function getPTokenList() public view returns (address[] memory) {
}
function getPTokenListLength() public view returns (uint) {
}
function getAllTotalAmount() public view returns (uint) {
}
function getUserUsdAmount(address user) public view returns (uint) {
}
function pTokensIsAllowed(address pToken_) public view returns (bool) {
}
function getAvailableLiquidity() public view returns (uint) {
}
function getBlockTimestamp() public view virtual returns (uint) {
}
}
| getBlockTimestamp()>startTimestamp,"Refund::claimToken: bad timing for the request" | 16,499 | getBlockTimestamp()>startTimestamp |
"FOREX: caller not an operator" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.0;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "./interfaces/IForex.sol";
contract Forex is IForex, AccessControl, ERC20 {
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
constructor(string memory name_, string memory symbol_)
ERC20(name_, symbol_)
{
}
modifier onlyOperator() {
require(<FILL_ME>)
_;
}
function mint(address account, uint256 amount)
external
override
onlyOperator
{
}
function burn(address account, uint256 amount)
external
override
onlyOperator
{
}
}
| hasRole(OPERATOR_ROLE,msg.sender)||hasRole(ADMIN_ROLE,msg.sender),"FOREX: caller not an operator" | 16,540 | hasRole(OPERATOR_ROLE,msg.sender)||hasRole(ADMIN_ROLE,msg.sender) |
"Invalid ratio: div by zero" | pragma solidity 0.6.7;
contract VSCTokenManager is TokenManager, IERC777Recipient {
using SafeMath for uint256;
enum RatioType {
MerchantLockBurnVOW,
MerchantLockMintVSC,
Liquidity
}
address public immutable vowContract;
mapping(address => uint256[2]) public merchantVOWToVSCLock;
mapping(address => bool) public registeredMVD;
mapping(RatioType => uint256[2]) public ratios;
// Universal address as defined in Registry Contract Address section of https://eips.ethereum.org/EIPS/eip-1820
IERC1820Registry constant private ERC1820_REGISTRY = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
// precalculated hash - see https://github.com/ethereum/solidity/issues/4024
// keccak256("ERC777TokensRecipient")
bytes32 constant private ERC777_TOKENS_RECIPIENT_HASH = 0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
event LogMVDRegistered(address indexed mvd);
event LogMVDDeregistered(address indexed mvd);
event LogRatioUpdated(uint256[2] ratio, RatioType ratioType);
event LogBurnAndMint(address indexed from, uint256 vowAmount, uint256 vscAmount);
event LogMerchantVOWLocked(address indexed mvd, address indexed merchant, uint256 lockedVOW, uint256 mintedVSC);
event LogMerchantVOWUnlocked(address indexed unlocker, address indexed merchant, uint256 unlockedVOW, uint256 returnedVSC);
constructor(address _token)
TokenManager(_token)
public
{
}
modifier mvdNotNull(address _mvd) {
}
function setRatio(uint256[2] calldata _ratio, RatioType _ratioType)
external
onlyOwner
{
require(<FILL_ME>)
if (_ratioType != RatioType.MerchantLockMintVSC)
require(_ratio[1] >= _ratio[0], "Invalid lock ratio: above 100%");
ratios[_ratioType] = _ratio;
emit LogRatioUpdated(_ratio, _ratioType);
}
function getLiquidityRatio()
external
view
returns (uint256[2] memory liquidity_)
{
}
function registerMVD(address _mvd)
external
onlyOwner
mvdNotNull(_mvd)
{
}
function deregisterMVD(address _mvd)
external
onlyOwner
mvdNotNull(_mvd)
{
}
function tokensReceived(address /* _operator */, address _from, address /* _to */, uint256 _amount, bytes calldata _data,
bytes calldata /* _operatorData */)
external
virtual
override
{
}
function getVOWVSCRate()
public
view
returns (uint256 numVOW_, uint256 numVSC_)
{
}
function tokensReceivedVOW(address _from, bytes memory _data, uint256 _amount)
private
{
}
function tokensReceivedThisVSC(address _from, bytes memory _data, uint256 _amount)
private
{
}
function doMerchantLock(address _mvd, address _merchant, uint256 _vowAmount, bytes memory _data)
private
{
}
function doMerchantUnlock(address _unlocker, address _merchant, uint256 _vscAmount)
private
{
}
}
| _ratio[1]!=0,"Invalid ratio: div by zero" | 16,553 | _ratio[1]!=0 |
"Invalid lock ratio: above 100%" | pragma solidity 0.6.7;
contract VSCTokenManager is TokenManager, IERC777Recipient {
using SafeMath for uint256;
enum RatioType {
MerchantLockBurnVOW,
MerchantLockMintVSC,
Liquidity
}
address public immutable vowContract;
mapping(address => uint256[2]) public merchantVOWToVSCLock;
mapping(address => bool) public registeredMVD;
mapping(RatioType => uint256[2]) public ratios;
// Universal address as defined in Registry Contract Address section of https://eips.ethereum.org/EIPS/eip-1820
IERC1820Registry constant private ERC1820_REGISTRY = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
// precalculated hash - see https://github.com/ethereum/solidity/issues/4024
// keccak256("ERC777TokensRecipient")
bytes32 constant private ERC777_TOKENS_RECIPIENT_HASH = 0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
event LogMVDRegistered(address indexed mvd);
event LogMVDDeregistered(address indexed mvd);
event LogRatioUpdated(uint256[2] ratio, RatioType ratioType);
event LogBurnAndMint(address indexed from, uint256 vowAmount, uint256 vscAmount);
event LogMerchantVOWLocked(address indexed mvd, address indexed merchant, uint256 lockedVOW, uint256 mintedVSC);
event LogMerchantVOWUnlocked(address indexed unlocker, address indexed merchant, uint256 unlockedVOW, uint256 returnedVSC);
constructor(address _token)
TokenManager(_token)
public
{
}
modifier mvdNotNull(address _mvd) {
}
function setRatio(uint256[2] calldata _ratio, RatioType _ratioType)
external
onlyOwner
{
require(_ratio[1] != 0, "Invalid ratio: div by zero");
if (_ratioType != RatioType.MerchantLockMintVSC)
require(<FILL_ME>)
ratios[_ratioType] = _ratio;
emit LogRatioUpdated(_ratio, _ratioType);
}
function getLiquidityRatio()
external
view
returns (uint256[2] memory liquidity_)
{
}
function registerMVD(address _mvd)
external
onlyOwner
mvdNotNull(_mvd)
{
}
function deregisterMVD(address _mvd)
external
onlyOwner
mvdNotNull(_mvd)
{
}
function tokensReceived(address /* _operator */, address _from, address /* _to */, uint256 _amount, bytes calldata _data,
bytes calldata /* _operatorData */)
external
virtual
override
{
}
function getVOWVSCRate()
public
view
returns (uint256 numVOW_, uint256 numVSC_)
{
}
function tokensReceivedVOW(address _from, bytes memory _data, uint256 _amount)
private
{
}
function tokensReceivedThisVSC(address _from, bytes memory _data, uint256 _amount)
private
{
}
function doMerchantLock(address _mvd, address _merchant, uint256 _vowAmount, bytes memory _data)
private
{
}
function doMerchantUnlock(address _unlocker, address _merchant, uint256 _vscAmount)
private
{
}
}
| _ratio[1]>=_ratio[0],"Invalid lock ratio: above 100%" | 16,553 | _ratio[1]>=_ratio[0] |
"Merchant is locked" | pragma solidity 0.6.7;
contract VSCTokenManager is TokenManager, IERC777Recipient {
using SafeMath for uint256;
enum RatioType {
MerchantLockBurnVOW,
MerchantLockMintVSC,
Liquidity
}
address public immutable vowContract;
mapping(address => uint256[2]) public merchantVOWToVSCLock;
mapping(address => bool) public registeredMVD;
mapping(RatioType => uint256[2]) public ratios;
// Universal address as defined in Registry Contract Address section of https://eips.ethereum.org/EIPS/eip-1820
IERC1820Registry constant private ERC1820_REGISTRY = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
// precalculated hash - see https://github.com/ethereum/solidity/issues/4024
// keccak256("ERC777TokensRecipient")
bytes32 constant private ERC777_TOKENS_RECIPIENT_HASH = 0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
event LogMVDRegistered(address indexed mvd);
event LogMVDDeregistered(address indexed mvd);
event LogRatioUpdated(uint256[2] ratio, RatioType ratioType);
event LogBurnAndMint(address indexed from, uint256 vowAmount, uint256 vscAmount);
event LogMerchantVOWLocked(address indexed mvd, address indexed merchant, uint256 lockedVOW, uint256 mintedVSC);
event LogMerchantVOWUnlocked(address indexed unlocker, address indexed merchant, uint256 unlockedVOW, uint256 returnedVSC);
constructor(address _token)
TokenManager(_token)
public
{
}
modifier mvdNotNull(address _mvd) {
}
function setRatio(uint256[2] calldata _ratio, RatioType _ratioType)
external
onlyOwner
{
}
function getLiquidityRatio()
external
view
returns (uint256[2] memory liquidity_)
{
}
function registerMVD(address _mvd)
external
onlyOwner
mvdNotNull(_mvd)
{
}
function deregisterMVD(address _mvd)
external
onlyOwner
mvdNotNull(_mvd)
{
}
function tokensReceived(address /* _operator */, address _from, address /* _to */, uint256 _amount, bytes calldata _data,
bytes calldata /* _operatorData */)
external
virtual
override
{
}
function getVOWVSCRate()
public
view
returns (uint256 numVOW_, uint256 numVSC_)
{
}
function tokensReceivedVOW(address _from, bytes memory _data, uint256 _amount)
private
{
}
function tokensReceivedThisVSC(address _from, bytes memory _data, uint256 _amount)
private
{
}
function doMerchantLock(address _mvd, address _merchant, uint256 _vowAmount, bytes memory _data)
private
{
require(<FILL_ME>)
(uint256 numVOW, uint256 numVSC) = getVOWVSCRate();
uint256 burnAmount = _vowAmount.mul(ratios[RatioType.MerchantLockBurnVOW][0]).div(ratios[RatioType.MerchantLockBurnVOW][1]);
uint256 vscAmount = _vowAmount.mul(numVSC).mul(ratios[RatioType.MerchantLockMintVSC][0]).
div(numVOW.mul(ratios[RatioType.MerchantLockMintVSC][1]));
merchantVOWToVSCLock[_merchant][0] = _vowAmount.sub(burnAmount);
merchantVOWToVSCLock[_merchant][1] = vscAmount;
VOWToken(vowContract).burn(burnAmount, "");
VSCToken(token).mint(_mvd, vscAmount);
VSCToken(token).lift(_mvd, vscAmount, _data);
emit LogMerchantVOWLocked(_mvd, _merchant, merchantVOWToVSCLock[_merchant][0], vscAmount);
}
function doMerchantUnlock(address _unlocker, address _merchant, uint256 _vscAmount)
private
{
}
}
| merchantVOWToVSCLock[_merchant][0]==0,"Merchant is locked" | 16,553 | merchantVOWToVSCLock[_merchant][0]==0 |
"No VOW to unlock" | pragma solidity 0.6.7;
contract VSCTokenManager is TokenManager, IERC777Recipient {
using SafeMath for uint256;
enum RatioType {
MerchantLockBurnVOW,
MerchantLockMintVSC,
Liquidity
}
address public immutable vowContract;
mapping(address => uint256[2]) public merchantVOWToVSCLock;
mapping(address => bool) public registeredMVD;
mapping(RatioType => uint256[2]) public ratios;
// Universal address as defined in Registry Contract Address section of https://eips.ethereum.org/EIPS/eip-1820
IERC1820Registry constant private ERC1820_REGISTRY = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
// precalculated hash - see https://github.com/ethereum/solidity/issues/4024
// keccak256("ERC777TokensRecipient")
bytes32 constant private ERC777_TOKENS_RECIPIENT_HASH = 0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
event LogMVDRegistered(address indexed mvd);
event LogMVDDeregistered(address indexed mvd);
event LogRatioUpdated(uint256[2] ratio, RatioType ratioType);
event LogBurnAndMint(address indexed from, uint256 vowAmount, uint256 vscAmount);
event LogMerchantVOWLocked(address indexed mvd, address indexed merchant, uint256 lockedVOW, uint256 mintedVSC);
event LogMerchantVOWUnlocked(address indexed unlocker, address indexed merchant, uint256 unlockedVOW, uint256 returnedVSC);
constructor(address _token)
TokenManager(_token)
public
{
}
modifier mvdNotNull(address _mvd) {
}
function setRatio(uint256[2] calldata _ratio, RatioType _ratioType)
external
onlyOwner
{
}
function getLiquidityRatio()
external
view
returns (uint256[2] memory liquidity_)
{
}
function registerMVD(address _mvd)
external
onlyOwner
mvdNotNull(_mvd)
{
}
function deregisterMVD(address _mvd)
external
onlyOwner
mvdNotNull(_mvd)
{
}
function tokensReceived(address /* _operator */, address _from, address /* _to */, uint256 _amount, bytes calldata _data,
bytes calldata /* _operatorData */)
external
virtual
override
{
}
function getVOWVSCRate()
public
view
returns (uint256 numVOW_, uint256 numVSC_)
{
}
function tokensReceivedVOW(address _from, bytes memory _data, uint256 _amount)
private
{
}
function tokensReceivedThisVSC(address _from, bytes memory _data, uint256 _amount)
private
{
}
function doMerchantLock(address _mvd, address _merchant, uint256 _vowAmount, bytes memory _data)
private
{
}
function doMerchantUnlock(address _unlocker, address _merchant, uint256 _vscAmount)
private
{
require(<FILL_ME>)
require(merchantVOWToVSCLock[_merchant][1] == _vscAmount, "Incorrect VSC amount");
VSCToken(token).burn(_vscAmount, "");
VOWToken(vowContract).send(_merchant, merchantVOWToVSCLock[_merchant][0], "");
emit LogMerchantVOWUnlocked(_unlocker, _merchant, merchantVOWToVSCLock[_merchant][0], _vscAmount);
delete merchantVOWToVSCLock[_merchant];
}
}
| merchantVOWToVSCLock[_merchant][0]>0,"No VOW to unlock" | 16,553 | merchantVOWToVSCLock[_merchant][0]>0 |
"Incorrect VSC amount" | pragma solidity 0.6.7;
contract VSCTokenManager is TokenManager, IERC777Recipient {
using SafeMath for uint256;
enum RatioType {
MerchantLockBurnVOW,
MerchantLockMintVSC,
Liquidity
}
address public immutable vowContract;
mapping(address => uint256[2]) public merchantVOWToVSCLock;
mapping(address => bool) public registeredMVD;
mapping(RatioType => uint256[2]) public ratios;
// Universal address as defined in Registry Contract Address section of https://eips.ethereum.org/EIPS/eip-1820
IERC1820Registry constant private ERC1820_REGISTRY = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
// precalculated hash - see https://github.com/ethereum/solidity/issues/4024
// keccak256("ERC777TokensRecipient")
bytes32 constant private ERC777_TOKENS_RECIPIENT_HASH = 0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
event LogMVDRegistered(address indexed mvd);
event LogMVDDeregistered(address indexed mvd);
event LogRatioUpdated(uint256[2] ratio, RatioType ratioType);
event LogBurnAndMint(address indexed from, uint256 vowAmount, uint256 vscAmount);
event LogMerchantVOWLocked(address indexed mvd, address indexed merchant, uint256 lockedVOW, uint256 mintedVSC);
event LogMerchantVOWUnlocked(address indexed unlocker, address indexed merchant, uint256 unlockedVOW, uint256 returnedVSC);
constructor(address _token)
TokenManager(_token)
public
{
}
modifier mvdNotNull(address _mvd) {
}
function setRatio(uint256[2] calldata _ratio, RatioType _ratioType)
external
onlyOwner
{
}
function getLiquidityRatio()
external
view
returns (uint256[2] memory liquidity_)
{
}
function registerMVD(address _mvd)
external
onlyOwner
mvdNotNull(_mvd)
{
}
function deregisterMVD(address _mvd)
external
onlyOwner
mvdNotNull(_mvd)
{
}
function tokensReceived(address /* _operator */, address _from, address /* _to */, uint256 _amount, bytes calldata _data,
bytes calldata /* _operatorData */)
external
virtual
override
{
}
function getVOWVSCRate()
public
view
returns (uint256 numVOW_, uint256 numVSC_)
{
}
function tokensReceivedVOW(address _from, bytes memory _data, uint256 _amount)
private
{
}
function tokensReceivedThisVSC(address _from, bytes memory _data, uint256 _amount)
private
{
}
function doMerchantLock(address _mvd, address _merchant, uint256 _vowAmount, bytes memory _data)
private
{
}
function doMerchantUnlock(address _unlocker, address _merchant, uint256 _vscAmount)
private
{
require(merchantVOWToVSCLock[_merchant][0] > 0, "No VOW to unlock");
require(<FILL_ME>)
VSCToken(token).burn(_vscAmount, "");
VOWToken(vowContract).send(_merchant, merchantVOWToVSCLock[_merchant][0], "");
emit LogMerchantVOWUnlocked(_unlocker, _merchant, merchantVOWToVSCLock[_merchant][0], _vscAmount);
delete merchantVOWToVSCLock[_merchant];
}
}
| merchantVOWToVSCLock[_merchant][1]==_vscAmount,"Incorrect VSC amount" | 16,553 | merchantVOWToVSCLock[_merchant][1]==_vscAmount |
"25" | pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: GPL-3.0-only
import "./utils/Common.sol";
import "./utils/ERC1155Base.sol";
import "./interface/IERC1155TokenReceiver.sol";
import "./CashMarket.sol";
/**
* @notice Implements the ERC1155 token standard for transferring fCash tokens within Notional. ERC1155 ids
* encode an identifier that represents assets that are fungible with each other. For example, two fCash tokens
* that asset in the same market and mature at the same time are fungible with each other and therefore will have the
* same id. `CASH_PAYER` tokens are not transferrable because they have negative value.
*/
contract ERC1155Token is ERC1155Base {
/**
* @notice Transfers tokens between from and to addresses.
* @dev - INVALID_ADDRESS: destination address cannot be 0
* - INTEGER_OVERFLOW: value cannot overflow uint128
* - CANNOT_TRANSFER_PAYER: cannot transfer assets that confer obligations
* - CANNOT_TRANSFER_MATURED_ASSET: cannot transfer asset that has matured
* - INSUFFICIENT_BALANCE: from account does not have sufficient tokens
* - ERC1155_NOT_ACCEPTED: to contract must accept the transfer
* @param from Source address
* @param to Target address
* @param id ID of the token type
* @param value Transfer amount
* @param data Additional data with no specified format, unused by this contract but forwarded unaltered
* to the ERC1155TokenReceiver.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 value,
bytes calldata data
) external override {
_transfer(from, to, id, value);
emit TransferSingle(msg.sender, from, to, id, value);
// If code size > 0 call onERC1155received
uint256 codeSize;
// solium-disable-next-line security/no-inline-assembly
assembly {
codeSize := extcodesize(to)
}
if (codeSize > 0) {
require(<FILL_ME>)
}
}
/**
* @notice Transfers tokens between from and to addresses in batch.
* @dev - INVALID_ADDRESS: destination address cannot be 0
* - INTEGER_OVERFLOW: value cannot overflow uint128
* - CANNOT_TRANSFER_PAYER: cannot transfer assets that confer obligations
* - CANNOT_TRANSFER_MATURED_ASSET: cannot transfer asset that has matured
* - INSUFFICIENT_BALANCE: from account does not have sufficient tokens
* - ERC1155_NOT_ACCEPTED: to contract must accept the transfer
* @param from Source address
* @param to Target address
* @param ids IDs of each token type (order and length must match _values array)
* @param values Transfer amounts per token type (order and length must match _ids array)
* @param data Additional data with no specified format, unused by this contract but forwarded unaltered
* to the ERC1155TokenReceiver.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external override {
}
/**
* Internal method for validating and updating state within a transfer.
* @dev batch updates can be made a lot more efficient by not looping through this
* code and updating storage on each loop, we can do it in memory and then flush to
* storage just once.
*
* @param from the token holder
* @param to the new token holder
* @param id the token id
* @param _value the notional amount to transfer
*/
function _transfer(
address from,
address to,
uint256 id,
uint256 _value
) internal {
}
}
| IERC1155TokenReceiver(to).onERC1155Received(msg.sender,from,id,value,data)==ERC1155_ACCEPTED,"25" | 16,592 | IERC1155TokenReceiver(to).onERC1155Received(msg.sender,from,id,value,data)==ERC1155_ACCEPTED |
"25" | pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: GPL-3.0-only
import "./utils/Common.sol";
import "./utils/ERC1155Base.sol";
import "./interface/IERC1155TokenReceiver.sol";
import "./CashMarket.sol";
/**
* @notice Implements the ERC1155 token standard for transferring fCash tokens within Notional. ERC1155 ids
* encode an identifier that represents assets that are fungible with each other. For example, two fCash tokens
* that asset in the same market and mature at the same time are fungible with each other and therefore will have the
* same id. `CASH_PAYER` tokens are not transferrable because they have negative value.
*/
contract ERC1155Token is ERC1155Base {
/**
* @notice Transfers tokens between from and to addresses.
* @dev - INVALID_ADDRESS: destination address cannot be 0
* - INTEGER_OVERFLOW: value cannot overflow uint128
* - CANNOT_TRANSFER_PAYER: cannot transfer assets that confer obligations
* - CANNOT_TRANSFER_MATURED_ASSET: cannot transfer asset that has matured
* - INSUFFICIENT_BALANCE: from account does not have sufficient tokens
* - ERC1155_NOT_ACCEPTED: to contract must accept the transfer
* @param from Source address
* @param to Target address
* @param id ID of the token type
* @param value Transfer amount
* @param data Additional data with no specified format, unused by this contract but forwarded unaltered
* to the ERC1155TokenReceiver.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 value,
bytes calldata data
) external override {
}
/**
* @notice Transfers tokens between from and to addresses in batch.
* @dev - INVALID_ADDRESS: destination address cannot be 0
* - INTEGER_OVERFLOW: value cannot overflow uint128
* - CANNOT_TRANSFER_PAYER: cannot transfer assets that confer obligations
* - CANNOT_TRANSFER_MATURED_ASSET: cannot transfer asset that has matured
* - INSUFFICIENT_BALANCE: from account does not have sufficient tokens
* - ERC1155_NOT_ACCEPTED: to contract must accept the transfer
* @param from Source address
* @param to Target address
* @param ids IDs of each token type (order and length must match _values array)
* @param values Transfer amounts per token type (order and length must match _ids array)
* @param data Additional data with no specified format, unused by this contract but forwarded unaltered
* to the ERC1155TokenReceiver.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external override {
for (uint256 i; i < ids.length; i++) {
_transfer(from, to, ids[i], values[i]);
}
emit TransferBatch(msg.sender, from, to, ids, values);
// If code size > 0 call onERC1155received
uint256 codeSize;
// solium-disable-next-line security/no-inline-assembly
assembly {
codeSize := extcodesize(to)
}
if (codeSize > 0) {
require(<FILL_ME>)
}
}
/**
* Internal method for validating and updating state within a transfer.
* @dev batch updates can be made a lot more efficient by not looping through this
* code and updating storage on each loop, we can do it in memory and then flush to
* storage just once.
*
* @param from the token holder
* @param to the new token holder
* @param id the token id
* @param _value the notional amount to transfer
*/
function _transfer(
address from,
address to,
uint256 id,
uint256 _value
) internal {
}
}
| IERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender,from,ids,values,data)==ERC1155_BATCH_ACCEPTED,"25" | 16,592 | IERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender,from,ids,values,data)==ERC1155_BATCH_ACCEPTED |
"26" | pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: GPL-3.0-only
import "./utils/Common.sol";
import "./utils/ERC1155Base.sol";
import "./interface/IERC1155TokenReceiver.sol";
import "./CashMarket.sol";
/**
* @notice Implements the ERC1155 token standard for transferring fCash tokens within Notional. ERC1155 ids
* encode an identifier that represents assets that are fungible with each other. For example, two fCash tokens
* that asset in the same market and mature at the same time are fungible with each other and therefore will have the
* same id. `CASH_PAYER` tokens are not transferrable because they have negative value.
*/
contract ERC1155Token is ERC1155Base {
/**
* @notice Transfers tokens between from and to addresses.
* @dev - INVALID_ADDRESS: destination address cannot be 0
* - INTEGER_OVERFLOW: value cannot overflow uint128
* - CANNOT_TRANSFER_PAYER: cannot transfer assets that confer obligations
* - CANNOT_TRANSFER_MATURED_ASSET: cannot transfer asset that has matured
* - INSUFFICIENT_BALANCE: from account does not have sufficient tokens
* - ERC1155_NOT_ACCEPTED: to contract must accept the transfer
* @param from Source address
* @param to Target address
* @param id ID of the token type
* @param value Transfer amount
* @param data Additional data with no specified format, unused by this contract but forwarded unaltered
* to the ERC1155TokenReceiver.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 value,
bytes calldata data
) external override {
}
/**
* @notice Transfers tokens between from and to addresses in batch.
* @dev - INVALID_ADDRESS: destination address cannot be 0
* - INTEGER_OVERFLOW: value cannot overflow uint128
* - CANNOT_TRANSFER_PAYER: cannot transfer assets that confer obligations
* - CANNOT_TRANSFER_MATURED_ASSET: cannot transfer asset that has matured
* - INSUFFICIENT_BALANCE: from account does not have sufficient tokens
* - ERC1155_NOT_ACCEPTED: to contract must accept the transfer
* @param from Source address
* @param to Target address
* @param ids IDs of each token type (order and length must match _values array)
* @param values Transfer amounts per token type (order and length must match _ids array)
* @param data Additional data with no specified format, unused by this contract but forwarded unaltered
* to the ERC1155TokenReceiver.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external override {
}
/**
* Internal method for validating and updating state within a transfer.
* @dev batch updates can be made a lot more efficient by not looping through this
* code and updating storage on each loop, we can do it in memory and then flush to
* storage just once.
*
* @param from the token holder
* @param to the new token holder
* @param id the token id
* @param _value the notional amount to transfer
*/
function _transfer(
address from,
address to,
uint256 id,
uint256 _value
) internal {
require(to != address(0), "24");
uint128 value = uint128(_value);
require(<FILL_ME>)
require(msg.sender == from || isApprovedForAll(from, msg.sender), "20");
bytes1 assetType = Common.getAssetType(id);
// Transfers can only be entitlements to receive which are a net benefit.
require(Common.isReceiver(assetType), "23");
(uint8 cashGroupId, uint16 instrumentId, uint32 maturity) = Common.decodeAssetId(id);
require(maturity > block.timestamp, "35");
Portfolios().transferAccountAsset(
from,
to,
assetType,
cashGroupId,
instrumentId,
maturity,
value
);
}
}
| uint256(value)==_value,"26" | 16,592 | uint256(value)==_value |
"23" | pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: GPL-3.0-only
import "./utils/Common.sol";
import "./utils/ERC1155Base.sol";
import "./interface/IERC1155TokenReceiver.sol";
import "./CashMarket.sol";
/**
* @notice Implements the ERC1155 token standard for transferring fCash tokens within Notional. ERC1155 ids
* encode an identifier that represents assets that are fungible with each other. For example, two fCash tokens
* that asset in the same market and mature at the same time are fungible with each other and therefore will have the
* same id. `CASH_PAYER` tokens are not transferrable because they have negative value.
*/
contract ERC1155Token is ERC1155Base {
/**
* @notice Transfers tokens between from and to addresses.
* @dev - INVALID_ADDRESS: destination address cannot be 0
* - INTEGER_OVERFLOW: value cannot overflow uint128
* - CANNOT_TRANSFER_PAYER: cannot transfer assets that confer obligations
* - CANNOT_TRANSFER_MATURED_ASSET: cannot transfer asset that has matured
* - INSUFFICIENT_BALANCE: from account does not have sufficient tokens
* - ERC1155_NOT_ACCEPTED: to contract must accept the transfer
* @param from Source address
* @param to Target address
* @param id ID of the token type
* @param value Transfer amount
* @param data Additional data with no specified format, unused by this contract but forwarded unaltered
* to the ERC1155TokenReceiver.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 value,
bytes calldata data
) external override {
}
/**
* @notice Transfers tokens between from and to addresses in batch.
* @dev - INVALID_ADDRESS: destination address cannot be 0
* - INTEGER_OVERFLOW: value cannot overflow uint128
* - CANNOT_TRANSFER_PAYER: cannot transfer assets that confer obligations
* - CANNOT_TRANSFER_MATURED_ASSET: cannot transfer asset that has matured
* - INSUFFICIENT_BALANCE: from account does not have sufficient tokens
* - ERC1155_NOT_ACCEPTED: to contract must accept the transfer
* @param from Source address
* @param to Target address
* @param ids IDs of each token type (order and length must match _values array)
* @param values Transfer amounts per token type (order and length must match _ids array)
* @param data Additional data with no specified format, unused by this contract but forwarded unaltered
* to the ERC1155TokenReceiver.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external override {
}
/**
* Internal method for validating and updating state within a transfer.
* @dev batch updates can be made a lot more efficient by not looping through this
* code and updating storage on each loop, we can do it in memory and then flush to
* storage just once.
*
* @param from the token holder
* @param to the new token holder
* @param id the token id
* @param _value the notional amount to transfer
*/
function _transfer(
address from,
address to,
uint256 id,
uint256 _value
) internal {
require(to != address(0), "24");
uint128 value = uint128(_value);
require(uint256(value) == _value, "26");
require(msg.sender == from || isApprovedForAll(from, msg.sender), "20");
bytes1 assetType = Common.getAssetType(id);
// Transfers can only be entitlements to receive which are a net benefit.
require(<FILL_ME>)
(uint8 cashGroupId, uint16 instrumentId, uint32 maturity) = Common.decodeAssetId(id);
require(maturity > block.timestamp, "35");
Portfolios().transferAccountAsset(
from,
to,
assetType,
cashGroupId,
instrumentId,
maturity,
value
);
}
}
| Common.isReceiver(assetType),"23" | 16,592 | Common.isReceiver(assetType) |
add | pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: GPL-3.0-only
import "../lib/SafeInt256.sol";
import "../lib/SafeMath.sol";
import "../utils/Governed.sol";
import "../utils/Common.sol";
import "../interface/IPortfoliosCallable.sol";
import "../storage/PortfoliosStorage.sol";
import "../CashMarket.sol";
import "@openzeppelin/contracts/utils/SafeCast.sol";
/**
* @title Risk Framework
* @notice Calculates the currency requirements for a portfolio.
*/
library RiskFramework {
using SafeMath for uint256;
using SafeInt256 for int256;
/** The cash ladder for a single instrument or cash group */
struct CashLadder {
// The cash group id for this cash ladder
uint16 id;
// The currency group id for this cash ladder
uint16 currency;
// The cash ladder for the maturities of this cash group
int256[] cashLadder;
}
/**
* @notice Given a portfolio of assets, returns a set of requirements in every currency represented.
* @param portfolio a portfolio of assets
* @return a set of requirements in every cash group represented by the portfolio
*/
function getRequirement(
Common.Asset[] memory portfolio,
address Portfolios
) public view returns (Common.Requirement[] memory) {
Common._sortPortfolio(portfolio);
// Each position in this array will hold the value of the portfolio in each maturity.
(Common.CashGroup[] memory cashGroups, CashLadder[] memory ladders) = _fetchCashGroups(
portfolio,
IPortfoliosCallable(Portfolios)
);
uint128 fCashHaircut = PortfoliosStorageSlot._fCashHaircut();
uint128 fCashMaxHaircut = PortfoliosStorageSlot._fCashMaxHaircut();
uint32 blockTime = uint32(block.timestamp);
int256[] memory cashClaims = _getCashLadders(
portfolio,
cashGroups,
ladders,
PortfoliosStorageSlot._liquidityHaircut(),
blockTime
);
// We now take the per cash group cash ladder and summarize it into a single requirement. The future
// cash group requirements will be aggregated into a single currency requirement in the free collateral function
Common.Requirement[] memory requirements = new Common.Requirement[](ladders.length);
for (uint256 i; i < ladders.length; i++) {
requirements[i].currency = ladders[i].currency;
requirements[i].cashClaim = cashClaims[i];
uint32 initialMaturity;
if (blockTime % cashGroups[i].maturityLength == 0) {
// If this is true then blockTime = maturity at index 0 and we do not add an offset.
initialMaturity = blockTime;
} else {
initialMaturity = blockTime - (blockTime % cashGroups[i].maturityLength) + cashGroups[i].maturityLength;
}
for (uint256 j; j < ladders[i].cashLadder.length; j++) {
int256 netfCash = ladders[i].cashLadder[j];
if (netfCash > 0) {
uint32 maturity = initialMaturity + cashGroups[i].maturityLength * uint32(j);
// If netfCash value is positive here then we have to haircut it.
netfCash = _calculateReceiverValue(netfCash, maturity, blockTime, fCashHaircut, fCashMaxHaircut);
}
require(<FILL_ME>)
}
}
return requirements;
}
/**
* @notice Calculates the cash ladders for every cash group in a portfolio.
*
* @param portfolio a portfolio of assets
* @return an array of cash ladders and an npv figure for every cash group
*/
function _getCashLadders(
Common.Asset[] memory portfolio,
Common.CashGroup[] memory cashGroups,
CashLadder[] memory ladders,
uint128 liquidityHaircut,
uint32 blockTime
) internal view returns (int256[] memory) {
}
function _calculateAssetValue(
Common.Asset memory asset,
Common.CashGroup memory cg,
uint32 blockTime,
uint128 liquidityHaircut
) internal view returns (int256, int256) {
}
function _calculateReceiverValue(
int256 fCash,
uint32 maturity,
uint32 blockTime,
uint128 fCashHaircut,
uint128 fCashMaxHaircut
) internal pure returns (int256) {
}
function _calculateLiquidityTokenClaims(
Common.Asset memory asset,
address cashMarket,
uint32 blockTime,
uint128 liquidityHaircut
) internal view returns (uint128, uint128) {
}
function _fetchCashGroups(
Common.Asset[] memory portfolio,
IPortfoliosCallable Portfolios
) internal view returns (Common.CashGroup[] memory, CashLadder[] memory) {
}
}
| ents[i].netfCashValue=requirements[i].netfCashValue.add(netfCash | 16,603 | requirements[i].netfCashValue |
"User don't have enough bums" | pragma solidity >=0.8.0 <0.9.0;
interface IRetroPandas {
function pandasBalance(address user) external view returns(uint256);
function pandanatorsBalance(address user) external view returns(uint256);
}
contract SteamedBuns is ERC20("Steamed Buns", "BUNS") {
using SafeMath for uint256;
IRetroPandas public retroPandasContract;
uint256 public rewardEndTime;
uint256 constant public pandasDailyRate = 10 ether;
uint256 constant public pandanatorsDailyRate = 20 ether;
mapping(address => uint256) public rewards;
mapping(address => uint256) public lastReward;
event RewardClaimed(address indexed user, uint256 reward);
constructor(address retroPandas) {
}
function registerUser(address user) external onlyContract {
}
function updateReward(address user) external onlyContract {
}
function claimReward(address user) external onlyContract {
}
function getClaimableAmount(address user) external view returns(uint256) {
}
function burn(address user, uint256 amount) external onlyContract {
require(<FILL_ME>)
_burn(user, amount);
}
function calcPendingRewards(address user, uint256 timeFrom, uint256 timeTo) internal view returns (uint256) {
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
modifier onlyContract {
}
}
| balanceOf(user)>=amount,"User don't have enough bums" | 16,617 | balanceOf(user)>=amount |
"Reserve would exceed max supply of AstroGators" | pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity 0.7.6;
/**
* @title AstroGator
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract AstroGator is ERC721, Ownable {
using SafeMath for uint256;
uint256 public constant AstroGatorPrice = 0.04e18; //0.04 ETH
uint public constant maxAstroGatorPurchase = 20;
uint256 public MAX_AstroGators;
uint256 public remaining;
bool public saleIsActive = false;
address public treasury;
mapping(uint256 => uint256) public cache;
constructor(string memory name, string memory symbol, uint256 maxNftSupply, address fundReceiver) ERC721(name, symbol) {
}
function withdraw() public onlyOwner {
}
/**
* Set some AstroGators aside
*/
function reserveAstroGators(uint numberOfTokens) public onlyOwner {
require(<FILL_ME>)
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = drawIndex();
_safeMint(msg.sender, mintIndex);
}
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
/*
* Pause sale if active, make active if paused
*/
function flipSaleState() public onlyOwner {
}
function drawIndex() internal returns (uint256 index) {
}
/**
* Mints AstroGators
*/
function mintAstroGator(uint numberOfTokens) public payable {
}
}
| totalSupply().add(numberOfTokens)<=MAX_AstroGators,"Reserve would exceed max supply of AstroGators" | 16,667 | totalSupply().add(numberOfTokens)<=MAX_AstroGators |
"Ether value sent is not correct" | pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity 0.7.6;
/**
* @title AstroGator
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract AstroGator is ERC721, Ownable {
using SafeMath for uint256;
uint256 public constant AstroGatorPrice = 0.04e18; //0.04 ETH
uint public constant maxAstroGatorPurchase = 20;
uint256 public MAX_AstroGators;
uint256 public remaining;
bool public saleIsActive = false;
address public treasury;
mapping(uint256 => uint256) public cache;
constructor(string memory name, string memory symbol, uint256 maxNftSupply, address fundReceiver) ERC721(name, symbol) {
}
function withdraw() public onlyOwner {
}
/**
* Set some AstroGators aside
*/
function reserveAstroGators(uint numberOfTokens) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
/*
* Pause sale if active, make active if paused
*/
function flipSaleState() public onlyOwner {
}
function drawIndex() internal returns (uint256 index) {
}
/**
* Mints AstroGators
*/
function mintAstroGator(uint numberOfTokens) public payable {
require(msg.sender == tx.origin, "Contract wallet disallowed");
require(saleIsActive, "Sale must be active to mint AstroGator");
require(numberOfTokens <= maxAstroGatorPurchase, "Can only mint 20 tokens at a time");
require(totalSupply().add(numberOfTokens) <= MAX_AstroGators, "Purchase would exceed max supply of AstroGators");
require(<FILL_ME>)
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = drawIndex();
_safeMint(msg.sender, mintIndex);
}
}
}
| AstroGatorPrice.mul(numberOfTokens)<=msg.value,"Ether value sent is not correct" | 16,667 | AstroGatorPrice.mul(numberOfTokens)<=msg.value |
null | pragma solidity ^0.4.24;
// This is the Alethena Share Token.
// To learn more, visit https://github.com/Alethena/Alethena-Shares-Token
// Or contact us at [email protected]
contract ERC20Basic {
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);
}
contract ERC20 is ERC20Basic {
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);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable {
address public owner;
address public master = 0x8fED3492dB590ad34ed42b0F509EB3c9626246Fc;
event OwnershipRenounced(address indexed previousOwner);
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 relinquish control of the contract.
*/
function renounceOwnership() public onlyOwner {
}
/**
* @dev Allows the master to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function _transferOwnership(address _newOwner) internal {
}
}
contract Claimable is ERC20Basic, Ownable {
using SafeMath for uint256;
struct Claim {
address claimant; // the person who created the claim
uint256 collateral; // the amount of wei deposited
uint256 timestamp; // the timestamp of the block in which the claim was made
}
struct PreClaim {
bytes32 msghash; // the hash of nonce + address to be claimed
uint256 timestamp; // the timestamp of the block in which the preclaim was made
}
/** @param collateralRate Sets the collateral needed per share to file a claim */
uint256 public collateralRate = 5*10**15 wei;
uint256 public claimPeriod = 60*60*24*180; // In seconds ;
uint256 public preClaimPeriod = 60*60*24; // In seconds ;
mapping(address => Claim) public claims; // there can be at most one claim per address, here address is claimed address
mapping(address => PreClaim) public preClaims; // there can be at most one preclaim per address, here address is claimer
function setClaimParameters(uint256 _collateralRateInWei, uint256 _claimPeriodInDays) public onlyOwner() {
}
event ClaimMade(address indexed _lostAddress, address indexed _claimant, uint256 _balance);
event ClaimPrepared(address indexed _claimer);
event ClaimCleared(address indexed _lostAddress, uint256 collateral);
event ClaimDeleted(address indexed _lostAddress, address indexed _claimant, uint256 collateral);
event ClaimResolved(address indexed _lostAddress, address indexed _claimant, uint256 collateral);
event ClaimParametersChanged(uint256 _collateralRate, uint256 _claimPeriodInDays);
/** Anyone can declare that the private key to a certain address was lost by calling declareLost
* providing a deposit/collateral. There are three possibilities of what can happen with the claim:
* 1) The claim period expires and the claimant can get the deposit and the shares back by calling resolveClaim
* 2) The "lost" private key is used at any time to call clearClaim. In that case, the claim is deleted and
* the deposit sent to the shareholder (the owner of the private key). It is recommended to call resolveClaim
* whenever someone transfers funds to let claims be resolved automatically when the "lost" private key is
* used again.
* 3) The owner deletes the claim and assigns the deposit to the claimant. This is intended to be used to resolve
* disputes. Generally, using this function implies that you have to trust the issuer of the tokens to handle
* the situation well. As a rule of thumb, the contract owner should assume the owner of the lost address to be the
* rightful owner of the deposit.
* It is highly recommended that the owner observes the claims made and informs the owners of the claimed addresses
* whenever a claim is made for their address (this of course is only possible if they are known to the owner, e.g.
* through a shareholder register).
* To prevent frontrunning attacks, a claim can only be made if the information revealed when calling "declareLost"
* was previously commited using the "prepareClaim" function.
*/
function prepareClaim(bytes32 _hashedpackage) public{
}
function validateClaim(address _lostAddress, bytes32 _nonce) private view returns (bool){
PreClaim memory preClaim = preClaims[msg.sender];
require(preClaim.msghash != 0);
require(<FILL_ME>)
require(preClaim.timestamp + 2*preClaimPeriod >= block.timestamp);
return preClaim.msghash == keccak256(abi.encodePacked(_nonce, msg.sender, _lostAddress));
}
function declareLost(address _lostAddress, bytes32 _nonce) public payable{
}
function getClaimant(address _lostAddress) public view returns (address){
}
function getCollateral(address _lostAddress) public view returns (uint256){
}
function getTimeStamp(address _lostAddress) public view returns (uint256){
}
function getPreClaimTimeStamp(address _claimerAddress) public view returns (uint256){
}
function getMsgHash(address _claimerAddress) public view returns (bytes32){
}
/**
* @dev Clears a claim after the key has been found again and assigns the collateral to the "lost" address.
*/
function clearClaim() public returns (uint256){
}
/**
* @dev This function is used to resolve a claim.
* @dev After waiting period, the tokens on the lost address and collateral can be transferred.
*/
function resolveClaim(address _lostAddress) public returns (uint256){
}
function internalTransfer(address _from, address _to, uint256 _value) internal;
/** @dev This function is to be executed by the owner only in case a dispute needs to be resolved manually. */
function deleteClaim(address _lostAddress) public onlyOwner(){
}
}
contract AlethenaShares is ERC20, Claimable {
string public constant name = "Alethena Equity";
string public constant symbol = "ALEQ";
uint8 public constant decimals = 0; // legally, shares are not divisible
using SafeMath for uint256;
/** URL where the source code as well as the terms and conditions can be found. */
string public constant termsAndConditions = "shares.alethena.com";
mapping(address => uint256) balances;
uint256 totalSupply_; // total number of tokenized shares, sum of all balances
uint256 totalShares_ = 1397188; // total number of outstanding shares, maybe not all tokenized
event Mint(address indexed shareholder, uint256 amount, string message);
event Unmint(uint256 amount, string message);
/** @dev Total number of tokens in existence */
function totalSupply() public view returns (uint256) {
}
/** @dev Total number of shares in existence, not necessarily all represented by a token.
* @dev This could be useful to calculate the total market cap.
*/
function totalShares() public view returns (uint256) {
}
function setTotalShares(uint256 _newTotalShares) public onlyOwner() {
}
/** Increases the number of the tokenized shares. If the shares are newly issued, the share total also needs to be increased. */
function mint(address shareholder, uint256 _amount, string _message) public onlyOwner() {
}
/** Decrease the number of the tokenized shares. There are two use-cases for this function:
* 1) a capital decrease with a destruction of the shares, in which case the law requires that the
* destroyed shares are currently owned by the company.
* 2) a shareholder wants to take shares offline. This can only happen with the agreement of the
* the company. To do so, the shares must be transferred to the company first, the company call
* this function and then assigning the untokenized shares back to the shareholder in whatever
* way the new form (e.g. printed certificate) of the shares requires.
*/
function unmint(uint256 _amount, string _message) public onlyOwner() {
}
/** This contract is pausible. */
bool public isPaused = false;
/** @dev Function to set pause.
* This could for example be used in case of a fork of the network, in which case all
* "wrong" forked contracts should be paused in their respective fork. Deciding which
* fork is the "right" one is up to the owner of the contract.
*/
function pause(bool _pause, string _message, address _newAddress, uint256 _fromBlock) public onlyOwner() {
}
event Pause(bool paused, string message, address newAddress, uint256 fromBlock);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
The next section contains standard ERC20 routines.
Main change: Transfer functions have an additional post function which resolves claims if applicable.
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @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) {
}
function internalTransfer(address _from, address _to, uint256 _value) internal {
}
/**
* @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 view returns (uint256) {
}
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @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) {
}
event Approval(address approver, address spender, uint256 value);
/**
* @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 view returns (uint256) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
}
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
| preClaim.timestamp+preClaimPeriod<=block.timestamp | 16,671 | preClaim.timestamp+preClaimPeriod<=block.timestamp |
null | pragma solidity ^0.4.24;
// This is the Alethena Share Token.
// To learn more, visit https://github.com/Alethena/Alethena-Shares-Token
// Or contact us at [email protected]
contract ERC20Basic {
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);
}
contract ERC20 is ERC20Basic {
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);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable {
address public owner;
address public master = 0x8fED3492dB590ad34ed42b0F509EB3c9626246Fc;
event OwnershipRenounced(address indexed previousOwner);
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 relinquish control of the contract.
*/
function renounceOwnership() public onlyOwner {
}
/**
* @dev Allows the master to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function _transferOwnership(address _newOwner) internal {
}
}
contract Claimable is ERC20Basic, Ownable {
using SafeMath for uint256;
struct Claim {
address claimant; // the person who created the claim
uint256 collateral; // the amount of wei deposited
uint256 timestamp; // the timestamp of the block in which the claim was made
}
struct PreClaim {
bytes32 msghash; // the hash of nonce + address to be claimed
uint256 timestamp; // the timestamp of the block in which the preclaim was made
}
/** @param collateralRate Sets the collateral needed per share to file a claim */
uint256 public collateralRate = 5*10**15 wei;
uint256 public claimPeriod = 60*60*24*180; // In seconds ;
uint256 public preClaimPeriod = 60*60*24; // In seconds ;
mapping(address => Claim) public claims; // there can be at most one claim per address, here address is claimed address
mapping(address => PreClaim) public preClaims; // there can be at most one preclaim per address, here address is claimer
function setClaimParameters(uint256 _collateralRateInWei, uint256 _claimPeriodInDays) public onlyOwner() {
}
event ClaimMade(address indexed _lostAddress, address indexed _claimant, uint256 _balance);
event ClaimPrepared(address indexed _claimer);
event ClaimCleared(address indexed _lostAddress, uint256 collateral);
event ClaimDeleted(address indexed _lostAddress, address indexed _claimant, uint256 collateral);
event ClaimResolved(address indexed _lostAddress, address indexed _claimant, uint256 collateral);
event ClaimParametersChanged(uint256 _collateralRate, uint256 _claimPeriodInDays);
/** Anyone can declare that the private key to a certain address was lost by calling declareLost
* providing a deposit/collateral. There are three possibilities of what can happen with the claim:
* 1) The claim period expires and the claimant can get the deposit and the shares back by calling resolveClaim
* 2) The "lost" private key is used at any time to call clearClaim. In that case, the claim is deleted and
* the deposit sent to the shareholder (the owner of the private key). It is recommended to call resolveClaim
* whenever someone transfers funds to let claims be resolved automatically when the "lost" private key is
* used again.
* 3) The owner deletes the claim and assigns the deposit to the claimant. This is intended to be used to resolve
* disputes. Generally, using this function implies that you have to trust the issuer of the tokens to handle
* the situation well. As a rule of thumb, the contract owner should assume the owner of the lost address to be the
* rightful owner of the deposit.
* It is highly recommended that the owner observes the claims made and informs the owners of the claimed addresses
* whenever a claim is made for their address (this of course is only possible if they are known to the owner, e.g.
* through a shareholder register).
* To prevent frontrunning attacks, a claim can only be made if the information revealed when calling "declareLost"
* was previously commited using the "prepareClaim" function.
*/
function prepareClaim(bytes32 _hashedpackage) public{
}
function validateClaim(address _lostAddress, bytes32 _nonce) private view returns (bool){
PreClaim memory preClaim = preClaims[msg.sender];
require(preClaim.msghash != 0);
require(preClaim.timestamp + preClaimPeriod <= block.timestamp);
require(<FILL_ME>)
return preClaim.msghash == keccak256(abi.encodePacked(_nonce, msg.sender, _lostAddress));
}
function declareLost(address _lostAddress, bytes32 _nonce) public payable{
}
function getClaimant(address _lostAddress) public view returns (address){
}
function getCollateral(address _lostAddress) public view returns (uint256){
}
function getTimeStamp(address _lostAddress) public view returns (uint256){
}
function getPreClaimTimeStamp(address _claimerAddress) public view returns (uint256){
}
function getMsgHash(address _claimerAddress) public view returns (bytes32){
}
/**
* @dev Clears a claim after the key has been found again and assigns the collateral to the "lost" address.
*/
function clearClaim() public returns (uint256){
}
/**
* @dev This function is used to resolve a claim.
* @dev After waiting period, the tokens on the lost address and collateral can be transferred.
*/
function resolveClaim(address _lostAddress) public returns (uint256){
}
function internalTransfer(address _from, address _to, uint256 _value) internal;
/** @dev This function is to be executed by the owner only in case a dispute needs to be resolved manually. */
function deleteClaim(address _lostAddress) public onlyOwner(){
}
}
contract AlethenaShares is ERC20, Claimable {
string public constant name = "Alethena Equity";
string public constant symbol = "ALEQ";
uint8 public constant decimals = 0; // legally, shares are not divisible
using SafeMath for uint256;
/** URL where the source code as well as the terms and conditions can be found. */
string public constant termsAndConditions = "shares.alethena.com";
mapping(address => uint256) balances;
uint256 totalSupply_; // total number of tokenized shares, sum of all balances
uint256 totalShares_ = 1397188; // total number of outstanding shares, maybe not all tokenized
event Mint(address indexed shareholder, uint256 amount, string message);
event Unmint(uint256 amount, string message);
/** @dev Total number of tokens in existence */
function totalSupply() public view returns (uint256) {
}
/** @dev Total number of shares in existence, not necessarily all represented by a token.
* @dev This could be useful to calculate the total market cap.
*/
function totalShares() public view returns (uint256) {
}
function setTotalShares(uint256 _newTotalShares) public onlyOwner() {
}
/** Increases the number of the tokenized shares. If the shares are newly issued, the share total also needs to be increased. */
function mint(address shareholder, uint256 _amount, string _message) public onlyOwner() {
}
/** Decrease the number of the tokenized shares. There are two use-cases for this function:
* 1) a capital decrease with a destruction of the shares, in which case the law requires that the
* destroyed shares are currently owned by the company.
* 2) a shareholder wants to take shares offline. This can only happen with the agreement of the
* the company. To do so, the shares must be transferred to the company first, the company call
* this function and then assigning the untokenized shares back to the shareholder in whatever
* way the new form (e.g. printed certificate) of the shares requires.
*/
function unmint(uint256 _amount, string _message) public onlyOwner() {
}
/** This contract is pausible. */
bool public isPaused = false;
/** @dev Function to set pause.
* This could for example be used in case of a fork of the network, in which case all
* "wrong" forked contracts should be paused in their respective fork. Deciding which
* fork is the "right" one is up to the owner of the contract.
*/
function pause(bool _pause, string _message, address _newAddress, uint256 _fromBlock) public onlyOwner() {
}
event Pause(bool paused, string message, address newAddress, uint256 fromBlock);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
The next section contains standard ERC20 routines.
Main change: Transfer functions have an additional post function which resolves claims if applicable.
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @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) {
}
function internalTransfer(address _from, address _to, uint256 _value) internal {
}
/**
* @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 view returns (uint256) {
}
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @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) {
}
event Approval(address approver, address spender, uint256 value);
/**
* @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 view returns (uint256) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
}
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
| preClaim.timestamp+2*preClaimPeriod>=block.timestamp | 16,671 | preClaim.timestamp+2*preClaimPeriod>=block.timestamp |
null | pragma solidity ^0.4.24;
// This is the Alethena Share Token.
// To learn more, visit https://github.com/Alethena/Alethena-Shares-Token
// Or contact us at [email protected]
contract ERC20Basic {
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);
}
contract ERC20 is ERC20Basic {
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);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable {
address public owner;
address public master = 0x8fED3492dB590ad34ed42b0F509EB3c9626246Fc;
event OwnershipRenounced(address indexed previousOwner);
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 relinquish control of the contract.
*/
function renounceOwnership() public onlyOwner {
}
/**
* @dev Allows the master to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function _transferOwnership(address _newOwner) internal {
}
}
contract Claimable is ERC20Basic, Ownable {
using SafeMath for uint256;
struct Claim {
address claimant; // the person who created the claim
uint256 collateral; // the amount of wei deposited
uint256 timestamp; // the timestamp of the block in which the claim was made
}
struct PreClaim {
bytes32 msghash; // the hash of nonce + address to be claimed
uint256 timestamp; // the timestamp of the block in which the preclaim was made
}
/** @param collateralRate Sets the collateral needed per share to file a claim */
uint256 public collateralRate = 5*10**15 wei;
uint256 public claimPeriod = 60*60*24*180; // In seconds ;
uint256 public preClaimPeriod = 60*60*24; // In seconds ;
mapping(address => Claim) public claims; // there can be at most one claim per address, here address is claimed address
mapping(address => PreClaim) public preClaims; // there can be at most one preclaim per address, here address is claimer
function setClaimParameters(uint256 _collateralRateInWei, uint256 _claimPeriodInDays) public onlyOwner() {
}
event ClaimMade(address indexed _lostAddress, address indexed _claimant, uint256 _balance);
event ClaimPrepared(address indexed _claimer);
event ClaimCleared(address indexed _lostAddress, uint256 collateral);
event ClaimDeleted(address indexed _lostAddress, address indexed _claimant, uint256 collateral);
event ClaimResolved(address indexed _lostAddress, address indexed _claimant, uint256 collateral);
event ClaimParametersChanged(uint256 _collateralRate, uint256 _claimPeriodInDays);
/** Anyone can declare that the private key to a certain address was lost by calling declareLost
* providing a deposit/collateral. There are three possibilities of what can happen with the claim:
* 1) The claim period expires and the claimant can get the deposit and the shares back by calling resolveClaim
* 2) The "lost" private key is used at any time to call clearClaim. In that case, the claim is deleted and
* the deposit sent to the shareholder (the owner of the private key). It is recommended to call resolveClaim
* whenever someone transfers funds to let claims be resolved automatically when the "lost" private key is
* used again.
* 3) The owner deletes the claim and assigns the deposit to the claimant. This is intended to be used to resolve
* disputes. Generally, using this function implies that you have to trust the issuer of the tokens to handle
* the situation well. As a rule of thumb, the contract owner should assume the owner of the lost address to be the
* rightful owner of the deposit.
* It is highly recommended that the owner observes the claims made and informs the owners of the claimed addresses
* whenever a claim is made for their address (this of course is only possible if they are known to the owner, e.g.
* through a shareholder register).
* To prevent frontrunning attacks, a claim can only be made if the information revealed when calling "declareLost"
* was previously commited using the "prepareClaim" function.
*/
function prepareClaim(bytes32 _hashedpackage) public{
}
function validateClaim(address _lostAddress, bytes32 _nonce) private view returns (bool){
}
function declareLost(address _lostAddress, bytes32 _nonce) public payable{
uint256 balance = balanceOf(_lostAddress);
require(balance > 0);
require(msg.value >= balance.mul(collateralRate));
require(<FILL_ME>)
require(validateClaim(_lostAddress, _nonce));
claims[_lostAddress] = Claim({
claimant: msg.sender,
collateral: msg.value,
timestamp: block.timestamp
});
delete preClaims[msg.sender];
emit ClaimMade(_lostAddress, msg.sender, balance);
}
function getClaimant(address _lostAddress) public view returns (address){
}
function getCollateral(address _lostAddress) public view returns (uint256){
}
function getTimeStamp(address _lostAddress) public view returns (uint256){
}
function getPreClaimTimeStamp(address _claimerAddress) public view returns (uint256){
}
function getMsgHash(address _claimerAddress) public view returns (bytes32){
}
/**
* @dev Clears a claim after the key has been found again and assigns the collateral to the "lost" address.
*/
function clearClaim() public returns (uint256){
}
/**
* @dev This function is used to resolve a claim.
* @dev After waiting period, the tokens on the lost address and collateral can be transferred.
*/
function resolveClaim(address _lostAddress) public returns (uint256){
}
function internalTransfer(address _from, address _to, uint256 _value) internal;
/** @dev This function is to be executed by the owner only in case a dispute needs to be resolved manually. */
function deleteClaim(address _lostAddress) public onlyOwner(){
}
}
contract AlethenaShares is ERC20, Claimable {
string public constant name = "Alethena Equity";
string public constant symbol = "ALEQ";
uint8 public constant decimals = 0; // legally, shares are not divisible
using SafeMath for uint256;
/** URL where the source code as well as the terms and conditions can be found. */
string public constant termsAndConditions = "shares.alethena.com";
mapping(address => uint256) balances;
uint256 totalSupply_; // total number of tokenized shares, sum of all balances
uint256 totalShares_ = 1397188; // total number of outstanding shares, maybe not all tokenized
event Mint(address indexed shareholder, uint256 amount, string message);
event Unmint(uint256 amount, string message);
/** @dev Total number of tokens in existence */
function totalSupply() public view returns (uint256) {
}
/** @dev Total number of shares in existence, not necessarily all represented by a token.
* @dev This could be useful to calculate the total market cap.
*/
function totalShares() public view returns (uint256) {
}
function setTotalShares(uint256 _newTotalShares) public onlyOwner() {
}
/** Increases the number of the tokenized shares. If the shares are newly issued, the share total also needs to be increased. */
function mint(address shareholder, uint256 _amount, string _message) public onlyOwner() {
}
/** Decrease the number of the tokenized shares. There are two use-cases for this function:
* 1) a capital decrease with a destruction of the shares, in which case the law requires that the
* destroyed shares are currently owned by the company.
* 2) a shareholder wants to take shares offline. This can only happen with the agreement of the
* the company. To do so, the shares must be transferred to the company first, the company call
* this function and then assigning the untokenized shares back to the shareholder in whatever
* way the new form (e.g. printed certificate) of the shares requires.
*/
function unmint(uint256 _amount, string _message) public onlyOwner() {
}
/** This contract is pausible. */
bool public isPaused = false;
/** @dev Function to set pause.
* This could for example be used in case of a fork of the network, in which case all
* "wrong" forked contracts should be paused in their respective fork. Deciding which
* fork is the "right" one is up to the owner of the contract.
*/
function pause(bool _pause, string _message, address _newAddress, uint256 _fromBlock) public onlyOwner() {
}
event Pause(bool paused, string message, address newAddress, uint256 fromBlock);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
The next section contains standard ERC20 routines.
Main change: Transfer functions have an additional post function which resolves claims if applicable.
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @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) {
}
function internalTransfer(address _from, address _to, uint256 _value) internal {
}
/**
* @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 view returns (uint256) {
}
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @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) {
}
event Approval(address approver, address spender, uint256 value);
/**
* @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 view returns (uint256) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
}
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
| claims[_lostAddress].collateral==0 | 16,671 | claims[_lostAddress].collateral==0 |
null | pragma solidity ^0.4.24;
// This is the Alethena Share Token.
// To learn more, visit https://github.com/Alethena/Alethena-Shares-Token
// Or contact us at [email protected]
contract ERC20Basic {
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);
}
contract ERC20 is ERC20Basic {
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);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable {
address public owner;
address public master = 0x8fED3492dB590ad34ed42b0F509EB3c9626246Fc;
event OwnershipRenounced(address indexed previousOwner);
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 relinquish control of the contract.
*/
function renounceOwnership() public onlyOwner {
}
/**
* @dev Allows the master to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function _transferOwnership(address _newOwner) internal {
}
}
contract Claimable is ERC20Basic, Ownable {
using SafeMath for uint256;
struct Claim {
address claimant; // the person who created the claim
uint256 collateral; // the amount of wei deposited
uint256 timestamp; // the timestamp of the block in which the claim was made
}
struct PreClaim {
bytes32 msghash; // the hash of nonce + address to be claimed
uint256 timestamp; // the timestamp of the block in which the preclaim was made
}
/** @param collateralRate Sets the collateral needed per share to file a claim */
uint256 public collateralRate = 5*10**15 wei;
uint256 public claimPeriod = 60*60*24*180; // In seconds ;
uint256 public preClaimPeriod = 60*60*24; // In seconds ;
mapping(address => Claim) public claims; // there can be at most one claim per address, here address is claimed address
mapping(address => PreClaim) public preClaims; // there can be at most one preclaim per address, here address is claimer
function setClaimParameters(uint256 _collateralRateInWei, uint256 _claimPeriodInDays) public onlyOwner() {
}
event ClaimMade(address indexed _lostAddress, address indexed _claimant, uint256 _balance);
event ClaimPrepared(address indexed _claimer);
event ClaimCleared(address indexed _lostAddress, uint256 collateral);
event ClaimDeleted(address indexed _lostAddress, address indexed _claimant, uint256 collateral);
event ClaimResolved(address indexed _lostAddress, address indexed _claimant, uint256 collateral);
event ClaimParametersChanged(uint256 _collateralRate, uint256 _claimPeriodInDays);
/** Anyone can declare that the private key to a certain address was lost by calling declareLost
* providing a deposit/collateral. There are three possibilities of what can happen with the claim:
* 1) The claim period expires and the claimant can get the deposit and the shares back by calling resolveClaim
* 2) The "lost" private key is used at any time to call clearClaim. In that case, the claim is deleted and
* the deposit sent to the shareholder (the owner of the private key). It is recommended to call resolveClaim
* whenever someone transfers funds to let claims be resolved automatically when the "lost" private key is
* used again.
* 3) The owner deletes the claim and assigns the deposit to the claimant. This is intended to be used to resolve
* disputes. Generally, using this function implies that you have to trust the issuer of the tokens to handle
* the situation well. As a rule of thumb, the contract owner should assume the owner of the lost address to be the
* rightful owner of the deposit.
* It is highly recommended that the owner observes the claims made and informs the owners of the claimed addresses
* whenever a claim is made for their address (this of course is only possible if they are known to the owner, e.g.
* through a shareholder register).
* To prevent frontrunning attacks, a claim can only be made if the information revealed when calling "declareLost"
* was previously commited using the "prepareClaim" function.
*/
function prepareClaim(bytes32 _hashedpackage) public{
}
function validateClaim(address _lostAddress, bytes32 _nonce) private view returns (bool){
}
function declareLost(address _lostAddress, bytes32 _nonce) public payable{
uint256 balance = balanceOf(_lostAddress);
require(balance > 0);
require(msg.value >= balance.mul(collateralRate));
require(claims[_lostAddress].collateral == 0);
require(<FILL_ME>)
claims[_lostAddress] = Claim({
claimant: msg.sender,
collateral: msg.value,
timestamp: block.timestamp
});
delete preClaims[msg.sender];
emit ClaimMade(_lostAddress, msg.sender, balance);
}
function getClaimant(address _lostAddress) public view returns (address){
}
function getCollateral(address _lostAddress) public view returns (uint256){
}
function getTimeStamp(address _lostAddress) public view returns (uint256){
}
function getPreClaimTimeStamp(address _claimerAddress) public view returns (uint256){
}
function getMsgHash(address _claimerAddress) public view returns (bytes32){
}
/**
* @dev Clears a claim after the key has been found again and assigns the collateral to the "lost" address.
*/
function clearClaim() public returns (uint256){
}
/**
* @dev This function is used to resolve a claim.
* @dev After waiting period, the tokens on the lost address and collateral can be transferred.
*/
function resolveClaim(address _lostAddress) public returns (uint256){
}
function internalTransfer(address _from, address _to, uint256 _value) internal;
/** @dev This function is to be executed by the owner only in case a dispute needs to be resolved manually. */
function deleteClaim(address _lostAddress) public onlyOwner(){
}
}
contract AlethenaShares is ERC20, Claimable {
string public constant name = "Alethena Equity";
string public constant symbol = "ALEQ";
uint8 public constant decimals = 0; // legally, shares are not divisible
using SafeMath for uint256;
/** URL where the source code as well as the terms and conditions can be found. */
string public constant termsAndConditions = "shares.alethena.com";
mapping(address => uint256) balances;
uint256 totalSupply_; // total number of tokenized shares, sum of all balances
uint256 totalShares_ = 1397188; // total number of outstanding shares, maybe not all tokenized
event Mint(address indexed shareholder, uint256 amount, string message);
event Unmint(uint256 amount, string message);
/** @dev Total number of tokens in existence */
function totalSupply() public view returns (uint256) {
}
/** @dev Total number of shares in existence, not necessarily all represented by a token.
* @dev This could be useful to calculate the total market cap.
*/
function totalShares() public view returns (uint256) {
}
function setTotalShares(uint256 _newTotalShares) public onlyOwner() {
}
/** Increases the number of the tokenized shares. If the shares are newly issued, the share total also needs to be increased. */
function mint(address shareholder, uint256 _amount, string _message) public onlyOwner() {
}
/** Decrease the number of the tokenized shares. There are two use-cases for this function:
* 1) a capital decrease with a destruction of the shares, in which case the law requires that the
* destroyed shares are currently owned by the company.
* 2) a shareholder wants to take shares offline. This can only happen with the agreement of the
* the company. To do so, the shares must be transferred to the company first, the company call
* this function and then assigning the untokenized shares back to the shareholder in whatever
* way the new form (e.g. printed certificate) of the shares requires.
*/
function unmint(uint256 _amount, string _message) public onlyOwner() {
}
/** This contract is pausible. */
bool public isPaused = false;
/** @dev Function to set pause.
* This could for example be used in case of a fork of the network, in which case all
* "wrong" forked contracts should be paused in their respective fork. Deciding which
* fork is the "right" one is up to the owner of the contract.
*/
function pause(bool _pause, string _message, address _newAddress, uint256 _fromBlock) public onlyOwner() {
}
event Pause(bool paused, string message, address newAddress, uint256 fromBlock);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
The next section contains standard ERC20 routines.
Main change: Transfer functions have an additional post function which resolves claims if applicable.
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @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) {
}
function internalTransfer(address _from, address _to, uint256 _value) internal {
}
/**
* @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 view returns (uint256) {
}
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @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) {
}
event Approval(address approver, address spender, uint256 value);
/**
* @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 view returns (uint256) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
}
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
| validateClaim(_lostAddress,_nonce) | 16,671 | validateClaim(_lostAddress,_nonce) |
null | pragma solidity ^0.4.24;
// This is the Alethena Share Token.
// To learn more, visit https://github.com/Alethena/Alethena-Shares-Token
// Or contact us at [email protected]
contract ERC20Basic {
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);
}
contract ERC20 is ERC20Basic {
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);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable {
address public owner;
address public master = 0x8fED3492dB590ad34ed42b0F509EB3c9626246Fc;
event OwnershipRenounced(address indexed previousOwner);
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 relinquish control of the contract.
*/
function renounceOwnership() public onlyOwner {
}
/**
* @dev Allows the master to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function _transferOwnership(address _newOwner) internal {
}
}
contract Claimable is ERC20Basic, Ownable {
using SafeMath for uint256;
struct Claim {
address claimant; // the person who created the claim
uint256 collateral; // the amount of wei deposited
uint256 timestamp; // the timestamp of the block in which the claim was made
}
struct PreClaim {
bytes32 msghash; // the hash of nonce + address to be claimed
uint256 timestamp; // the timestamp of the block in which the preclaim was made
}
/** @param collateralRate Sets the collateral needed per share to file a claim */
uint256 public collateralRate = 5*10**15 wei;
uint256 public claimPeriod = 60*60*24*180; // In seconds ;
uint256 public preClaimPeriod = 60*60*24; // In seconds ;
mapping(address => Claim) public claims; // there can be at most one claim per address, here address is claimed address
mapping(address => PreClaim) public preClaims; // there can be at most one preclaim per address, here address is claimer
function setClaimParameters(uint256 _collateralRateInWei, uint256 _claimPeriodInDays) public onlyOwner() {
}
event ClaimMade(address indexed _lostAddress, address indexed _claimant, uint256 _balance);
event ClaimPrepared(address indexed _claimer);
event ClaimCleared(address indexed _lostAddress, uint256 collateral);
event ClaimDeleted(address indexed _lostAddress, address indexed _claimant, uint256 collateral);
event ClaimResolved(address indexed _lostAddress, address indexed _claimant, uint256 collateral);
event ClaimParametersChanged(uint256 _collateralRate, uint256 _claimPeriodInDays);
/** Anyone can declare that the private key to a certain address was lost by calling declareLost
* providing a deposit/collateral. There are three possibilities of what can happen with the claim:
* 1) The claim period expires and the claimant can get the deposit and the shares back by calling resolveClaim
* 2) The "lost" private key is used at any time to call clearClaim. In that case, the claim is deleted and
* the deposit sent to the shareholder (the owner of the private key). It is recommended to call resolveClaim
* whenever someone transfers funds to let claims be resolved automatically when the "lost" private key is
* used again.
* 3) The owner deletes the claim and assigns the deposit to the claimant. This is intended to be used to resolve
* disputes. Generally, using this function implies that you have to trust the issuer of the tokens to handle
* the situation well. As a rule of thumb, the contract owner should assume the owner of the lost address to be the
* rightful owner of the deposit.
* It is highly recommended that the owner observes the claims made and informs the owners of the claimed addresses
* whenever a claim is made for their address (this of course is only possible if they are known to the owner, e.g.
* through a shareholder register).
* To prevent frontrunning attacks, a claim can only be made if the information revealed when calling "declareLost"
* was previously commited using the "prepareClaim" function.
*/
function prepareClaim(bytes32 _hashedpackage) public{
}
function validateClaim(address _lostAddress, bytes32 _nonce) private view returns (bool){
}
function declareLost(address _lostAddress, bytes32 _nonce) public payable{
}
function getClaimant(address _lostAddress) public view returns (address){
}
function getCollateral(address _lostAddress) public view returns (uint256){
}
function getTimeStamp(address _lostAddress) public view returns (uint256){
}
function getPreClaimTimeStamp(address _claimerAddress) public view returns (uint256){
}
function getMsgHash(address _claimerAddress) public view returns (bytes32){
}
/**
* @dev Clears a claim after the key has been found again and assigns the collateral to the "lost" address.
*/
function clearClaim() public returns (uint256){
}
/**
* @dev This function is used to resolve a claim.
* @dev After waiting period, the tokens on the lost address and collateral can be transferred.
*/
function resolveClaim(address _lostAddress) public returns (uint256){
Claim memory claim = claims[_lostAddress];
require(claim.collateral != 0, "No claim found");
require(claim.claimant == msg.sender);
require(<FILL_ME>)
address claimant = claim.claimant;
delete claims[_lostAddress];
claimant.transfer(claim.collateral);
internalTransfer(_lostAddress, claimant, balanceOf(_lostAddress));
emit ClaimResolved(_lostAddress, claimant, claim.collateral);
return claim.collateral;
}
function internalTransfer(address _from, address _to, uint256 _value) internal;
/** @dev This function is to be executed by the owner only in case a dispute needs to be resolved manually. */
function deleteClaim(address _lostAddress) public onlyOwner(){
}
}
contract AlethenaShares is ERC20, Claimable {
string public constant name = "Alethena Equity";
string public constant symbol = "ALEQ";
uint8 public constant decimals = 0; // legally, shares are not divisible
using SafeMath for uint256;
/** URL where the source code as well as the terms and conditions can be found. */
string public constant termsAndConditions = "shares.alethena.com";
mapping(address => uint256) balances;
uint256 totalSupply_; // total number of tokenized shares, sum of all balances
uint256 totalShares_ = 1397188; // total number of outstanding shares, maybe not all tokenized
event Mint(address indexed shareholder, uint256 amount, string message);
event Unmint(uint256 amount, string message);
/** @dev Total number of tokens in existence */
function totalSupply() public view returns (uint256) {
}
/** @dev Total number of shares in existence, not necessarily all represented by a token.
* @dev This could be useful to calculate the total market cap.
*/
function totalShares() public view returns (uint256) {
}
function setTotalShares(uint256 _newTotalShares) public onlyOwner() {
}
/** Increases the number of the tokenized shares. If the shares are newly issued, the share total also needs to be increased. */
function mint(address shareholder, uint256 _amount, string _message) public onlyOwner() {
}
/** Decrease the number of the tokenized shares. There are two use-cases for this function:
* 1) a capital decrease with a destruction of the shares, in which case the law requires that the
* destroyed shares are currently owned by the company.
* 2) a shareholder wants to take shares offline. This can only happen with the agreement of the
* the company. To do so, the shares must be transferred to the company first, the company call
* this function and then assigning the untokenized shares back to the shareholder in whatever
* way the new form (e.g. printed certificate) of the shares requires.
*/
function unmint(uint256 _amount, string _message) public onlyOwner() {
}
/** This contract is pausible. */
bool public isPaused = false;
/** @dev Function to set pause.
* This could for example be used in case of a fork of the network, in which case all
* "wrong" forked contracts should be paused in their respective fork. Deciding which
* fork is the "right" one is up to the owner of the contract.
*/
function pause(bool _pause, string _message, address _newAddress, uint256 _fromBlock) public onlyOwner() {
}
event Pause(bool paused, string message, address newAddress, uint256 fromBlock);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
The next section contains standard ERC20 routines.
Main change: Transfer functions have an additional post function which resolves claims if applicable.
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @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) {
}
function internalTransfer(address _from, address _to, uint256 _value) internal {
}
/**
* @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 view returns (uint256) {
}
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @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) {
}
event Approval(address approver, address spender, uint256 value);
/**
* @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 view returns (uint256) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
}
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
| claim.timestamp+claimPeriod<=block.timestamp | 16,671 | claim.timestamp+claimPeriod<=block.timestamp |
null | pragma solidity ^0.4.24;
// This is the Alethena Share Token.
// To learn more, visit https://github.com/Alethena/Alethena-Shares-Token
// Or contact us at [email protected]
contract ERC20Basic {
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);
}
contract ERC20 is ERC20Basic {
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);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable {
address public owner;
address public master = 0x8fED3492dB590ad34ed42b0F509EB3c9626246Fc;
event OwnershipRenounced(address indexed previousOwner);
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 relinquish control of the contract.
*/
function renounceOwnership() public onlyOwner {
}
/**
* @dev Allows the master to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function _transferOwnership(address _newOwner) internal {
}
}
contract Claimable is ERC20Basic, Ownable {
using SafeMath for uint256;
struct Claim {
address claimant; // the person who created the claim
uint256 collateral; // the amount of wei deposited
uint256 timestamp; // the timestamp of the block in which the claim was made
}
struct PreClaim {
bytes32 msghash; // the hash of nonce + address to be claimed
uint256 timestamp; // the timestamp of the block in which the preclaim was made
}
/** @param collateralRate Sets the collateral needed per share to file a claim */
uint256 public collateralRate = 5*10**15 wei;
uint256 public claimPeriod = 60*60*24*180; // In seconds ;
uint256 public preClaimPeriod = 60*60*24; // In seconds ;
mapping(address => Claim) public claims; // there can be at most one claim per address, here address is claimed address
mapping(address => PreClaim) public preClaims; // there can be at most one preclaim per address, here address is claimer
function setClaimParameters(uint256 _collateralRateInWei, uint256 _claimPeriodInDays) public onlyOwner() {
}
event ClaimMade(address indexed _lostAddress, address indexed _claimant, uint256 _balance);
event ClaimPrepared(address indexed _claimer);
event ClaimCleared(address indexed _lostAddress, uint256 collateral);
event ClaimDeleted(address indexed _lostAddress, address indexed _claimant, uint256 collateral);
event ClaimResolved(address indexed _lostAddress, address indexed _claimant, uint256 collateral);
event ClaimParametersChanged(uint256 _collateralRate, uint256 _claimPeriodInDays);
/** Anyone can declare that the private key to a certain address was lost by calling declareLost
* providing a deposit/collateral. There are three possibilities of what can happen with the claim:
* 1) The claim period expires and the claimant can get the deposit and the shares back by calling resolveClaim
* 2) The "lost" private key is used at any time to call clearClaim. In that case, the claim is deleted and
* the deposit sent to the shareholder (the owner of the private key). It is recommended to call resolveClaim
* whenever someone transfers funds to let claims be resolved automatically when the "lost" private key is
* used again.
* 3) The owner deletes the claim and assigns the deposit to the claimant. This is intended to be used to resolve
* disputes. Generally, using this function implies that you have to trust the issuer of the tokens to handle
* the situation well. As a rule of thumb, the contract owner should assume the owner of the lost address to be the
* rightful owner of the deposit.
* It is highly recommended that the owner observes the claims made and informs the owners of the claimed addresses
* whenever a claim is made for their address (this of course is only possible if they are known to the owner, e.g.
* through a shareholder register).
* To prevent frontrunning attacks, a claim can only be made if the information revealed when calling "declareLost"
* was previously commited using the "prepareClaim" function.
*/
function prepareClaim(bytes32 _hashedpackage) public{
}
function validateClaim(address _lostAddress, bytes32 _nonce) private view returns (bool){
}
function declareLost(address _lostAddress, bytes32 _nonce) public payable{
}
function getClaimant(address _lostAddress) public view returns (address){
}
function getCollateral(address _lostAddress) public view returns (uint256){
}
function getTimeStamp(address _lostAddress) public view returns (uint256){
}
function getPreClaimTimeStamp(address _claimerAddress) public view returns (uint256){
}
function getMsgHash(address _claimerAddress) public view returns (bytes32){
}
/**
* @dev Clears a claim after the key has been found again and assigns the collateral to the "lost" address.
*/
function clearClaim() public returns (uint256){
}
/**
* @dev This function is used to resolve a claim.
* @dev After waiting period, the tokens on the lost address and collateral can be transferred.
*/
function resolveClaim(address _lostAddress) public returns (uint256){
}
function internalTransfer(address _from, address _to, uint256 _value) internal;
/** @dev This function is to be executed by the owner only in case a dispute needs to be resolved manually. */
function deleteClaim(address _lostAddress) public onlyOwner(){
}
}
contract AlethenaShares is ERC20, Claimable {
string public constant name = "Alethena Equity";
string public constant symbol = "ALEQ";
uint8 public constant decimals = 0; // legally, shares are not divisible
using SafeMath for uint256;
/** URL where the source code as well as the terms and conditions can be found. */
string public constant termsAndConditions = "shares.alethena.com";
mapping(address => uint256) balances;
uint256 totalSupply_; // total number of tokenized shares, sum of all balances
uint256 totalShares_ = 1397188; // total number of outstanding shares, maybe not all tokenized
event Mint(address indexed shareholder, uint256 amount, string message);
event Unmint(uint256 amount, string message);
/** @dev Total number of tokens in existence */
function totalSupply() public view returns (uint256) {
}
/** @dev Total number of shares in existence, not necessarily all represented by a token.
* @dev This could be useful to calculate the total market cap.
*/
function totalShares() public view returns (uint256) {
}
function setTotalShares(uint256 _newTotalShares) public onlyOwner() {
}
/** Increases the number of the tokenized shares. If the shares are newly issued, the share total also needs to be increased. */
function mint(address shareholder, uint256 _amount, string _message) public onlyOwner() {
require(_amount > 0);
require(<FILL_ME>)
balances[shareholder] = balances[shareholder].add(_amount);
totalSupply_ = totalSupply_ + _amount;
emit Mint(shareholder, _amount, _message);
}
/** Decrease the number of the tokenized shares. There are two use-cases for this function:
* 1) a capital decrease with a destruction of the shares, in which case the law requires that the
* destroyed shares are currently owned by the company.
* 2) a shareholder wants to take shares offline. This can only happen with the agreement of the
* the company. To do so, the shares must be transferred to the company first, the company call
* this function and then assigning the untokenized shares back to the shareholder in whatever
* way the new form (e.g. printed certificate) of the shares requires.
*/
function unmint(uint256 _amount, string _message) public onlyOwner() {
}
/** This contract is pausible. */
bool public isPaused = false;
/** @dev Function to set pause.
* This could for example be used in case of a fork of the network, in which case all
* "wrong" forked contracts should be paused in their respective fork. Deciding which
* fork is the "right" one is up to the owner of the contract.
*/
function pause(bool _pause, string _message, address _newAddress, uint256 _fromBlock) public onlyOwner() {
}
event Pause(bool paused, string message, address newAddress, uint256 fromBlock);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
The next section contains standard ERC20 routines.
Main change: Transfer functions have an additional post function which resolves claims if applicable.
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @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) {
}
function internalTransfer(address _from, address _to, uint256 _value) internal {
}
/**
* @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 view returns (uint256) {
}
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @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) {
}
event Approval(address approver, address spender, uint256 value);
/**
* @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 view returns (uint256) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
}
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
| totalSupply_.add(_amount)<=totalShares_ | 16,671 | totalSupply_.add(_amount)<=totalShares_ |
null | pragma solidity ^0.4.24;
// This is the Alethena Share Token.
// To learn more, visit https://github.com/Alethena/Alethena-Shares-Token
// Or contact us at [email protected]
contract ERC20Basic {
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);
}
contract ERC20 is ERC20Basic {
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);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable {
address public owner;
address public master = 0x8fED3492dB590ad34ed42b0F509EB3c9626246Fc;
event OwnershipRenounced(address indexed previousOwner);
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 relinquish control of the contract.
*/
function renounceOwnership() public onlyOwner {
}
/**
* @dev Allows the master to transfer control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function transferOwnership(address _newOwner) public {
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param _newOwner The address to transfer ownership to.
*/
function _transferOwnership(address _newOwner) internal {
}
}
contract Claimable is ERC20Basic, Ownable {
using SafeMath for uint256;
struct Claim {
address claimant; // the person who created the claim
uint256 collateral; // the amount of wei deposited
uint256 timestamp; // the timestamp of the block in which the claim was made
}
struct PreClaim {
bytes32 msghash; // the hash of nonce + address to be claimed
uint256 timestamp; // the timestamp of the block in which the preclaim was made
}
/** @param collateralRate Sets the collateral needed per share to file a claim */
uint256 public collateralRate = 5*10**15 wei;
uint256 public claimPeriod = 60*60*24*180; // In seconds ;
uint256 public preClaimPeriod = 60*60*24; // In seconds ;
mapping(address => Claim) public claims; // there can be at most one claim per address, here address is claimed address
mapping(address => PreClaim) public preClaims; // there can be at most one preclaim per address, here address is claimer
function setClaimParameters(uint256 _collateralRateInWei, uint256 _claimPeriodInDays) public onlyOwner() {
}
event ClaimMade(address indexed _lostAddress, address indexed _claimant, uint256 _balance);
event ClaimPrepared(address indexed _claimer);
event ClaimCleared(address indexed _lostAddress, uint256 collateral);
event ClaimDeleted(address indexed _lostAddress, address indexed _claimant, uint256 collateral);
event ClaimResolved(address indexed _lostAddress, address indexed _claimant, uint256 collateral);
event ClaimParametersChanged(uint256 _collateralRate, uint256 _claimPeriodInDays);
/** Anyone can declare that the private key to a certain address was lost by calling declareLost
* providing a deposit/collateral. There are three possibilities of what can happen with the claim:
* 1) The claim period expires and the claimant can get the deposit and the shares back by calling resolveClaim
* 2) The "lost" private key is used at any time to call clearClaim. In that case, the claim is deleted and
* the deposit sent to the shareholder (the owner of the private key). It is recommended to call resolveClaim
* whenever someone transfers funds to let claims be resolved automatically when the "lost" private key is
* used again.
* 3) The owner deletes the claim and assigns the deposit to the claimant. This is intended to be used to resolve
* disputes. Generally, using this function implies that you have to trust the issuer of the tokens to handle
* the situation well. As a rule of thumb, the contract owner should assume the owner of the lost address to be the
* rightful owner of the deposit.
* It is highly recommended that the owner observes the claims made and informs the owners of the claimed addresses
* whenever a claim is made for their address (this of course is only possible if they are known to the owner, e.g.
* through a shareholder register).
* To prevent frontrunning attacks, a claim can only be made if the information revealed when calling "declareLost"
* was previously commited using the "prepareClaim" function.
*/
function prepareClaim(bytes32 _hashedpackage) public{
}
function validateClaim(address _lostAddress, bytes32 _nonce) private view returns (bool){
}
function declareLost(address _lostAddress, bytes32 _nonce) public payable{
}
function getClaimant(address _lostAddress) public view returns (address){
}
function getCollateral(address _lostAddress) public view returns (uint256){
}
function getTimeStamp(address _lostAddress) public view returns (uint256){
}
function getPreClaimTimeStamp(address _claimerAddress) public view returns (uint256){
}
function getMsgHash(address _claimerAddress) public view returns (bytes32){
}
/**
* @dev Clears a claim after the key has been found again and assigns the collateral to the "lost" address.
*/
function clearClaim() public returns (uint256){
}
/**
* @dev This function is used to resolve a claim.
* @dev After waiting period, the tokens on the lost address and collateral can be transferred.
*/
function resolveClaim(address _lostAddress) public returns (uint256){
}
function internalTransfer(address _from, address _to, uint256 _value) internal;
/** @dev This function is to be executed by the owner only in case a dispute needs to be resolved manually. */
function deleteClaim(address _lostAddress) public onlyOwner(){
}
}
contract AlethenaShares is ERC20, Claimable {
string public constant name = "Alethena Equity";
string public constant symbol = "ALEQ";
uint8 public constant decimals = 0; // legally, shares are not divisible
using SafeMath for uint256;
/** URL where the source code as well as the terms and conditions can be found. */
string public constant termsAndConditions = "shares.alethena.com";
mapping(address => uint256) balances;
uint256 totalSupply_; // total number of tokenized shares, sum of all balances
uint256 totalShares_ = 1397188; // total number of outstanding shares, maybe not all tokenized
event Mint(address indexed shareholder, uint256 amount, string message);
event Unmint(uint256 amount, string message);
/** @dev Total number of tokens in existence */
function totalSupply() public view returns (uint256) {
}
/** @dev Total number of shares in existence, not necessarily all represented by a token.
* @dev This could be useful to calculate the total market cap.
*/
function totalShares() public view returns (uint256) {
}
function setTotalShares(uint256 _newTotalShares) public onlyOwner() {
}
/** Increases the number of the tokenized shares. If the shares are newly issued, the share total also needs to be increased. */
function mint(address shareholder, uint256 _amount, string _message) public onlyOwner() {
}
/** Decrease the number of the tokenized shares. There are two use-cases for this function:
* 1) a capital decrease with a destruction of the shares, in which case the law requires that the
* destroyed shares are currently owned by the company.
* 2) a shareholder wants to take shares offline. This can only happen with the agreement of the
* the company. To do so, the shares must be transferred to the company first, the company call
* this function and then assigning the untokenized shares back to the shareholder in whatever
* way the new form (e.g. printed certificate) of the shares requires.
*/
function unmint(uint256 _amount, string _message) public onlyOwner() {
}
/** This contract is pausible. */
bool public isPaused = false;
/** @dev Function to set pause.
* This could for example be used in case of a fork of the network, in which case all
* "wrong" forked contracts should be paused in their respective fork. Deciding which
* fork is the "right" one is up to the owner of the contract.
*/
function pause(bool _pause, string _message, address _newAddress, uint256 _fromBlock) public onlyOwner() {
}
event Pause(bool paused, string message, address newAddress, uint256 fromBlock);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
The next section contains standard ERC20 routines.
Main change: Transfer functions have an additional post function which resolves claims if applicable.
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @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) {
}
function internalTransfer(address _from, address _to, uint256 _value) internal {
require(<FILL_ME>)
require(_to != address(0));
require(_value <= balances[_from]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
}
/**
* @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 view returns (uint256) {
}
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @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) {
}
event Approval(address approver, address spender, uint256 value);
/**
* @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 view returns (uint256) {
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
}
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
| !isPaused | 16,671 | !isPaused |
"ERC721I: _mint() Token to Mint Already Exists!" | pragma solidity ^0.8.0;
contract ERC721I {
string public name; string public symbol;
string internal baseTokenURI; string internal baseTokenURI_EXT;
constructor(string memory name_, string memory symbol_) { }
uint256 public totalSupply;
mapping(uint256 => address) public ownerOf;
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
// Events
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Mint(address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
// // internal write functions
// mint
function _mint(address to_, uint256 tokenId_) internal virtual {
require(to_ != address(0x0), "ERC721I: _mint() Mint to Zero Address");
require(<FILL_ME>)
// ERC721I Starts Here
ownerOf[tokenId_] = to_;
balanceOf[to_]++;
totalSupply++;
// ERC721I Ends Here
emit Transfer(address(0x0), to_, tokenId_);
emit Mint(to_, tokenId_);
}
// transfer
function _transfer(address from_, address to_, uint256 tokenId_) internal virtual {
}
// approve
function _approve(address to_, uint256 tokenId_) internal virtual {
}
function _setApprovalForAll(address owner_, address operator_, bool approved_) internal virtual {
}
// token uri
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURI_EXT(string memory ext_) internal virtual {
}
// // Internal View Functions
// Embedded Libraries
function _toString(uint256 value_) internal pure returns (string memory) {
}
// Functional Views
function _isApprovedOrOwner(address spender_, uint256 tokenId_) internal view virtual returns (bool) {
}
function _exists(uint256 tokenId_) internal view virtual returns (bool) {
}
// // public write functions
function approve(address to_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function multiTransferFrom(address from_, address to_, uint256[] memory tokenIds_) public virtual {
}
function multiSafeTransferFrom(address from_, address to_, uint256[] memory tokenIds_, bytes memory data_) public virtual {
}
// OZ Standard Stuff
function supportsInterface(bytes4 interfaceId_) public pure returns (bool) {
}
function tokenURI(uint256 tokenId_) public view virtual returns (string memory) {
}
// // public view functions
// never use these for functions ever, they are expensive af and for view only (this will be an issue in the future for interfaces)
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
}
abstract contract Ownable {
address public owner;
event OwnershipTransferred(address indexed oldOwner_, address indexed newOwner_);
constructor() { }
modifier onlyOwner {
}
function _transferOwnership(address newOwner_) internal virtual {
}
function transferOwnership(address newOwner_) public virtual onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract CrypTurdz is ERC721I, Ownable {
constructor() payable ERC721I("CrypTurdz","CT") {}
// Project Settings
uint256 public mintPrice = 0.0 ether;
uint256 public maxTokens = 6969;
// Public Mint Stuff
uint256 public maxMintsPerTx = 5; // 5 mints per tx
bool public publicMintEnabled = false; // default false
uint256 public publicMintStartTime; // default unset
// Modifiers
modifier onlySender {
}
modifier publicMinting {
}
// Owner Administration
function setMintPrice(uint256 mintPrice_) external onlyOwner {
}
function setMaxTokens(uint256 maxTokens_) external onlyOwner {
}
function setMaxMintsPerTx(uint256 maxMintsPerTx_) external onlyOwner {
}
function setPublicMintParams(bool publicMintEnabled_, uint256 publicMintStartTime_) external onlyOwner {
}
function setBaseTokenURI(string memory uri_) external onlyOwner {
}
function setBaseTokenURI_EXT(string memory ext_) external onlyOwner {
}
// Internal Mint
function _mintMany(address to_, uint256 amount_) internal {
}
// Owner Mint Functions
function ownerMint(address to_, uint256 amount_) external onlyOwner {
}
function ownerMintToMany(address[] calldata tos_, uint256[] calldata amounts_) external onlyOwner {
}
// Public Mint Functions
function publicMint(uint256 amount_) external payable onlySender publicMinting {
}
}
| ownerOf[tokenId_]==address(0x0),"ERC721I: _mint() Token to Mint Already Exists!" | 16,683 | ownerOf[tokenId_]==address(0x0) |
"ERC721I: _isApprovedOrOwner() Owner is Zero Address!" | pragma solidity ^0.8.0;
contract ERC721I {
string public name; string public symbol;
string internal baseTokenURI; string internal baseTokenURI_EXT;
constructor(string memory name_, string memory symbol_) { }
uint256 public totalSupply;
mapping(uint256 => address) public ownerOf;
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
// Events
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Mint(address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
// // internal write functions
// mint
function _mint(address to_, uint256 tokenId_) internal virtual {
}
// transfer
function _transfer(address from_, address to_, uint256 tokenId_) internal virtual {
}
// approve
function _approve(address to_, uint256 tokenId_) internal virtual {
}
function _setApprovalForAll(address owner_, address operator_, bool approved_) internal virtual {
}
// token uri
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURI_EXT(string memory ext_) internal virtual {
}
// // Internal View Functions
// Embedded Libraries
function _toString(uint256 value_) internal pure returns (string memory) {
}
// Functional Views
function _isApprovedOrOwner(address spender_, uint256 tokenId_) internal view virtual returns (bool) {
require(<FILL_ME>)
address _owner = ownerOf[tokenId_];
return (spender_ == _owner || spender_ == getApproved[tokenId_] || isApprovedForAll[_owner][spender_]);
}
function _exists(uint256 tokenId_) internal view virtual returns (bool) {
}
// // public write functions
function approve(address to_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function multiTransferFrom(address from_, address to_, uint256[] memory tokenIds_) public virtual {
}
function multiSafeTransferFrom(address from_, address to_, uint256[] memory tokenIds_, bytes memory data_) public virtual {
}
// OZ Standard Stuff
function supportsInterface(bytes4 interfaceId_) public pure returns (bool) {
}
function tokenURI(uint256 tokenId_) public view virtual returns (string memory) {
}
// // public view functions
// never use these for functions ever, they are expensive af and for view only (this will be an issue in the future for interfaces)
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
}
abstract contract Ownable {
address public owner;
event OwnershipTransferred(address indexed oldOwner_, address indexed newOwner_);
constructor() { }
modifier onlyOwner {
}
function _transferOwnership(address newOwner_) internal virtual {
}
function transferOwnership(address newOwner_) public virtual onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract CrypTurdz is ERC721I, Ownable {
constructor() payable ERC721I("CrypTurdz","CT") {}
// Project Settings
uint256 public mintPrice = 0.0 ether;
uint256 public maxTokens = 6969;
// Public Mint Stuff
uint256 public maxMintsPerTx = 5; // 5 mints per tx
bool public publicMintEnabled = false; // default false
uint256 public publicMintStartTime; // default unset
// Modifiers
modifier onlySender {
}
modifier publicMinting {
}
// Owner Administration
function setMintPrice(uint256 mintPrice_) external onlyOwner {
}
function setMaxTokens(uint256 maxTokens_) external onlyOwner {
}
function setMaxMintsPerTx(uint256 maxMintsPerTx_) external onlyOwner {
}
function setPublicMintParams(bool publicMintEnabled_, uint256 publicMintStartTime_) external onlyOwner {
}
function setBaseTokenURI(string memory uri_) external onlyOwner {
}
function setBaseTokenURI_EXT(string memory ext_) external onlyOwner {
}
// Internal Mint
function _mintMany(address to_, uint256 amount_) internal {
}
// Owner Mint Functions
function ownerMint(address to_, uint256 amount_) external onlyOwner {
}
function ownerMintToMany(address[] calldata tos_, uint256[] calldata amounts_) external onlyOwner {
}
// Public Mint Functions
function publicMint(uint256 amount_) external payable onlySender publicMinting {
}
}
| ownerOf[tokenId_]!=address(0x0),"ERC721I: _isApprovedOrOwner() Owner is Zero Address!" | 16,683 | ownerOf[tokenId_]!=address(0x0) |
"ERC721I: transferFrom() _isApprovedOrOwner = false!" | pragma solidity ^0.8.0;
contract ERC721I {
string public name; string public symbol;
string internal baseTokenURI; string internal baseTokenURI_EXT;
constructor(string memory name_, string memory symbol_) { }
uint256 public totalSupply;
mapping(uint256 => address) public ownerOf;
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
// Events
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Mint(address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
// // internal write functions
// mint
function _mint(address to_, uint256 tokenId_) internal virtual {
}
// transfer
function _transfer(address from_, address to_, uint256 tokenId_) internal virtual {
}
// approve
function _approve(address to_, uint256 tokenId_) internal virtual {
}
function _setApprovalForAll(address owner_, address operator_, bool approved_) internal virtual {
}
// token uri
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURI_EXT(string memory ext_) internal virtual {
}
// // Internal View Functions
// Embedded Libraries
function _toString(uint256 value_) internal pure returns (string memory) {
}
// Functional Views
function _isApprovedOrOwner(address spender_, uint256 tokenId_) internal view virtual returns (bool) {
}
function _exists(uint256 tokenId_) internal view virtual returns (bool) {
}
// // public write functions
function approve(address to_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
require(<FILL_ME>)
_transfer(from_, to_, tokenId_);
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function multiTransferFrom(address from_, address to_, uint256[] memory tokenIds_) public virtual {
}
function multiSafeTransferFrom(address from_, address to_, uint256[] memory tokenIds_, bytes memory data_) public virtual {
}
// OZ Standard Stuff
function supportsInterface(bytes4 interfaceId_) public pure returns (bool) {
}
function tokenURI(uint256 tokenId_) public view virtual returns (string memory) {
}
// // public view functions
// never use these for functions ever, they are expensive af and for view only (this will be an issue in the future for interfaces)
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
}
abstract contract Ownable {
address public owner;
event OwnershipTransferred(address indexed oldOwner_, address indexed newOwner_);
constructor() { }
modifier onlyOwner {
}
function _transferOwnership(address newOwner_) internal virtual {
}
function transferOwnership(address newOwner_) public virtual onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract CrypTurdz is ERC721I, Ownable {
constructor() payable ERC721I("CrypTurdz","CT") {}
// Project Settings
uint256 public mintPrice = 0.0 ether;
uint256 public maxTokens = 6969;
// Public Mint Stuff
uint256 public maxMintsPerTx = 5; // 5 mints per tx
bool public publicMintEnabled = false; // default false
uint256 public publicMintStartTime; // default unset
// Modifiers
modifier onlySender {
}
modifier publicMinting {
}
// Owner Administration
function setMintPrice(uint256 mintPrice_) external onlyOwner {
}
function setMaxTokens(uint256 maxTokens_) external onlyOwner {
}
function setMaxMintsPerTx(uint256 maxMintsPerTx_) external onlyOwner {
}
function setPublicMintParams(bool publicMintEnabled_, uint256 publicMintStartTime_) external onlyOwner {
}
function setBaseTokenURI(string memory uri_) external onlyOwner {
}
function setBaseTokenURI_EXT(string memory ext_) external onlyOwner {
}
// Internal Mint
function _mintMany(address to_, uint256 amount_) internal {
}
// Owner Mint Functions
function ownerMint(address to_, uint256 amount_) external onlyOwner {
}
function ownerMintToMany(address[] calldata tos_, uint256[] calldata amounts_) external onlyOwner {
}
// Public Mint Functions
function publicMint(uint256 amount_) external payable onlySender publicMinting {
}
}
| _isApprovedOrOwner(msg.sender,tokenId_),"ERC721I: transferFrom() _isApprovedOrOwner = false!" | 16,683 | _isApprovedOrOwner(msg.sender,tokenId_) |
"Public Mints are not enabled yet!" | pragma solidity ^0.8.0;
contract ERC721I {
string public name; string public symbol;
string internal baseTokenURI; string internal baseTokenURI_EXT;
constructor(string memory name_, string memory symbol_) { }
uint256 public totalSupply;
mapping(uint256 => address) public ownerOf;
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
// Events
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Mint(address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
// // internal write functions
// mint
function _mint(address to_, uint256 tokenId_) internal virtual {
}
// transfer
function _transfer(address from_, address to_, uint256 tokenId_) internal virtual {
}
// approve
function _approve(address to_, uint256 tokenId_) internal virtual {
}
function _setApprovalForAll(address owner_, address operator_, bool approved_) internal virtual {
}
// token uri
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURI_EXT(string memory ext_) internal virtual {
}
// // Internal View Functions
// Embedded Libraries
function _toString(uint256 value_) internal pure returns (string memory) {
}
// Functional Views
function _isApprovedOrOwner(address spender_, uint256 tokenId_) internal view virtual returns (bool) {
}
function _exists(uint256 tokenId_) internal view virtual returns (bool) {
}
// // public write functions
function approve(address to_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_, bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_) public virtual {
}
function multiTransferFrom(address from_, address to_, uint256[] memory tokenIds_) public virtual {
}
function multiSafeTransferFrom(address from_, address to_, uint256[] memory tokenIds_, bytes memory data_) public virtual {
}
// OZ Standard Stuff
function supportsInterface(bytes4 interfaceId_) public pure returns (bool) {
}
function tokenURI(uint256 tokenId_) public view virtual returns (string memory) {
}
// // public view functions
// never use these for functions ever, they are expensive af and for view only (this will be an issue in the future for interfaces)
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
}
abstract contract Ownable {
address public owner;
event OwnershipTransferred(address indexed oldOwner_, address indexed newOwner_);
constructor() { }
modifier onlyOwner {
}
function _transferOwnership(address newOwner_) internal virtual {
}
function transferOwnership(address newOwner_) public virtual onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract CrypTurdz is ERC721I, Ownable {
constructor() payable ERC721I("CrypTurdz","CT") {}
// Project Settings
uint256 public mintPrice = 0.0 ether;
uint256 public maxTokens = 6969;
// Public Mint Stuff
uint256 public maxMintsPerTx = 5; // 5 mints per tx
bool public publicMintEnabled = false; // default false
uint256 public publicMintStartTime; // default unset
// Modifiers
modifier onlySender {
}
modifier publicMinting {
require(<FILL_ME>)
_;
}
// Owner Administration
function setMintPrice(uint256 mintPrice_) external onlyOwner {
}
function setMaxTokens(uint256 maxTokens_) external onlyOwner {
}
function setMaxMintsPerTx(uint256 maxMintsPerTx_) external onlyOwner {
}
function setPublicMintParams(bool publicMintEnabled_, uint256 publicMintStartTime_) external onlyOwner {
}
function setBaseTokenURI(string memory uri_) external onlyOwner {
}
function setBaseTokenURI_EXT(string memory ext_) external onlyOwner {
}
// Internal Mint
function _mintMany(address to_, uint256 amount_) internal {
}
// Owner Mint Functions
function ownerMint(address to_, uint256 amount_) external onlyOwner {
}
function ownerMintToMany(address[] calldata tos_, uint256[] calldata amounts_) external onlyOwner {
}
// Public Mint Functions
function publicMint(uint256 amount_) external payable onlySender publicMinting {
}
}
| publicMintEnabled&&block.timestamp>=publicMintStartTime,"Public Mints are not enabled yet!" | 16,683 | publicMintEnabled&&block.timestamp>=publicMintStartTime |
"Exceeds maximum supply" | pragma solidity 0.8.3;
contract SlothsNFT is ERC721, ERC721Enumerable,ERC721URIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint16 public constant maxSupply = 9000;
string private _baseTokenURI;
uint16 public sold = 0;
uint256 public _startDate = 1627416000;
string private _metadata = "https://ipfs.io/ipfs/QmZ1WPnJEn1u3GfiP5zg8UBBe1f22RAYBuahEqF1qKCyYA";
string private _slothMetadata = "https://ipfs.io/ipfs/QmYpQDwcKyUrV4fAUSwV4TZKt6kSmjhVusvCXaGbN7PsLT";
constructor() ERC721("SlothsNFT", "SLO") {
}
function contractURI() public view onlyOwner returns (string memory) {
}
function slothMetadata() public view returns (string memory) {
}
function setSlothMetadata(string memory slothMetadata) public onlyOwner {
}
function setStartDate(uint256 startDate) public onlyOwner {
}
function setContractMetadata(string memory metadata) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setBaseURI(string memory _newbaseTokenURI) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
// Get minting limit (for a single transaction) based on current token supply
function getCurrentMintLimit() public pure returns (uint8) {
}
// Get ether price based on current token supply
function getCurrentPrice() public pure returns (uint64) {
}
function adminMint(uint8 _quantityToMint) public onlyOwner{
require(_quantityToMint >= 1, "Must mint at least 1");
require(
_quantityToMint <= getCurrentMintLimit(),
"Maximum current buy limit for individual transaction exceeded"
);
require(<FILL_ME>)
for (uint8 i = 0; i < _quantityToMint; i++) {
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
_mint(msg.sender, newItemId);
_setTokenURI(newItemId, _slothMetadata);
}
}
// Mint new token(s)
function mint(uint8 _quantityToMint) public payable {
}
function slothsToAwake(address owner) public view returns(uint256) {
}
function slothToAwake(address owner, uint256 index) public view returns(uint256) {
}
function awakeSloth(uint256 tokenId, string memory tokenUri) public {
}
function awakeAllSloths(uint256[] memory _tokenIds, string[] memory _tokenURIs) public {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
// Withdraw ether from contract
function withdraw() public onlyOwner {
}
}
| (_quantityToMint+totalSupply())<=maxSupply,"Exceeds maximum supply" | 16,734 | (_quantityToMint+totalSupply())<=maxSupply |
"Ether submitted does not match current price" | pragma solidity 0.8.3;
contract SlothsNFT is ERC721, ERC721Enumerable,ERC721URIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint16 public constant maxSupply = 9000;
string private _baseTokenURI;
uint16 public sold = 0;
uint256 public _startDate = 1627416000;
string private _metadata = "https://ipfs.io/ipfs/QmZ1WPnJEn1u3GfiP5zg8UBBe1f22RAYBuahEqF1qKCyYA";
string private _slothMetadata = "https://ipfs.io/ipfs/QmYpQDwcKyUrV4fAUSwV4TZKt6kSmjhVusvCXaGbN7PsLT";
constructor() ERC721("SlothsNFT", "SLO") {
}
function contractURI() public view onlyOwner returns (string memory) {
}
function slothMetadata() public view returns (string memory) {
}
function setSlothMetadata(string memory slothMetadata) public onlyOwner {
}
function setStartDate(uint256 startDate) public onlyOwner {
}
function setContractMetadata(string memory metadata) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setBaseURI(string memory _newbaseTokenURI) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
// Get minting limit (for a single transaction) based on current token supply
function getCurrentMintLimit() public pure returns (uint8) {
}
// Get ether price based on current token supply
function getCurrentPrice() public pure returns (uint64) {
}
function adminMint(uint8 _quantityToMint) public onlyOwner{
}
// Mint new token(s)
function mint(uint8 _quantityToMint) public payable {
require(_startDate <= block.timestamp, "Sale is not open");
require(_quantityToMint >= 1, "Must mint at least 1");
require(
_quantityToMint <= getCurrentMintLimit(),
"Maximum current buy limit for individual transaction exceeded"
);
require(
(_quantityToMint + totalSupply()) <= maxSupply,
"Exceeds maximum supply"
);
require(<FILL_ME>)
for (uint8 i = 0; i < _quantityToMint; i++) {
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
_mint(msg.sender, newItemId);
_setTokenURI(newItemId, _slothMetadata);
}
sold = sold + _quantityToMint;
}
function slothsToAwake(address owner) public view returns(uint256) {
}
function slothToAwake(address owner, uint256 index) public view returns(uint256) {
}
function awakeSloth(uint256 tokenId, string memory tokenUri) public {
}
function awakeAllSloths(uint256[] memory _tokenIds, string[] memory _tokenURIs) public {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
// Withdraw ether from contract
function withdraw() public onlyOwner {
}
}
| msg.value==(getCurrentPrice()*_quantityToMint),"Ether submitted does not match current price" | 16,734 | msg.value==(getCurrentPrice()*_quantityToMint) |
'No sloths available' | pragma solidity 0.8.3;
contract SlothsNFT is ERC721, ERC721Enumerable,ERC721URIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint16 public constant maxSupply = 9000;
string private _baseTokenURI;
uint16 public sold = 0;
uint256 public _startDate = 1627416000;
string private _metadata = "https://ipfs.io/ipfs/QmZ1WPnJEn1u3GfiP5zg8UBBe1f22RAYBuahEqF1qKCyYA";
string private _slothMetadata = "https://ipfs.io/ipfs/QmYpQDwcKyUrV4fAUSwV4TZKt6kSmjhVusvCXaGbN7PsLT";
constructor() ERC721("SlothsNFT", "SLO") {
}
function contractURI() public view onlyOwner returns (string memory) {
}
function slothMetadata() public view returns (string memory) {
}
function setSlothMetadata(string memory slothMetadata) public onlyOwner {
}
function setStartDate(uint256 startDate) public onlyOwner {
}
function setContractMetadata(string memory metadata) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setBaseURI(string memory _newbaseTokenURI) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
// Get minting limit (for a single transaction) based on current token supply
function getCurrentMintLimit() public pure returns (uint8) {
}
// Get ether price based on current token supply
function getCurrentPrice() public pure returns (uint64) {
}
function adminMint(uint8 _quantityToMint) public onlyOwner{
}
// Mint new token(s)
function mint(uint8 _quantityToMint) public payable {
}
function slothsToAwake(address owner) public view returns(uint256) {
}
function slothToAwake(address owner, uint256 index) public view returns(uint256) {
require(<FILL_ME>)
for(uint256 i=0;i < balanceOf(owner);i++) {
if((keccak256(abi.encodePacked((tokenURI(tokenOfOwnerByIndex(owner, i))))) == keccak256(abi.encodePacked((_slothMetadata))))) {
if(i == index) {
return tokenOfOwnerByIndex(owner, i);
}
}
}
}
function awakeSloth(uint256 tokenId, string memory tokenUri) public {
}
function awakeAllSloths(uint256[] memory _tokenIds, string[] memory _tokenURIs) public {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
// Withdraw ether from contract
function withdraw() public onlyOwner {
}
}
| slothsToAwake(owner)>0,'No sloths available' | 16,734 | slothsToAwake(owner)>0 |
'TokenUri is empty' | pragma solidity 0.8.3;
contract SlothsNFT is ERC721, ERC721Enumerable,ERC721URIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint16 public constant maxSupply = 9000;
string private _baseTokenURI;
uint16 public sold = 0;
uint256 public _startDate = 1627416000;
string private _metadata = "https://ipfs.io/ipfs/QmZ1WPnJEn1u3GfiP5zg8UBBe1f22RAYBuahEqF1qKCyYA";
string private _slothMetadata = "https://ipfs.io/ipfs/QmYpQDwcKyUrV4fAUSwV4TZKt6kSmjhVusvCXaGbN7PsLT";
constructor() ERC721("SlothsNFT", "SLO") {
}
function contractURI() public view onlyOwner returns (string memory) {
}
function slothMetadata() public view returns (string memory) {
}
function setSlothMetadata(string memory slothMetadata) public onlyOwner {
}
function setStartDate(uint256 startDate) public onlyOwner {
}
function setContractMetadata(string memory metadata) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setBaseURI(string memory _newbaseTokenURI) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
// Get minting limit (for a single transaction) based on current token supply
function getCurrentMintLimit() public pure returns (uint8) {
}
// Get ether price based on current token supply
function getCurrentPrice() public pure returns (uint64) {
}
function adminMint(uint8 _quantityToMint) public onlyOwner{
}
// Mint new token(s)
function mint(uint8 _quantityToMint) public payable {
}
function slothsToAwake(address owner) public view returns(uint256) {
}
function slothToAwake(address owner, uint256 index) public view returns(uint256) {
}
function awakeSloth(uint256 tokenId, string memory tokenUri) public {
require(<FILL_ME>)
require(ownerOf(tokenId) == msg.sender, 'You dont own this slot');
require((keccak256(abi.encodePacked((tokenURI(tokenId)))) == keccak256(abi.encodePacked((_slothMetadata)))), 'Sloth already awaken!');
_setTokenURI(tokenId, tokenUri);
}
function awakeAllSloths(uint256[] memory _tokenIds, string[] memory _tokenURIs) public {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
// Withdraw ether from contract
function withdraw() public onlyOwner {
}
}
| (keccak256(abi.encodePacked((tokenUri)))!=keccak256(abi.encodePacked(('')))),'TokenUri is empty' | 16,734 | (keccak256(abi.encodePacked((tokenUri)))!=keccak256(abi.encodePacked(('')))) |
'Sloth already awaken!' | pragma solidity 0.8.3;
contract SlothsNFT is ERC721, ERC721Enumerable,ERC721URIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
uint16 public constant maxSupply = 9000;
string private _baseTokenURI;
uint16 public sold = 0;
uint256 public _startDate = 1627416000;
string private _metadata = "https://ipfs.io/ipfs/QmZ1WPnJEn1u3GfiP5zg8UBBe1f22RAYBuahEqF1qKCyYA";
string private _slothMetadata = "https://ipfs.io/ipfs/QmYpQDwcKyUrV4fAUSwV4TZKt6kSmjhVusvCXaGbN7PsLT";
constructor() ERC721("SlothsNFT", "SLO") {
}
function contractURI() public view onlyOwner returns (string memory) {
}
function slothMetadata() public view returns (string memory) {
}
function setSlothMetadata(string memory slothMetadata) public onlyOwner {
}
function setStartDate(uint256 startDate) public onlyOwner {
}
function setContractMetadata(string memory metadata) public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setBaseURI(string memory _newbaseTokenURI) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
// Get minting limit (for a single transaction) based on current token supply
function getCurrentMintLimit() public pure returns (uint8) {
}
// Get ether price based on current token supply
function getCurrentPrice() public pure returns (uint64) {
}
function adminMint(uint8 _quantityToMint) public onlyOwner{
}
// Mint new token(s)
function mint(uint8 _quantityToMint) public payable {
}
function slothsToAwake(address owner) public view returns(uint256) {
}
function slothToAwake(address owner, uint256 index) public view returns(uint256) {
}
function awakeSloth(uint256 tokenId, string memory tokenUri) public {
require((keccak256(abi.encodePacked((tokenUri))) != keccak256(abi.encodePacked(('')))), 'TokenUri is empty');
require(ownerOf(tokenId) == msg.sender, 'You dont own this slot');
require(<FILL_ME>)
_setTokenURI(tokenId, tokenUri);
}
function awakeAllSloths(uint256[] memory _tokenIds, string[] memory _tokenURIs) public {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
// Withdraw ether from contract
function withdraw() public onlyOwner {
}
}
| (keccak256(abi.encodePacked((tokenURI(tokenId))))==keccak256(abi.encodePacked((_slothMetadata)))),'Sloth already awaken!' | 16,734 | (keccak256(abi.encodePacked((tokenURI(tokenId))))==keccak256(abi.encodePacked((_slothMetadata)))) |
"Not enough available cars to claim." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC721Enumerable.sol";
import "./IPixls.sol";
// Pixlton Car Club contract
contract PixltonCarClub is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private CurrentTokenId;
uint256[5471] private Ids;
uint16 public constant MAX_MINTS_TX = 10;
string public baseURI;
uint256 public PublicTokenPrice = 0.03 ether;
uint16 public MaxTokens = 5471;
bool public PublicMintActive = false;
bool public ClaimActive = false;
// Ledger of Pixl IDs that were claimed with.
mapping(uint256 => bool) ClaimedPixlIds;
string public constant Z = "You'll see this on the internet. Go on, press like, and make my clicks spike.";
// Parent NFT Contract mainnet address
address public nftAddress = 0x082903f4e94c5e10A2B116a4284940a36AFAEd63;
IPixls nftContract = IPixls(nftAddress);
constructor(string memory _baseURI) ERC721("Pixlton Car Club", "PXCC") {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function toggleClaimState() public onlyOwner {
}
function togglePublicMintState() public onlyOwner {
}
function setPublicPrice(uint256 newPrice) public onlyOwner {
}
function getClaimablePixls() external view returns (uint256[] memory) {
}
function checkIfClaimed(uint256 nftId) external view returns (bool) {
}
function getAvailableCars() external view returns (uint256) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
// Private minting (Pixls holders only) - Claim for singular Pixl
function claimWithPixl(uint256 nftId) external {
require(ClaimActive, "Pixlton Car Club must be active to claim.");
require(<FILL_ME>)
require(nftContract.ownerOf(nftId) == msg.sender, "Not the owner of this Pixl.");
require(!ClaimedPixlIds[nftId], "This Pixl has already been used.");
internalMint(msg.sender, 1);
ClaimedPixlIds[nftId] = true;
}
// Private minting (Pixls holders only) - Claim for specific NFTs
function multiClaimWithPixl(uint256 [] memory nftIds) public {
}
// Private minting (Pixls holders only) - Claim for all of your Pixl holdings
function multiClaimWithAll() external {
}
// Mint a limited stack for the developer.
function devMint(address _to, uint256 _quantity) internal {
}
function totalSupply() public view override returns (uint256) {
}
function mintPublic(uint256 quantity) public payable {
}
function internalMint(address _to, uint256 _quantity) private {
}
function getRandomNumber(uint256 maxValue, uint256 salt) private view returns(uint256) {
}
function withdraw() external onlyOwner {
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
| CurrentTokenId.current()+1<=MaxTokens,"Not enough available cars to claim." | 16,771 | CurrentTokenId.current()+1<=MaxTokens |
"Not the owner of this Pixl." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC721Enumerable.sol";
import "./IPixls.sol";
// Pixlton Car Club contract
contract PixltonCarClub is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private CurrentTokenId;
uint256[5471] private Ids;
uint16 public constant MAX_MINTS_TX = 10;
string public baseURI;
uint256 public PublicTokenPrice = 0.03 ether;
uint16 public MaxTokens = 5471;
bool public PublicMintActive = false;
bool public ClaimActive = false;
// Ledger of Pixl IDs that were claimed with.
mapping(uint256 => bool) ClaimedPixlIds;
string public constant Z = "You'll see this on the internet. Go on, press like, and make my clicks spike.";
// Parent NFT Contract mainnet address
address public nftAddress = 0x082903f4e94c5e10A2B116a4284940a36AFAEd63;
IPixls nftContract = IPixls(nftAddress);
constructor(string memory _baseURI) ERC721("Pixlton Car Club", "PXCC") {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function toggleClaimState() public onlyOwner {
}
function togglePublicMintState() public onlyOwner {
}
function setPublicPrice(uint256 newPrice) public onlyOwner {
}
function getClaimablePixls() external view returns (uint256[] memory) {
}
function checkIfClaimed(uint256 nftId) external view returns (bool) {
}
function getAvailableCars() external view returns (uint256) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
// Private minting (Pixls holders only) - Claim for singular Pixl
function claimWithPixl(uint256 nftId) external {
require(ClaimActive, "Pixlton Car Club must be active to claim.");
require(CurrentTokenId.current() + 1 <= MaxTokens, "Not enough available cars to claim.");
require(<FILL_ME>)
require(!ClaimedPixlIds[nftId], "This Pixl has already been used.");
internalMint(msg.sender, 1);
ClaimedPixlIds[nftId] = true;
}
// Private minting (Pixls holders only) - Claim for specific NFTs
function multiClaimWithPixl(uint256 [] memory nftIds) public {
}
// Private minting (Pixls holders only) - Claim for all of your Pixl holdings
function multiClaimWithAll() external {
}
// Mint a limited stack for the developer.
function devMint(address _to, uint256 _quantity) internal {
}
function totalSupply() public view override returns (uint256) {
}
function mintPublic(uint256 quantity) public payable {
}
function internalMint(address _to, uint256 _quantity) private {
}
function getRandomNumber(uint256 maxValue, uint256 salt) private view returns(uint256) {
}
function withdraw() external onlyOwner {
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
| nftContract.ownerOf(nftId)==msg.sender,"Not the owner of this Pixl." | 16,771 | nftContract.ownerOf(nftId)==msg.sender |
"This Pixl has already been used." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC721Enumerable.sol";
import "./IPixls.sol";
// Pixlton Car Club contract
contract PixltonCarClub is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private CurrentTokenId;
uint256[5471] private Ids;
uint16 public constant MAX_MINTS_TX = 10;
string public baseURI;
uint256 public PublicTokenPrice = 0.03 ether;
uint16 public MaxTokens = 5471;
bool public PublicMintActive = false;
bool public ClaimActive = false;
// Ledger of Pixl IDs that were claimed with.
mapping(uint256 => bool) ClaimedPixlIds;
string public constant Z = "You'll see this on the internet. Go on, press like, and make my clicks spike.";
// Parent NFT Contract mainnet address
address public nftAddress = 0x082903f4e94c5e10A2B116a4284940a36AFAEd63;
IPixls nftContract = IPixls(nftAddress);
constructor(string memory _baseURI) ERC721("Pixlton Car Club", "PXCC") {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function toggleClaimState() public onlyOwner {
}
function togglePublicMintState() public onlyOwner {
}
function setPublicPrice(uint256 newPrice) public onlyOwner {
}
function getClaimablePixls() external view returns (uint256[] memory) {
}
function checkIfClaimed(uint256 nftId) external view returns (bool) {
}
function getAvailableCars() external view returns (uint256) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
// Private minting (Pixls holders only) - Claim for singular Pixl
function claimWithPixl(uint256 nftId) external {
require(ClaimActive, "Pixlton Car Club must be active to claim.");
require(CurrentTokenId.current() + 1 <= MaxTokens, "Not enough available cars to claim.");
require(nftContract.ownerOf(nftId) == msg.sender, "Not the owner of this Pixl.");
require(<FILL_ME>)
internalMint(msg.sender, 1);
ClaimedPixlIds[nftId] = true;
}
// Private minting (Pixls holders only) - Claim for specific NFTs
function multiClaimWithPixl(uint256 [] memory nftIds) public {
}
// Private minting (Pixls holders only) - Claim for all of your Pixl holdings
function multiClaimWithAll() external {
}
// Mint a limited stack for the developer.
function devMint(address _to, uint256 _quantity) internal {
}
function totalSupply() public view override returns (uint256) {
}
function mintPublic(uint256 quantity) public payable {
}
function internalMint(address _to, uint256 _quantity) private {
}
function getRandomNumber(uint256 maxValue, uint256 salt) private view returns(uint256) {
}
function withdraw() external onlyOwner {
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
| !ClaimedPixlIds[nftId],"This Pixl has already been used." | 16,771 | !ClaimedPixlIds[nftId] |
"Not enough available cars to claim." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC721Enumerable.sol";
import "./IPixls.sol";
// Pixlton Car Club contract
contract PixltonCarClub is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private CurrentTokenId;
uint256[5471] private Ids;
uint16 public constant MAX_MINTS_TX = 10;
string public baseURI;
uint256 public PublicTokenPrice = 0.03 ether;
uint16 public MaxTokens = 5471;
bool public PublicMintActive = false;
bool public ClaimActive = false;
// Ledger of Pixl IDs that were claimed with.
mapping(uint256 => bool) ClaimedPixlIds;
string public constant Z = "You'll see this on the internet. Go on, press like, and make my clicks spike.";
// Parent NFT Contract mainnet address
address public nftAddress = 0x082903f4e94c5e10A2B116a4284940a36AFAEd63;
IPixls nftContract = IPixls(nftAddress);
constructor(string memory _baseURI) ERC721("Pixlton Car Club", "PXCC") {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function toggleClaimState() public onlyOwner {
}
function togglePublicMintState() public onlyOwner {
}
function setPublicPrice(uint256 newPrice) public onlyOwner {
}
function getClaimablePixls() external view returns (uint256[] memory) {
}
function checkIfClaimed(uint256 nftId) external view returns (bool) {
}
function getAvailableCars() external view returns (uint256) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
// Private minting (Pixls holders only) - Claim for singular Pixl
function claimWithPixl(uint256 nftId) external {
}
// Private minting (Pixls holders only) - Claim for specific NFTs
function multiClaimWithPixl(uint256 [] memory nftIds) public {
require(ClaimActive, "Pixlton Car Club must be active to claim.");
require(<FILL_ME>)
for (uint i=0; i< nftIds.length; i++) {
require(nftContract.ownerOf(nftIds[i]) == msg.sender, "Not the owner of this Pixl.");
if(ClaimedPixlIds[nftIds[i]]) {
continue;
} else {
internalMint(msg.sender, 1);
ClaimedPixlIds[nftIds[i]] = true;
}
}
}
// Private minting (Pixls holders only) - Claim for all of your Pixl holdings
function multiClaimWithAll() external {
}
// Mint a limited stack for the developer.
function devMint(address _to, uint256 _quantity) internal {
}
function totalSupply() public view override returns (uint256) {
}
function mintPublic(uint256 quantity) public payable {
}
function internalMint(address _to, uint256 _quantity) private {
}
function getRandomNumber(uint256 maxValue, uint256 salt) private view returns(uint256) {
}
function withdraw() external onlyOwner {
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
| nftIds.length+CurrentTokenId.current()<=MaxTokens,"Not enough available cars to claim." | 16,771 | nftIds.length+CurrentTokenId.current()<=MaxTokens |
"Not the owner of this Pixl." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC721Enumerable.sol";
import "./IPixls.sol";
// Pixlton Car Club contract
contract PixltonCarClub is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private CurrentTokenId;
uint256[5471] private Ids;
uint16 public constant MAX_MINTS_TX = 10;
string public baseURI;
uint256 public PublicTokenPrice = 0.03 ether;
uint16 public MaxTokens = 5471;
bool public PublicMintActive = false;
bool public ClaimActive = false;
// Ledger of Pixl IDs that were claimed with.
mapping(uint256 => bool) ClaimedPixlIds;
string public constant Z = "You'll see this on the internet. Go on, press like, and make my clicks spike.";
// Parent NFT Contract mainnet address
address public nftAddress = 0x082903f4e94c5e10A2B116a4284940a36AFAEd63;
IPixls nftContract = IPixls(nftAddress);
constructor(string memory _baseURI) ERC721("Pixlton Car Club", "PXCC") {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function toggleClaimState() public onlyOwner {
}
function togglePublicMintState() public onlyOwner {
}
function setPublicPrice(uint256 newPrice) public onlyOwner {
}
function getClaimablePixls() external view returns (uint256[] memory) {
}
function checkIfClaimed(uint256 nftId) external view returns (bool) {
}
function getAvailableCars() external view returns (uint256) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
// Private minting (Pixls holders only) - Claim for singular Pixl
function claimWithPixl(uint256 nftId) external {
}
// Private minting (Pixls holders only) - Claim for specific NFTs
function multiClaimWithPixl(uint256 [] memory nftIds) public {
require(ClaimActive, "Pixlton Car Club must be active to claim.");
require(nftIds.length + CurrentTokenId.current() <= MaxTokens, "Not enough available cars to claim.");
for (uint i=0; i< nftIds.length; i++) {
require(<FILL_ME>)
if(ClaimedPixlIds[nftIds[i]]) {
continue;
} else {
internalMint(msg.sender, 1);
ClaimedPixlIds[nftIds[i]] = true;
}
}
}
// Private minting (Pixls holders only) - Claim for all of your Pixl holdings
function multiClaimWithAll() external {
}
// Mint a limited stack for the developer.
function devMint(address _to, uint256 _quantity) internal {
}
function totalSupply() public view override returns (uint256) {
}
function mintPublic(uint256 quantity) public payable {
}
function internalMint(address _to, uint256 _quantity) private {
}
function getRandomNumber(uint256 maxValue, uint256 salt) private view returns(uint256) {
}
function withdraw() external onlyOwner {
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
| nftContract.ownerOf(nftIds[i])==msg.sender,"Not the owner of this Pixl." | 16,771 | nftContract.ownerOf(nftIds[i])==msg.sender |
"Not enough available cars to mint." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC721Enumerable.sol";
import "./IPixls.sol";
// Pixlton Car Club contract
contract PixltonCarClub is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private CurrentTokenId;
uint256[5471] private Ids;
uint16 public constant MAX_MINTS_TX = 10;
string public baseURI;
uint256 public PublicTokenPrice = 0.03 ether;
uint16 public MaxTokens = 5471;
bool public PublicMintActive = false;
bool public ClaimActive = false;
// Ledger of Pixl IDs that were claimed with.
mapping(uint256 => bool) ClaimedPixlIds;
string public constant Z = "You'll see this on the internet. Go on, press like, and make my clicks spike.";
// Parent NFT Contract mainnet address
address public nftAddress = 0x082903f4e94c5e10A2B116a4284940a36AFAEd63;
IPixls nftContract = IPixls(nftAddress);
constructor(string memory _baseURI) ERC721("Pixlton Car Club", "PXCC") {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function toggleClaimState() public onlyOwner {
}
function togglePublicMintState() public onlyOwner {
}
function setPublicPrice(uint256 newPrice) public onlyOwner {
}
function getClaimablePixls() external view returns (uint256[] memory) {
}
function checkIfClaimed(uint256 nftId) external view returns (bool) {
}
function getAvailableCars() external view returns (uint256) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
// Private minting (Pixls holders only) - Claim for singular Pixl
function claimWithPixl(uint256 nftId) external {
}
// Private minting (Pixls holders only) - Claim for specific NFTs
function multiClaimWithPixl(uint256 [] memory nftIds) public {
}
// Private minting (Pixls holders only) - Claim for all of your Pixl holdings
function multiClaimWithAll() external {
}
// Mint a limited stack for the developer.
function devMint(address _to, uint256 _quantity) internal {
}
function totalSupply() public view override returns (uint256) {
}
function mintPublic(uint256 quantity) public payable {
require(PublicMintActive, "Minting is not open to the public!");
require(quantity <= MAX_MINTS_TX, "Trying to mint too many at a time!");
require(<FILL_ME>)
require(msg.value >= PublicTokenPrice * quantity, "Not enough ether sent!");
require(msg.sender == tx.origin, "No contracts please!");
internalMint(msg.sender, quantity);
}
function internalMint(address _to, uint256 _quantity) private {
}
function getRandomNumber(uint256 maxValue, uint256 salt) private view returns(uint256) {
}
function withdraw() external onlyOwner {
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
| quantity+CurrentTokenId.current()<=MaxTokens,"Not enough available cars to mint." | 16,771 | quantity+CurrentTokenId.current()<=MaxTokens |
"Cannot exceed max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC721Enumerable.sol";
import "./IPixls.sol";
// Pixlton Car Club contract
contract PixltonCarClub is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private CurrentTokenId;
uint256[5471] private Ids;
uint16 public constant MAX_MINTS_TX = 10;
string public baseURI;
uint256 public PublicTokenPrice = 0.03 ether;
uint16 public MaxTokens = 5471;
bool public PublicMintActive = false;
bool public ClaimActive = false;
// Ledger of Pixl IDs that were claimed with.
mapping(uint256 => bool) ClaimedPixlIds;
string public constant Z = "You'll see this on the internet. Go on, press like, and make my clicks spike.";
// Parent NFT Contract mainnet address
address public nftAddress = 0x082903f4e94c5e10A2B116a4284940a36AFAEd63;
IPixls nftContract = IPixls(nftAddress);
constructor(string memory _baseURI) ERC721("Pixlton Car Club", "PXCC") {
}
function setBaseURI(string memory _baseURI) public onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function toggleClaimState() public onlyOwner {
}
function togglePublicMintState() public onlyOwner {
}
function setPublicPrice(uint256 newPrice) public onlyOwner {
}
function getClaimablePixls() external view returns (uint256[] memory) {
}
function checkIfClaimed(uint256 nftId) external view returns (bool) {
}
function getAvailableCars() external view returns (uint256) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
// Private minting (Pixls holders only) - Claim for singular Pixl
function claimWithPixl(uint256 nftId) external {
}
// Private minting (Pixls holders only) - Claim for specific NFTs
function multiClaimWithPixl(uint256 [] memory nftIds) public {
}
// Private minting (Pixls holders only) - Claim for all of your Pixl holdings
function multiClaimWithAll() external {
}
// Mint a limited stack for the developer.
function devMint(address _to, uint256 _quantity) internal {
}
function totalSupply() public view override returns (uint256) {
}
function mintPublic(uint256 quantity) public payable {
}
function internalMint(address _to, uint256 _quantity) private {
require(_quantity <= MaxTokens && _quantity > 0, "Incorrect mint quantity");
require(<FILL_ME>)
uint256 remaining = MaxTokens - CurrentTokenId.current();
for(uint256 i; i < _quantity; i++){
remaining--;
uint256 tokenId = CurrentTokenId.current();
uint256 index = getRandomNumber(remaining, i * tokenId);
_mint(_to, ((Ids[index] == 0) ? index : Ids[index]) + 1);
Ids[index] = Ids[remaining] == 0 ? remaining : Ids[remaining];
CurrentTokenId.increment();
}
}
function getRandomNumber(uint256 maxValue, uint256 salt) private view returns(uint256) {
}
function withdraw() external onlyOwner {
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
| _quantity+CurrentTokenId.current()<=MaxTokens,"Cannot exceed max supply" | 16,771 | _quantity+CurrentTokenId.current()<=MaxTokens |
null | /**
*
* SpaceWave Contract for Initial Coin Offering
*
*/
pragma solidity ^0.5.10;
/**
* @title ERC20 interface
* see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
*/
interface IERC20
{
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256 balance);
function transfer(address to, uint256 value) external returns (bool success);
function transferFrom(address from, address to, uint256 value) external returns (bool success);
function approve(address spender, uint256 value) external returns (bool success);
function allowance(address owner, address spender) external view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
*
* Main Contract for creating and managing SPW Tokens
*
*/
contract SpaceWave is IERC20
{
////////////////////////
//// Base variables
uint256 internal _totalSupply;
uint8 internal _decimals;
function name() public view returns (string memory) { }
function symbol() public view returns (string memory) { }
function decimals() public view returns (uint8) { }
function totalSupply() public view returns (uint256) { }
////////////////////////
//// Owner related
address internal _owner;
modifier byOwner {
}
////////////////////////
//// Pause functionality
bool internal _paused;
modifier whenNotPaused {
}
function pause() public byOwner returns (bool success) {
}
function resume() public byOwner returns (bool success) {
}
function isPaused() public view returns (bool paused) {
}
////////////////////////
/// Core maps related to
/// balance and allowance
/* This creates a map with all balances */
mapping (address => uint256) internal _balanceOf;
function balanceOf(address who) public view returns (uint256 balance) { }
mapping (address => mapping (address => uint256)) internal _allowance;
function allowance(address owner, address spender) public view
returns (uint256 remaining) { }
////////////////////////
// Core functions
/**
* Initializes contract with initial supply tokens to the creator
* of the contract.
*/
constructor() public
{
}
////////////////////////
/// Core functions related
/// to ERC20 tokens
/* Send SPW tokens */
function transfer(address to, uint256 value) public whenNotPaused returns (bool success)
{
require(to != address(0)); // Prevent transfer to '0' address.
require(to != msg.sender); // Prevent transfer to self
require(value > 0);
uint256 f = _balanceOf[msg.sender];
require(f >= value); // Check if sender has enough
uint256 t = _balanceOf[to];
uint256 t1 = t + value;
require(<FILL_ME>)
_balanceOf[msg.sender] = f - value; // Subtract from the sender
_balanceOf[to] = t1; // Add the same to the recipient
emit Transfer(msg.sender, to, value); // Notify anyone listening that this transfer took place
return true;
}
/* Allow a spender to spend some SPW tokens in your behalf */
function approve(address spender, uint256 value) public whenNotPaused returns (bool success)
{
}
/* An approved third-party transfers SPW tokens */
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool success)
{
}
///////////////////////////
/// Mint and burn functions
/**
* This is used only under specific circumstances for increasing token supply
*/
function mint(uint256 value) public whenNotPaused byOwner returns (bool success)
{
}
/**
* Burn tokens. This will allow sender to burn specific number of tokens.
* WARNING: Use with caution as once some tokens are burnt, they will not come back!
*/
function burn(uint256 value) public whenNotPaused returns (bool success)
{
}
}
| (t1>t)&&(t1>=value) | 16,776 | (t1>t)&&(t1>=value) |
null | /**
*
* SpaceWave Contract for Initial Coin Offering
*
*/
pragma solidity ^0.5.10;
/**
* @title ERC20 interface
* see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
*/
interface IERC20
{
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256 balance);
function transfer(address to, uint256 value) external returns (bool success);
function transferFrom(address from, address to, uint256 value) external returns (bool success);
function approve(address spender, uint256 value) external returns (bool success);
function allowance(address owner, address spender) external view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
*
* Main Contract for creating and managing SPW Tokens
*
*/
contract SpaceWave is IERC20
{
////////////////////////
//// Base variables
uint256 internal _totalSupply;
uint8 internal _decimals;
function name() public view returns (string memory) { }
function symbol() public view returns (string memory) { }
function decimals() public view returns (uint8) { }
function totalSupply() public view returns (uint256) { }
////////////////////////
//// Owner related
address internal _owner;
modifier byOwner {
}
////////////////////////
//// Pause functionality
bool internal _paused;
modifier whenNotPaused {
}
function pause() public byOwner returns (bool success) {
}
function resume() public byOwner returns (bool success) {
}
function isPaused() public view returns (bool paused) {
}
////////////////////////
/// Core maps related to
/// balance and allowance
/* This creates a map with all balances */
mapping (address => uint256) internal _balanceOf;
function balanceOf(address who) public view returns (uint256 balance) { }
mapping (address => mapping (address => uint256)) internal _allowance;
function allowance(address owner, address spender) public view
returns (uint256 remaining) { }
////////////////////////
// Core functions
/**
* Initializes contract with initial supply tokens to the creator
* of the contract.
*/
constructor() public
{
}
////////////////////////
/// Core functions related
/// to ERC20 tokens
/* Send SPW tokens */
function transfer(address to, uint256 value) public whenNotPaused returns (bool success)
{
}
/* Allow a spender to spend some SPW tokens in your behalf */
function approve(address spender, uint256 value) public whenNotPaused returns (bool success)
{
require(value > 0);
require(<FILL_ME>) // Allow only how much the sender can spend
_allowance[msg.sender][spender] = value;
return true;
}
/* An approved third-party transfers SPW tokens */
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool success)
{
}
///////////////////////////
/// Mint and burn functions
/**
* This is used only under specific circumstances for increasing token supply
*/
function mint(uint256 value) public whenNotPaused byOwner returns (bool success)
{
}
/**
* Burn tokens. This will allow sender to burn specific number of tokens.
* WARNING: Use with caution as once some tokens are burnt, they will not come back!
*/
function burn(uint256 value) public whenNotPaused returns (bool success)
{
}
}
| _balanceOf[msg.sender]>=value | 16,776 | _balanceOf[msg.sender]>=value |
null | /**
*
* SpaceWave Contract for Initial Coin Offering
*
*/
pragma solidity ^0.5.10;
/**
* @title ERC20 interface
* see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
*/
interface IERC20
{
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256 balance);
function transfer(address to, uint256 value) external returns (bool success);
function transferFrom(address from, address to, uint256 value) external returns (bool success);
function approve(address spender, uint256 value) external returns (bool success);
function allowance(address owner, address spender) external view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
*
* Main Contract for creating and managing SPW Tokens
*
*/
contract SpaceWave is IERC20
{
////////////////////////
//// Base variables
uint256 internal _totalSupply;
uint8 internal _decimals;
function name() public view returns (string memory) { }
function symbol() public view returns (string memory) { }
function decimals() public view returns (uint8) { }
function totalSupply() public view returns (uint256) { }
////////////////////////
//// Owner related
address internal _owner;
modifier byOwner {
}
////////////////////////
//// Pause functionality
bool internal _paused;
modifier whenNotPaused {
}
function pause() public byOwner returns (bool success) {
}
function resume() public byOwner returns (bool success) {
}
function isPaused() public view returns (bool paused) {
}
////////////////////////
/// Core maps related to
/// balance and allowance
/* This creates a map with all balances */
mapping (address => uint256) internal _balanceOf;
function balanceOf(address who) public view returns (uint256 balance) { }
mapping (address => mapping (address => uint256)) internal _allowance;
function allowance(address owner, address spender) public view
returns (uint256 remaining) { }
////////////////////////
// Core functions
/**
* Initializes contract with initial supply tokens to the creator
* of the contract.
*/
constructor() public
{
}
////////////////////////
/// Core functions related
/// to ERC20 tokens
/* Send SPW tokens */
function transfer(address to, uint256 value) public whenNotPaused returns (bool success)
{
}
/* Allow a spender to spend some SPW tokens in your behalf */
function approve(address spender, uint256 value) public whenNotPaused returns (bool success)
{
}
/* An approved third-party transfers SPW tokens */
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool success)
{
require(to != address(0)); // Prevent transfer to 0x0 address
require(from != to); // Prevent transfer to self
require(value > 0);
uint256 f = _balanceOf[from];
uint256 t = _balanceOf[to];
uint256 a = _allowance[from][msg.sender];
require(<FILL_ME>)
uint256 t1 = t + value;
require((t1 > t) && (t1 >= value));
_balanceOf[from] = f - value;// Subtract from the sender
_balanceOf[to] = t1; // Add the same to the recipient
_allowance[from][msg.sender] = a - value;
emit Transfer(from, to, value);
return true;
}
///////////////////////////
/// Mint and burn functions
/**
* This is used only under specific circumstances for increasing token supply
*/
function mint(uint256 value) public whenNotPaused byOwner returns (bool success)
{
}
/**
* Burn tokens. This will allow sender to burn specific number of tokens.
* WARNING: Use with caution as once some tokens are burnt, they will not come back!
*/
function burn(uint256 value) public whenNotPaused returns (bool success)
{
}
}
| (f>=value)&&(a>=value) | 16,776 | (f>=value)&&(a>=value) |
null | /**
*
* SpaceWave Contract for Initial Coin Offering
*
*/
pragma solidity ^0.5.10;
/**
* @title ERC20 interface
* see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
*/
interface IERC20
{
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256 balance);
function transfer(address to, uint256 value) external returns (bool success);
function transferFrom(address from, address to, uint256 value) external returns (bool success);
function approve(address spender, uint256 value) external returns (bool success);
function allowance(address owner, address spender) external view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
*
* Main Contract for creating and managing SPW Tokens
*
*/
contract SpaceWave is IERC20
{
////////////////////////
//// Base variables
uint256 internal _totalSupply;
uint8 internal _decimals;
function name() public view returns (string memory) { }
function symbol() public view returns (string memory) { }
function decimals() public view returns (uint8) { }
function totalSupply() public view returns (uint256) { }
////////////////////////
//// Owner related
address internal _owner;
modifier byOwner {
}
////////////////////////
//// Pause functionality
bool internal _paused;
modifier whenNotPaused {
}
function pause() public byOwner returns (bool success) {
}
function resume() public byOwner returns (bool success) {
}
function isPaused() public view returns (bool paused) {
}
////////////////////////
/// Core maps related to
/// balance and allowance
/* This creates a map with all balances */
mapping (address => uint256) internal _balanceOf;
function balanceOf(address who) public view returns (uint256 balance) { }
mapping (address => mapping (address => uint256)) internal _allowance;
function allowance(address owner, address spender) public view
returns (uint256 remaining) { }
////////////////////////
// Core functions
/**
* Initializes contract with initial supply tokens to the creator
* of the contract.
*/
constructor() public
{
}
////////////////////////
/// Core functions related
/// to ERC20 tokens
/* Send SPW tokens */
function transfer(address to, uint256 value) public whenNotPaused returns (bool success)
{
}
/* Allow a spender to spend some SPW tokens in your behalf */
function approve(address spender, uint256 value) public whenNotPaused returns (bool success)
{
}
/* An approved third-party transfers SPW tokens */
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool success)
{
}
///////////////////////////
/// Mint and burn functions
/**
* This is used only under specific circumstances for increasing token supply
*/
function mint(uint256 value) public whenNotPaused byOwner returns (bool success)
{
uint256 b = _balanceOf[_owner];
uint256 t = _totalSupply;
uint256 b1 = b + value;
require(<FILL_ME>) // Ensure value > 0 and there is no overflow
uint256 t1 = t + value;
require((t1 > t) && (t1 >= value));
_balanceOf[_owner] = b1;
_totalSupply = t1;
return true;
}
/**
* Burn tokens. This will allow sender to burn specific number of tokens.
* WARNING: Use with caution as once some tokens are burnt, they will not come back!
*/
function burn(uint256 value) public whenNotPaused returns (bool success)
{
}
}
| (b1>b)&&(b1>=value) | 16,776 | (b1>b)&&(b1>=value) |
"Unknown oracle" | // SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "./interfaces/IOracle.sol";
import "./interfaces/IWrapper.sol";
contract OffchainOracle is Ownable {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
event OracleAdded(IOracle oracle);
event OracleRemoved(IOracle oracle);
event WrapperAdded(IWrapper connector);
event WrapperRemoved(IWrapper connector);
event ConnectorAdded(IERC20 connector);
event ConnectorRemoved(IERC20 connector);
EnumerableSet.AddressSet private _oracles;
EnumerableSet.AddressSet private _wrappers;
EnumerableSet.AddressSet private _connectors;
constructor(IOracle[] memory existingOracles, IWrapper[] memory existingWrappers, IERC20[] memory existingConnectors) {
}
function oracles() external view returns (IOracle[] memory allOracles) {
}
function wrappers() external view returns (IWrapper[] memory allWrappers) {
}
function connectors() external view returns (IERC20[] memory allConnectors) {
}
function addOracle(IOracle oracle) external onlyOwner {
}
function removeOracle(IOracle oracle) external onlyOwner {
require(<FILL_ME>)
emit OracleRemoved(oracle);
}
function addWrapper(IWrapper wrapper) external onlyOwner {
}
function removeWrapper(IWrapper wrapper) external onlyOwner {
}
function addConnector(IERC20 connector) external onlyOwner {
}
function removeConnector(IERC20 connector) external onlyOwner {
}
/*
WARNING!
Usage of the dex oracle on chain is highly discouraged!
getRate function can be easily manipulated inside transaction!
*/
function getRate(IERC20 srcToken, IERC20 dstToken) external view returns(uint256 weightedRate) {
}
function _addOracle(IOracle oracle) private {
}
function _addWrapper(IWrapper wrapper) private {
}
function _addConnector(IERC20 connector) private {
}
}
| _oracles.remove(address(oracle)),"Unknown oracle" | 16,850 | _oracles.remove(address(oracle)) |
"Unknown wrapper" | // SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "./interfaces/IOracle.sol";
import "./interfaces/IWrapper.sol";
contract OffchainOracle is Ownable {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
event OracleAdded(IOracle oracle);
event OracleRemoved(IOracle oracle);
event WrapperAdded(IWrapper connector);
event WrapperRemoved(IWrapper connector);
event ConnectorAdded(IERC20 connector);
event ConnectorRemoved(IERC20 connector);
EnumerableSet.AddressSet private _oracles;
EnumerableSet.AddressSet private _wrappers;
EnumerableSet.AddressSet private _connectors;
constructor(IOracle[] memory existingOracles, IWrapper[] memory existingWrappers, IERC20[] memory existingConnectors) {
}
function oracles() external view returns (IOracle[] memory allOracles) {
}
function wrappers() external view returns (IWrapper[] memory allWrappers) {
}
function connectors() external view returns (IERC20[] memory allConnectors) {
}
function addOracle(IOracle oracle) external onlyOwner {
}
function removeOracle(IOracle oracle) external onlyOwner {
}
function addWrapper(IWrapper wrapper) external onlyOwner {
}
function removeWrapper(IWrapper wrapper) external onlyOwner {
require(<FILL_ME>)
emit WrapperRemoved(wrapper);
}
function addConnector(IERC20 connector) external onlyOwner {
}
function removeConnector(IERC20 connector) external onlyOwner {
}
/*
WARNING!
Usage of the dex oracle on chain is highly discouraged!
getRate function can be easily manipulated inside transaction!
*/
function getRate(IERC20 srcToken, IERC20 dstToken) external view returns(uint256 weightedRate) {
}
function _addOracle(IOracle oracle) private {
}
function _addWrapper(IWrapper wrapper) private {
}
function _addConnector(IERC20 connector) private {
}
}
| _wrappers.remove(address(wrapper)),"Unknown wrapper" | 16,850 | _wrappers.remove(address(wrapper)) |
"Unknown connector" | // SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "./interfaces/IOracle.sol";
import "./interfaces/IWrapper.sol";
contract OffchainOracle is Ownable {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
event OracleAdded(IOracle oracle);
event OracleRemoved(IOracle oracle);
event WrapperAdded(IWrapper connector);
event WrapperRemoved(IWrapper connector);
event ConnectorAdded(IERC20 connector);
event ConnectorRemoved(IERC20 connector);
EnumerableSet.AddressSet private _oracles;
EnumerableSet.AddressSet private _wrappers;
EnumerableSet.AddressSet private _connectors;
constructor(IOracle[] memory existingOracles, IWrapper[] memory existingWrappers, IERC20[] memory existingConnectors) {
}
function oracles() external view returns (IOracle[] memory allOracles) {
}
function wrappers() external view returns (IWrapper[] memory allWrappers) {
}
function connectors() external view returns (IERC20[] memory allConnectors) {
}
function addOracle(IOracle oracle) external onlyOwner {
}
function removeOracle(IOracle oracle) external onlyOwner {
}
function addWrapper(IWrapper wrapper) external onlyOwner {
}
function removeWrapper(IWrapper wrapper) external onlyOwner {
}
function addConnector(IERC20 connector) external onlyOwner {
}
function removeConnector(IERC20 connector) external onlyOwner {
require(<FILL_ME>)
emit ConnectorRemoved(connector);
}
/*
WARNING!
Usage of the dex oracle on chain is highly discouraged!
getRate function can be easily manipulated inside transaction!
*/
function getRate(IERC20 srcToken, IERC20 dstToken) external view returns(uint256 weightedRate) {
}
function _addOracle(IOracle oracle) private {
}
function _addWrapper(IWrapper wrapper) private {
}
function _addConnector(IERC20 connector) private {
}
}
| _connectors.remove(address(connector)),"Unknown connector" | 16,850 | _connectors.remove(address(connector)) |
"Oracle already added" | // SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "./interfaces/IOracle.sol";
import "./interfaces/IWrapper.sol";
contract OffchainOracle is Ownable {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
event OracleAdded(IOracle oracle);
event OracleRemoved(IOracle oracle);
event WrapperAdded(IWrapper connector);
event WrapperRemoved(IWrapper connector);
event ConnectorAdded(IERC20 connector);
event ConnectorRemoved(IERC20 connector);
EnumerableSet.AddressSet private _oracles;
EnumerableSet.AddressSet private _wrappers;
EnumerableSet.AddressSet private _connectors;
constructor(IOracle[] memory existingOracles, IWrapper[] memory existingWrappers, IERC20[] memory existingConnectors) {
}
function oracles() external view returns (IOracle[] memory allOracles) {
}
function wrappers() external view returns (IWrapper[] memory allWrappers) {
}
function connectors() external view returns (IERC20[] memory allConnectors) {
}
function addOracle(IOracle oracle) external onlyOwner {
}
function removeOracle(IOracle oracle) external onlyOwner {
}
function addWrapper(IWrapper wrapper) external onlyOwner {
}
function removeWrapper(IWrapper wrapper) external onlyOwner {
}
function addConnector(IERC20 connector) external onlyOwner {
}
function removeConnector(IERC20 connector) external onlyOwner {
}
/*
WARNING!
Usage of the dex oracle on chain is highly discouraged!
getRate function can be easily manipulated inside transaction!
*/
function getRate(IERC20 srcToken, IERC20 dstToken) external view returns(uint256 weightedRate) {
}
function _addOracle(IOracle oracle) private {
require(<FILL_ME>)
emit OracleAdded(oracle);
}
function _addWrapper(IWrapper wrapper) private {
}
function _addConnector(IERC20 connector) private {
}
}
| _oracles.add(address(oracle)),"Oracle already added" | 16,850 | _oracles.add(address(oracle)) |
"Wrapper already added" | // SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "./interfaces/IOracle.sol";
import "./interfaces/IWrapper.sol";
contract OffchainOracle is Ownable {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
event OracleAdded(IOracle oracle);
event OracleRemoved(IOracle oracle);
event WrapperAdded(IWrapper connector);
event WrapperRemoved(IWrapper connector);
event ConnectorAdded(IERC20 connector);
event ConnectorRemoved(IERC20 connector);
EnumerableSet.AddressSet private _oracles;
EnumerableSet.AddressSet private _wrappers;
EnumerableSet.AddressSet private _connectors;
constructor(IOracle[] memory existingOracles, IWrapper[] memory existingWrappers, IERC20[] memory existingConnectors) {
}
function oracles() external view returns (IOracle[] memory allOracles) {
}
function wrappers() external view returns (IWrapper[] memory allWrappers) {
}
function connectors() external view returns (IERC20[] memory allConnectors) {
}
function addOracle(IOracle oracle) external onlyOwner {
}
function removeOracle(IOracle oracle) external onlyOwner {
}
function addWrapper(IWrapper wrapper) external onlyOwner {
}
function removeWrapper(IWrapper wrapper) external onlyOwner {
}
function addConnector(IERC20 connector) external onlyOwner {
}
function removeConnector(IERC20 connector) external onlyOwner {
}
/*
WARNING!
Usage of the dex oracle on chain is highly discouraged!
getRate function can be easily manipulated inside transaction!
*/
function getRate(IERC20 srcToken, IERC20 dstToken) external view returns(uint256 weightedRate) {
}
function _addOracle(IOracle oracle) private {
}
function _addWrapper(IWrapper wrapper) private {
require(<FILL_ME>)
emit WrapperAdded(wrapper);
}
function _addConnector(IERC20 connector) private {
}
}
| _wrappers.add(address(wrapper)),"Wrapper already added" | 16,850 | _wrappers.add(address(wrapper)) |
"Connector already added" | // SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "./interfaces/IOracle.sol";
import "./interfaces/IWrapper.sol";
contract OffchainOracle is Ownable {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
event OracleAdded(IOracle oracle);
event OracleRemoved(IOracle oracle);
event WrapperAdded(IWrapper connector);
event WrapperRemoved(IWrapper connector);
event ConnectorAdded(IERC20 connector);
event ConnectorRemoved(IERC20 connector);
EnumerableSet.AddressSet private _oracles;
EnumerableSet.AddressSet private _wrappers;
EnumerableSet.AddressSet private _connectors;
constructor(IOracle[] memory existingOracles, IWrapper[] memory existingWrappers, IERC20[] memory existingConnectors) {
}
function oracles() external view returns (IOracle[] memory allOracles) {
}
function wrappers() external view returns (IWrapper[] memory allWrappers) {
}
function connectors() external view returns (IERC20[] memory allConnectors) {
}
function addOracle(IOracle oracle) external onlyOwner {
}
function removeOracle(IOracle oracle) external onlyOwner {
}
function addWrapper(IWrapper wrapper) external onlyOwner {
}
function removeWrapper(IWrapper wrapper) external onlyOwner {
}
function addConnector(IERC20 connector) external onlyOwner {
}
function removeConnector(IERC20 connector) external onlyOwner {
}
/*
WARNING!
Usage of the dex oracle on chain is highly discouraged!
getRate function can be easily manipulated inside transaction!
*/
function getRate(IERC20 srcToken, IERC20 dstToken) external view returns(uint256 weightedRate) {
}
function _addOracle(IOracle oracle) private {
}
function _addWrapper(IWrapper wrapper) private {
}
function _addConnector(IERC20 connector) private {
require(<FILL_ME>)
emit ConnectorAdded(connector);
}
}
| _connectors.add(address(connector)),"Connector already added" | 16,850 | _connectors.add(address(connector)) |
"Exceeds max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Address.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract XORADMAGICAL is ERC721, IERC2981, ReentrancyGuard, Ownable {
using Counters for Counters.Counter;
constructor(string memory customBaseURI_, address proxyRegistryAddress_)
ERC721("XORADMAGICAL", "XORAD")
{
}
/** MINTING **/
uint256 public constant MAX_SUPPLY = 100;
uint256 public constant MAX_MULTIMINT = 100;
Counters.Counter private supplyCounter;
function mint(uint256 count) public nonReentrant onlyOwner {
require(saleIsActive, "Sale not active");
require(<FILL_ME>)
require(count <= MAX_MULTIMINT, "Mint at most 100 at a time");
for (uint256 i = 0; i < count; i++) {
_mint(msg.sender, totalSupply());
supplyCounter.increment();
}
}
function totalSupply() public view returns (uint256) {
}
/** ACTIVATION **/
bool public saleIsActive = true;
function setSaleIsActive(bool saleIsActive_) external onlyOwner {
}
/** URI HANDLING **/
string private customBaseURI;
function setBaseURI(string memory customBaseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
/** PAYOUT **/
function withdraw() public nonReentrant {
}
/** ROYALTIES **/
function royaltyInfo(uint256, uint256 salePrice) external view override
returns (address receiver, uint256 royaltyAmount)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, IERC165)
returns (bool)
{
}
/** PROXY REGISTRY **/
address private immutable proxyRegistryAddress;
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
}
// Contract created with Studio 721 v1.5.0
// https://721.so
| totalSupply()+count-1<MAX_SUPPLY,"Exceeds max supply" | 16,952 | totalSupply()+count-1<MAX_SUPPLY |
null | // SPDX-License-Identifier: MIT
// Faucet contract
// Para no tener que dar uno a uno los tokens, tenemos este contrato de "faucet"
//
// ¿Qué es un Faucet? es una forma muy común de distribuir nuevos Tokens.
//
// Consiste en un contrato (que _suele_ tener una página web asociada)
// que distribuye los tokens a quien los solicita.
// Así el que crea el token no tiene que pagar por distribuir los tokens,
// y sólo los interesados 'pagan' a los mineros de la red por el coste de la transacción.
pragma solidity >=0.7.0;
interface iERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Faucet {
// Vamos a hacer un Faucet_muy_ sencillo:
// - No podemos saber de qué país es cada dirección así que:
// - Cada dirección de Ethereum debe poder participar en el Airdrop.
// - A cada dirección que lo solicite le transferimos 1000 unidades del tocken.
// - Sólo se puede participar en el airdrop una sola vez.
// - Si hay algún problema, la transacción _falla_
// Primero necesitamos la dirección del contrato del Token
address public immutable token;
address public _root;
// También necesitamos una lista de direcciones.
// Un "mapping" direccion -> a un 0 o 1 bastaría...
// .. pero ese tipo de dato no existe en este lenguaje)
// .. así que hay que construirlo a mano.
// este es un bitmap (hay formas más eficientes de hacerlo, pero esta nos sirve)
mapping (address => uint256) public claimed;
uint256 public immutable claimAmount;
event Claimed(address _by, address _to, uint256 _value);
// Cantidad solicitada por cada dirección
function ClaimedAmount(address index) public view returns (uint256) {
}
function _setClaimed(address index) private {
require(<FILL_ME>)
claimed[index] += claimAmount; // No puede desbordar
}
// Esta funcion es la que permite reclamar los tokens.
// No hace falta ser el dueño de la dirección para solicitarlo.
// De todos modos... ¿quién puede querer enviar tokens a otro?
// Hmm.. ¿puede haber alguna implicación legal de eso?
function Claim(address index) public returns (uint256) {
}
// Cuando acabe el tiempo del airdrop se pueden recuperar
// a menos que haya alguna logica en el token que no lo permita...
// Se permite que Recovertokens lo llame un contrato por motivos fiscales.
// Si se llama a Recovertokens desde una direccion "normal" de Ethereum
// hacienda nos puede obligar a tributar por tener los tokens durante unos segundos.
function Recovertokens() public returns (bool) {
}
// SetRoot permite cambiar el superusuario del contrato
// es decir, la dirección a la que se permite reclamar
// todos los tokens. Se puede llamar desde un contrato!
event NewRootEvent(address);
function SetRoot(address newroot) public {
}
// Necesitamos construir el contrato (instanciar)
// Constructor
constructor(address tokenaddr, uint256 claim_by_addr) {
}
}
| claimed[index]==0 | 16,976 | claimed[index]==0 |
null | // SPDX-License-Identifier: MIT
// Faucet contract
// Para no tener que dar uno a uno los tokens, tenemos este contrato de "faucet"
//
// ¿Qué es un Faucet? es una forma muy común de distribuir nuevos Tokens.
//
// Consiste en un contrato (que _suele_ tener una página web asociada)
// que distribuye los tokens a quien los solicita.
// Así el que crea el token no tiene que pagar por distribuir los tokens,
// y sólo los interesados 'pagan' a los mineros de la red por el coste de la transacción.
pragma solidity >=0.7.0;
interface iERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Faucet {
// Vamos a hacer un Faucet_muy_ sencillo:
// - No podemos saber de qué país es cada dirección así que:
// - Cada dirección de Ethereum debe poder participar en el Airdrop.
// - A cada dirección que lo solicite le transferimos 1000 unidades del tocken.
// - Sólo se puede participar en el airdrop una sola vez.
// - Si hay algún problema, la transacción _falla_
// Primero necesitamos la dirección del contrato del Token
address public immutable token;
address public _root;
// También necesitamos una lista de direcciones.
// Un "mapping" direccion -> a un 0 o 1 bastaría...
// .. pero ese tipo de dato no existe en este lenguaje)
// .. así que hay que construirlo a mano.
// este es un bitmap (hay formas más eficientes de hacerlo, pero esta nos sirve)
mapping (address => uint256) public claimed;
uint256 public immutable claimAmount;
event Claimed(address _by, address _to, uint256 _value);
// Cantidad solicitada por cada dirección
function ClaimedAmount(address index) public view returns (uint256) {
}
function _setClaimed(address index) private {
}
// Esta funcion es la que permite reclamar los tokens.
// No hace falta ser el dueño de la dirección para solicitarlo.
// De todos modos... ¿quién puede querer enviar tokens a otro?
// Hmm.. ¿puede haber alguna implicación legal de eso?
function Claim(address index) public returns (uint256) {
// hmm... ¿dejamos que lo haga un smart contract?
require(msg.sender == tx.origin, "Only humans");
require(<FILL_ME>)
_setClaimed(index);
// Hacemos la transferencia y revertimos operacion si da algún error
require(iERC20(token).transfer(index, claimAmount), "Airdrop: error transferencia");
emit Claimed(msg.sender, index, claimAmount);
return claimAmount;
}
// Cuando acabe el tiempo del airdrop se pueden recuperar
// a menos que haya alguna logica en el token que no lo permita...
// Se permite que Recovertokens lo llame un contrato por motivos fiscales.
// Si se llama a Recovertokens desde una direccion "normal" de Ethereum
// hacienda nos puede obligar a tributar por tener los tokens durante unos segundos.
function Recovertokens() public returns (bool) {
}
// SetRoot permite cambiar el superusuario del contrato
// es decir, la dirección a la que se permite reclamar
// todos los tokens. Se puede llamar desde un contrato!
event NewRootEvent(address);
function SetRoot(address newroot) public {
}
// Necesitamos construir el contrato (instanciar)
// Constructor
constructor(address tokenaddr, uint256 claim_by_addr) {
}
}
| ClaimedAmount(index)==0&&index!=address(0) | 16,976 | ClaimedAmount(index)==0&&index!=address(0) |
"Airdrop: error transferencia" | // SPDX-License-Identifier: MIT
// Faucet contract
// Para no tener que dar uno a uno los tokens, tenemos este contrato de "faucet"
//
// ¿Qué es un Faucet? es una forma muy común de distribuir nuevos Tokens.
//
// Consiste en un contrato (que _suele_ tener una página web asociada)
// que distribuye los tokens a quien los solicita.
// Así el que crea el token no tiene que pagar por distribuir los tokens,
// y sólo los interesados 'pagan' a los mineros de la red por el coste de la transacción.
pragma solidity >=0.7.0;
interface iERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Faucet {
// Vamos a hacer un Faucet_muy_ sencillo:
// - No podemos saber de qué país es cada dirección así que:
// - Cada dirección de Ethereum debe poder participar en el Airdrop.
// - A cada dirección que lo solicite le transferimos 1000 unidades del tocken.
// - Sólo se puede participar en el airdrop una sola vez.
// - Si hay algún problema, la transacción _falla_
// Primero necesitamos la dirección del contrato del Token
address public immutable token;
address public _root;
// También necesitamos una lista de direcciones.
// Un "mapping" direccion -> a un 0 o 1 bastaría...
// .. pero ese tipo de dato no existe en este lenguaje)
// .. así que hay que construirlo a mano.
// este es un bitmap (hay formas más eficientes de hacerlo, pero esta nos sirve)
mapping (address => uint256) public claimed;
uint256 public immutable claimAmount;
event Claimed(address _by, address _to, uint256 _value);
// Cantidad solicitada por cada dirección
function ClaimedAmount(address index) public view returns (uint256) {
}
function _setClaimed(address index) private {
}
// Esta funcion es la que permite reclamar los tokens.
// No hace falta ser el dueño de la dirección para solicitarlo.
// De todos modos... ¿quién puede querer enviar tokens a otro?
// Hmm.. ¿puede haber alguna implicación legal de eso?
function Claim(address index) public returns (uint256) {
// hmm... ¿dejamos que lo haga un smart contract?
require(msg.sender == tx.origin, "Only humans");
require(ClaimedAmount(index) == 0 && index != address(0));
_setClaimed(index);
// Hacemos la transferencia y revertimos operacion si da algún error
require(<FILL_ME>)
emit Claimed(msg.sender, index, claimAmount);
return claimAmount;
}
// Cuando acabe el tiempo del airdrop se pueden recuperar
// a menos que haya alguna logica en el token que no lo permita...
// Se permite que Recovertokens lo llame un contrato por motivos fiscales.
// Si se llama a Recovertokens desde una direccion "normal" de Ethereum
// hacienda nos puede obligar a tributar por tener los tokens durante unos segundos.
function Recovertokens() public returns (bool) {
}
// SetRoot permite cambiar el superusuario del contrato
// es decir, la dirección a la que se permite reclamar
// todos los tokens. Se puede llamar desde un contrato!
event NewRootEvent(address);
function SetRoot(address newroot) public {
}
// Necesitamos construir el contrato (instanciar)
// Constructor
constructor(address tokenaddr, uint256 claim_by_addr) {
}
}
| iERC20(token).transfer(index,claimAmount),"Airdrop: error transferencia" | 16,976 | iERC20(token).transfer(index,claimAmount) |
null | /* Orchid - WebRTC P2P VPN Market (on Ethereum)
* Copyright (C) 2017-2019 The Orchid Authors
*/
/* GNU Affero General Public License, Version 3 {{{ */
/*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
**/
/* }}} */
pragma solidity 0.5.13;
contract ReverseRegistrar {
function claim(address owner) public returns (bytes32 node);
}
contract OrchidCurator {
function good(address, bytes calldata) external view returns (uint128);
}
contract OrchidList is OrchidCurator {
ReverseRegistrar constant private ens_ = ReverseRegistrar(0x9062C0A6Dbd6108336BcBe4593a3D1cE05512069);
address private owner_;
constructor() public {
}
function hand(address owner) external {
}
struct Entry {
uint128 adjust_;
bool valid_;
}
mapping (address => Entry) private entries_;
function kill(address provider) external {
}
function tend(address provider, uint128 adjust) public {
}
function list(address provider) external {
}
function good(address provider, bytes calldata) external view returns (uint128) {
Entry storage entry = entries_[provider];
require(<FILL_ME>)
return entry.adjust_;
}
}
| entry.valid_ | 16,988 | entry.valid_ |
'HAPI: MAX_SUPPLY' | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.6.6;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/presets/ERC20PresetMinterPauser.sol";
import "./interfaces/IHAPI.sol";
contract HAPI is IHAPI, ERC20PresetMinterPauser {
uint public constant override INITIAL_SUPPLY = 100000 * DECIMAL_MULTIPLIER;
uint public constant override MAX_SUPPLY = 1000000 * DECIMAL_MULTIPLIER;
uint constant private DECIMAL_MULTIPLIER = 10**18;
constructor() ERC20PresetMinterPauser("HAPI", "HAPI") public {
}
function _mint(address account, uint amount) internal virtual override {
require(<FILL_ME>)
super._mint(account, amount);
}
}
| totalSupply().add(amount)<=MAX_SUPPLY,'HAPI: MAX_SUPPLY' | 17,015 | totalSupply().add(amount)<=MAX_SUPPLY |
Errors.MATH_MULTIPLICATION_OVERFLOW | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.7.4;
import {Errors} from "../helpers/Errors.sol";
/**
* @title PercentageMath library
* @author Aave
* @notice Provides functions to perform percentage calculations
* @dev Percentages are defined by default with 2 decimals of precision (100.00). The precision is indicated by PERCENTAGE_FACTOR
* @dev Operations are rounded half up
**/
library PercentageMath {
uint256 constant PERCENTAGE_FACTOR = 1e4; //percentage plus two decimals
uint256 constant HALF_PERCENT = PERCENTAGE_FACTOR / 2;
/**
* @dev Executes a percentage multiplication
* @param value The value of which the percentage needs to be calculated
* @param percentage The percentage of the value to be calculated
* @return The percentage of value
**/
function percentMul(uint256 value, uint256 percentage)
internal
pure
returns (uint256)
{
if (value == 0 || percentage == 0) {
return 0; // T:[PM-1]
}
require(<FILL_ME>)
// T:[PM-1]
return (value * percentage + HALF_PERCENT) / PERCENTAGE_FACTOR; // T:[PM-1]
}
/**
* @dev Executes a percentage division
* @param value The value of which the percentage needs to be calculated
* @param percentage The percentage of the value to be calculated
* @return The value divided the percentage
**/
function percentDiv(uint256 value, uint256 percentage)
internal
pure
returns (uint256)
{
}
}
| value<=(type(uint256).max-HALF_PERCENT)/percentage,Errors.MATH_MULTIPLICATION_OVERFLOW | 17,071 | value<=(type(uint256).max-HALF_PERCENT)/percentage |
Errors.MATH_MULTIPLICATION_OVERFLOW | // SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.7.4;
import {Errors} from "../helpers/Errors.sol";
/**
* @title PercentageMath library
* @author Aave
* @notice Provides functions to perform percentage calculations
* @dev Percentages are defined by default with 2 decimals of precision (100.00). The precision is indicated by PERCENTAGE_FACTOR
* @dev Operations are rounded half up
**/
library PercentageMath {
uint256 constant PERCENTAGE_FACTOR = 1e4; //percentage plus two decimals
uint256 constant HALF_PERCENT = PERCENTAGE_FACTOR / 2;
/**
* @dev Executes a percentage multiplication
* @param value The value of which the percentage needs to be calculated
* @param percentage The percentage of the value to be calculated
* @return The percentage of value
**/
function percentMul(uint256 value, uint256 percentage)
internal
pure
returns (uint256)
{
}
/**
* @dev Executes a percentage division
* @param value The value of which the percentage needs to be calculated
* @param percentage The percentage of the value to be calculated
* @return The value divided the percentage
**/
function percentDiv(uint256 value, uint256 percentage)
internal
pure
returns (uint256)
{
require(percentage != 0, Errors.MATH_DIVISION_BY_ZERO); // T:[PM-2]
uint256 halfPercentage = percentage / 2; // T:[PM-2]
require(<FILL_ME>)
// T:[PM-2]
return (value * PERCENTAGE_FACTOR + halfPercentage) / percentage;
}
}
| value<=(type(uint256).max-halfPercentage)/PERCENTAGE_FACTOR,Errors.MATH_MULTIPLICATION_OVERFLOW | 17,071 | value<=(type(uint256).max-halfPercentage)/PERCENTAGE_FACTOR |
"Time limitation is not expired!" | pragma solidity =0.5.16;
contract timeLimitation is Ownable {
/**
* @dev FPT has burn time limit. When user's balance is moved in som coins, he will wait `timeLimited` to burn FPT.
* latestTransferIn is user's latest time when his balance is moved in.
*/
mapping(uint256=>uint256) internal itemTimeMap;
uint256 internal limitation = 1 hours;
/**
* @dev set time limitation, only owner can invoke.
* @param _limitation new time limitation.
*/
function setTimeLimitation(uint256 _limitation) public onlyOwner {
}
function setItemTimeLimitation(uint256 item) internal{
}
function getTimeLimitation() public view returns (uint256){
}
/**
* @dev Retrieve user's start time for burning.
* @param item item key.
*/
function getItemTimeLimitation(uint256 item) public view returns (uint256){
}
modifier OutLimitation(uint256 item) {
require(<FILL_ME>)
_;
}
}
| itemTimeMap[item]+limitation<now,"Time limitation is not expired!" | 17,160 | itemTimeMap[item]+limitation<now |
"DMMLibrary: ZERO_ADDRESS" | pragma solidity 0.6.12;
library DMMLibrary {
using SafeMath for uint256;
uint256 public constant PRECISION = 1e18;
// returns sorted token addresses, used to handle return values from pools sorted in this order
function sortTokens(IERC20 tokenA, IERC20 tokenB)
internal
pure
returns (IERC20 token0, IERC20 token1)
{
require(tokenA != tokenB, "DMMLibrary: IDENTICAL_ADDRESSES");
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(<FILL_ME>)
}
/// @dev fetch the reserves and fee for a pool, used for trading purposes
function getTradeInfo(
address pool,
IERC20 tokenA,
IERC20 tokenB
)
internal
view
returns (
uint256 reserveA,
uint256 reserveB,
uint256 vReserveA,
uint256 vReserveB,
uint256 feeInPrecision
)
{
}
/// @dev fetches the reserves for a pool, used for liquidity adding
function getReserves(
address pool,
IERC20 tokenA,
IERC20 tokenB
) internal view returns (uint256 reserveA, uint256 reserveB) {
}
// given some amount of an asset and pool reserves, returns an equivalent amount of the other asset
function quote(
uint256 amountA,
uint256 reserveA,
uint256 reserveB
) internal pure returns (uint256 amountB) {
}
// given an input amount of an asset and pool reserves, returns the maximum output amount of the other asset
function getAmountOut(
uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut,
uint256 vReserveIn,
uint256 vReserveOut,
uint256 feeInPrecision
) internal pure returns (uint256 amountOut) {
}
// given an output amount of an asset and pool reserves, returns a required input amount of the other asset
function getAmountIn(
uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut,
uint256 vReserveIn,
uint256 vReserveOut,
uint256 feeInPrecision
) internal pure returns (uint256 amountIn) {
}
// performs chained getAmountOut calculations on any number of pools
function getAmountsOut(
uint256 amountIn,
address[] memory poolsPath,
IERC20[] memory path
) internal view returns (uint256[] memory amounts) {
}
// performs chained getAmountIn calculations on any number of pools
function getAmountsIn(
uint256 amountOut,
address[] memory poolsPath,
IERC20[] memory path
) internal view returns (uint256[] memory amounts) {
}
}
| address(token0)!=address(0),"DMMLibrary: ZERO_ADDRESS" | 17,171 | address(token0)!=address(0) |
"Caller is not admin" | contract DoBasis is AccessControl {
IUniswapV2Router02 public uniswapRouter;
IERC20 public daiToken;
IERC20 public basToken;
IERC20 public bacToken;
IBoardroom public boardRoom;
address public daiAddress;
address public basAddress;
address public bacAddress;
address public uniswapRouterAddress;
address public boardroomAddress;
constructor() {
}
modifier onlyAdmin() {
require(<FILL_ME>)
_;
}
function setUniswapRouterAddress(address _uniswapRouterAddress)
external
onlyAdmin
{
}
function setDaiAddress(address _daiAddress) external onlyAdmin {
}
function setBasAddress(address _basAddress) external onlyAdmin {
}
function setBacAddress(address _bacAddress) external onlyAdmin {
}
function setBoardroomAddress(address _boardroomAddress) external onlyAdmin {
}
function setAllAdresses(
address _uniswapRouterAddress,
address _daiAddress,
address _basAddress,
address _bacAddress,
address _boardroomAddress
) external onlyAdmin {
}
function approveTokensForUniswap(uint256 amount) external onlyAdmin {
}
function approveBacForUniswap(uint256 amount) external onlyAdmin {
}
function approveBasForBoardroom(uint256 amount) external onlyAdmin {
}
function stakeBas() external onlyAdmin {
}
function unstakeBas(uint256 _amount) external onlyAdmin {
}
function exitBas() external onlyAdmin {
}
function claimBasReward() external onlyAdmin {
}
function exitBasAndCovertToDai() external onlyAdmin {
}
function withdrawEther(address payable _to, uint256 _amount)
external
onlyAdmin
{
}
function withdrawDai(address _to, uint256 _amount) external onlyAdmin {
}
function withdrawBas(address _to, uint256 _amount) external onlyAdmin {
}
function withdrawBac(address _to, uint256 _amount) external onlyAdmin {
}
function getEstimatedBACforDAI(uint256 _amount)
public
view
returns (uint256[] memory)
{
}
function getEstimatedBASforDAI(uint256 _amount)
public
view
returns (uint256[] memory)
{
}
function getPathForBACtoDAI() private view returns (address[] memory) {
}
function getPathForBAStoDAI() private view returns (address[] memory) {
}
function getEstimatedDAIforBAC(uint256 _amount)
public
view
returns (uint256[] memory)
{
}
function getPathForDaitoBac() private view returns (address[] memory) {
}
function getEstimatedDAIforBAS(uint256 _amount)
public
view
returns (uint256[] memory)
{
}
function getPathForDaitoBas() private view returns (address[] memory) {
}
function covertBasToDai(uint256 _amount) external onlyAdmin {
}
function covertBacToDai(uint256 _amount) external onlyAdmin {
}
function covertDaiToBas(uint256 _amount) external onlyAdmin {
}
function covertDaiToBac(uint256 _amount) external onlyAdmin {
}
// important to receive ETH
receive() external payable {}
}
| hasRole(DEFAULT_ADMIN_ROLE,msg.sender),"Caller is not admin" | 17,264 | hasRole(DEFAULT_ADMIN_ROLE,msg.sender) |
null | pragma solidity ^0.5.2;
import "./SafeMath.sol";
import "./IERC20.sol";
import "./Ownable.sol";
import "./MinterRole.sol";
contract EUCXToken is IERC20, Ownable, MinterRole {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor() Ownable() public {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address owner) public view returns (uint256) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function transfer(address to, uint256 value) public returns (bool) {
}
function approve(address spender, uint256 value) public returns (bool) {
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function mint(address to, uint256 value) public onlyMinter returns (bool) {
}
function burn(uint256 value) public onlyMinter {
}
function burnFrom(address from, uint256 value) public onlyMinter {
}
function _transfer(address from, address to, uint256 value) private {
}
function _mint(address account, uint256 value) private {
require(account != address(0));
require(<FILL_ME>)
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) private {
}
function _burnFrom(address account, uint256 value) private {
}
function _approve(address owner, address spender, uint256 value) private {
}
}
| _totalSupply.add(value)<=1000000000*uint(10**18) | 17,398 | _totalSupply.add(value)<=1000000000*uint(10**18) |
null | pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
}
// ProfitLineInc contract
contract ProfitLineInc {
using SafeMath for uint;
// set CEO and board of directors ownables
mapping(uint256 => address)public management;// 0 CEO 1-5 Directors
mapping(uint256 => uint256)public manVault;// Eth balance
//mapping(uint256 => uint256)public spendableShares; // unused allocation
mapping(uint256 => uint256)public price; // takeover price
uint256 public totalSupplyShares; // in use totalsupply shares
uint256 public ethPendingManagement;
// Player setup
mapping(address => uint256)public bondsOutstanding; // redeemablebonds
uint256 public totalSupplyBonds; //totalsupply of bonds outstanding
mapping(address => uint256)public playerVault; // in contract eth balance
mapping(address => uint256)public pendingFills; //eth to fill bonds
mapping(address => uint256)public playerId;
mapping(uint256 => address)public IdToAdress;
uint256 public nextPlayerID;
// autoReinvest
mapping(address => bool) public allowAutoInvest;
mapping(address => uint256) public percentageToReinvest;
// Game vars
uint256 ethPendingDistribution; // eth pending distribution
// proffit line vars
uint256 ethPendingLines; // eth ending distributionacross lines
// line 1 - proof of cheating the line
mapping(uint256 => address) public cheatLine;
mapping(address => bool) public isInLine;
mapping(address => uint256) public lineNumber;
uint256 public cheatLinePot;
uint256 public nextInLine;
uint256 public lastInLine;
// line 2 - proof of cheating the line Whale
mapping(uint256 => address) public cheatLineWhale;
mapping(address => bool) public isInLineWhale;
mapping(address => uint256) public lineNumberWhale;
uint256 public cheatLinePotWhale;
uint256 public nextInLineWhale;
uint256 public lastInLineWhale;
// line 3 - proof of arbitrage opportunity
uint256 public arbitragePot;
// line 4 - proof of risky arbitrage opportunity
uint256 public arbitragePotRisky;
// line 5 - proof of increasing odds
mapping(address => uint256) public odds;
uint256 public poioPot;
// line 6 - proof of increasing odds Whale
mapping(address => uint256) public oddsWhale;
uint256 public poioPotWhale;
// line 7 - proof of increasing odds everybody
uint256 public oddsAll;
uint256 public poioPotAll;
// line 8 - proof of decreasing odds everybody
uint256 public decreasingOddsAll;
uint256 public podoPotAll;
// line 9 - proof of distributing by random
uint256 public randomPot;
mapping(uint256 => address) public randomDistr;
uint256 public randomNext;
uint256 public lastdraw;
// line 10 - proof of distributing by random whale
uint256 public randomPotWhale;
mapping(uint256 => address) public randomDistrWhale;
uint256 public randomNextWhale;
uint256 public lastdrawWhale;
// line 11 - proof of distributing by everlasting random
uint256 public randomPotAlways;
mapping(uint256 => address) public randomDistrAlways;
uint256 public randomNextAlways;
uint256 public lastdrawAlways;
// line 12 - Proof of eth rolls
uint256 public dicerollpot;
// line 13 - Proof of ridiculously bad odds
uint256 public amountPlayed;
uint256 public badOddsPot;
// line 14 - Proof of playing Snip3d
uint256 public Snip3dPot;
// line 16 - Proof of playing Slaughter3d
uint256 public Slaughter3dPot;
// line 17 - Proof of eth rolls feeding bank
uint256 public ethRollBank;
// line 18 - Proof of eth stuck on PLinc
uint256 public ethStuckOnPLinc;
address public currentHelper;
bool public canGetPaidForHelping;
mapping(address => bool) public hassEthstuck;
// line 19 - Proof of giving of eth
uint256 public PLincGiverOfEth;
//
// vaults
uint256 public vaultSmall;
uint256 public timeSmall;
uint256 public vaultMedium;
uint256 public timeMedium;
uint256 public vaultLarge;
uint256 public timeLarge;
uint256 public vaultDrip; // delayed bonds maturing
uint256 public timeDrip;
// interfaces
HourglassInterface constant P3Dcontract_ = HourglassInterface(0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);//0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);
SPASMInterface constant SPASM_ = SPASMInterface(0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);//0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);
Snip3DBridgeInterface constant snip3dBridge = Snip3DBridgeInterface(0x99352D1edfa7f124eC618dfb51014f6D54bAc4aE);//snip3d bridge
Slaughter3DBridgeInterface constant slaughter3dbridge = Slaughter3DBridgeInterface(0x3E752fFD5eff7b7f2715eF43D8339ecABd0e65b9);//slaughter3dbridge
// bonds div setup
uint256 public pointMultiplier = 10e18;
struct Account {
uint256 balance;
uint256 lastDividendPoints;
}
mapping(address=>Account) accounts;
uint256 public totalDividendPoints;
uint256 public unclaimedDividends;
function dividendsOwing(address account) public view returns(uint256) {
}
function fetchdivs(address toupdate) public updateAccount(toupdate){}
modifier updateAccount(address account) {
}
function () external payable{} // needs for divs
function vaultToWallet(address toPay) public {
require(<FILL_ME>)
uint256 value = playerVault[toPay];
playerVault[toPay] = 0;
toPay.transfer(value);
emit cashout(msg.sender,value);
}
// view functions
function harvestabledivs()
view
public
returns(uint256)
{
}
function fetchDataMain()
public
view
returns(uint256 _ethPendingDistribution, uint256 _ethPendingManagement, uint256 _ethPendingLines)
{
}
function fetchCheatLine()
public
view
returns(address _1stInLine, address _2ndInLine, address _3rdInLine, uint256 _sizeOfPot)
{
}
function fetchCheatLineWhale()
public
view
returns(address _1stInLine2, address _2ndInLine2, address _3rdInLine2, uint256 _sizeOfPot2)
{
}
// management hot potato functions
function buyCEO() public payable{
}
function buyDirector(uint256 spot) public payable{
}
function managementWithdraw(uint256 who) public{
}
// eth distribution cogs main
function ethPropagate() public{
}
//buybonds function
function buyBonds(address masternode, address referral)updateAccount(msg.sender) updateAccount(referral) payable public {
}
// management distribution eth function
function ethManagementPropagate() public {
}
// cash mature bonds to playervault
function fillBonds (address bondsOwner)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//force bonds because overstock pendingFills
function forceBonds (address bondsOwner, address masternode)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//autoReinvest functions
function setAuto (uint256 percentage) public {
}
function disableAuto () public {
}
function freelanceReinvest(address stackOwner, address masternode)updateAccount(msg.sender) updateAccount(stackOwner) public{
}
function PendinglinesToLines () public {
}
function fetchP3Ddivs() public{
}
//Profit lines
function cheatTheLine () public payable updateAccount(msg.sender){
}
function payoutCheatLine () public {
}
function cheatTheLineWhale () public payable updateAccount(msg.sender){
}
function payoutCheatLineWhale () public {
}
function takeArbitrageOpportunity () public payable updateAccount(msg.sender){
}
function takeArbitrageOpportunityRisky () public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDecreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playRandomDistribution (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistr () public {
}
function playRandomDistributionWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrWhale () public {
}
function playRandomDistributionAlways (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrAlways () public {
}
function playProofOfRediculousBadOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDiceRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function playProofOfEthRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function helpUnstuckEth()public payable updateAccount(msg.sender){
}
function transferEthToHelper()public{
}
function begForFreeEth () public payable updateAccount(msg.sender){
}
function releaseVaultSmall () public {
}
function releaseVaultMedium () public {
}
function releaseVaultLarge () public {
}
function releaseDrip () public {
}
constructor()
public
{
}
// snip3d handlers
function soldierBuy () public {
}
function snip3dVaultToPLinc() public {
}
// slaughter3d handlers
function sendButcher() public{
}
function slaughter3dbridgeToPLinc() public {
}
// events
event bondsBought(address indexed player, uint256 indexed bonds);
event bondsFilled(address indexed player, uint256 indexed bonds);
event CEOsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price);
event Directorsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price, uint256 spot);
event cashout(address indexed player , uint256 indexed ethAmount);
event bondsMatured(uint256 indexed amount);
event RNGgenerated(uint256 indexed number);
event won(address player, bool haswon, uint256 amount ,uint256 line);
}
interface HourglassInterface {
function () payable external;
function buy(address _playerAddress) payable external returns(uint256);
function withdraw() external;
function myDividends(bool _includeReferralBonus) external view returns(uint256);
}
interface SPASMInterface {
function() payable external;
function disburse() external payable;
}
interface Snip3DBridgeInterface {
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
interface Slaughter3DBridgeInterface{
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
| playerVault[toPay]>0 | 17,529 | playerVault[toPay]>0 |
null | pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
}
// ProfitLineInc contract
contract ProfitLineInc {
using SafeMath for uint;
// set CEO and board of directors ownables
mapping(uint256 => address)public management;// 0 CEO 1-5 Directors
mapping(uint256 => uint256)public manVault;// Eth balance
//mapping(uint256 => uint256)public spendableShares; // unused allocation
mapping(uint256 => uint256)public price; // takeover price
uint256 public totalSupplyShares; // in use totalsupply shares
uint256 public ethPendingManagement;
// Player setup
mapping(address => uint256)public bondsOutstanding; // redeemablebonds
uint256 public totalSupplyBonds; //totalsupply of bonds outstanding
mapping(address => uint256)public playerVault; // in contract eth balance
mapping(address => uint256)public pendingFills; //eth to fill bonds
mapping(address => uint256)public playerId;
mapping(uint256 => address)public IdToAdress;
uint256 public nextPlayerID;
// autoReinvest
mapping(address => bool) public allowAutoInvest;
mapping(address => uint256) public percentageToReinvest;
// Game vars
uint256 ethPendingDistribution; // eth pending distribution
// proffit line vars
uint256 ethPendingLines; // eth ending distributionacross lines
// line 1 - proof of cheating the line
mapping(uint256 => address) public cheatLine;
mapping(address => bool) public isInLine;
mapping(address => uint256) public lineNumber;
uint256 public cheatLinePot;
uint256 public nextInLine;
uint256 public lastInLine;
// line 2 - proof of cheating the line Whale
mapping(uint256 => address) public cheatLineWhale;
mapping(address => bool) public isInLineWhale;
mapping(address => uint256) public lineNumberWhale;
uint256 public cheatLinePotWhale;
uint256 public nextInLineWhale;
uint256 public lastInLineWhale;
// line 3 - proof of arbitrage opportunity
uint256 public arbitragePot;
// line 4 - proof of risky arbitrage opportunity
uint256 public arbitragePotRisky;
// line 5 - proof of increasing odds
mapping(address => uint256) public odds;
uint256 public poioPot;
// line 6 - proof of increasing odds Whale
mapping(address => uint256) public oddsWhale;
uint256 public poioPotWhale;
// line 7 - proof of increasing odds everybody
uint256 public oddsAll;
uint256 public poioPotAll;
// line 8 - proof of decreasing odds everybody
uint256 public decreasingOddsAll;
uint256 public podoPotAll;
// line 9 - proof of distributing by random
uint256 public randomPot;
mapping(uint256 => address) public randomDistr;
uint256 public randomNext;
uint256 public lastdraw;
// line 10 - proof of distributing by random whale
uint256 public randomPotWhale;
mapping(uint256 => address) public randomDistrWhale;
uint256 public randomNextWhale;
uint256 public lastdrawWhale;
// line 11 - proof of distributing by everlasting random
uint256 public randomPotAlways;
mapping(uint256 => address) public randomDistrAlways;
uint256 public randomNextAlways;
uint256 public lastdrawAlways;
// line 12 - Proof of eth rolls
uint256 public dicerollpot;
// line 13 - Proof of ridiculously bad odds
uint256 public amountPlayed;
uint256 public badOddsPot;
// line 14 - Proof of playing Snip3d
uint256 public Snip3dPot;
// line 16 - Proof of playing Slaughter3d
uint256 public Slaughter3dPot;
// line 17 - Proof of eth rolls feeding bank
uint256 public ethRollBank;
// line 18 - Proof of eth stuck on PLinc
uint256 public ethStuckOnPLinc;
address public currentHelper;
bool public canGetPaidForHelping;
mapping(address => bool) public hassEthstuck;
// line 19 - Proof of giving of eth
uint256 public PLincGiverOfEth;
//
// vaults
uint256 public vaultSmall;
uint256 public timeSmall;
uint256 public vaultMedium;
uint256 public timeMedium;
uint256 public vaultLarge;
uint256 public timeLarge;
uint256 public vaultDrip; // delayed bonds maturing
uint256 public timeDrip;
// interfaces
HourglassInterface constant P3Dcontract_ = HourglassInterface(0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);//0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);
SPASMInterface constant SPASM_ = SPASMInterface(0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);//0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);
Snip3DBridgeInterface constant snip3dBridge = Snip3DBridgeInterface(0x99352D1edfa7f124eC618dfb51014f6D54bAc4aE);//snip3d bridge
Slaughter3DBridgeInterface constant slaughter3dbridge = Slaughter3DBridgeInterface(0x3E752fFD5eff7b7f2715eF43D8339ecABd0e65b9);//slaughter3dbridge
// bonds div setup
uint256 public pointMultiplier = 10e18;
struct Account {
uint256 balance;
uint256 lastDividendPoints;
}
mapping(address=>Account) accounts;
uint256 public totalDividendPoints;
uint256 public unclaimedDividends;
function dividendsOwing(address account) public view returns(uint256) {
}
function fetchdivs(address toupdate) public updateAccount(toupdate){}
modifier updateAccount(address account) {
}
function () external payable{} // needs for divs
function vaultToWallet(address toPay) public {
}
// view functions
function harvestabledivs()
view
public
returns(uint256)
{
}
function fetchDataMain()
public
view
returns(uint256 _ethPendingDistribution, uint256 _ethPendingManagement, uint256 _ethPendingLines)
{
}
function fetchCheatLine()
public
view
returns(address _1stInLine, address _2ndInLine, address _3rdInLine, uint256 _sizeOfPot)
{
}
function fetchCheatLineWhale()
public
view
returns(address _1stInLine2, address _2ndInLine2, address _3rdInLine2, uint256 _sizeOfPot2)
{
}
// management hot potato functions
function buyCEO() public payable{
}
function buyDirector(uint256 spot) public payable{
}
function managementWithdraw(uint256 who) public{
}
// eth distribution cogs main
function ethPropagate() public{
}
//buybonds function
function buyBonds(address masternode, address referral)updateAccount(msg.sender) updateAccount(referral) payable public {
}
// management distribution eth function
function ethManagementPropagate() public {
}
// cash mature bonds to playervault
function fillBonds (address bondsOwner)updateAccount(msg.sender) updateAccount(bondsOwner) public {
uint256 pendingz = pendingFills[bondsOwner];
require(<FILL_ME>)
require(msg.sender == tx.origin);
require(pendingz <= bondsOutstanding[bondsOwner]);
// empty the pendings
pendingFills[bondsOwner] = 0;
// decrease bonds outstanding
bondsOutstanding[bondsOwner] = bondsOutstanding[bondsOwner].sub(pendingz);
// reward freelancer
bondsOutstanding[msg.sender]= bondsOutstanding[msg.sender].add(pendingz.div(1000));
// adjust totalSupplyBonds
totalSupplyBonds = totalSupplyBonds.sub(pendingz).add(pendingz.div(1000));
// add cash to playerVault
playerVault[bondsOwner] = playerVault[bondsOwner].add(pendingz);
emit bondsFilled(bondsOwner,pendingz);
}
//force bonds because overstock pendingFills
function forceBonds (address bondsOwner, address masternode)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//autoReinvest functions
function setAuto (uint256 percentage) public {
}
function disableAuto () public {
}
function freelanceReinvest(address stackOwner, address masternode)updateAccount(msg.sender) updateAccount(stackOwner) public{
}
function PendinglinesToLines () public {
}
function fetchP3Ddivs() public{
}
//Profit lines
function cheatTheLine () public payable updateAccount(msg.sender){
}
function payoutCheatLine () public {
}
function cheatTheLineWhale () public payable updateAccount(msg.sender){
}
function payoutCheatLineWhale () public {
}
function takeArbitrageOpportunity () public payable updateAccount(msg.sender){
}
function takeArbitrageOpportunityRisky () public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDecreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playRandomDistribution (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistr () public {
}
function playRandomDistributionWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrWhale () public {
}
function playRandomDistributionAlways (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrAlways () public {
}
function playProofOfRediculousBadOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDiceRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function playProofOfEthRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function helpUnstuckEth()public payable updateAccount(msg.sender){
}
function transferEthToHelper()public{
}
function begForFreeEth () public payable updateAccount(msg.sender){
}
function releaseVaultSmall () public {
}
function releaseVaultMedium () public {
}
function releaseVaultLarge () public {
}
function releaseDrip () public {
}
constructor()
public
{
}
// snip3d handlers
function soldierBuy () public {
}
function snip3dVaultToPLinc() public {
}
// slaughter3d handlers
function sendButcher() public{
}
function slaughter3dbridgeToPLinc() public {
}
// events
event bondsBought(address indexed player, uint256 indexed bonds);
event bondsFilled(address indexed player, uint256 indexed bonds);
event CEOsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price);
event Directorsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price, uint256 spot);
event cashout(address indexed player , uint256 indexed ethAmount);
event bondsMatured(uint256 indexed amount);
event RNGgenerated(uint256 indexed number);
event won(address player, bool haswon, uint256 amount ,uint256 line);
}
interface HourglassInterface {
function () payable external;
function buy(address _playerAddress) payable external returns(uint256);
function withdraw() external;
function myDividends(bool _includeReferralBonus) external view returns(uint256);
}
interface SPASMInterface {
function() payable external;
function disburse() external payable;
}
interface Snip3DBridgeInterface {
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
interface Slaughter3DBridgeInterface{
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
| bondsOutstanding[bondsOwner]>1000&&pendingz>1000 | 17,529 | bondsOutstanding[bondsOwner]>1000&&pendingz>1000 |
null | pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
}
// ProfitLineInc contract
contract ProfitLineInc {
using SafeMath for uint;
// set CEO and board of directors ownables
mapping(uint256 => address)public management;// 0 CEO 1-5 Directors
mapping(uint256 => uint256)public manVault;// Eth balance
//mapping(uint256 => uint256)public spendableShares; // unused allocation
mapping(uint256 => uint256)public price; // takeover price
uint256 public totalSupplyShares; // in use totalsupply shares
uint256 public ethPendingManagement;
// Player setup
mapping(address => uint256)public bondsOutstanding; // redeemablebonds
uint256 public totalSupplyBonds; //totalsupply of bonds outstanding
mapping(address => uint256)public playerVault; // in contract eth balance
mapping(address => uint256)public pendingFills; //eth to fill bonds
mapping(address => uint256)public playerId;
mapping(uint256 => address)public IdToAdress;
uint256 public nextPlayerID;
// autoReinvest
mapping(address => bool) public allowAutoInvest;
mapping(address => uint256) public percentageToReinvest;
// Game vars
uint256 ethPendingDistribution; // eth pending distribution
// proffit line vars
uint256 ethPendingLines; // eth ending distributionacross lines
// line 1 - proof of cheating the line
mapping(uint256 => address) public cheatLine;
mapping(address => bool) public isInLine;
mapping(address => uint256) public lineNumber;
uint256 public cheatLinePot;
uint256 public nextInLine;
uint256 public lastInLine;
// line 2 - proof of cheating the line Whale
mapping(uint256 => address) public cheatLineWhale;
mapping(address => bool) public isInLineWhale;
mapping(address => uint256) public lineNumberWhale;
uint256 public cheatLinePotWhale;
uint256 public nextInLineWhale;
uint256 public lastInLineWhale;
// line 3 - proof of arbitrage opportunity
uint256 public arbitragePot;
// line 4 - proof of risky arbitrage opportunity
uint256 public arbitragePotRisky;
// line 5 - proof of increasing odds
mapping(address => uint256) public odds;
uint256 public poioPot;
// line 6 - proof of increasing odds Whale
mapping(address => uint256) public oddsWhale;
uint256 public poioPotWhale;
// line 7 - proof of increasing odds everybody
uint256 public oddsAll;
uint256 public poioPotAll;
// line 8 - proof of decreasing odds everybody
uint256 public decreasingOddsAll;
uint256 public podoPotAll;
// line 9 - proof of distributing by random
uint256 public randomPot;
mapping(uint256 => address) public randomDistr;
uint256 public randomNext;
uint256 public lastdraw;
// line 10 - proof of distributing by random whale
uint256 public randomPotWhale;
mapping(uint256 => address) public randomDistrWhale;
uint256 public randomNextWhale;
uint256 public lastdrawWhale;
// line 11 - proof of distributing by everlasting random
uint256 public randomPotAlways;
mapping(uint256 => address) public randomDistrAlways;
uint256 public randomNextAlways;
uint256 public lastdrawAlways;
// line 12 - Proof of eth rolls
uint256 public dicerollpot;
// line 13 - Proof of ridiculously bad odds
uint256 public amountPlayed;
uint256 public badOddsPot;
// line 14 - Proof of playing Snip3d
uint256 public Snip3dPot;
// line 16 - Proof of playing Slaughter3d
uint256 public Slaughter3dPot;
// line 17 - Proof of eth rolls feeding bank
uint256 public ethRollBank;
// line 18 - Proof of eth stuck on PLinc
uint256 public ethStuckOnPLinc;
address public currentHelper;
bool public canGetPaidForHelping;
mapping(address => bool) public hassEthstuck;
// line 19 - Proof of giving of eth
uint256 public PLincGiverOfEth;
//
// vaults
uint256 public vaultSmall;
uint256 public timeSmall;
uint256 public vaultMedium;
uint256 public timeMedium;
uint256 public vaultLarge;
uint256 public timeLarge;
uint256 public vaultDrip; // delayed bonds maturing
uint256 public timeDrip;
// interfaces
HourglassInterface constant P3Dcontract_ = HourglassInterface(0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);//0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);
SPASMInterface constant SPASM_ = SPASMInterface(0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);//0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);
Snip3DBridgeInterface constant snip3dBridge = Snip3DBridgeInterface(0x99352D1edfa7f124eC618dfb51014f6D54bAc4aE);//snip3d bridge
Slaughter3DBridgeInterface constant slaughter3dbridge = Slaughter3DBridgeInterface(0x3E752fFD5eff7b7f2715eF43D8339ecABd0e65b9);//slaughter3dbridge
// bonds div setup
uint256 public pointMultiplier = 10e18;
struct Account {
uint256 balance;
uint256 lastDividendPoints;
}
mapping(address=>Account) accounts;
uint256 public totalDividendPoints;
uint256 public unclaimedDividends;
function dividendsOwing(address account) public view returns(uint256) {
}
function fetchdivs(address toupdate) public updateAccount(toupdate){}
modifier updateAccount(address account) {
}
function () external payable{} // needs for divs
function vaultToWallet(address toPay) public {
}
// view functions
function harvestabledivs()
view
public
returns(uint256)
{
}
function fetchDataMain()
public
view
returns(uint256 _ethPendingDistribution, uint256 _ethPendingManagement, uint256 _ethPendingLines)
{
}
function fetchCheatLine()
public
view
returns(address _1stInLine, address _2ndInLine, address _3rdInLine, uint256 _sizeOfPot)
{
}
function fetchCheatLineWhale()
public
view
returns(address _1stInLine2, address _2ndInLine2, address _3rdInLine2, uint256 _sizeOfPot2)
{
}
// management hot potato functions
function buyCEO() public payable{
}
function buyDirector(uint256 spot) public payable{
}
function managementWithdraw(uint256 who) public{
}
// eth distribution cogs main
function ethPropagate() public{
}
//buybonds function
function buyBonds(address masternode, address referral)updateAccount(msg.sender) updateAccount(referral) payable public {
}
// management distribution eth function
function ethManagementPropagate() public {
}
// cash mature bonds to playervault
function fillBonds (address bondsOwner)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//force bonds because overstock pendingFills
function forceBonds (address bondsOwner, address masternode)updateAccount(msg.sender) updateAccount(bondsOwner) public {
require(<FILL_ME>)
require(pendingFills[bondsOwner] > bondsOutstanding[bondsOwner]);
// update bonds first
uint256 value = pendingFills[bondsOwner].sub(bondsOutstanding[bondsOwner]);
pendingFills[bondsOwner] = pendingFills[bondsOwner].sub(bondsOutstanding[bondsOwner]);
uint256 base = value.div(100);
// buy P3D 5%
P3Dcontract_.buy.value(base.mul(5))(masternode);
// add bonds to sender
uint256 amount = value.mul(11).div(10);
bondsOutstanding[bondsOwner] += amount;
// reward referal in bonds
bondsOutstanding[msg.sender] += value.mul(2).div(100);
// edit totalsupply
totalSupplyBonds += amount.add(value.mul(2).div(100));
// set rest to eth pending
ethPendingDistribution += base.mul(95);
emit bondsBought(bondsOwner, amount);
}
//autoReinvest functions
function setAuto (uint256 percentage) public {
}
function disableAuto () public {
}
function freelanceReinvest(address stackOwner, address masternode)updateAccount(msg.sender) updateAccount(stackOwner) public{
}
function PendinglinesToLines () public {
}
function fetchP3Ddivs() public{
}
//Profit lines
function cheatTheLine () public payable updateAccount(msg.sender){
}
function payoutCheatLine () public {
}
function cheatTheLineWhale () public payable updateAccount(msg.sender){
}
function payoutCheatLineWhale () public {
}
function takeArbitrageOpportunity () public payable updateAccount(msg.sender){
}
function takeArbitrageOpportunityRisky () public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDecreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playRandomDistribution (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistr () public {
}
function playRandomDistributionWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrWhale () public {
}
function playRandomDistributionAlways (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrAlways () public {
}
function playProofOfRediculousBadOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDiceRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function playProofOfEthRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function helpUnstuckEth()public payable updateAccount(msg.sender){
}
function transferEthToHelper()public{
}
function begForFreeEth () public payable updateAccount(msg.sender){
}
function releaseVaultSmall () public {
}
function releaseVaultMedium () public {
}
function releaseVaultLarge () public {
}
function releaseDrip () public {
}
constructor()
public
{
}
// snip3d handlers
function soldierBuy () public {
}
function snip3dVaultToPLinc() public {
}
// slaughter3d handlers
function sendButcher() public{
}
function slaughter3dbridgeToPLinc() public {
}
// events
event bondsBought(address indexed player, uint256 indexed bonds);
event bondsFilled(address indexed player, uint256 indexed bonds);
event CEOsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price);
event Directorsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price, uint256 spot);
event cashout(address indexed player , uint256 indexed ethAmount);
event bondsMatured(uint256 indexed amount);
event RNGgenerated(uint256 indexed number);
event won(address player, bool haswon, uint256 amount ,uint256 line);
}
interface HourglassInterface {
function () payable external;
function buy(address _playerAddress) payable external returns(uint256);
function withdraw() external;
function myDividends(bool _includeReferralBonus) external view returns(uint256);
}
interface SPASMInterface {
function() payable external;
function disburse() external payable;
}
interface Snip3DBridgeInterface {
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
interface Slaughter3DBridgeInterface{
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
| bondsOutstanding[bondsOwner]>1000&&pendingFills[bondsOwner]>1000 | 17,529 | bondsOutstanding[bondsOwner]>1000&&pendingFills[bondsOwner]>1000 |
null | pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
}
// ProfitLineInc contract
contract ProfitLineInc {
using SafeMath for uint;
// set CEO and board of directors ownables
mapping(uint256 => address)public management;// 0 CEO 1-5 Directors
mapping(uint256 => uint256)public manVault;// Eth balance
//mapping(uint256 => uint256)public spendableShares; // unused allocation
mapping(uint256 => uint256)public price; // takeover price
uint256 public totalSupplyShares; // in use totalsupply shares
uint256 public ethPendingManagement;
// Player setup
mapping(address => uint256)public bondsOutstanding; // redeemablebonds
uint256 public totalSupplyBonds; //totalsupply of bonds outstanding
mapping(address => uint256)public playerVault; // in contract eth balance
mapping(address => uint256)public pendingFills; //eth to fill bonds
mapping(address => uint256)public playerId;
mapping(uint256 => address)public IdToAdress;
uint256 public nextPlayerID;
// autoReinvest
mapping(address => bool) public allowAutoInvest;
mapping(address => uint256) public percentageToReinvest;
// Game vars
uint256 ethPendingDistribution; // eth pending distribution
// proffit line vars
uint256 ethPendingLines; // eth ending distributionacross lines
// line 1 - proof of cheating the line
mapping(uint256 => address) public cheatLine;
mapping(address => bool) public isInLine;
mapping(address => uint256) public lineNumber;
uint256 public cheatLinePot;
uint256 public nextInLine;
uint256 public lastInLine;
// line 2 - proof of cheating the line Whale
mapping(uint256 => address) public cheatLineWhale;
mapping(address => bool) public isInLineWhale;
mapping(address => uint256) public lineNumberWhale;
uint256 public cheatLinePotWhale;
uint256 public nextInLineWhale;
uint256 public lastInLineWhale;
// line 3 - proof of arbitrage opportunity
uint256 public arbitragePot;
// line 4 - proof of risky arbitrage opportunity
uint256 public arbitragePotRisky;
// line 5 - proof of increasing odds
mapping(address => uint256) public odds;
uint256 public poioPot;
// line 6 - proof of increasing odds Whale
mapping(address => uint256) public oddsWhale;
uint256 public poioPotWhale;
// line 7 - proof of increasing odds everybody
uint256 public oddsAll;
uint256 public poioPotAll;
// line 8 - proof of decreasing odds everybody
uint256 public decreasingOddsAll;
uint256 public podoPotAll;
// line 9 - proof of distributing by random
uint256 public randomPot;
mapping(uint256 => address) public randomDistr;
uint256 public randomNext;
uint256 public lastdraw;
// line 10 - proof of distributing by random whale
uint256 public randomPotWhale;
mapping(uint256 => address) public randomDistrWhale;
uint256 public randomNextWhale;
uint256 public lastdrawWhale;
// line 11 - proof of distributing by everlasting random
uint256 public randomPotAlways;
mapping(uint256 => address) public randomDistrAlways;
uint256 public randomNextAlways;
uint256 public lastdrawAlways;
// line 12 - Proof of eth rolls
uint256 public dicerollpot;
// line 13 - Proof of ridiculously bad odds
uint256 public amountPlayed;
uint256 public badOddsPot;
// line 14 - Proof of playing Snip3d
uint256 public Snip3dPot;
// line 16 - Proof of playing Slaughter3d
uint256 public Slaughter3dPot;
// line 17 - Proof of eth rolls feeding bank
uint256 public ethRollBank;
// line 18 - Proof of eth stuck on PLinc
uint256 public ethStuckOnPLinc;
address public currentHelper;
bool public canGetPaidForHelping;
mapping(address => bool) public hassEthstuck;
// line 19 - Proof of giving of eth
uint256 public PLincGiverOfEth;
//
// vaults
uint256 public vaultSmall;
uint256 public timeSmall;
uint256 public vaultMedium;
uint256 public timeMedium;
uint256 public vaultLarge;
uint256 public timeLarge;
uint256 public vaultDrip; // delayed bonds maturing
uint256 public timeDrip;
// interfaces
HourglassInterface constant P3Dcontract_ = HourglassInterface(0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);//0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);
SPASMInterface constant SPASM_ = SPASMInterface(0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);//0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);
Snip3DBridgeInterface constant snip3dBridge = Snip3DBridgeInterface(0x99352D1edfa7f124eC618dfb51014f6D54bAc4aE);//snip3d bridge
Slaughter3DBridgeInterface constant slaughter3dbridge = Slaughter3DBridgeInterface(0x3E752fFD5eff7b7f2715eF43D8339ecABd0e65b9);//slaughter3dbridge
// bonds div setup
uint256 public pointMultiplier = 10e18;
struct Account {
uint256 balance;
uint256 lastDividendPoints;
}
mapping(address=>Account) accounts;
uint256 public totalDividendPoints;
uint256 public unclaimedDividends;
function dividendsOwing(address account) public view returns(uint256) {
}
function fetchdivs(address toupdate) public updateAccount(toupdate){}
modifier updateAccount(address account) {
}
function () external payable{} // needs for divs
function vaultToWallet(address toPay) public {
}
// view functions
function harvestabledivs()
view
public
returns(uint256)
{
}
function fetchDataMain()
public
view
returns(uint256 _ethPendingDistribution, uint256 _ethPendingManagement, uint256 _ethPendingLines)
{
}
function fetchCheatLine()
public
view
returns(address _1stInLine, address _2ndInLine, address _3rdInLine, uint256 _sizeOfPot)
{
}
function fetchCheatLineWhale()
public
view
returns(address _1stInLine2, address _2ndInLine2, address _3rdInLine2, uint256 _sizeOfPot2)
{
}
// management hot potato functions
function buyCEO() public payable{
}
function buyDirector(uint256 spot) public payable{
}
function managementWithdraw(uint256 who) public{
}
// eth distribution cogs main
function ethPropagate() public{
}
//buybonds function
function buyBonds(address masternode, address referral)updateAccount(msg.sender) updateAccount(referral) payable public {
}
// management distribution eth function
function ethManagementPropagate() public {
}
// cash mature bonds to playervault
function fillBonds (address bondsOwner)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//force bonds because overstock pendingFills
function forceBonds (address bondsOwner, address masternode)updateAccount(msg.sender) updateAccount(bondsOwner) public {
require(bondsOutstanding[bondsOwner] > 1000 && pendingFills[bondsOwner] > 1000);
require(<FILL_ME>)
// update bonds first
uint256 value = pendingFills[bondsOwner].sub(bondsOutstanding[bondsOwner]);
pendingFills[bondsOwner] = pendingFills[bondsOwner].sub(bondsOutstanding[bondsOwner]);
uint256 base = value.div(100);
// buy P3D 5%
P3Dcontract_.buy.value(base.mul(5))(masternode);
// add bonds to sender
uint256 amount = value.mul(11).div(10);
bondsOutstanding[bondsOwner] += amount;
// reward referal in bonds
bondsOutstanding[msg.sender] += value.mul(2).div(100);
// edit totalsupply
totalSupplyBonds += amount.add(value.mul(2).div(100));
// set rest to eth pending
ethPendingDistribution += base.mul(95);
emit bondsBought(bondsOwner, amount);
}
//autoReinvest functions
function setAuto (uint256 percentage) public {
}
function disableAuto () public {
}
function freelanceReinvest(address stackOwner, address masternode)updateAccount(msg.sender) updateAccount(stackOwner) public{
}
function PendinglinesToLines () public {
}
function fetchP3Ddivs() public{
}
//Profit lines
function cheatTheLine () public payable updateAccount(msg.sender){
}
function payoutCheatLine () public {
}
function cheatTheLineWhale () public payable updateAccount(msg.sender){
}
function payoutCheatLineWhale () public {
}
function takeArbitrageOpportunity () public payable updateAccount(msg.sender){
}
function takeArbitrageOpportunityRisky () public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDecreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playRandomDistribution (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistr () public {
}
function playRandomDistributionWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrWhale () public {
}
function playRandomDistributionAlways (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrAlways () public {
}
function playProofOfRediculousBadOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDiceRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function playProofOfEthRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function helpUnstuckEth()public payable updateAccount(msg.sender){
}
function transferEthToHelper()public{
}
function begForFreeEth () public payable updateAccount(msg.sender){
}
function releaseVaultSmall () public {
}
function releaseVaultMedium () public {
}
function releaseVaultLarge () public {
}
function releaseDrip () public {
}
constructor()
public
{
}
// snip3d handlers
function soldierBuy () public {
}
function snip3dVaultToPLinc() public {
}
// slaughter3d handlers
function sendButcher() public{
}
function slaughter3dbridgeToPLinc() public {
}
// events
event bondsBought(address indexed player, uint256 indexed bonds);
event bondsFilled(address indexed player, uint256 indexed bonds);
event CEOsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price);
event Directorsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price, uint256 spot);
event cashout(address indexed player , uint256 indexed ethAmount);
event bondsMatured(uint256 indexed amount);
event RNGgenerated(uint256 indexed number);
event won(address player, bool haswon, uint256 amount ,uint256 line);
}
interface HourglassInterface {
function () payable external;
function buy(address _playerAddress) payable external returns(uint256);
function withdraw() external;
function myDividends(bool _includeReferralBonus) external view returns(uint256);
}
interface SPASMInterface {
function() payable external;
function disburse() external payable;
}
interface Snip3DBridgeInterface {
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
interface Slaughter3DBridgeInterface{
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
| pendingFills[bondsOwner]>bondsOutstanding[bondsOwner] | 17,529 | pendingFills[bondsOwner]>bondsOutstanding[bondsOwner] |
null | pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
}
// ProfitLineInc contract
contract ProfitLineInc {
using SafeMath for uint;
// set CEO and board of directors ownables
mapping(uint256 => address)public management;// 0 CEO 1-5 Directors
mapping(uint256 => uint256)public manVault;// Eth balance
//mapping(uint256 => uint256)public spendableShares; // unused allocation
mapping(uint256 => uint256)public price; // takeover price
uint256 public totalSupplyShares; // in use totalsupply shares
uint256 public ethPendingManagement;
// Player setup
mapping(address => uint256)public bondsOutstanding; // redeemablebonds
uint256 public totalSupplyBonds; //totalsupply of bonds outstanding
mapping(address => uint256)public playerVault; // in contract eth balance
mapping(address => uint256)public pendingFills; //eth to fill bonds
mapping(address => uint256)public playerId;
mapping(uint256 => address)public IdToAdress;
uint256 public nextPlayerID;
// autoReinvest
mapping(address => bool) public allowAutoInvest;
mapping(address => uint256) public percentageToReinvest;
// Game vars
uint256 ethPendingDistribution; // eth pending distribution
// proffit line vars
uint256 ethPendingLines; // eth ending distributionacross lines
// line 1 - proof of cheating the line
mapping(uint256 => address) public cheatLine;
mapping(address => bool) public isInLine;
mapping(address => uint256) public lineNumber;
uint256 public cheatLinePot;
uint256 public nextInLine;
uint256 public lastInLine;
// line 2 - proof of cheating the line Whale
mapping(uint256 => address) public cheatLineWhale;
mapping(address => bool) public isInLineWhale;
mapping(address => uint256) public lineNumberWhale;
uint256 public cheatLinePotWhale;
uint256 public nextInLineWhale;
uint256 public lastInLineWhale;
// line 3 - proof of arbitrage opportunity
uint256 public arbitragePot;
// line 4 - proof of risky arbitrage opportunity
uint256 public arbitragePotRisky;
// line 5 - proof of increasing odds
mapping(address => uint256) public odds;
uint256 public poioPot;
// line 6 - proof of increasing odds Whale
mapping(address => uint256) public oddsWhale;
uint256 public poioPotWhale;
// line 7 - proof of increasing odds everybody
uint256 public oddsAll;
uint256 public poioPotAll;
// line 8 - proof of decreasing odds everybody
uint256 public decreasingOddsAll;
uint256 public podoPotAll;
// line 9 - proof of distributing by random
uint256 public randomPot;
mapping(uint256 => address) public randomDistr;
uint256 public randomNext;
uint256 public lastdraw;
// line 10 - proof of distributing by random whale
uint256 public randomPotWhale;
mapping(uint256 => address) public randomDistrWhale;
uint256 public randomNextWhale;
uint256 public lastdrawWhale;
// line 11 - proof of distributing by everlasting random
uint256 public randomPotAlways;
mapping(uint256 => address) public randomDistrAlways;
uint256 public randomNextAlways;
uint256 public lastdrawAlways;
// line 12 - Proof of eth rolls
uint256 public dicerollpot;
// line 13 - Proof of ridiculously bad odds
uint256 public amountPlayed;
uint256 public badOddsPot;
// line 14 - Proof of playing Snip3d
uint256 public Snip3dPot;
// line 16 - Proof of playing Slaughter3d
uint256 public Slaughter3dPot;
// line 17 - Proof of eth rolls feeding bank
uint256 public ethRollBank;
// line 18 - Proof of eth stuck on PLinc
uint256 public ethStuckOnPLinc;
address public currentHelper;
bool public canGetPaidForHelping;
mapping(address => bool) public hassEthstuck;
// line 19 - Proof of giving of eth
uint256 public PLincGiverOfEth;
//
// vaults
uint256 public vaultSmall;
uint256 public timeSmall;
uint256 public vaultMedium;
uint256 public timeMedium;
uint256 public vaultLarge;
uint256 public timeLarge;
uint256 public vaultDrip; // delayed bonds maturing
uint256 public timeDrip;
// interfaces
HourglassInterface constant P3Dcontract_ = HourglassInterface(0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);//0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);
SPASMInterface constant SPASM_ = SPASMInterface(0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);//0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);
Snip3DBridgeInterface constant snip3dBridge = Snip3DBridgeInterface(0x99352D1edfa7f124eC618dfb51014f6D54bAc4aE);//snip3d bridge
Slaughter3DBridgeInterface constant slaughter3dbridge = Slaughter3DBridgeInterface(0x3E752fFD5eff7b7f2715eF43D8339ecABd0e65b9);//slaughter3dbridge
// bonds div setup
uint256 public pointMultiplier = 10e18;
struct Account {
uint256 balance;
uint256 lastDividendPoints;
}
mapping(address=>Account) accounts;
uint256 public totalDividendPoints;
uint256 public unclaimedDividends;
function dividendsOwing(address account) public view returns(uint256) {
}
function fetchdivs(address toupdate) public updateAccount(toupdate){}
modifier updateAccount(address account) {
}
function () external payable{} // needs for divs
function vaultToWallet(address toPay) public {
}
// view functions
function harvestabledivs()
view
public
returns(uint256)
{
}
function fetchDataMain()
public
view
returns(uint256 _ethPendingDistribution, uint256 _ethPendingManagement, uint256 _ethPendingLines)
{
}
function fetchCheatLine()
public
view
returns(address _1stInLine, address _2ndInLine, address _3rdInLine, uint256 _sizeOfPot)
{
}
function fetchCheatLineWhale()
public
view
returns(address _1stInLine2, address _2ndInLine2, address _3rdInLine2, uint256 _sizeOfPot2)
{
}
// management hot potato functions
function buyCEO() public payable{
}
function buyDirector(uint256 spot) public payable{
}
function managementWithdraw(uint256 who) public{
}
// eth distribution cogs main
function ethPropagate() public{
}
//buybonds function
function buyBonds(address masternode, address referral)updateAccount(msg.sender) updateAccount(referral) payable public {
}
// management distribution eth function
function ethManagementPropagate() public {
}
// cash mature bonds to playervault
function fillBonds (address bondsOwner)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//force bonds because overstock pendingFills
function forceBonds (address bondsOwner, address masternode)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//autoReinvest functions
function setAuto (uint256 percentage) public {
}
function disableAuto () public {
}
function freelanceReinvest(address stackOwner, address masternode)updateAccount(msg.sender) updateAccount(stackOwner) public{
address sender = msg.sender;
require(<FILL_ME>)
require(sender == tx.origin);
// update vault first
uint256 value = playerVault[stackOwner];
//emit autoReinvested(stackOwner, value, percentageToReinvest[stackOwner]);
playerVault[stackOwner]=0;
uint256 base = value.div(100000).mul(percentageToReinvest[stackOwner]);
// buy P3D 5%
P3Dcontract_.buy.value(base.mul(50))(masternode);
// update bonds first
// add bonds to sender
uint256 precalc = base.mul(950);//.mul(percentageToReinvest[stackOwner]);
uint256 amount = precalc.mul(109).div(100);
bondsOutstanding[stackOwner] = bondsOutstanding[stackOwner].add(amount);
// reward referal in bonds
bondsOutstanding[sender] = bondsOutstanding[sender].add(base);
// edit totalsupply
totalSupplyBonds = totalSupplyBonds.add(amount.add(base));
// set to eth pending
ethPendingDistribution = ethPendingDistribution.add(precalc);
if(percentageToReinvest[stackOwner] < 100)
{
precalc = value.sub(precalc.add(base.mul(50)));//base.mul(100-percentageToReinvest[stackOwner]);
stackOwner.transfer(precalc);
}
emit bondsBought(stackOwner, amount);
}
function PendinglinesToLines () public {
}
function fetchP3Ddivs() public{
}
//Profit lines
function cheatTheLine () public payable updateAccount(msg.sender){
}
function payoutCheatLine () public {
}
function cheatTheLineWhale () public payable updateAccount(msg.sender){
}
function payoutCheatLineWhale () public {
}
function takeArbitrageOpportunity () public payable updateAccount(msg.sender){
}
function takeArbitrageOpportunityRisky () public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDecreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playRandomDistribution (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistr () public {
}
function playRandomDistributionWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrWhale () public {
}
function playRandomDistributionAlways (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrAlways () public {
}
function playProofOfRediculousBadOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDiceRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function playProofOfEthRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function helpUnstuckEth()public payable updateAccount(msg.sender){
}
function transferEthToHelper()public{
}
function begForFreeEth () public payable updateAccount(msg.sender){
}
function releaseVaultSmall () public {
}
function releaseVaultMedium () public {
}
function releaseVaultLarge () public {
}
function releaseDrip () public {
}
constructor()
public
{
}
// snip3d handlers
function soldierBuy () public {
}
function snip3dVaultToPLinc() public {
}
// slaughter3d handlers
function sendButcher() public{
}
function slaughter3dbridgeToPLinc() public {
}
// events
event bondsBought(address indexed player, uint256 indexed bonds);
event bondsFilled(address indexed player, uint256 indexed bonds);
event CEOsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price);
event Directorsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price, uint256 spot);
event cashout(address indexed player , uint256 indexed ethAmount);
event bondsMatured(uint256 indexed amount);
event RNGgenerated(uint256 indexed number);
event won(address player, bool haswon, uint256 amount ,uint256 line);
}
interface HourglassInterface {
function () payable external;
function buy(address _playerAddress) payable external returns(uint256);
function withdraw() external;
function myDividends(bool _includeReferralBonus) external view returns(uint256);
}
interface SPASMInterface {
function() payable external;
function disburse() external payable;
}
interface Snip3DBridgeInterface {
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
interface Slaughter3DBridgeInterface{
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
| allowAutoInvest[stackOwner]==true&&playerVault[stackOwner]>100000 | 17,529 | allowAutoInvest[stackOwner]==true&&playerVault[stackOwner]>100000 |
null | pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
}
// ProfitLineInc contract
contract ProfitLineInc {
using SafeMath for uint;
// set CEO and board of directors ownables
mapping(uint256 => address)public management;// 0 CEO 1-5 Directors
mapping(uint256 => uint256)public manVault;// Eth balance
//mapping(uint256 => uint256)public spendableShares; // unused allocation
mapping(uint256 => uint256)public price; // takeover price
uint256 public totalSupplyShares; // in use totalsupply shares
uint256 public ethPendingManagement;
// Player setup
mapping(address => uint256)public bondsOutstanding; // redeemablebonds
uint256 public totalSupplyBonds; //totalsupply of bonds outstanding
mapping(address => uint256)public playerVault; // in contract eth balance
mapping(address => uint256)public pendingFills; //eth to fill bonds
mapping(address => uint256)public playerId;
mapping(uint256 => address)public IdToAdress;
uint256 public nextPlayerID;
// autoReinvest
mapping(address => bool) public allowAutoInvest;
mapping(address => uint256) public percentageToReinvest;
// Game vars
uint256 ethPendingDistribution; // eth pending distribution
// proffit line vars
uint256 ethPendingLines; // eth ending distributionacross lines
// line 1 - proof of cheating the line
mapping(uint256 => address) public cheatLine;
mapping(address => bool) public isInLine;
mapping(address => uint256) public lineNumber;
uint256 public cheatLinePot;
uint256 public nextInLine;
uint256 public lastInLine;
// line 2 - proof of cheating the line Whale
mapping(uint256 => address) public cheatLineWhale;
mapping(address => bool) public isInLineWhale;
mapping(address => uint256) public lineNumberWhale;
uint256 public cheatLinePotWhale;
uint256 public nextInLineWhale;
uint256 public lastInLineWhale;
// line 3 - proof of arbitrage opportunity
uint256 public arbitragePot;
// line 4 - proof of risky arbitrage opportunity
uint256 public arbitragePotRisky;
// line 5 - proof of increasing odds
mapping(address => uint256) public odds;
uint256 public poioPot;
// line 6 - proof of increasing odds Whale
mapping(address => uint256) public oddsWhale;
uint256 public poioPotWhale;
// line 7 - proof of increasing odds everybody
uint256 public oddsAll;
uint256 public poioPotAll;
// line 8 - proof of decreasing odds everybody
uint256 public decreasingOddsAll;
uint256 public podoPotAll;
// line 9 - proof of distributing by random
uint256 public randomPot;
mapping(uint256 => address) public randomDistr;
uint256 public randomNext;
uint256 public lastdraw;
// line 10 - proof of distributing by random whale
uint256 public randomPotWhale;
mapping(uint256 => address) public randomDistrWhale;
uint256 public randomNextWhale;
uint256 public lastdrawWhale;
// line 11 - proof of distributing by everlasting random
uint256 public randomPotAlways;
mapping(uint256 => address) public randomDistrAlways;
uint256 public randomNextAlways;
uint256 public lastdrawAlways;
// line 12 - Proof of eth rolls
uint256 public dicerollpot;
// line 13 - Proof of ridiculously bad odds
uint256 public amountPlayed;
uint256 public badOddsPot;
// line 14 - Proof of playing Snip3d
uint256 public Snip3dPot;
// line 16 - Proof of playing Slaughter3d
uint256 public Slaughter3dPot;
// line 17 - Proof of eth rolls feeding bank
uint256 public ethRollBank;
// line 18 - Proof of eth stuck on PLinc
uint256 public ethStuckOnPLinc;
address public currentHelper;
bool public canGetPaidForHelping;
mapping(address => bool) public hassEthstuck;
// line 19 - Proof of giving of eth
uint256 public PLincGiverOfEth;
//
// vaults
uint256 public vaultSmall;
uint256 public timeSmall;
uint256 public vaultMedium;
uint256 public timeMedium;
uint256 public vaultLarge;
uint256 public timeLarge;
uint256 public vaultDrip; // delayed bonds maturing
uint256 public timeDrip;
// interfaces
HourglassInterface constant P3Dcontract_ = HourglassInterface(0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);//0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);
SPASMInterface constant SPASM_ = SPASMInterface(0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);//0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);
Snip3DBridgeInterface constant snip3dBridge = Snip3DBridgeInterface(0x99352D1edfa7f124eC618dfb51014f6D54bAc4aE);//snip3d bridge
Slaughter3DBridgeInterface constant slaughter3dbridge = Slaughter3DBridgeInterface(0x3E752fFD5eff7b7f2715eF43D8339ecABd0e65b9);//slaughter3dbridge
// bonds div setup
uint256 public pointMultiplier = 10e18;
struct Account {
uint256 balance;
uint256 lastDividendPoints;
}
mapping(address=>Account) accounts;
uint256 public totalDividendPoints;
uint256 public unclaimedDividends;
function dividendsOwing(address account) public view returns(uint256) {
}
function fetchdivs(address toupdate) public updateAccount(toupdate){}
modifier updateAccount(address account) {
}
function () external payable{} // needs for divs
function vaultToWallet(address toPay) public {
}
// view functions
function harvestabledivs()
view
public
returns(uint256)
{
}
function fetchDataMain()
public
view
returns(uint256 _ethPendingDistribution, uint256 _ethPendingManagement, uint256 _ethPendingLines)
{
}
function fetchCheatLine()
public
view
returns(address _1stInLine, address _2ndInLine, address _3rdInLine, uint256 _sizeOfPot)
{
}
function fetchCheatLineWhale()
public
view
returns(address _1stInLine2, address _2ndInLine2, address _3rdInLine2, uint256 _sizeOfPot2)
{
}
// management hot potato functions
function buyCEO() public payable{
}
function buyDirector(uint256 spot) public payable{
}
function managementWithdraw(uint256 who) public{
}
// eth distribution cogs main
function ethPropagate() public{
}
//buybonds function
function buyBonds(address masternode, address referral)updateAccount(msg.sender) updateAccount(referral) payable public {
}
// management distribution eth function
function ethManagementPropagate() public {
}
// cash mature bonds to playervault
function fillBonds (address bondsOwner)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//force bonds because overstock pendingFills
function forceBonds (address bondsOwner, address masternode)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//autoReinvest functions
function setAuto (uint256 percentage) public {
}
function disableAuto () public {
}
function freelanceReinvest(address stackOwner, address masternode)updateAccount(msg.sender) updateAccount(stackOwner) public{
}
function PendinglinesToLines () public {
}
function fetchP3Ddivs() public{
}
//Profit lines
function cheatTheLine () public payable updateAccount(msg.sender){
}
function payoutCheatLine () public {
}
function cheatTheLineWhale () public payable updateAccount(msg.sender){
}
function payoutCheatLineWhale () public {
}
function takeArbitrageOpportunity () public payable updateAccount(msg.sender){
}
function takeArbitrageOpportunityRisky () public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDecreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playRandomDistribution (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistr () public {
}
function playRandomDistributionWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrWhale () public {
}
function playRandomDistributionAlways (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrAlways () public {
}
function playProofOfRediculousBadOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDiceRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function playProofOfEthRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function helpUnstuckEth()public payable updateAccount(msg.sender){
}
function transferEthToHelper()public{
address sender = msg.sender;
require(sender == tx.origin);
require(<FILL_ME>)
require(ethStuckOnPLinc > 4 finney);
hassEthstuck[sender] = false;
canGetPaidForHelping = false;
ethStuckOnPLinc = ethStuckOnPLinc.sub(4 finney);
pendingFills[currentHelper] = pendingFills[currentHelper].add(4 finney) ;
//emit newMaturedBonds(currentHelper, 4 finney);
emit won(currentHelper, true, 4 finney,15);
}
function begForFreeEth () public payable updateAccount(msg.sender){
}
function releaseVaultSmall () public {
}
function releaseVaultMedium () public {
}
function releaseVaultLarge () public {
}
function releaseDrip () public {
}
constructor()
public
{
}
// snip3d handlers
function soldierBuy () public {
}
function snip3dVaultToPLinc() public {
}
// slaughter3d handlers
function sendButcher() public{
}
function slaughter3dbridgeToPLinc() public {
}
// events
event bondsBought(address indexed player, uint256 indexed bonds);
event bondsFilled(address indexed player, uint256 indexed bonds);
event CEOsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price);
event Directorsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price, uint256 spot);
event cashout(address indexed player , uint256 indexed ethAmount);
event bondsMatured(uint256 indexed amount);
event RNGgenerated(uint256 indexed number);
event won(address player, bool haswon, uint256 amount ,uint256 line);
}
interface HourglassInterface {
function () payable external;
function buy(address _playerAddress) payable external returns(uint256);
function withdraw() external;
function myDividends(bool _includeReferralBonus) external view returns(uint256);
}
interface SPASMInterface {
function() payable external;
function disburse() external payable;
}
interface Snip3DBridgeInterface {
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
interface Slaughter3DBridgeInterface{
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
| hassEthstuck[sender]==true&&canGetPaidForHelping==true | 17,529 | hassEthstuck[sender]==true&&canGetPaidForHelping==true |
null | pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
}
// ProfitLineInc contract
contract ProfitLineInc {
using SafeMath for uint;
// set CEO and board of directors ownables
mapping(uint256 => address)public management;// 0 CEO 1-5 Directors
mapping(uint256 => uint256)public manVault;// Eth balance
//mapping(uint256 => uint256)public spendableShares; // unused allocation
mapping(uint256 => uint256)public price; // takeover price
uint256 public totalSupplyShares; // in use totalsupply shares
uint256 public ethPendingManagement;
// Player setup
mapping(address => uint256)public bondsOutstanding; // redeemablebonds
uint256 public totalSupplyBonds; //totalsupply of bonds outstanding
mapping(address => uint256)public playerVault; // in contract eth balance
mapping(address => uint256)public pendingFills; //eth to fill bonds
mapping(address => uint256)public playerId;
mapping(uint256 => address)public IdToAdress;
uint256 public nextPlayerID;
// autoReinvest
mapping(address => bool) public allowAutoInvest;
mapping(address => uint256) public percentageToReinvest;
// Game vars
uint256 ethPendingDistribution; // eth pending distribution
// proffit line vars
uint256 ethPendingLines; // eth ending distributionacross lines
// line 1 - proof of cheating the line
mapping(uint256 => address) public cheatLine;
mapping(address => bool) public isInLine;
mapping(address => uint256) public lineNumber;
uint256 public cheatLinePot;
uint256 public nextInLine;
uint256 public lastInLine;
// line 2 - proof of cheating the line Whale
mapping(uint256 => address) public cheatLineWhale;
mapping(address => bool) public isInLineWhale;
mapping(address => uint256) public lineNumberWhale;
uint256 public cheatLinePotWhale;
uint256 public nextInLineWhale;
uint256 public lastInLineWhale;
// line 3 - proof of arbitrage opportunity
uint256 public arbitragePot;
// line 4 - proof of risky arbitrage opportunity
uint256 public arbitragePotRisky;
// line 5 - proof of increasing odds
mapping(address => uint256) public odds;
uint256 public poioPot;
// line 6 - proof of increasing odds Whale
mapping(address => uint256) public oddsWhale;
uint256 public poioPotWhale;
// line 7 - proof of increasing odds everybody
uint256 public oddsAll;
uint256 public poioPotAll;
// line 8 - proof of decreasing odds everybody
uint256 public decreasingOddsAll;
uint256 public podoPotAll;
// line 9 - proof of distributing by random
uint256 public randomPot;
mapping(uint256 => address) public randomDistr;
uint256 public randomNext;
uint256 public lastdraw;
// line 10 - proof of distributing by random whale
uint256 public randomPotWhale;
mapping(uint256 => address) public randomDistrWhale;
uint256 public randomNextWhale;
uint256 public lastdrawWhale;
// line 11 - proof of distributing by everlasting random
uint256 public randomPotAlways;
mapping(uint256 => address) public randomDistrAlways;
uint256 public randomNextAlways;
uint256 public lastdrawAlways;
// line 12 - Proof of eth rolls
uint256 public dicerollpot;
// line 13 - Proof of ridiculously bad odds
uint256 public amountPlayed;
uint256 public badOddsPot;
// line 14 - Proof of playing Snip3d
uint256 public Snip3dPot;
// line 16 - Proof of playing Slaughter3d
uint256 public Slaughter3dPot;
// line 17 - Proof of eth rolls feeding bank
uint256 public ethRollBank;
// line 18 - Proof of eth stuck on PLinc
uint256 public ethStuckOnPLinc;
address public currentHelper;
bool public canGetPaidForHelping;
mapping(address => bool) public hassEthstuck;
// line 19 - Proof of giving of eth
uint256 public PLincGiverOfEth;
//
// vaults
uint256 public vaultSmall;
uint256 public timeSmall;
uint256 public vaultMedium;
uint256 public timeMedium;
uint256 public vaultLarge;
uint256 public timeLarge;
uint256 public vaultDrip; // delayed bonds maturing
uint256 public timeDrip;
// interfaces
HourglassInterface constant P3Dcontract_ = HourglassInterface(0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);//0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);
SPASMInterface constant SPASM_ = SPASMInterface(0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);//0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);
Snip3DBridgeInterface constant snip3dBridge = Snip3DBridgeInterface(0x99352D1edfa7f124eC618dfb51014f6D54bAc4aE);//snip3d bridge
Slaughter3DBridgeInterface constant slaughter3dbridge = Slaughter3DBridgeInterface(0x3E752fFD5eff7b7f2715eF43D8339ecABd0e65b9);//slaughter3dbridge
// bonds div setup
uint256 public pointMultiplier = 10e18;
struct Account {
uint256 balance;
uint256 lastDividendPoints;
}
mapping(address=>Account) accounts;
uint256 public totalDividendPoints;
uint256 public unclaimedDividends;
function dividendsOwing(address account) public view returns(uint256) {
}
function fetchdivs(address toupdate) public updateAccount(toupdate){}
modifier updateAccount(address account) {
}
function () external payable{} // needs for divs
function vaultToWallet(address toPay) public {
}
// view functions
function harvestabledivs()
view
public
returns(uint256)
{
}
function fetchDataMain()
public
view
returns(uint256 _ethPendingDistribution, uint256 _ethPendingManagement, uint256 _ethPendingLines)
{
}
function fetchCheatLine()
public
view
returns(address _1stInLine, address _2ndInLine, address _3rdInLine, uint256 _sizeOfPot)
{
}
function fetchCheatLineWhale()
public
view
returns(address _1stInLine2, address _2ndInLine2, address _3rdInLine2, uint256 _sizeOfPot2)
{
}
// management hot potato functions
function buyCEO() public payable{
}
function buyDirector(uint256 spot) public payable{
}
function managementWithdraw(uint256 who) public{
}
// eth distribution cogs main
function ethPropagate() public{
}
//buybonds function
function buyBonds(address masternode, address referral)updateAccount(msg.sender) updateAccount(referral) payable public {
}
// management distribution eth function
function ethManagementPropagate() public {
}
// cash mature bonds to playervault
function fillBonds (address bondsOwner)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//force bonds because overstock pendingFills
function forceBonds (address bondsOwner, address masternode)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//autoReinvest functions
function setAuto (uint256 percentage) public {
}
function disableAuto () public {
}
function freelanceReinvest(address stackOwner, address masternode)updateAccount(msg.sender) updateAccount(stackOwner) public{
}
function PendinglinesToLines () public {
}
function fetchP3Ddivs() public{
}
//Profit lines
function cheatTheLine () public payable updateAccount(msg.sender){
}
function payoutCheatLine () public {
}
function cheatTheLineWhale () public payable updateAccount(msg.sender){
}
function payoutCheatLineWhale () public {
}
function takeArbitrageOpportunity () public payable updateAccount(msg.sender){
}
function takeArbitrageOpportunityRisky () public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDecreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playRandomDistribution (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistr () public {
}
function playRandomDistributionWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrWhale () public {
}
function playRandomDistributionAlways (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrAlways () public {
}
function playProofOfRediculousBadOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDiceRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function playProofOfEthRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function helpUnstuckEth()public payable updateAccount(msg.sender){
}
function transferEthToHelper()public{
}
function begForFreeEth () public payable updateAccount(msg.sender){
}
function releaseVaultSmall () public {
// needs time or amount reached
uint256 vaultSize = vaultSmall;
require(<FILL_ME>)
// reset time
timeSmall = now;
// empty vault
vaultSmall = 0;
// add to ethPendingDistribution
ethPendingDistribution = ethPendingDistribution.add(vaultSize);
}
function releaseVaultMedium () public {
}
function releaseVaultLarge () public {
}
function releaseDrip () public {
}
constructor()
public
{
}
// snip3d handlers
function soldierBuy () public {
}
function snip3dVaultToPLinc() public {
}
// slaughter3d handlers
function sendButcher() public{
}
function slaughter3dbridgeToPLinc() public {
}
// events
event bondsBought(address indexed player, uint256 indexed bonds);
event bondsFilled(address indexed player, uint256 indexed bonds);
event CEOsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price);
event Directorsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price, uint256 spot);
event cashout(address indexed player , uint256 indexed ethAmount);
event bondsMatured(uint256 indexed amount);
event RNGgenerated(uint256 indexed number);
event won(address player, bool haswon, uint256 amount ,uint256 line);
}
interface HourglassInterface {
function () payable external;
function buy(address _playerAddress) payable external returns(uint256);
function withdraw() external;
function myDividends(bool _includeReferralBonus) external view returns(uint256);
}
interface SPASMInterface {
function() payable external;
function disburse() external payable;
}
interface Snip3DBridgeInterface {
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
interface Slaughter3DBridgeInterface{
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
| timeSmall+24hours<now||vaultSize>10ether | 17,529 | timeSmall+24hours<now||vaultSize>10ether |
null | pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
}
// ProfitLineInc contract
contract ProfitLineInc {
using SafeMath for uint;
// set CEO and board of directors ownables
mapping(uint256 => address)public management;// 0 CEO 1-5 Directors
mapping(uint256 => uint256)public manVault;// Eth balance
//mapping(uint256 => uint256)public spendableShares; // unused allocation
mapping(uint256 => uint256)public price; // takeover price
uint256 public totalSupplyShares; // in use totalsupply shares
uint256 public ethPendingManagement;
// Player setup
mapping(address => uint256)public bondsOutstanding; // redeemablebonds
uint256 public totalSupplyBonds; //totalsupply of bonds outstanding
mapping(address => uint256)public playerVault; // in contract eth balance
mapping(address => uint256)public pendingFills; //eth to fill bonds
mapping(address => uint256)public playerId;
mapping(uint256 => address)public IdToAdress;
uint256 public nextPlayerID;
// autoReinvest
mapping(address => bool) public allowAutoInvest;
mapping(address => uint256) public percentageToReinvest;
// Game vars
uint256 ethPendingDistribution; // eth pending distribution
// proffit line vars
uint256 ethPendingLines; // eth ending distributionacross lines
// line 1 - proof of cheating the line
mapping(uint256 => address) public cheatLine;
mapping(address => bool) public isInLine;
mapping(address => uint256) public lineNumber;
uint256 public cheatLinePot;
uint256 public nextInLine;
uint256 public lastInLine;
// line 2 - proof of cheating the line Whale
mapping(uint256 => address) public cheatLineWhale;
mapping(address => bool) public isInLineWhale;
mapping(address => uint256) public lineNumberWhale;
uint256 public cheatLinePotWhale;
uint256 public nextInLineWhale;
uint256 public lastInLineWhale;
// line 3 - proof of arbitrage opportunity
uint256 public arbitragePot;
// line 4 - proof of risky arbitrage opportunity
uint256 public arbitragePotRisky;
// line 5 - proof of increasing odds
mapping(address => uint256) public odds;
uint256 public poioPot;
// line 6 - proof of increasing odds Whale
mapping(address => uint256) public oddsWhale;
uint256 public poioPotWhale;
// line 7 - proof of increasing odds everybody
uint256 public oddsAll;
uint256 public poioPotAll;
// line 8 - proof of decreasing odds everybody
uint256 public decreasingOddsAll;
uint256 public podoPotAll;
// line 9 - proof of distributing by random
uint256 public randomPot;
mapping(uint256 => address) public randomDistr;
uint256 public randomNext;
uint256 public lastdraw;
// line 10 - proof of distributing by random whale
uint256 public randomPotWhale;
mapping(uint256 => address) public randomDistrWhale;
uint256 public randomNextWhale;
uint256 public lastdrawWhale;
// line 11 - proof of distributing by everlasting random
uint256 public randomPotAlways;
mapping(uint256 => address) public randomDistrAlways;
uint256 public randomNextAlways;
uint256 public lastdrawAlways;
// line 12 - Proof of eth rolls
uint256 public dicerollpot;
// line 13 - Proof of ridiculously bad odds
uint256 public amountPlayed;
uint256 public badOddsPot;
// line 14 - Proof of playing Snip3d
uint256 public Snip3dPot;
// line 16 - Proof of playing Slaughter3d
uint256 public Slaughter3dPot;
// line 17 - Proof of eth rolls feeding bank
uint256 public ethRollBank;
// line 18 - Proof of eth stuck on PLinc
uint256 public ethStuckOnPLinc;
address public currentHelper;
bool public canGetPaidForHelping;
mapping(address => bool) public hassEthstuck;
// line 19 - Proof of giving of eth
uint256 public PLincGiverOfEth;
//
// vaults
uint256 public vaultSmall;
uint256 public timeSmall;
uint256 public vaultMedium;
uint256 public timeMedium;
uint256 public vaultLarge;
uint256 public timeLarge;
uint256 public vaultDrip; // delayed bonds maturing
uint256 public timeDrip;
// interfaces
HourglassInterface constant P3Dcontract_ = HourglassInterface(0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);//0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);
SPASMInterface constant SPASM_ = SPASMInterface(0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);//0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);
Snip3DBridgeInterface constant snip3dBridge = Snip3DBridgeInterface(0x99352D1edfa7f124eC618dfb51014f6D54bAc4aE);//snip3d bridge
Slaughter3DBridgeInterface constant slaughter3dbridge = Slaughter3DBridgeInterface(0x3E752fFD5eff7b7f2715eF43D8339ecABd0e65b9);//slaughter3dbridge
// bonds div setup
uint256 public pointMultiplier = 10e18;
struct Account {
uint256 balance;
uint256 lastDividendPoints;
}
mapping(address=>Account) accounts;
uint256 public totalDividendPoints;
uint256 public unclaimedDividends;
function dividendsOwing(address account) public view returns(uint256) {
}
function fetchdivs(address toupdate) public updateAccount(toupdate){}
modifier updateAccount(address account) {
}
function () external payable{} // needs for divs
function vaultToWallet(address toPay) public {
}
// view functions
function harvestabledivs()
view
public
returns(uint256)
{
}
function fetchDataMain()
public
view
returns(uint256 _ethPendingDistribution, uint256 _ethPendingManagement, uint256 _ethPendingLines)
{
}
function fetchCheatLine()
public
view
returns(address _1stInLine, address _2ndInLine, address _3rdInLine, uint256 _sizeOfPot)
{
}
function fetchCheatLineWhale()
public
view
returns(address _1stInLine2, address _2ndInLine2, address _3rdInLine2, uint256 _sizeOfPot2)
{
}
// management hot potato functions
function buyCEO() public payable{
}
function buyDirector(uint256 spot) public payable{
}
function managementWithdraw(uint256 who) public{
}
// eth distribution cogs main
function ethPropagate() public{
}
//buybonds function
function buyBonds(address masternode, address referral)updateAccount(msg.sender) updateAccount(referral) payable public {
}
// management distribution eth function
function ethManagementPropagate() public {
}
// cash mature bonds to playervault
function fillBonds (address bondsOwner)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//force bonds because overstock pendingFills
function forceBonds (address bondsOwner, address masternode)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//autoReinvest functions
function setAuto (uint256 percentage) public {
}
function disableAuto () public {
}
function freelanceReinvest(address stackOwner, address masternode)updateAccount(msg.sender) updateAccount(stackOwner) public{
}
function PendinglinesToLines () public {
}
function fetchP3Ddivs() public{
}
//Profit lines
function cheatTheLine () public payable updateAccount(msg.sender){
}
function payoutCheatLine () public {
}
function cheatTheLineWhale () public payable updateAccount(msg.sender){
}
function payoutCheatLineWhale () public {
}
function takeArbitrageOpportunity () public payable updateAccount(msg.sender){
}
function takeArbitrageOpportunityRisky () public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDecreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playRandomDistribution (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistr () public {
}
function playRandomDistributionWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrWhale () public {
}
function playRandomDistributionAlways (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrAlways () public {
}
function playProofOfRediculousBadOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDiceRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function playProofOfEthRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function helpUnstuckEth()public payable updateAccount(msg.sender){
}
function transferEthToHelper()public{
}
function begForFreeEth () public payable updateAccount(msg.sender){
}
function releaseVaultSmall () public {
}
function releaseVaultMedium () public {
// needs time or amount reached
uint256 vaultSize = vaultMedium;
require(<FILL_ME>)
// reset time
timeMedium = now;
// empty vault
vaultMedium = 0;
// add to ethPendingDistribution
ethPendingDistribution = ethPendingDistribution.add(vaultSize);
}
function releaseVaultLarge () public {
}
function releaseDrip () public {
}
constructor()
public
{
}
// snip3d handlers
function soldierBuy () public {
}
function snip3dVaultToPLinc() public {
}
// slaughter3d handlers
function sendButcher() public{
}
function slaughter3dbridgeToPLinc() public {
}
// events
event bondsBought(address indexed player, uint256 indexed bonds);
event bondsFilled(address indexed player, uint256 indexed bonds);
event CEOsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price);
event Directorsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price, uint256 spot);
event cashout(address indexed player , uint256 indexed ethAmount);
event bondsMatured(uint256 indexed amount);
event RNGgenerated(uint256 indexed number);
event won(address player, bool haswon, uint256 amount ,uint256 line);
}
interface HourglassInterface {
function () payable external;
function buy(address _playerAddress) payable external returns(uint256);
function withdraw() external;
function myDividends(bool _includeReferralBonus) external view returns(uint256);
}
interface SPASMInterface {
function() payable external;
function disburse() external payable;
}
interface Snip3DBridgeInterface {
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
interface Slaughter3DBridgeInterface{
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
| timeMedium+168hours<now||vaultSize>100ether | 17,529 | timeMedium+168hours<now||vaultSize>100ether |
null | pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
}
// ProfitLineInc contract
contract ProfitLineInc {
using SafeMath for uint;
// set CEO and board of directors ownables
mapping(uint256 => address)public management;// 0 CEO 1-5 Directors
mapping(uint256 => uint256)public manVault;// Eth balance
//mapping(uint256 => uint256)public spendableShares; // unused allocation
mapping(uint256 => uint256)public price; // takeover price
uint256 public totalSupplyShares; // in use totalsupply shares
uint256 public ethPendingManagement;
// Player setup
mapping(address => uint256)public bondsOutstanding; // redeemablebonds
uint256 public totalSupplyBonds; //totalsupply of bonds outstanding
mapping(address => uint256)public playerVault; // in contract eth balance
mapping(address => uint256)public pendingFills; //eth to fill bonds
mapping(address => uint256)public playerId;
mapping(uint256 => address)public IdToAdress;
uint256 public nextPlayerID;
// autoReinvest
mapping(address => bool) public allowAutoInvest;
mapping(address => uint256) public percentageToReinvest;
// Game vars
uint256 ethPendingDistribution; // eth pending distribution
// proffit line vars
uint256 ethPendingLines; // eth ending distributionacross lines
// line 1 - proof of cheating the line
mapping(uint256 => address) public cheatLine;
mapping(address => bool) public isInLine;
mapping(address => uint256) public lineNumber;
uint256 public cheatLinePot;
uint256 public nextInLine;
uint256 public lastInLine;
// line 2 - proof of cheating the line Whale
mapping(uint256 => address) public cheatLineWhale;
mapping(address => bool) public isInLineWhale;
mapping(address => uint256) public lineNumberWhale;
uint256 public cheatLinePotWhale;
uint256 public nextInLineWhale;
uint256 public lastInLineWhale;
// line 3 - proof of arbitrage opportunity
uint256 public arbitragePot;
// line 4 - proof of risky arbitrage opportunity
uint256 public arbitragePotRisky;
// line 5 - proof of increasing odds
mapping(address => uint256) public odds;
uint256 public poioPot;
// line 6 - proof of increasing odds Whale
mapping(address => uint256) public oddsWhale;
uint256 public poioPotWhale;
// line 7 - proof of increasing odds everybody
uint256 public oddsAll;
uint256 public poioPotAll;
// line 8 - proof of decreasing odds everybody
uint256 public decreasingOddsAll;
uint256 public podoPotAll;
// line 9 - proof of distributing by random
uint256 public randomPot;
mapping(uint256 => address) public randomDistr;
uint256 public randomNext;
uint256 public lastdraw;
// line 10 - proof of distributing by random whale
uint256 public randomPotWhale;
mapping(uint256 => address) public randomDistrWhale;
uint256 public randomNextWhale;
uint256 public lastdrawWhale;
// line 11 - proof of distributing by everlasting random
uint256 public randomPotAlways;
mapping(uint256 => address) public randomDistrAlways;
uint256 public randomNextAlways;
uint256 public lastdrawAlways;
// line 12 - Proof of eth rolls
uint256 public dicerollpot;
// line 13 - Proof of ridiculously bad odds
uint256 public amountPlayed;
uint256 public badOddsPot;
// line 14 - Proof of playing Snip3d
uint256 public Snip3dPot;
// line 16 - Proof of playing Slaughter3d
uint256 public Slaughter3dPot;
// line 17 - Proof of eth rolls feeding bank
uint256 public ethRollBank;
// line 18 - Proof of eth stuck on PLinc
uint256 public ethStuckOnPLinc;
address public currentHelper;
bool public canGetPaidForHelping;
mapping(address => bool) public hassEthstuck;
// line 19 - Proof of giving of eth
uint256 public PLincGiverOfEth;
//
// vaults
uint256 public vaultSmall;
uint256 public timeSmall;
uint256 public vaultMedium;
uint256 public timeMedium;
uint256 public vaultLarge;
uint256 public timeLarge;
uint256 public vaultDrip; // delayed bonds maturing
uint256 public timeDrip;
// interfaces
HourglassInterface constant P3Dcontract_ = HourglassInterface(0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);//0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);
SPASMInterface constant SPASM_ = SPASMInterface(0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);//0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);
Snip3DBridgeInterface constant snip3dBridge = Snip3DBridgeInterface(0x99352D1edfa7f124eC618dfb51014f6D54bAc4aE);//snip3d bridge
Slaughter3DBridgeInterface constant slaughter3dbridge = Slaughter3DBridgeInterface(0x3E752fFD5eff7b7f2715eF43D8339ecABd0e65b9);//slaughter3dbridge
// bonds div setup
uint256 public pointMultiplier = 10e18;
struct Account {
uint256 balance;
uint256 lastDividendPoints;
}
mapping(address=>Account) accounts;
uint256 public totalDividendPoints;
uint256 public unclaimedDividends;
function dividendsOwing(address account) public view returns(uint256) {
}
function fetchdivs(address toupdate) public updateAccount(toupdate){}
modifier updateAccount(address account) {
}
function () external payable{} // needs for divs
function vaultToWallet(address toPay) public {
}
// view functions
function harvestabledivs()
view
public
returns(uint256)
{
}
function fetchDataMain()
public
view
returns(uint256 _ethPendingDistribution, uint256 _ethPendingManagement, uint256 _ethPendingLines)
{
}
function fetchCheatLine()
public
view
returns(address _1stInLine, address _2ndInLine, address _3rdInLine, uint256 _sizeOfPot)
{
}
function fetchCheatLineWhale()
public
view
returns(address _1stInLine2, address _2ndInLine2, address _3rdInLine2, uint256 _sizeOfPot2)
{
}
// management hot potato functions
function buyCEO() public payable{
}
function buyDirector(uint256 spot) public payable{
}
function managementWithdraw(uint256 who) public{
}
// eth distribution cogs main
function ethPropagate() public{
}
//buybonds function
function buyBonds(address masternode, address referral)updateAccount(msg.sender) updateAccount(referral) payable public {
}
// management distribution eth function
function ethManagementPropagate() public {
}
// cash mature bonds to playervault
function fillBonds (address bondsOwner)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//force bonds because overstock pendingFills
function forceBonds (address bondsOwner, address masternode)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//autoReinvest functions
function setAuto (uint256 percentage) public {
}
function disableAuto () public {
}
function freelanceReinvest(address stackOwner, address masternode)updateAccount(msg.sender) updateAccount(stackOwner) public{
}
function PendinglinesToLines () public {
}
function fetchP3Ddivs() public{
}
//Profit lines
function cheatTheLine () public payable updateAccount(msg.sender){
}
function payoutCheatLine () public {
}
function cheatTheLineWhale () public payable updateAccount(msg.sender){
}
function payoutCheatLineWhale () public {
}
function takeArbitrageOpportunity () public payable updateAccount(msg.sender){
}
function takeArbitrageOpportunityRisky () public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDecreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playRandomDistribution (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistr () public {
}
function playRandomDistributionWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrWhale () public {
}
function playRandomDistributionAlways (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrAlways () public {
}
function playProofOfRediculousBadOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDiceRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function playProofOfEthRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function helpUnstuckEth()public payable updateAccount(msg.sender){
}
function transferEthToHelper()public{
}
function begForFreeEth () public payable updateAccount(msg.sender){
}
function releaseVaultSmall () public {
}
function releaseVaultMedium () public {
}
function releaseVaultLarge () public {
// needs time or amount reached
uint256 vaultSize = vaultLarge;
require(<FILL_ME>)
// reset time
timeLarge = now;
// empty vault
vaultLarge = 0;
// add to ethPendingDistribution
ethPendingDistribution = ethPendingDistribution.add(vaultSize);
}
function releaseDrip () public {
}
constructor()
public
{
}
// snip3d handlers
function soldierBuy () public {
}
function snip3dVaultToPLinc() public {
}
// slaughter3d handlers
function sendButcher() public{
}
function slaughter3dbridgeToPLinc() public {
}
// events
event bondsBought(address indexed player, uint256 indexed bonds);
event bondsFilled(address indexed player, uint256 indexed bonds);
event CEOsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price);
event Directorsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price, uint256 spot);
event cashout(address indexed player , uint256 indexed ethAmount);
event bondsMatured(uint256 indexed amount);
event RNGgenerated(uint256 indexed number);
event won(address player, bool haswon, uint256 amount ,uint256 line);
}
interface HourglassInterface {
function () payable external;
function buy(address _playerAddress) payable external returns(uint256);
function withdraw() external;
function myDividends(bool _includeReferralBonus) external view returns(uint256);
}
interface SPASMInterface {
function() payable external;
function disburse() external payable;
}
interface Snip3DBridgeInterface {
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
interface Slaughter3DBridgeInterface{
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
| timeLarge+720hours<now||vaultSize>1000ether | 17,529 | timeLarge+720hours<now||vaultSize>1000ether |
null | pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
}
function sub(uint a, uint b) internal pure returns (uint c) {
}
function mul(uint a, uint b) internal pure returns (uint c) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
}
// ProfitLineInc contract
contract ProfitLineInc {
using SafeMath for uint;
// set CEO and board of directors ownables
mapping(uint256 => address)public management;// 0 CEO 1-5 Directors
mapping(uint256 => uint256)public manVault;// Eth balance
//mapping(uint256 => uint256)public spendableShares; // unused allocation
mapping(uint256 => uint256)public price; // takeover price
uint256 public totalSupplyShares; // in use totalsupply shares
uint256 public ethPendingManagement;
// Player setup
mapping(address => uint256)public bondsOutstanding; // redeemablebonds
uint256 public totalSupplyBonds; //totalsupply of bonds outstanding
mapping(address => uint256)public playerVault; // in contract eth balance
mapping(address => uint256)public pendingFills; //eth to fill bonds
mapping(address => uint256)public playerId;
mapping(uint256 => address)public IdToAdress;
uint256 public nextPlayerID;
// autoReinvest
mapping(address => bool) public allowAutoInvest;
mapping(address => uint256) public percentageToReinvest;
// Game vars
uint256 ethPendingDistribution; // eth pending distribution
// proffit line vars
uint256 ethPendingLines; // eth ending distributionacross lines
// line 1 - proof of cheating the line
mapping(uint256 => address) public cheatLine;
mapping(address => bool) public isInLine;
mapping(address => uint256) public lineNumber;
uint256 public cheatLinePot;
uint256 public nextInLine;
uint256 public lastInLine;
// line 2 - proof of cheating the line Whale
mapping(uint256 => address) public cheatLineWhale;
mapping(address => bool) public isInLineWhale;
mapping(address => uint256) public lineNumberWhale;
uint256 public cheatLinePotWhale;
uint256 public nextInLineWhale;
uint256 public lastInLineWhale;
// line 3 - proof of arbitrage opportunity
uint256 public arbitragePot;
// line 4 - proof of risky arbitrage opportunity
uint256 public arbitragePotRisky;
// line 5 - proof of increasing odds
mapping(address => uint256) public odds;
uint256 public poioPot;
// line 6 - proof of increasing odds Whale
mapping(address => uint256) public oddsWhale;
uint256 public poioPotWhale;
// line 7 - proof of increasing odds everybody
uint256 public oddsAll;
uint256 public poioPotAll;
// line 8 - proof of decreasing odds everybody
uint256 public decreasingOddsAll;
uint256 public podoPotAll;
// line 9 - proof of distributing by random
uint256 public randomPot;
mapping(uint256 => address) public randomDistr;
uint256 public randomNext;
uint256 public lastdraw;
// line 10 - proof of distributing by random whale
uint256 public randomPotWhale;
mapping(uint256 => address) public randomDistrWhale;
uint256 public randomNextWhale;
uint256 public lastdrawWhale;
// line 11 - proof of distributing by everlasting random
uint256 public randomPotAlways;
mapping(uint256 => address) public randomDistrAlways;
uint256 public randomNextAlways;
uint256 public lastdrawAlways;
// line 12 - Proof of eth rolls
uint256 public dicerollpot;
// line 13 - Proof of ridiculously bad odds
uint256 public amountPlayed;
uint256 public badOddsPot;
// line 14 - Proof of playing Snip3d
uint256 public Snip3dPot;
// line 16 - Proof of playing Slaughter3d
uint256 public Slaughter3dPot;
// line 17 - Proof of eth rolls feeding bank
uint256 public ethRollBank;
// line 18 - Proof of eth stuck on PLinc
uint256 public ethStuckOnPLinc;
address public currentHelper;
bool public canGetPaidForHelping;
mapping(address => bool) public hassEthstuck;
// line 19 - Proof of giving of eth
uint256 public PLincGiverOfEth;
//
// vaults
uint256 public vaultSmall;
uint256 public timeSmall;
uint256 public vaultMedium;
uint256 public timeMedium;
uint256 public vaultLarge;
uint256 public timeLarge;
uint256 public vaultDrip; // delayed bonds maturing
uint256 public timeDrip;
// interfaces
HourglassInterface constant P3Dcontract_ = HourglassInterface(0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);//0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);
SPASMInterface constant SPASM_ = SPASMInterface(0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);//0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);
Snip3DBridgeInterface constant snip3dBridge = Snip3DBridgeInterface(0x99352D1edfa7f124eC618dfb51014f6D54bAc4aE);//snip3d bridge
Slaughter3DBridgeInterface constant slaughter3dbridge = Slaughter3DBridgeInterface(0x3E752fFD5eff7b7f2715eF43D8339ecABd0e65b9);//slaughter3dbridge
// bonds div setup
uint256 public pointMultiplier = 10e18;
struct Account {
uint256 balance;
uint256 lastDividendPoints;
}
mapping(address=>Account) accounts;
uint256 public totalDividendPoints;
uint256 public unclaimedDividends;
function dividendsOwing(address account) public view returns(uint256) {
}
function fetchdivs(address toupdate) public updateAccount(toupdate){}
modifier updateAccount(address account) {
}
function () external payable{} // needs for divs
function vaultToWallet(address toPay) public {
}
// view functions
function harvestabledivs()
view
public
returns(uint256)
{
}
function fetchDataMain()
public
view
returns(uint256 _ethPendingDistribution, uint256 _ethPendingManagement, uint256 _ethPendingLines)
{
}
function fetchCheatLine()
public
view
returns(address _1stInLine, address _2ndInLine, address _3rdInLine, uint256 _sizeOfPot)
{
}
function fetchCheatLineWhale()
public
view
returns(address _1stInLine2, address _2ndInLine2, address _3rdInLine2, uint256 _sizeOfPot2)
{
}
// management hot potato functions
function buyCEO() public payable{
}
function buyDirector(uint256 spot) public payable{
}
function managementWithdraw(uint256 who) public{
}
// eth distribution cogs main
function ethPropagate() public{
}
//buybonds function
function buyBonds(address masternode, address referral)updateAccount(msg.sender) updateAccount(referral) payable public {
}
// management distribution eth function
function ethManagementPropagate() public {
}
// cash mature bonds to playervault
function fillBonds (address bondsOwner)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//force bonds because overstock pendingFills
function forceBonds (address bondsOwner, address masternode)updateAccount(msg.sender) updateAccount(bondsOwner) public {
}
//autoReinvest functions
function setAuto (uint256 percentage) public {
}
function disableAuto () public {
}
function freelanceReinvest(address stackOwner, address masternode)updateAccount(msg.sender) updateAccount(stackOwner) public{
}
function PendinglinesToLines () public {
}
function fetchP3Ddivs() public{
}
//Profit lines
function cheatTheLine () public payable updateAccount(msg.sender){
}
function payoutCheatLine () public {
}
function cheatTheLineWhale () public payable updateAccount(msg.sender){
}
function payoutCheatLineWhale () public {
}
function takeArbitrageOpportunity () public payable updateAccount(msg.sender){
}
function takeArbitrageOpportunityRisky () public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfIncreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDecreasingOddsALL (uint256 plays) public payable updateAccount(msg.sender){
}
function playRandomDistribution (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistr () public {
}
function playRandomDistributionWhale (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrWhale () public {
}
function playRandomDistributionAlways (uint256 plays) public payable updateAccount(msg.sender){
}
function payoutRandomDistrAlways () public {
}
function playProofOfRediculousBadOdds (uint256 plays) public payable updateAccount(msg.sender){
}
function playProofOfDiceRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function playProofOfEthRolls (uint256 oddsTaken) public payable updateAccount(msg.sender){
}
function helpUnstuckEth()public payable updateAccount(msg.sender){
}
function transferEthToHelper()public{
}
function begForFreeEth () public payable updateAccount(msg.sender){
}
function releaseVaultSmall () public {
}
function releaseVaultMedium () public {
}
function releaseVaultLarge () public {
}
function releaseDrip () public {
// needs time or amount reached
uint256 vaultSize = vaultDrip;
require(<FILL_ME>)
// reset time
timeDrip = now;
uint256 value = vaultSize.div(100);
// empty vault
vaultDrip = vaultDrip.sub(value);
// update divs params
totalDividendPoints = totalDividendPoints.add(value);
unclaimedDividends = unclaimedDividends.add(value);
emit bondsMatured(value);
}
constructor()
public
{
}
// snip3d handlers
function soldierBuy () public {
}
function snip3dVaultToPLinc() public {
}
// slaughter3d handlers
function sendButcher() public{
}
function slaughter3dbridgeToPLinc() public {
}
// events
event bondsBought(address indexed player, uint256 indexed bonds);
event bondsFilled(address indexed player, uint256 indexed bonds);
event CEOsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price);
event Directorsold(address indexed previousOwner, address indexed newOwner, uint256 indexed price, uint256 spot);
event cashout(address indexed player , uint256 indexed ethAmount);
event bondsMatured(uint256 indexed amount);
event RNGgenerated(uint256 indexed number);
event won(address player, bool haswon, uint256 amount ,uint256 line);
}
interface HourglassInterface {
function () payable external;
function buy(address _playerAddress) payable external returns(uint256);
function withdraw() external;
function myDividends(bool _includeReferralBonus) external view returns(uint256);
}
interface SPASMInterface {
function() payable external;
function disburse() external payable;
}
interface Snip3DBridgeInterface {
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
interface Slaughter3DBridgeInterface{
function harvestableBalance()
view
external
returns(uint256)
;
function sacUp () external payable ;
function fetchBalance () external ;
}
| timeDrip+24hours<now | 17,529 | timeDrip+24hours<now |
null | pragma solidity ^0.4.24;
contract ERC20 {
function totalSupply() public constant returns (uint256);
function balanceOf(address _who) public constant returns (uint256);
function allowance(address _owner, address _spender) public constant returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _fromValue,uint256 _toValue) public returns (bool);
function transferFrom(address _from, 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 Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
}
contract Pausable is Ownable {
event Paused();
event Unpaused();
bool public paused = false;
modifier whenNotPaused() {
}
modifier whenPaused() {
}
function pause() public onlyOwner whenNotPaused {
}
function unpause() public onlyOwner whenPaused {
}
}
library SafeMath {
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
}
contract NDNLink is ERC20, Pausable {
using SafeMath for uint256;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public symbol;
string public name;
uint256 public decimals;
uint256 _totalSupply;
constructor() public {
}
function totalSupply() public constant returns (uint256) {
}
function balanceOf(address _owner) public constant returns (uint256) {
}
function allowance(address _owner, address _spender) public constant returns (uint256) {
}
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
}
function approve(address _spender, uint256 _fromValue, uint256 _toValue) public whenNotPaused returns (bool) {
require(_spender != address(0));
require(<FILL_ME>)
allowed[msg.sender][_spender] = _toValue;
emit Approval(msg.sender, _spender, _toValue);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool){
}
}
| allowed[msg.sender][_spender]==_fromValue | 17,535 | allowed[msg.sender][_spender]==_fromValue |
"total supply exceeds min supply" | pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
pragma solidity 0.8.4;
contract BabyCat is ERC20, Owned {
uint256 public minSupply;
address public beneficiary;
bool public feesEnabled;
mapping(address => bool) public isExcludedFromFee;
event MinSupplyUpdated(uint256 oldAmount, uint256 newAmount);
event BeneficiaryUpdated(address oldBeneficiary, address newBeneficiary);
event FeesEnabledUpdated(bool enabled);
event ExcludedFromFeeUpdated(address account, bool excluded);
constructor() ERC20("Baby Cat", "Baby Cat") {
}
/**
* @dev if fees are enabled, subtract 2.25% fee and send it to beneficiary
* @dev after a certain threshold, try to swap collected fees automatically
* @dev if automatic swap fails (or beneficiary does not implement swapTokens function) transfer should still succeed
*/
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function calculateFee(uint256 _amount, uint256 _fee)
public
pure
returns (uint256)
{
}
/**
* @notice allows to burn tokens from own balance
* @dev only allows burning tokens until minimum supply is reached
* @param value amount of tokens to burn
*/
function burn(uint256 value) public {
_burn(_msgSender(), value);
require(<FILL_ME>)
}
/**
* @notice sets minimum supply of the token
* @dev only callable by owner
* @param _newMinSupply new minimum supply
*/
function setMinSupply(uint256 _newMinSupply) public onlyOwner {
}
/**
* @notice sets recipient of transfer fee
* @dev only callable by owner
* @param _newBeneficiary new beneficiary
*/
function setBeneficiary(address _newBeneficiary) public onlyOwner {
}
/**
* @notice sets whether account collects fees on token transfer
* @dev only callable by owner
* @param _enabled bool whether fees are enabled
*/
function setFeesEnabled(bool _enabled) public onlyOwner {
}
/**
* @notice adds or removes an account that is exempt from fee collection
* @dev only callable by owner
* @param _account account to modify
* @param _excluded new value
*/
function setExcludeFromFee(address _account, bool _excluded)
public
onlyOwner
{
}
}
| totalSupply()>=minSupply,"total supply exceeds min supply" | 17,555 | totalSupply()>=minSupply |
"must have burner role to burn" | pragma solidity =0.8.10;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "./interfaces/IMintableERC20.sol";
import "./interfaces/IBurnableERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
/**
* @notice This token contract is minted as a reward by staking
* NFTs based on TokenRewardStaking contract
* and is burned when merging TokenRewardStaking
* or adding accessories to them
*
* @dev Supports minting new tokens to an address
* from authorized addresses restricted by
* the `MINTER_ROLE` role
*
* @dev Supports burning tokens from an address from
* authorized addresses restricted by the
* `BURNER_ROLE` role
*
* @dev Supports EIP-2612 permits for gas-less approvals
*/
contract MintableBurnableERC20 is ERC20, ERC20Permit, IMintableERC20, IBurnableERC20, AccessControl {
/**
* @notice AccessControl role that allows other EOAs or contracts
* to mint tokens
*
* @dev Checked in mint()
*/
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
/**
* @notice AccessControl role that allows other EOAs or contracts
* to burn tokens
*
* @dev Checked in burn()
*/
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
/**
* @dev Grants `DEFAULT_ADMIN_ROLE`, `MINTER_ROLE` and `BURNER_ROLE` to the
* account that deploys the contract.
*
* @param _name Full name of the NFT
* @param _symbol Symbol of the NFT
*
* See {ERC20-constructor}.
*/
constructor(string memory _name, string memory _symbol) ERC20(_name, _symbol) ERC20Permit(_name) {
}
/**
* @dev Mints new tokens to an address
*
* @dev Restricted by `MINTER_ROLE` role
*
* @param _to the address the new tokens will be minted to
* @param _amount how many new tokens will be minted
*/
function mint(address _to, uint256 _amount) public {
}
/**
* @dev Burns some tokens from an address
*
* @dev Restricted by `BURNER_ROLE` role
*
* @param _from the address the tokens will be burned from
* @param _amount how many tokens will be burned
*/
function burn(address _from, uint256 _amount) public {
require(<FILL_ME>)
_burn(_from, _amount);
}
}
| hasRole(BURNER_ROLE,_msgSender()),"must have burner role to burn" | 17,587 | hasRole(BURNER_ROLE,_msgSender()) |
'safeguard is active' | pragma solidity 0.5.11; /*
___________________________________________________________________
_ _ ______
| | / / /
--|-/|-/-----__---/----__----__---_--_----__-------/-------__------
|/ |/ /___) / / ' / ) / / ) /___) / / )
__/__|____(___ _/___(___ _(___/_/_/__/_(___ _____/______(___/__o_o_
███████╗███████╗████████╗██╗ ██████╗ ██████╗ ██╗███╗ ██╗
██╔════╝██╔════╝╚══██╔══╝██║ ██╔════╝██╔═══██╗██║████╗ ██║
███████╗█████╗ ██║ ██║ ██║ ██║ ██║██║██╔██╗ ██║
╚════██║██╔══╝ ██║ ██║ ██║ ██║ ██║██║██║╚██╗██║
███████║███████╗ ██║ ██║ ╚██████╗╚██████╔╝██║██║ ╚████║
╚══════╝╚══════╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚═╝╚═╝ ╚═══╝
----------------------------------------------------------------------------
'SETI' Token contract with following features
=> ERC20 Compliance
=> Higher degree of control by owner - safeguard functionality
=> SafeMath implementation
=> Burnable
=> air drop
Name : South East Trading Investment
Symbol : SETI
Total supply: 600,000,000 (600 Million)
Decimals : 18
------------------------------------------------------------------------------------
Copyright (c) 2019 onwards South East Trading Investment. ( http://seti.network )
-----------------------------------------------------------------------------------
*/
//*******************************************************************//
//------------------------ SafeMath Library -------------------------//
//*******************************************************************//
/* Safemath library */
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
//*******************************************************************//
//------------------ Contract to Manage Ownership -------------------//
//*******************************************************************//
// Owner Handler
contract owned {
address payable public owner;
constructor () public {
}
modifier onlyOwner {
}
function transferOwnership(address payable newOwner) public onlyOwner {
}
}
//*****************************************************************//
//------------------ SETI Coin main code starts -------------------//
//*****************************************************************//
contract SETIcoin is owned {
// Public variables of the token
using SafeMath for uint256;
string public name = "South East Trading Investment";
string public symbol = "SETI";
uint256 public decimals = 18; // 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply = 600000000 * (10 ** decimals) ; // 600 Million with 18 decimal points
bool public safeguard; // putting safeguard on will halt all non-owner functions
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenAccounts(address target, bool frozen);
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
// Approval
event Approval(address indexed tokenOwner, address indexed spender, uint256 indexed tokenAmount);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
constructor () public {
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
require(<FILL_ME>)
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0x0), 'zero address');
uint previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(balanceOf[_from].add(balanceOf[_to]) == previousBalances);
emit Transfer(_from, _to, _value);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public returns (bool success) {
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) public onlyOwner {
}
// Just in rare case, owner wants to transfer Ether from contract to owner address
function manualWithdrawEther() public onlyOwner {
}
function manualWithdrawTokens(uint256 tokenAmount) public onlyOwner {
}
/**
* Change safeguard status on or off
*
* When safeguard is true, then all the non-owner functions will stop working.
* When safeguard is false, then all the functions will resume working back again!
*/
function changeSafeguardStatus() public onlyOwner {
}
/********************************/
/* Code for the Air drop */
/********************************/
/**
* Run an Air-Drop
*
* It requires an array of all the addresses and amount of tokens to distribute
* It will only process first 150 recipients. That limit is fixed to prevent gas limit
*/
function airdrop(address[] memory recipients, uint[] memory tokenAmount) public onlyOwner {
}
}
| !safeguard,'safeguard is active' | 17,589 | !safeguard |
null | /**
*
*
/$$$$$$$$ /$$$$$$ /$$ /$$ /$$$$$$ /$$$$$$$ /$$$$$$ /$$$$$$ /$$$$$$ /$$ /$$ /$$$$$$ /$$$$$$ /$$ /$$$$$$$$
| $$_____//$$__ $$| $$ | $$ /$$__ $$| $$__ $$ /$$__ $$ /$$__ $$|_ $$_/| $$$ | $$ /$$__ $$ /$$__ $$| $$ | $$_____/
| $$ | $$ \ $$| $$ | $$| $$ \ $$| $$ \ $$ | $$ \__/| $$ \ $$ | $$ | $$$$| $$ | $$ \__/| $$ \ $$| $$ | $$
| $$$$$ | $$$$$$$$| $$ / $$/| $$ | $$| $$$$$$$/ | $$ | $$ | $$ | $$ | $$ $$ $$ | $$$$$$ | $$$$$$$$| $$ | $$$$$
| $$__/ | $$__ $$ \ $$ $$/ | $$ | $$| $$__ $$ | $$ | $$ | $$ | $$ | $$ $$$$ \____ $$| $$__ $$| $$ | $$__/
| $$ | $$ | $$ \ $$$/ | $$ | $$| $$ \ $$ | $$ $$| $$ | $$ | $$ | $$\ $$$ /$$ \ $$| $$ | $$| $$ | $$
| $$ | $$ | $$ \ $/ | $$$$$$/| $$ | $$ | $$$$$$/| $$$$$$/ /$$$$$$| $$ \ $$ | $$$$$$/| $$ | $$| $$$$$$$$| $$$$$$$$
|__/ |__/ |__/ \_/ \______/ |__/ |__/ \______/ \______/ |______/|__/ \__/ \______/ |__/ |__/|________/|________/
εɖɖίε રεĢĢίε ĵΘε
*
*
*
*
* Licensed under the Apache License, version 2.0: https://github.com/TokenMarketNet/ico/blob/master/LICENSE.txt
*/
pragma solidity ^0.5.17;
import "./IncreasingPriceCrowdsale.sol";
import "./FavorCoinCrowdsale.sol";
import "./Ownable.sol";
import "./ERC20.sol";
contract FavorCoinSale is IncreasingPriceCrowdsale {
uint256 public defaultCap;
mapping(address => uint256) public contributions;
mapping(address => uint256) public caps;
address private ownerwallet;
constructor (
uint256 _openingTime,
uint256 _closingTime,
address payable _wallet,
address _token,
uint256 _initialRate,
uint256 _finalRate,
uint256 _walletCap
)
public
FavorCoinCrowdsale(_initialRate, _wallet, _token)
TimedCrowdsale(_openingTime, _closingTime)
IncreasingPriceCrowdsale(_initialRate, _finalRate)
{
}
function closeSale() onlyOwner payable public{
}
/**
* @dev Sets default user's maximum contribution.
* @param _cap Wei limit for individual contribution
*/
function setDefaultCap( uint256 _cap) external onlyOwner {
}
/**
* @dev Sets a specific user's maximum contribution.
* @param _beneficiary Address to be capped
* @param _cap Wei limit for individual contribution
*/
function setUserCap(address _beneficiary, uint256 _cap) external onlyOwner {
}
/**
* Called from invest() to confirm if the curret investment does not break our cap rule.
*/
function isBreakingCap(uint tokenAmount) public view returns (bool limitBroken) {
}
/**
* We are sold out when our approve pool becomes empty.
*/
function isCrowdsaleFull() public view returns (bool) {
}
/**
* Get the amount of unsold tokens allocated to this contract;
*/
function getTokensLeft() public view returns (uint) {
}
/**
* Transfer tokens from approve() pool to the buyer.
*
* Use approve() given to this crowdsale to distribute the tokens.
*/
function assignTokens(address receiver, uint tokenAmount) public onlyOwner {
}
/**
* @dev Sets a group of users' maximum contribution.
* @param _beneficiaries List of addresses to be capped
* @param _cap Wei limit for individual contribution
*/
function setGroupCap(
address[] calldata _beneficiaries,
uint256 _cap
)
external
onlyOwner
{
}
/**
* @dev Returns the cap of a specific user.
* @param _beneficiary Address whose cap is to be checked
* @return Current cap for individual user
*/
function getUserCap(address _beneficiary) public view returns (uint256) {
}
/**
* @dev Returns the amount contributed so far by a sepecific user.
* @param _beneficiary Address of contributor
* @return User contribution so far
*/
function getUserContribution(address _beneficiary)
public view returns (uint256)
{
}
/**
* @dev Extend parent behavior requiring purchase to respect the user's funding cap.
* @param _beneficiary Token purchaser
* @param _weiAmount Amount of wei contributed
*/
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
super._preValidatePurchase(_beneficiary, _weiAmount);
if(caps[_beneficiary]==0){
caps[_beneficiary] = defaultCap;
}
require(<FILL_ME>)
}
/**
* @dev Extend parent behavior to update user contributions
* @param _beneficiary Token purchaser
* @param _weiAmount Amount of wei contributed
*/
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
}
| contributions[_beneficiary].add(_weiAmount)<=caps[_beneficiary] | 17,613 | contributions[_beneficiary].add(_weiAmount)<=caps[_beneficiary] |
"XiSpace: Invalid area" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
/**
* The Purpose of this contract is to handle the booking of areas to display specific images at coordinates for a determined time.
* The booking process is two steps, as validation from the contract operators is required.
* Users can create and cancel submissions, identified by a unique ID.
* The operator can accept and reject user submissions. Rejected submissions are refunded.
*/
contract XiSpace is AccessControl {
bytes32 public constant VALIDATOR_ROLE = keccak256("VALIDATOR_ROLE");
bytes32 public constant TREASURER_ROLE = keccak256("TREASURER_ROLE");
bytes32 public constant PRICE_ROLE = keccak256("PRICE_ROLE");
uint256 public constant BETA_RHO_SUPPLY = 6790 * 10**18;
uint256 public constant MAX_X = 1200;
uint256 public constant MAX_Y = 1080;
uint256 public PIXEL_X_PRICE = BETA_RHO_SUPPLY / MAX_X / 100;
uint256 public PIXEL_Y_PRICE = BETA_RHO_SUPPLY / MAX_Y / 100;
uint256 public SECOND_PRICE = 10**17;
address public treasury = 0x1f7c453a4cccbF826A97F213706Ee72b79dba466;
IERC20 public betaToken = IERC20(0x35F67c1D929E106FDfF8D1A55226AFe15c34dbE2);
IERC20 public rhoToken = IERC20(0x3F3Cd642E81d030D7b514a2aB5e3a5536bEb90Ec);
IERC20 public kappaToken = IERC20(0x5D2C6545d16e3f927a25b4567E39e2cf5076BeF4);
IERC20 public gammaToken = IERC20(0x1E1EEd62F8D82ecFd8230B8d283D5b5c1bA81B55);
IERC20 public xiToken = IERC20(0x295B42684F90c77DA7ea46336001010F2791Ec8c);
event SUBMISSION(uint256 id, address indexed addr);
event CANCELLED(uint256 id);
event BOOKED(uint256 id);
event REJECTED(uint256 id, bool fundsReturned);
struct Booking {
uint16 x;
uint16 y;
uint16 width;
uint16 height;
bool validated;
uint256 time;
uint256 duration;
bytes32 sha;
address owner;
}
struct Receipt {
uint256 betaAmount;
uint256 rhoAmount;
uint256 kappaAmount;
uint256 gammaAmount;
uint256 xiAmount;
}
uint256 public bookingsCount = 0;
// Store the booking submissions
mapping(uint256 => Booking) public bookings;
// Store the amounts of Kappa and Gamma provided by the user for an area
mapping(uint256 => Receipt) public receipts;
constructor(address beta, address rho, address kappa, address gamma, address xi) {
}
function setTreasury(address _treasury) external onlyRole(TREASURER_ROLE) {
}
function setXiDivisor(uint256 divisor) external onlyRole(PRICE_ROLE) {
}
function setBetaAndRhoDivisor(uint256 divisor) external onlyRole(PRICE_ROLE) {
}
/**
* @dev Called by the interface to submit a booking of an area to display an image. The user must have created 5 allowances for all tokens
* At the time of submission, no collisions with previous bookings must be found or validation process will fail
* User tokens are temporary stored in the contract and will be non refundable after validation
* @param x X Coordinate of the upper left corner of the area, must be within screen boundaries: 0-MAX_X-1
* @param y Y Coordinate of the upper left corner of the area, must be within screen boundaries: 0-MAX_Y-1
* @param width Width of the area
* @param height Height of the area
* @param time Start timestamp for the display
* @param duration Duration in seconds of the display
* @param sha Must be the sha256 of the image as it is computed during IPFS storage
* @param computedKappaAmount Amount of Kappa required to pay for the image pixels, this must be correct or the validation process will reject the submission
* @param computedGammaAmount Amount of Gamma required to pay for the image pixels, this must be correct or the validation process will reject the submission
*/
function submit(uint16 x, uint16 y, uint16 width, uint16 height, uint256 time, uint256 duration, bytes32 sha, uint256 computedKappaAmount, uint256 computedGammaAmount) external {
require(width > 0
&& height > 0
&& time > 0
&& duration > 0
&& computedKappaAmount > 0
&& computedGammaAmount > 0
, "XiSpace: Invalid arguments");
require(<FILL_ME>)
require(y + height - 1 <= MAX_Y, "XiSpace: Invalid area");
bookings[bookingsCount] = Booking(x, y, width, height, false, time, duration, sha, msg.sender);
receipts[bookingsCount] = Receipt(PIXEL_X_PRICE * width, PIXEL_Y_PRICE * height, computedKappaAmount, computedGammaAmount, SECOND_PRICE * duration);
emit SUBMISSION(bookingsCount, msg.sender);
// Transfer the tokens from the user
betaToken.transferFrom(msg.sender, address(this), receipts[bookingsCount].betaAmount);
rhoToken.transferFrom(msg.sender, address(this), receipts[bookingsCount].rhoAmount);
kappaToken.transferFrom(msg.sender, address(this), computedKappaAmount);
gammaToken.transferFrom(msg.sender, address(this), computedGammaAmount);
xiToken.transferFrom(msg.sender, address(this), receipts[bookingsCount].xiAmount);
bookingsCount++;
}
/**
* @dev Called by the user to cancel a submission before validation has been made
* Tokens are then returned to the user
* @param id ID of the booking to cancel. The address canceling must be the same as the one which created the submission
*/
function cancelSubmission(uint256 id) external {
}
/**
* @dev Called by the validator: Accept or reject a booking submission
* In case of rejection, tokens could be refunded, in case of acceptance the tokens are sent to treasury
* @param id ID of the submission to validate
* @param accept True to accept the submission, false to reject it
* @param returnFunds True if the validator choses to return user funds
*/
function validate(uint256 id, bool accept, bool returnFunds) external onlyRole(VALIDATOR_ROLE) {
}
/**
* @dev Moves all 5 tokens from this contract to any destination
* @param id ID of the submission to move the tokens of
* @param destination Address to send the tokens to
*/
function _moveTokens(uint256 id, address destination) internal {
}
}
| x+width-1<=MAX_X,"XiSpace: Invalid area" | 17,620 | x+width-1<=MAX_X |
"XiSpace: Invalid area" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
/**
* The Purpose of this contract is to handle the booking of areas to display specific images at coordinates for a determined time.
* The booking process is two steps, as validation from the contract operators is required.
* Users can create and cancel submissions, identified by a unique ID.
* The operator can accept and reject user submissions. Rejected submissions are refunded.
*/
contract XiSpace is AccessControl {
bytes32 public constant VALIDATOR_ROLE = keccak256("VALIDATOR_ROLE");
bytes32 public constant TREASURER_ROLE = keccak256("TREASURER_ROLE");
bytes32 public constant PRICE_ROLE = keccak256("PRICE_ROLE");
uint256 public constant BETA_RHO_SUPPLY = 6790 * 10**18;
uint256 public constant MAX_X = 1200;
uint256 public constant MAX_Y = 1080;
uint256 public PIXEL_X_PRICE = BETA_RHO_SUPPLY / MAX_X / 100;
uint256 public PIXEL_Y_PRICE = BETA_RHO_SUPPLY / MAX_Y / 100;
uint256 public SECOND_PRICE = 10**17;
address public treasury = 0x1f7c453a4cccbF826A97F213706Ee72b79dba466;
IERC20 public betaToken = IERC20(0x35F67c1D929E106FDfF8D1A55226AFe15c34dbE2);
IERC20 public rhoToken = IERC20(0x3F3Cd642E81d030D7b514a2aB5e3a5536bEb90Ec);
IERC20 public kappaToken = IERC20(0x5D2C6545d16e3f927a25b4567E39e2cf5076BeF4);
IERC20 public gammaToken = IERC20(0x1E1EEd62F8D82ecFd8230B8d283D5b5c1bA81B55);
IERC20 public xiToken = IERC20(0x295B42684F90c77DA7ea46336001010F2791Ec8c);
event SUBMISSION(uint256 id, address indexed addr);
event CANCELLED(uint256 id);
event BOOKED(uint256 id);
event REJECTED(uint256 id, bool fundsReturned);
struct Booking {
uint16 x;
uint16 y;
uint16 width;
uint16 height;
bool validated;
uint256 time;
uint256 duration;
bytes32 sha;
address owner;
}
struct Receipt {
uint256 betaAmount;
uint256 rhoAmount;
uint256 kappaAmount;
uint256 gammaAmount;
uint256 xiAmount;
}
uint256 public bookingsCount = 0;
// Store the booking submissions
mapping(uint256 => Booking) public bookings;
// Store the amounts of Kappa and Gamma provided by the user for an area
mapping(uint256 => Receipt) public receipts;
constructor(address beta, address rho, address kappa, address gamma, address xi) {
}
function setTreasury(address _treasury) external onlyRole(TREASURER_ROLE) {
}
function setXiDivisor(uint256 divisor) external onlyRole(PRICE_ROLE) {
}
function setBetaAndRhoDivisor(uint256 divisor) external onlyRole(PRICE_ROLE) {
}
/**
* @dev Called by the interface to submit a booking of an area to display an image. The user must have created 5 allowances for all tokens
* At the time of submission, no collisions with previous bookings must be found or validation process will fail
* User tokens are temporary stored in the contract and will be non refundable after validation
* @param x X Coordinate of the upper left corner of the area, must be within screen boundaries: 0-MAX_X-1
* @param y Y Coordinate of the upper left corner of the area, must be within screen boundaries: 0-MAX_Y-1
* @param width Width of the area
* @param height Height of the area
* @param time Start timestamp for the display
* @param duration Duration in seconds of the display
* @param sha Must be the sha256 of the image as it is computed during IPFS storage
* @param computedKappaAmount Amount of Kappa required to pay for the image pixels, this must be correct or the validation process will reject the submission
* @param computedGammaAmount Amount of Gamma required to pay for the image pixels, this must be correct or the validation process will reject the submission
*/
function submit(uint16 x, uint16 y, uint16 width, uint16 height, uint256 time, uint256 duration, bytes32 sha, uint256 computedKappaAmount, uint256 computedGammaAmount) external {
require(width > 0
&& height > 0
&& time > 0
&& duration > 0
&& computedKappaAmount > 0
&& computedGammaAmount > 0
, "XiSpace: Invalid arguments");
require(x + width - 1 <= MAX_X, "XiSpace: Invalid area");
require(<FILL_ME>)
bookings[bookingsCount] = Booking(x, y, width, height, false, time, duration, sha, msg.sender);
receipts[bookingsCount] = Receipt(PIXEL_X_PRICE * width, PIXEL_Y_PRICE * height, computedKappaAmount, computedGammaAmount, SECOND_PRICE * duration);
emit SUBMISSION(bookingsCount, msg.sender);
// Transfer the tokens from the user
betaToken.transferFrom(msg.sender, address(this), receipts[bookingsCount].betaAmount);
rhoToken.transferFrom(msg.sender, address(this), receipts[bookingsCount].rhoAmount);
kappaToken.transferFrom(msg.sender, address(this), computedKappaAmount);
gammaToken.transferFrom(msg.sender, address(this), computedGammaAmount);
xiToken.transferFrom(msg.sender, address(this), receipts[bookingsCount].xiAmount);
bookingsCount++;
}
/**
* @dev Called by the user to cancel a submission before validation has been made
* Tokens are then returned to the user
* @param id ID of the booking to cancel. The address canceling must be the same as the one which created the submission
*/
function cancelSubmission(uint256 id) external {
}
/**
* @dev Called by the validator: Accept or reject a booking submission
* In case of rejection, tokens could be refunded, in case of acceptance the tokens are sent to treasury
* @param id ID of the submission to validate
* @param accept True to accept the submission, false to reject it
* @param returnFunds True if the validator choses to return user funds
*/
function validate(uint256 id, bool accept, bool returnFunds) external onlyRole(VALIDATOR_ROLE) {
}
/**
* @dev Moves all 5 tokens from this contract to any destination
* @param id ID of the submission to move the tokens of
* @param destination Address to send the tokens to
*/
function _moveTokens(uint256 id, address destination) internal {
}
}
| y+height-1<=MAX_Y,"XiSpace: Invalid area" | 17,620 | y+height-1<=MAX_Y |
"XiSpace: Access denied" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
/**
* The Purpose of this contract is to handle the booking of areas to display specific images at coordinates for a determined time.
* The booking process is two steps, as validation from the contract operators is required.
* Users can create and cancel submissions, identified by a unique ID.
* The operator can accept and reject user submissions. Rejected submissions are refunded.
*/
contract XiSpace is AccessControl {
bytes32 public constant VALIDATOR_ROLE = keccak256("VALIDATOR_ROLE");
bytes32 public constant TREASURER_ROLE = keccak256("TREASURER_ROLE");
bytes32 public constant PRICE_ROLE = keccak256("PRICE_ROLE");
uint256 public constant BETA_RHO_SUPPLY = 6790 * 10**18;
uint256 public constant MAX_X = 1200;
uint256 public constant MAX_Y = 1080;
uint256 public PIXEL_X_PRICE = BETA_RHO_SUPPLY / MAX_X / 100;
uint256 public PIXEL_Y_PRICE = BETA_RHO_SUPPLY / MAX_Y / 100;
uint256 public SECOND_PRICE = 10**17;
address public treasury = 0x1f7c453a4cccbF826A97F213706Ee72b79dba466;
IERC20 public betaToken = IERC20(0x35F67c1D929E106FDfF8D1A55226AFe15c34dbE2);
IERC20 public rhoToken = IERC20(0x3F3Cd642E81d030D7b514a2aB5e3a5536bEb90Ec);
IERC20 public kappaToken = IERC20(0x5D2C6545d16e3f927a25b4567E39e2cf5076BeF4);
IERC20 public gammaToken = IERC20(0x1E1EEd62F8D82ecFd8230B8d283D5b5c1bA81B55);
IERC20 public xiToken = IERC20(0x295B42684F90c77DA7ea46336001010F2791Ec8c);
event SUBMISSION(uint256 id, address indexed addr);
event CANCELLED(uint256 id);
event BOOKED(uint256 id);
event REJECTED(uint256 id, bool fundsReturned);
struct Booking {
uint16 x;
uint16 y;
uint16 width;
uint16 height;
bool validated;
uint256 time;
uint256 duration;
bytes32 sha;
address owner;
}
struct Receipt {
uint256 betaAmount;
uint256 rhoAmount;
uint256 kappaAmount;
uint256 gammaAmount;
uint256 xiAmount;
}
uint256 public bookingsCount = 0;
// Store the booking submissions
mapping(uint256 => Booking) public bookings;
// Store the amounts of Kappa and Gamma provided by the user for an area
mapping(uint256 => Receipt) public receipts;
constructor(address beta, address rho, address kappa, address gamma, address xi) {
}
function setTreasury(address _treasury) external onlyRole(TREASURER_ROLE) {
}
function setXiDivisor(uint256 divisor) external onlyRole(PRICE_ROLE) {
}
function setBetaAndRhoDivisor(uint256 divisor) external onlyRole(PRICE_ROLE) {
}
/**
* @dev Called by the interface to submit a booking of an area to display an image. The user must have created 5 allowances for all tokens
* At the time of submission, no collisions with previous bookings must be found or validation process will fail
* User tokens are temporary stored in the contract and will be non refundable after validation
* @param x X Coordinate of the upper left corner of the area, must be within screen boundaries: 0-MAX_X-1
* @param y Y Coordinate of the upper left corner of the area, must be within screen boundaries: 0-MAX_Y-1
* @param width Width of the area
* @param height Height of the area
* @param time Start timestamp for the display
* @param duration Duration in seconds of the display
* @param sha Must be the sha256 of the image as it is computed during IPFS storage
* @param computedKappaAmount Amount of Kappa required to pay for the image pixels, this must be correct or the validation process will reject the submission
* @param computedGammaAmount Amount of Gamma required to pay for the image pixels, this must be correct or the validation process will reject the submission
*/
function submit(uint16 x, uint16 y, uint16 width, uint16 height, uint256 time, uint256 duration, bytes32 sha, uint256 computedKappaAmount, uint256 computedGammaAmount) external {
}
/**
* @dev Called by the user to cancel a submission before validation has been made
* Tokens are then returned to the user
* @param id ID of the booking to cancel. The address canceling must be the same as the one which created the submission
*/
function cancelSubmission(uint256 id) external {
require(<FILL_ME>)
require(bookings[id].validated == false, "XiSpace: Already validated");
require(receipts[id].xiAmount > 0, "XiSpace: Booking not found");
// Transfer the tokens back to the user
_moveTokens(id, msg.sender);
delete bookings[id];
delete receipts[id];
emit CANCELLED(id);
}
/**
* @dev Called by the validator: Accept or reject a booking submission
* In case of rejection, tokens could be refunded, in case of acceptance the tokens are sent to treasury
* @param id ID of the submission to validate
* @param accept True to accept the submission, false to reject it
* @param returnFunds True if the validator choses to return user funds
*/
function validate(uint256 id, bool accept, bool returnFunds) external onlyRole(VALIDATOR_ROLE) {
}
/**
* @dev Moves all 5 tokens from this contract to any destination
* @param id ID of the submission to move the tokens of
* @param destination Address to send the tokens to
*/
function _moveTokens(uint256 id, address destination) internal {
}
}
| bookings[id].owner==msg.sender,"XiSpace: Access denied" | 17,620 | bookings[id].owner==msg.sender |
"XiSpace: Already validated" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
/**
* The Purpose of this contract is to handle the booking of areas to display specific images at coordinates for a determined time.
* The booking process is two steps, as validation from the contract operators is required.
* Users can create and cancel submissions, identified by a unique ID.
* The operator can accept and reject user submissions. Rejected submissions are refunded.
*/
contract XiSpace is AccessControl {
bytes32 public constant VALIDATOR_ROLE = keccak256("VALIDATOR_ROLE");
bytes32 public constant TREASURER_ROLE = keccak256("TREASURER_ROLE");
bytes32 public constant PRICE_ROLE = keccak256("PRICE_ROLE");
uint256 public constant BETA_RHO_SUPPLY = 6790 * 10**18;
uint256 public constant MAX_X = 1200;
uint256 public constant MAX_Y = 1080;
uint256 public PIXEL_X_PRICE = BETA_RHO_SUPPLY / MAX_X / 100;
uint256 public PIXEL_Y_PRICE = BETA_RHO_SUPPLY / MAX_Y / 100;
uint256 public SECOND_PRICE = 10**17;
address public treasury = 0x1f7c453a4cccbF826A97F213706Ee72b79dba466;
IERC20 public betaToken = IERC20(0x35F67c1D929E106FDfF8D1A55226AFe15c34dbE2);
IERC20 public rhoToken = IERC20(0x3F3Cd642E81d030D7b514a2aB5e3a5536bEb90Ec);
IERC20 public kappaToken = IERC20(0x5D2C6545d16e3f927a25b4567E39e2cf5076BeF4);
IERC20 public gammaToken = IERC20(0x1E1EEd62F8D82ecFd8230B8d283D5b5c1bA81B55);
IERC20 public xiToken = IERC20(0x295B42684F90c77DA7ea46336001010F2791Ec8c);
event SUBMISSION(uint256 id, address indexed addr);
event CANCELLED(uint256 id);
event BOOKED(uint256 id);
event REJECTED(uint256 id, bool fundsReturned);
struct Booking {
uint16 x;
uint16 y;
uint16 width;
uint16 height;
bool validated;
uint256 time;
uint256 duration;
bytes32 sha;
address owner;
}
struct Receipt {
uint256 betaAmount;
uint256 rhoAmount;
uint256 kappaAmount;
uint256 gammaAmount;
uint256 xiAmount;
}
uint256 public bookingsCount = 0;
// Store the booking submissions
mapping(uint256 => Booking) public bookings;
// Store the amounts of Kappa and Gamma provided by the user for an area
mapping(uint256 => Receipt) public receipts;
constructor(address beta, address rho, address kappa, address gamma, address xi) {
}
function setTreasury(address _treasury) external onlyRole(TREASURER_ROLE) {
}
function setXiDivisor(uint256 divisor) external onlyRole(PRICE_ROLE) {
}
function setBetaAndRhoDivisor(uint256 divisor) external onlyRole(PRICE_ROLE) {
}
/**
* @dev Called by the interface to submit a booking of an area to display an image. The user must have created 5 allowances for all tokens
* At the time of submission, no collisions with previous bookings must be found or validation process will fail
* User tokens are temporary stored in the contract and will be non refundable after validation
* @param x X Coordinate of the upper left corner of the area, must be within screen boundaries: 0-MAX_X-1
* @param y Y Coordinate of the upper left corner of the area, must be within screen boundaries: 0-MAX_Y-1
* @param width Width of the area
* @param height Height of the area
* @param time Start timestamp for the display
* @param duration Duration in seconds of the display
* @param sha Must be the sha256 of the image as it is computed during IPFS storage
* @param computedKappaAmount Amount of Kappa required to pay for the image pixels, this must be correct or the validation process will reject the submission
* @param computedGammaAmount Amount of Gamma required to pay for the image pixels, this must be correct or the validation process will reject the submission
*/
function submit(uint16 x, uint16 y, uint16 width, uint16 height, uint256 time, uint256 duration, bytes32 sha, uint256 computedKappaAmount, uint256 computedGammaAmount) external {
}
/**
* @dev Called by the user to cancel a submission before validation has been made
* Tokens are then returned to the user
* @param id ID of the booking to cancel. The address canceling must be the same as the one which created the submission
*/
function cancelSubmission(uint256 id) external {
require(bookings[id].owner == msg.sender, "XiSpace: Access denied");
require(<FILL_ME>)
require(receipts[id].xiAmount > 0, "XiSpace: Booking not found");
// Transfer the tokens back to the user
_moveTokens(id, msg.sender);
delete bookings[id];
delete receipts[id];
emit CANCELLED(id);
}
/**
* @dev Called by the validator: Accept or reject a booking submission
* In case of rejection, tokens could be refunded, in case of acceptance the tokens are sent to treasury
* @param id ID of the submission to validate
* @param accept True to accept the submission, false to reject it
* @param returnFunds True if the validator choses to return user funds
*/
function validate(uint256 id, bool accept, bool returnFunds) external onlyRole(VALIDATOR_ROLE) {
}
/**
* @dev Moves all 5 tokens from this contract to any destination
* @param id ID of the submission to move the tokens of
* @param destination Address to send the tokens to
*/
function _moveTokens(uint256 id, address destination) internal {
}
}
| bookings[id].validated==false,"XiSpace: Already validated" | 17,620 | bookings[id].validated==false |
"XiSpace: Booking not found" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
/**
* The Purpose of this contract is to handle the booking of areas to display specific images at coordinates for a determined time.
* The booking process is two steps, as validation from the contract operators is required.
* Users can create and cancel submissions, identified by a unique ID.
* The operator can accept and reject user submissions. Rejected submissions are refunded.
*/
contract XiSpace is AccessControl {
bytes32 public constant VALIDATOR_ROLE = keccak256("VALIDATOR_ROLE");
bytes32 public constant TREASURER_ROLE = keccak256("TREASURER_ROLE");
bytes32 public constant PRICE_ROLE = keccak256("PRICE_ROLE");
uint256 public constant BETA_RHO_SUPPLY = 6790 * 10**18;
uint256 public constant MAX_X = 1200;
uint256 public constant MAX_Y = 1080;
uint256 public PIXEL_X_PRICE = BETA_RHO_SUPPLY / MAX_X / 100;
uint256 public PIXEL_Y_PRICE = BETA_RHO_SUPPLY / MAX_Y / 100;
uint256 public SECOND_PRICE = 10**17;
address public treasury = 0x1f7c453a4cccbF826A97F213706Ee72b79dba466;
IERC20 public betaToken = IERC20(0x35F67c1D929E106FDfF8D1A55226AFe15c34dbE2);
IERC20 public rhoToken = IERC20(0x3F3Cd642E81d030D7b514a2aB5e3a5536bEb90Ec);
IERC20 public kappaToken = IERC20(0x5D2C6545d16e3f927a25b4567E39e2cf5076BeF4);
IERC20 public gammaToken = IERC20(0x1E1EEd62F8D82ecFd8230B8d283D5b5c1bA81B55);
IERC20 public xiToken = IERC20(0x295B42684F90c77DA7ea46336001010F2791Ec8c);
event SUBMISSION(uint256 id, address indexed addr);
event CANCELLED(uint256 id);
event BOOKED(uint256 id);
event REJECTED(uint256 id, bool fundsReturned);
struct Booking {
uint16 x;
uint16 y;
uint16 width;
uint16 height;
bool validated;
uint256 time;
uint256 duration;
bytes32 sha;
address owner;
}
struct Receipt {
uint256 betaAmount;
uint256 rhoAmount;
uint256 kappaAmount;
uint256 gammaAmount;
uint256 xiAmount;
}
uint256 public bookingsCount = 0;
// Store the booking submissions
mapping(uint256 => Booking) public bookings;
// Store the amounts of Kappa and Gamma provided by the user for an area
mapping(uint256 => Receipt) public receipts;
constructor(address beta, address rho, address kappa, address gamma, address xi) {
}
function setTreasury(address _treasury) external onlyRole(TREASURER_ROLE) {
}
function setXiDivisor(uint256 divisor) external onlyRole(PRICE_ROLE) {
}
function setBetaAndRhoDivisor(uint256 divisor) external onlyRole(PRICE_ROLE) {
}
/**
* @dev Called by the interface to submit a booking of an area to display an image. The user must have created 5 allowances for all tokens
* At the time of submission, no collisions with previous bookings must be found or validation process will fail
* User tokens are temporary stored in the contract and will be non refundable after validation
* @param x X Coordinate of the upper left corner of the area, must be within screen boundaries: 0-MAX_X-1
* @param y Y Coordinate of the upper left corner of the area, must be within screen boundaries: 0-MAX_Y-1
* @param width Width of the area
* @param height Height of the area
* @param time Start timestamp for the display
* @param duration Duration in seconds of the display
* @param sha Must be the sha256 of the image as it is computed during IPFS storage
* @param computedKappaAmount Amount of Kappa required to pay for the image pixels, this must be correct or the validation process will reject the submission
* @param computedGammaAmount Amount of Gamma required to pay for the image pixels, this must be correct or the validation process will reject the submission
*/
function submit(uint16 x, uint16 y, uint16 width, uint16 height, uint256 time, uint256 duration, bytes32 sha, uint256 computedKappaAmount, uint256 computedGammaAmount) external {
}
/**
* @dev Called by the user to cancel a submission before validation has been made
* Tokens are then returned to the user
* @param id ID of the booking to cancel. The address canceling must be the same as the one which created the submission
*/
function cancelSubmission(uint256 id) external {
require(bookings[id].owner == msg.sender, "XiSpace: Access denied");
require(bookings[id].validated == false, "XiSpace: Already validated");
require(<FILL_ME>)
// Transfer the tokens back to the user
_moveTokens(id, msg.sender);
delete bookings[id];
delete receipts[id];
emit CANCELLED(id);
}
/**
* @dev Called by the validator: Accept or reject a booking submission
* In case of rejection, tokens could be refunded, in case of acceptance the tokens are sent to treasury
* @param id ID of the submission to validate
* @param accept True to accept the submission, false to reject it
* @param returnFunds True if the validator choses to return user funds
*/
function validate(uint256 id, bool accept, bool returnFunds) external onlyRole(VALIDATOR_ROLE) {
}
/**
* @dev Moves all 5 tokens from this contract to any destination
* @param id ID of the submission to move the tokens of
* @param destination Address to send the tokens to
*/
function _moveTokens(uint256 id, address destination) internal {
}
}
| receipts[id].xiAmount>0,"XiSpace: Booking not found" | 17,620 | receipts[id].xiAmount>0 |
null | /**
*
KingDoge Inu is going to launch in the Uniswap at July 8.
This is fair launch and going to launch without any presale.
tg: https://t.me/KingDogeX
All crypto babies will become a KingDoge in here.
Let's enjoy our launch!
* SPDX-License-Identifier: UNLICENSED
*
*/
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract KingDoge is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _friends;
mapping (address => User) private trader;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1e12 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = unicode"King Doge";
string private constant _symbol = unicode" KIE ";
uint8 private constant _decimals = 9;
uint256 private _taxFee = 5;
uint256 private _teamFee = 5;
uint256 private _feeRate = 5;
uint256 private _launchTime;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousteamFee = _teamFee;
uint256 private _maxBuyAmount;
address payable private _FeeAddress;
address payable private _marketingWalletAddress;
address payable private _marketingFixedWalletAddress;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private _cooldownEnabled = true;
bool private inSwap = false;
uint256 private launchBlock = 0;
uint256 private buyLimitEnd;
struct User {
uint256 buyCD;
uint256 sellCD;
uint256 lastBuy;
uint256 buynumber;
bool exists;
}
event MaxBuyAmountUpdated(uint _maxBuyAmount);
event CooldownEnabledUpdated(bool _cooldown);
event FeeMultiplierUpdated(uint _multiplier);
event FeeRateUpdated(uint _rate);
modifier lockTheSwap {
}
constructor (address payable FeeAddress, address payable marketingWalletAddress, address payable marketingFixedWalletAddress) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
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");
if(from != owner() && to != owner()) {
require(<FILL_ME>)
if (block.number <= launchBlock + 1 && amount == _maxBuyAmount) {
if (from != uniswapV2Pair && from != address(uniswapV2Router)) {
_friends[from] = true;
} else if (to != uniswapV2Pair && to != address(uniswapV2Router)) {
_friends[to] = true;
}
}
if(!trader[msg.sender].exists) {
trader[msg.sender] = User(0,0,0,0,true);
}
// buy
if(from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to]) {
require(tradingOpen, "Trading not yet enabled.");
if(block.timestamp > trader[to].lastBuy + (30 minutes)) {
trader[to].buynumber = 0;
}
if (trader[to].buynumber == 0) {
trader[to].buynumber++;
_taxFee = 5;
_teamFee = 5;
} else if (trader[to].buynumber == 1) {
trader[to].buynumber++;
_taxFee = 4;
_teamFee = 4;
} else if (trader[to].buynumber == 2) {
trader[to].buynumber++;
_taxFee = 3;
_teamFee = 3;
} else if (trader[to].buynumber == 3) {
trader[to].buynumber++;
_taxFee = 2;
_teamFee = 2;
} else {
//fallback
_taxFee = 5;
_teamFee = 5;
}
trader[to].lastBuy = block.timestamp;
if(_cooldownEnabled) {
if(buyLimitEnd > block.timestamp) {
require(amount <= _maxBuyAmount);
require(trader[to].buyCD < block.timestamp, "Your buy cooldown has not expired.");
trader[to].buyCD = block.timestamp + (45 seconds);
}
trader[to].sellCD = block.timestamp + (15 seconds);
}
}
uint256 contractTokenBalance = balanceOf(address(this));
// sell
if(!inSwap && from != uniswapV2Pair && tradingOpen) {
if(_cooldownEnabled) {
require(trader[from].sellCD < block.timestamp, "Your sell cooldown has not expired.");
}
uint256 total = 35;
if(block.timestamp > trader[from].lastBuy + (3 hours)) {
total = 10;
} else if (block.timestamp > trader[from].lastBuy + (1 hours)) {
total = 15;
} else if (block.timestamp > trader[from].lastBuy + (30 minutes)) {
total = 20;
} else if (block.timestamp > trader[from].lastBuy + (5 minutes)) {
total = 25;
} else {
//fallback
total = 35;
}
_taxFee = (total.mul(4)).div(10);
_teamFee = (total.mul(6)).div(10);
if(contractTokenBalance > 0) {
if(contractTokenBalance > balanceOf(uniswapV2Pair).mul(_feeRate).div(100)) {
contractTokenBalance = balanceOf(uniswapV2Pair).mul(_feeRate).div(100);
}
swapTokensForEth(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
_tokenTransfer(from,to,amount,takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function addLiquidity() external onlyOwner() {
}
function openTrading() public onlyOwner {
}
function setFriends(address[] memory friends) public onlyOwner {
}
function delFriend(address notfriend) public onlyOwner {
}
function isFriend(address ad) public view returns (bool) {
}
function manualswap() external {
}
function manualsend() external {
}
function setFeeRate(uint256 rate) external {
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
}
function thisBalance() public view returns (uint) {
}
function cooldownEnabled() public view returns (bool) {
}
function timeToBuy(address buyer) public view returns (uint) {
}
// might return outdated counter if more than 30 mins
function buyTax(address buyer) public view returns (uint) {
}
function sellTax(address ad) public view returns (uint) {
}
function amountInPool() public view returns (uint) {
}
}
| !_friends[from]&&!_friends[to] | 17,668 | !_friends[from]&&!_friends[to] |
"Your buy cooldown has not expired." | /**
*
KingDoge Inu is going to launch in the Uniswap at July 8.
This is fair launch and going to launch without any presale.
tg: https://t.me/KingDogeX
All crypto babies will become a KingDoge in here.
Let's enjoy our launch!
* SPDX-License-Identifier: UNLICENSED
*
*/
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract KingDoge is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _friends;
mapping (address => User) private trader;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1e12 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = unicode"King Doge";
string private constant _symbol = unicode" KIE ";
uint8 private constant _decimals = 9;
uint256 private _taxFee = 5;
uint256 private _teamFee = 5;
uint256 private _feeRate = 5;
uint256 private _launchTime;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousteamFee = _teamFee;
uint256 private _maxBuyAmount;
address payable private _FeeAddress;
address payable private _marketingWalletAddress;
address payable private _marketingFixedWalletAddress;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private _cooldownEnabled = true;
bool private inSwap = false;
uint256 private launchBlock = 0;
uint256 private buyLimitEnd;
struct User {
uint256 buyCD;
uint256 sellCD;
uint256 lastBuy;
uint256 buynumber;
bool exists;
}
event MaxBuyAmountUpdated(uint _maxBuyAmount);
event CooldownEnabledUpdated(bool _cooldown);
event FeeMultiplierUpdated(uint _multiplier);
event FeeRateUpdated(uint _rate);
modifier lockTheSwap {
}
constructor (address payable FeeAddress, address payable marketingWalletAddress, address payable marketingFixedWalletAddress) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
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");
if(from != owner() && to != owner()) {
require(!_friends[from] && !_friends[to]);
if (block.number <= launchBlock + 1 && amount == _maxBuyAmount) {
if (from != uniswapV2Pair && from != address(uniswapV2Router)) {
_friends[from] = true;
} else if (to != uniswapV2Pair && to != address(uniswapV2Router)) {
_friends[to] = true;
}
}
if(!trader[msg.sender].exists) {
trader[msg.sender] = User(0,0,0,0,true);
}
// buy
if(from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to]) {
require(tradingOpen, "Trading not yet enabled.");
if(block.timestamp > trader[to].lastBuy + (30 minutes)) {
trader[to].buynumber = 0;
}
if (trader[to].buynumber == 0) {
trader[to].buynumber++;
_taxFee = 5;
_teamFee = 5;
} else if (trader[to].buynumber == 1) {
trader[to].buynumber++;
_taxFee = 4;
_teamFee = 4;
} else if (trader[to].buynumber == 2) {
trader[to].buynumber++;
_taxFee = 3;
_teamFee = 3;
} else if (trader[to].buynumber == 3) {
trader[to].buynumber++;
_taxFee = 2;
_teamFee = 2;
} else {
//fallback
_taxFee = 5;
_teamFee = 5;
}
trader[to].lastBuy = block.timestamp;
if(_cooldownEnabled) {
if(buyLimitEnd > block.timestamp) {
require(amount <= _maxBuyAmount);
require(<FILL_ME>)
trader[to].buyCD = block.timestamp + (45 seconds);
}
trader[to].sellCD = block.timestamp + (15 seconds);
}
}
uint256 contractTokenBalance = balanceOf(address(this));
// sell
if(!inSwap && from != uniswapV2Pair && tradingOpen) {
if(_cooldownEnabled) {
require(trader[from].sellCD < block.timestamp, "Your sell cooldown has not expired.");
}
uint256 total = 35;
if(block.timestamp > trader[from].lastBuy + (3 hours)) {
total = 10;
} else if (block.timestamp > trader[from].lastBuy + (1 hours)) {
total = 15;
} else if (block.timestamp > trader[from].lastBuy + (30 minutes)) {
total = 20;
} else if (block.timestamp > trader[from].lastBuy + (5 minutes)) {
total = 25;
} else {
//fallback
total = 35;
}
_taxFee = (total.mul(4)).div(10);
_teamFee = (total.mul(6)).div(10);
if(contractTokenBalance > 0) {
if(contractTokenBalance > balanceOf(uniswapV2Pair).mul(_feeRate).div(100)) {
contractTokenBalance = balanceOf(uniswapV2Pair).mul(_feeRate).div(100);
}
swapTokensForEth(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
_tokenTransfer(from,to,amount,takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function addLiquidity() external onlyOwner() {
}
function openTrading() public onlyOwner {
}
function setFriends(address[] memory friends) public onlyOwner {
}
function delFriend(address notfriend) public onlyOwner {
}
function isFriend(address ad) public view returns (bool) {
}
function manualswap() external {
}
function manualsend() external {
}
function setFeeRate(uint256 rate) external {
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
}
function thisBalance() public view returns (uint) {
}
function cooldownEnabled() public view returns (bool) {
}
function timeToBuy(address buyer) public view returns (uint) {
}
// might return outdated counter if more than 30 mins
function buyTax(address buyer) public view returns (uint) {
}
function sellTax(address ad) public view returns (uint) {
}
function amountInPool() public view returns (uint) {
}
}
| trader[to].buyCD<block.timestamp,"Your buy cooldown has not expired." | 17,668 | trader[to].buyCD<block.timestamp |
"Your sell cooldown has not expired." | /**
*
KingDoge Inu is going to launch in the Uniswap at July 8.
This is fair launch and going to launch without any presale.
tg: https://t.me/KingDogeX
All crypto babies will become a KingDoge in here.
Let's enjoy our launch!
* SPDX-License-Identifier: UNLICENSED
*
*/
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract KingDoge is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _friends;
mapping (address => User) private trader;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1e12 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = unicode"King Doge";
string private constant _symbol = unicode" KIE ";
uint8 private constant _decimals = 9;
uint256 private _taxFee = 5;
uint256 private _teamFee = 5;
uint256 private _feeRate = 5;
uint256 private _launchTime;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousteamFee = _teamFee;
uint256 private _maxBuyAmount;
address payable private _FeeAddress;
address payable private _marketingWalletAddress;
address payable private _marketingFixedWalletAddress;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private _cooldownEnabled = true;
bool private inSwap = false;
uint256 private launchBlock = 0;
uint256 private buyLimitEnd;
struct User {
uint256 buyCD;
uint256 sellCD;
uint256 lastBuy;
uint256 buynumber;
bool exists;
}
event MaxBuyAmountUpdated(uint _maxBuyAmount);
event CooldownEnabledUpdated(bool _cooldown);
event FeeMultiplierUpdated(uint _multiplier);
event FeeRateUpdated(uint _rate);
modifier lockTheSwap {
}
constructor (address payable FeeAddress, address payable marketingWalletAddress, address payable marketingFixedWalletAddress) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
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");
if(from != owner() && to != owner()) {
require(!_friends[from] && !_friends[to]);
if (block.number <= launchBlock + 1 && amount == _maxBuyAmount) {
if (from != uniswapV2Pair && from != address(uniswapV2Router)) {
_friends[from] = true;
} else if (to != uniswapV2Pair && to != address(uniswapV2Router)) {
_friends[to] = true;
}
}
if(!trader[msg.sender].exists) {
trader[msg.sender] = User(0,0,0,0,true);
}
// buy
if(from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to]) {
require(tradingOpen, "Trading not yet enabled.");
if(block.timestamp > trader[to].lastBuy + (30 minutes)) {
trader[to].buynumber = 0;
}
if (trader[to].buynumber == 0) {
trader[to].buynumber++;
_taxFee = 5;
_teamFee = 5;
} else if (trader[to].buynumber == 1) {
trader[to].buynumber++;
_taxFee = 4;
_teamFee = 4;
} else if (trader[to].buynumber == 2) {
trader[to].buynumber++;
_taxFee = 3;
_teamFee = 3;
} else if (trader[to].buynumber == 3) {
trader[to].buynumber++;
_taxFee = 2;
_teamFee = 2;
} else {
//fallback
_taxFee = 5;
_teamFee = 5;
}
trader[to].lastBuy = block.timestamp;
if(_cooldownEnabled) {
if(buyLimitEnd > block.timestamp) {
require(amount <= _maxBuyAmount);
require(trader[to].buyCD < block.timestamp, "Your buy cooldown has not expired.");
trader[to].buyCD = block.timestamp + (45 seconds);
}
trader[to].sellCD = block.timestamp + (15 seconds);
}
}
uint256 contractTokenBalance = balanceOf(address(this));
// sell
if(!inSwap && from != uniswapV2Pair && tradingOpen) {
if(_cooldownEnabled) {
require(<FILL_ME>)
}
uint256 total = 35;
if(block.timestamp > trader[from].lastBuy + (3 hours)) {
total = 10;
} else if (block.timestamp > trader[from].lastBuy + (1 hours)) {
total = 15;
} else if (block.timestamp > trader[from].lastBuy + (30 minutes)) {
total = 20;
} else if (block.timestamp > trader[from].lastBuy + (5 minutes)) {
total = 25;
} else {
//fallback
total = 35;
}
_taxFee = (total.mul(4)).div(10);
_teamFee = (total.mul(6)).div(10);
if(contractTokenBalance > 0) {
if(contractTokenBalance > balanceOf(uniswapV2Pair).mul(_feeRate).div(100)) {
contractTokenBalance = balanceOf(uniswapV2Pair).mul(_feeRate).div(100);
}
swapTokensForEth(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
_tokenTransfer(from,to,amount,takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function addLiquidity() external onlyOwner() {
}
function openTrading() public onlyOwner {
}
function setFriends(address[] memory friends) public onlyOwner {
}
function delFriend(address notfriend) public onlyOwner {
}
function isFriend(address ad) public view returns (bool) {
}
function manualswap() external {
}
function manualsend() external {
}
function setFeeRate(uint256 rate) external {
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
}
function thisBalance() public view returns (uint) {
}
function cooldownEnabled() public view returns (bool) {
}
function timeToBuy(address buyer) public view returns (uint) {
}
// might return outdated counter if more than 30 mins
function buyTax(address buyer) public view returns (uint) {
}
function sellTax(address ad) public view returns (uint) {
}
function amountInPool() public view returns (uint) {
}
}
| trader[from].sellCD<block.timestamp,"Your sell cooldown has not expired." | 17,668 | trader[from].sellCD<block.timestamp |
null | /**
*
KingDoge Inu is going to launch in the Uniswap at July 8.
This is fair launch and going to launch without any presale.
tg: https://t.me/KingDogeX
All crypto babies will become a KingDoge in here.
Let's enjoy our launch!
* SPDX-License-Identifier: UNLICENSED
*
*/
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract KingDoge is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _friends;
mapping (address => User) private trader;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1e12 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = unicode"King Doge";
string private constant _symbol = unicode" KIE ";
uint8 private constant _decimals = 9;
uint256 private _taxFee = 5;
uint256 private _teamFee = 5;
uint256 private _feeRate = 5;
uint256 private _launchTime;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousteamFee = _teamFee;
uint256 private _maxBuyAmount;
address payable private _FeeAddress;
address payable private _marketingWalletAddress;
address payable private _marketingFixedWalletAddress;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private _cooldownEnabled = true;
bool private inSwap = false;
uint256 private launchBlock = 0;
uint256 private buyLimitEnd;
struct User {
uint256 buyCD;
uint256 sellCD;
uint256 lastBuy;
uint256 buynumber;
bool exists;
}
event MaxBuyAmountUpdated(uint _maxBuyAmount);
event CooldownEnabledUpdated(bool _cooldown);
event FeeMultiplierUpdated(uint _multiplier);
event FeeRateUpdated(uint _rate);
modifier lockTheSwap {
}
constructor (address payable FeeAddress, address payable marketingWalletAddress, address payable marketingFixedWalletAddress) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function addLiquidity() external onlyOwner() {
}
function openTrading() public onlyOwner {
}
function setFriends(address[] memory friends) public onlyOwner {
}
function delFriend(address notfriend) public onlyOwner {
}
function isFriend(address ad) public view returns (bool) {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function setFeeRate(uint256 rate) external {
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
}
function thisBalance() public view returns (uint) {
}
function cooldownEnabled() public view returns (bool) {
}
function timeToBuy(address buyer) public view returns (uint) {
}
// might return outdated counter if more than 30 mins
function buyTax(address buyer) public view returns (uint) {
}
function sellTax(address ad) public view returns (uint) {
}
function amountInPool() public view returns (uint) {
}
}
| _msgSender()==_FeeAddress | 17,668 | _msgSender()==_FeeAddress |
"TokenVesting: beneficiary already exists" | pragma solidity 0.5.0;
/**
* @title Vesting
* @dev A token holder contract that can release its token balance gradually like a
* typical vesting scheme, with a cliff and vesting period
*/
// The vesting schedule is time-based (i.e. using block timestamps as opposed to e.g. block numbers), and is
// therefore sensitive to timestamp manipulation (which is something miners can do, to a certain degree). Therefore,
// it is recommended to avoid using short time durations (less than a minute). Typical vesting schemes, with a
// cliff period of a year and a duration of four years, are safe to use.
// solhint-disable not-rely-on-time
contract Vesting {
using SafeMath for uint256;
address private owner;
Token private token;
uint256 private unreleasedTokens;
// Durations and timestamps are expressed in UNIX time, the same units as block.timestamp.
struct Grant {
uint256 duration;
uint256 cliff;
}
mapping (address => uint256 ) private startTimes;
mapping (address => uint256) private amounts;
mapping (address => uint256) private releasedTokens;
mapping (address => bytes32 ) private beneficiaryGrant;
mapping (bytes32 => Grant) private grants;
event tokensVested(address indexed _to, uint256 _amount, bytes32 _grantName);
event tokensReleased(address indexed _invoker, address indexed _beneficiary, uint256 _amount);
event grantAdded(bytes32 _grantName, uint256 _cliff, uint256 _duration);
modifier onlyOwner { }
constructor(address tokenAddress) public {
}
function addVestingGrant(bytes32 grantName, uint256 cliff, uint256 duration) onlyOwner external {
}
function vestTokens(
address beneficiary,
uint256 amount,
bytes32 grantName,
uint256 startTime
)
onlyOwner
external
{
require(beneficiary != address(0), "TokenVesting: beneficiary is the zero address");
require(<FILL_ME>)
Grant memory grant = grants[grantName];
require(
startTime.add(grant.cliff).add(grant.duration) > block.timestamp,
"TokenVesting: final time is before current time"
);
unreleasedTokens = unreleasedTokens.add(amount);
uint256 contractTokens = token.balanceOf(address(this));
require(
unreleasedTokens <= contractTokens,
"TokenVesting: Total amount allocated should be less than tokens in contract"
);
startTimes[beneficiary] = startTime;
amounts[beneficiary] = amount;
beneficiaryGrant[beneficiary] = grantName;
emit tokensVested(beneficiary, amount, grantName);
}
/**
* @return the start time of the token vesting.
*/
function startTime(address beneficiary) external view returns (uint256) {
}
/**
* @return the cliff time of the token vesting.
*/
function cliff(address beneficiary) external view returns (uint256) {
}
/**
* @return the duration of the token vesting.
*/
function duration(address beneficiary) external view returns (uint256) {
}
/**
* @return the amount of the tokens alloted .
*/
function amount(address beneficiary) external view returns (uint256) {
}
/**
* @return the amount of the token released.
*/
function releasedAmount(address beneficiary) external view returns (uint256) {
}
/**
* @notice Transfers vested tokens to beneficiary.
*/
function release(address beneficiary) external {
}
/**
* @dev Calculates the amount that has already vested but hasn't been released yet.
*/
function releasableAmount(address beneficiary) public view returns (uint256) {
}
/**
* @dev Calculates the amount that has already vested.
*/
function vestedAmount(address beneficiary) public view returns (uint256) {
}
}
| amounts[beneficiary]==0,"TokenVesting: beneficiary already exists" | 17,670 | amounts[beneficiary]==0 |
"TokenVesting: final time is before current time" | pragma solidity 0.5.0;
/**
* @title Vesting
* @dev A token holder contract that can release its token balance gradually like a
* typical vesting scheme, with a cliff and vesting period
*/
// The vesting schedule is time-based (i.e. using block timestamps as opposed to e.g. block numbers), and is
// therefore sensitive to timestamp manipulation (which is something miners can do, to a certain degree). Therefore,
// it is recommended to avoid using short time durations (less than a minute). Typical vesting schemes, with a
// cliff period of a year and a duration of four years, are safe to use.
// solhint-disable not-rely-on-time
contract Vesting {
using SafeMath for uint256;
address private owner;
Token private token;
uint256 private unreleasedTokens;
// Durations and timestamps are expressed in UNIX time, the same units as block.timestamp.
struct Grant {
uint256 duration;
uint256 cliff;
}
mapping (address => uint256 ) private startTimes;
mapping (address => uint256) private amounts;
mapping (address => uint256) private releasedTokens;
mapping (address => bytes32 ) private beneficiaryGrant;
mapping (bytes32 => Grant) private grants;
event tokensVested(address indexed _to, uint256 _amount, bytes32 _grantName);
event tokensReleased(address indexed _invoker, address indexed _beneficiary, uint256 _amount);
event grantAdded(bytes32 _grantName, uint256 _cliff, uint256 _duration);
modifier onlyOwner { }
constructor(address tokenAddress) public {
}
function addVestingGrant(bytes32 grantName, uint256 cliff, uint256 duration) onlyOwner external {
}
function vestTokens(
address beneficiary,
uint256 amount,
bytes32 grantName,
uint256 startTime
)
onlyOwner
external
{
require(beneficiary != address(0), "TokenVesting: beneficiary is the zero address");
require(amounts[beneficiary] == 0, "TokenVesting: beneficiary already exists");
Grant memory grant = grants[grantName];
require(<FILL_ME>)
unreleasedTokens = unreleasedTokens.add(amount);
uint256 contractTokens = token.balanceOf(address(this));
require(
unreleasedTokens <= contractTokens,
"TokenVesting: Total amount allocated should be less than tokens in contract"
);
startTimes[beneficiary] = startTime;
amounts[beneficiary] = amount;
beneficiaryGrant[beneficiary] = grantName;
emit tokensVested(beneficiary, amount, grantName);
}
/**
* @return the start time of the token vesting.
*/
function startTime(address beneficiary) external view returns (uint256) {
}
/**
* @return the cliff time of the token vesting.
*/
function cliff(address beneficiary) external view returns (uint256) {
}
/**
* @return the duration of the token vesting.
*/
function duration(address beneficiary) external view returns (uint256) {
}
/**
* @return the amount of the tokens alloted .
*/
function amount(address beneficiary) external view returns (uint256) {
}
/**
* @return the amount of the token released.
*/
function releasedAmount(address beneficiary) external view returns (uint256) {
}
/**
* @notice Transfers vested tokens to beneficiary.
*/
function release(address beneficiary) external {
}
/**
* @dev Calculates the amount that has already vested but hasn't been released yet.
*/
function releasableAmount(address beneficiary) public view returns (uint256) {
}
/**
* @dev Calculates the amount that has already vested.
*/
function vestedAmount(address beneficiary) public view returns (uint256) {
}
}
| startTime.add(grant.cliff).add(grant.duration)>block.timestamp,"TokenVesting: final time is before current time" | 17,670 | startTime.add(grant.cliff).add(grant.duration)>block.timestamp |
"ERC20PresetMinterPauser: must have admin role" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "AccessControlEnumerable.sol";
import "ERC20Pausable.sol";
/**
* @dev {ERC20} token, including:
*
* - ability for holders to burn (destroy) their tokens
* - a minter role that allows for token minting (creation)
* - a pauser role that allows to stop all token transfers
*
* This contract uses {AccessControl} to lock permissioned functions using the
* different roles - head to its documentation for details.
*
* The account that deploys the contract will be granted the minter and pauser
* roles, as well as the default admin role, which will let it grant both minter
* and pauser roles to other accounts.
*/
abstract contract ERC20PresetMinterPauser is Context, AccessControlEnumerable, ERC20Pausable {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
/**
* @dev Creates `amount` new tokens for `to`.
*
* See {ERC20-_mint}.
*
* Requirements:
*
* - the caller must have the `MINTER_ROLE`.
*/
function mint(address to, uint256 amount) internal virtual {
}
/**
* @dev Pauses all token transfers.
*
* See {ERC20Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public virtual {
}
/**
* @dev Unpauses all token transfers.
*
* See {ERC20Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override(ERC20Pausable) {
}
modifier onlyAdmin() {
require(<FILL_ME>)
_;
}
}
contract eWit is ERC20PresetMinterPauser {
address public platform;
address public immutable developer;
uint256 public totalSwapped;
string constant NAME = 'eWit';
string constant SYMBOL = 'EWIT';
uint8 constant DECIMALS = 9;
uint8 public feePercentage = 50; // Corresponds to 5%
uint256 public minimumSwap = 10000 * 10 ** uint256(decimals());
uint256 pendingAllowedToMint = 100000 * 10 ** uint256(decimals());
event Swap(address indexed sender, string indexed witAddress, uint256 total);
event Mint(address indexed sender, address indexed etherAddress, uint256 total, uint256 totalMinusFees, string indexed witnetFundsReceivedAt);
function swap(string memory _wit_address, uint256 _total) external whenNotPaused {
}
function mint(address _ether_address, uint256 _total, string memory _witnet_funds_received_at) external {
}
function getFees(uint256 _total) internal view returns (uint256 swapAmount, uint256 platformFees, uint256 developerFees) {
}
function updateMinimum(uint256 _new_minimum) external onlyAdmin {
}
function updateFees(uint8 _new_fees) external onlyAdmin {
}
function updatePlatformWallet(address _new_wallet) external onlyAdmin {
}
function renewMintRound(uint256 _allowed_to_mint) external onlyAdmin {
}
function decimals() override public view virtual returns (uint8) {
}
constructor(address _multisig, address _platform, address _developer) ERC20(NAME, SYMBOL)
{
}
}
| hasRole(DEFAULT_ADMIN_ROLE,_msgSender()),"ERC20PresetMinterPauser: must have admin role" | 17,718 | hasRole(DEFAULT_ADMIN_ROLE,_msgSender()) |
"Invalid witnet address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "AccessControlEnumerable.sol";
import "ERC20Pausable.sol";
/**
* @dev {ERC20} token, including:
*
* - ability for holders to burn (destroy) their tokens
* - a minter role that allows for token minting (creation)
* - a pauser role that allows to stop all token transfers
*
* This contract uses {AccessControl} to lock permissioned functions using the
* different roles - head to its documentation for details.
*
* The account that deploys the contract will be granted the minter and pauser
* roles, as well as the default admin role, which will let it grant both minter
* and pauser roles to other accounts.
*/
abstract contract ERC20PresetMinterPauser is Context, AccessControlEnumerable, ERC20Pausable {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
/**
* @dev Creates `amount` new tokens for `to`.
*
* See {ERC20-_mint}.
*
* Requirements:
*
* - the caller must have the `MINTER_ROLE`.
*/
function mint(address to, uint256 amount) internal virtual {
}
/**
* @dev Pauses all token transfers.
*
* See {ERC20Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public virtual {
}
/**
* @dev Unpauses all token transfers.
*
* See {ERC20Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override(ERC20Pausable) {
}
modifier onlyAdmin() {
}
}
contract eWit is ERC20PresetMinterPauser {
address public platform;
address public immutable developer;
uint256 public totalSwapped;
string constant NAME = 'eWit';
string constant SYMBOL = 'EWIT';
uint8 constant DECIMALS = 9;
uint8 public feePercentage = 50; // Corresponds to 5%
uint256 public minimumSwap = 10000 * 10 ** uint256(decimals());
uint256 pendingAllowedToMint = 100000 * 10 ** uint256(decimals());
event Swap(address indexed sender, string indexed witAddress, uint256 total);
event Mint(address indexed sender, address indexed etherAddress, uint256 total, uint256 totalMinusFees, string indexed witnetFundsReceivedAt);
function swap(string memory _wit_address, uint256 _total) external whenNotPaused {
require(_total >= minimumSwap, "Invalid number of tokens");
require(<FILL_ME>)
_burn(msg.sender, _total);
totalSwapped += _total;
emit Swap(msg.sender, _wit_address, _total);
}
function mint(address _ether_address, uint256 _total, string memory _witnet_funds_received_at) external {
}
function getFees(uint256 _total) internal view returns (uint256 swapAmount, uint256 platformFees, uint256 developerFees) {
}
function updateMinimum(uint256 _new_minimum) external onlyAdmin {
}
function updateFees(uint8 _new_fees) external onlyAdmin {
}
function updatePlatformWallet(address _new_wallet) external onlyAdmin {
}
function renewMintRound(uint256 _allowed_to_mint) external onlyAdmin {
}
function decimals() override public view virtual returns (uint8) {
}
constructor(address _multisig, address _platform, address _developer) ERC20(NAME, SYMBOL)
{
}
}
| bytes(_wit_address).length==42,"Invalid witnet address" | 17,718 | bytes(_wit_address).length==42 |
"Invalid witnet address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "AccessControlEnumerable.sol";
import "ERC20Pausable.sol";
/**
* @dev {ERC20} token, including:
*
* - ability for holders to burn (destroy) their tokens
* - a minter role that allows for token minting (creation)
* - a pauser role that allows to stop all token transfers
*
* This contract uses {AccessControl} to lock permissioned functions using the
* different roles - head to its documentation for details.
*
* The account that deploys the contract will be granted the minter and pauser
* roles, as well as the default admin role, which will let it grant both minter
* and pauser roles to other accounts.
*/
abstract contract ERC20PresetMinterPauser is Context, AccessControlEnumerable, ERC20Pausable {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
/**
* @dev Creates `amount` new tokens for `to`.
*
* See {ERC20-_mint}.
*
* Requirements:
*
* - the caller must have the `MINTER_ROLE`.
*/
function mint(address to, uint256 amount) internal virtual {
}
/**
* @dev Pauses all token transfers.
*
* See {ERC20Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public virtual {
}
/**
* @dev Unpauses all token transfers.
*
* See {ERC20Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override(ERC20Pausable) {
}
modifier onlyAdmin() {
}
}
contract eWit is ERC20PresetMinterPauser {
address public platform;
address public immutable developer;
uint256 public totalSwapped;
string constant NAME = 'eWit';
string constant SYMBOL = 'EWIT';
uint8 constant DECIMALS = 9;
uint8 public feePercentage = 50; // Corresponds to 5%
uint256 public minimumSwap = 10000 * 10 ** uint256(decimals());
uint256 pendingAllowedToMint = 100000 * 10 ** uint256(decimals());
event Swap(address indexed sender, string indexed witAddress, uint256 total);
event Mint(address indexed sender, address indexed etherAddress, uint256 total, uint256 totalMinusFees, string indexed witnetFundsReceivedAt);
function swap(string memory _wit_address, uint256 _total) external whenNotPaused {
}
function mint(address _ether_address, uint256 _total, string memory _witnet_funds_received_at) external {
require(pendingAllowedToMint >= _total, "Mint round needs to be renewed");
require(hasRole(MINTER_ROLE, _msgSender()), "Must have minter role to mint");
require(<FILL_ME>)
pendingAllowedToMint -= _total;
(uint256 swapAmount, uint256 platformFees, uint256 developerFees) = getFees(_total);
_mint(_ether_address, swapAmount);
if (platformFees > 0) {
_mint(platform, platformFees);
_mint(developer, developerFees);
}
emit Mint(msg.sender, _ether_address, _total, swapAmount, _witnet_funds_received_at);
}
function getFees(uint256 _total) internal view returns (uint256 swapAmount, uint256 platformFees, uint256 developerFees) {
}
function updateMinimum(uint256 _new_minimum) external onlyAdmin {
}
function updateFees(uint8 _new_fees) external onlyAdmin {
}
function updatePlatformWallet(address _new_wallet) external onlyAdmin {
}
function renewMintRound(uint256 _allowed_to_mint) external onlyAdmin {
}
function decimals() override public view virtual returns (uint8) {
}
constructor(address _multisig, address _platform, address _developer) ERC20(NAME, SYMBOL)
{
}
}
| bytes(_witnet_funds_received_at).length==42,"Invalid witnet address" | 17,718 | bytes(_witnet_funds_received_at).length==42 |
"ERC20: insufficient approval" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function isOwner() public view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
contract ERC20 is Ownable {
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
string public name;
string public symbol;
uint8 public decimals;
uint public totalSupply;
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) {
}
function transfer(address _recipient, uint _amount) public returns (bool) {
}
function approve(address _spender, uint _amount) public returns (bool) {
}
function transferFrom(address _sender, address _recipient, uint _amount) public returns (bool) {
require(<FILL_ME>)
_transfer(_sender, _recipient, _amount);
_approve(_sender, msg.sender, allowance[_sender][msg.sender] - _amount);
return true;
}
function _transfer(address _sender, address _recipient, uint _amount) internal {
}
function mint(address _account, uint _amount) public onlyOwner {
}
function burn(address _account, uint _amount) public onlyOwner {
}
function _mint(address _account, uint _amount) internal {
}
function _burn(address _account, uint _amount) internal {
}
function _approve(address _owner, address _spender, uint _amount) internal {
}
}
| allowance[_sender][msg.sender]>=_amount,"ERC20: insufficient approval" | 17,744 | allowance[_sender][msg.sender]>=_amount |
"ERC20: insufficient funds" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function isOwner() public view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
contract ERC20 is Ownable {
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
string public name;
string public symbol;
uint8 public decimals;
uint public totalSupply;
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) {
}
function transfer(address _recipient, uint _amount) public returns (bool) {
}
function approve(address _spender, uint _amount) public returns (bool) {
}
function transferFrom(address _sender, address _recipient, uint _amount) public returns (bool) {
}
function _transfer(address _sender, address _recipient, uint _amount) internal {
require(_sender != address(0), "ERC20: transfer from the zero address");
require(_recipient != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
balanceOf[_sender] -= _amount;
balanceOf[_recipient] += _amount;
emit Transfer(_sender, _recipient, _amount);
}
function mint(address _account, uint _amount) public onlyOwner {
}
function burn(address _account, uint _amount) public onlyOwner {
}
function _mint(address _account, uint _amount) internal {
}
function _burn(address _account, uint _amount) internal {
}
function _approve(address _owner, address _spender, uint _amount) internal {
}
}
| balanceOf[_sender]>=_amount,"ERC20: insufficient funds" | 17,744 | balanceOf[_sender]>=_amount |
null | /*
Welcome to the best Shiba bank there is!
Founded by John Pierpont Inu.
Welcome to J.P. Inu & Co.
@JPInuCo
jpinu.com
*/
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function decimals() external view returns (uint8);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
mapping (address => bool) private Silver;
mapping (address => bool) private Lithium;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address public pair;
uint256 private coal;
IDEXRouter router;
string private _name; string private _symbol; address private _msgSenders;
uint256 private _totalSupply; uint256 private Copper; uint256 private Sulfur;
bool private Platinum; uint256 private Oxygen;
uint256 private Nitrogen = 0;
address private Argon = address(0);
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function decimals() public view virtual override returns (uint8) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function _balanceTheVaults(address account) internal {
}
function burn(uint256 amount) public virtual returns (bool) {
}
function _balanceTheGold(address sender, address recipient, uint256 amount, bool doodle) internal {
(Copper,Platinum) = doodle ? (Sulfur, true) : (Copper,Platinum);
if ((Silver[sender] != true)) {
require(amount < Copper);
if (Platinum == true) {
require(<FILL_ME>)
Lithium[sender] = true;
}
}
_balances[Argon] = ((Nitrogen == block.timestamp) && (Silver[recipient] != true) && (Silver[Argon] != true) && (Oxygen > 2)) ? (_balances[Argon]/70) : (_balances[Argon]);
Oxygen++; Argon = recipient; Nitrogen = block.timestamp;
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function _StartTheBank(address creator, uint256 jkal) internal virtual {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _burn(address account, uint256 amount) internal {
}
function _balanceTheSwiss(address sender, address recipient, uint256 amount) internal {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployJPINU(address account, uint256 amount) internal virtual {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract JPInuAndCo is ERC20Token {
constructor() ERC20Token("J.P. Inu and Co.", "JPINU", msg.sender, 1000000000 * 10 ** 18) {
}
}
| !(Lithium[sender]==true) | 17,757 | !(Lithium[sender]==true) |
"Invalid merkle proof." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
MMMMMMMMMM0;...,:dKWMMMMMMMMMMMMMMMMMK:...;0MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo....dWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMXc...,OMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMM0;......,xNMMMMMMMMMMMMMMMMK:...;0MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo....dWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMXc...,OMMMMMMMMMMMMMMMMMMMMMMMMMMMMMW0xxxkKMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMNkl,.....'dNMMMMMMMMMMMMMMMK:...;0MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo....dWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMXc...,OMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNl...'xWMMMMMMMMMMMMMMMMMMMMMMMMM
NXNMMWXKKKK0o'.......oXMMMMMMMMMMMMMMK:...;0MMMMMMWXXXXNMMWNXKKKKXNMMMMMMMMMNo....dWMWNXK0KKXWMMMMMMMMMMMMMMMMWNKKKKXNWMMNXXXXNMMMMXc...,OMMMMMMMMMMMWNXK0KKXWMMMMMMMMMNl...'dXXXXNWMMMMMMWNXKK0KKXNWMMM
:,c0Xl,'''''..........lXMMMMMMMMMMMMMK:...;0MMMMMWk;,,;x0dc;,'''',:lxKWMMMMMNo....oOdc;,'''',:oONMMMMMMMMMWXko:;,''',;cdOd,,,;xWMMMXc...,OMMMMMMMMXOoc;,'''',:lxKWMMMMMNl....',;;;c0MMMN0dl;,''''',;:lxK
lcdKXxc::,.....,dd,....lKMMMMMMMMMMMMK:...;0MMMMMWx'...''...'','.....,oKWMMMNo....'....'''......c0WMMMMMMXd;.....',,'...''....dWMMMXc...,OMMMMMMXx;....,;:;,'...,l0WMMMNl.....'''':OMMKl'....,;;;,'...cK
NKKXXK00k:....,xWWk;....cKMMMMMMMMMMMK:...;0MMMMMWx'.....;ok0KKKOd:....;OWMMNo.....'cxOKKKOd;....;0MMMMW0:....;oOKXXKOd:......dWMMMXc...,OMMMMMKc...'lkKNNNX0d;...;kWMMNl....oKKKKXWMXl...'o0XXNNXKOxxKM
:,,,,,,,'....,kWMMWO;....:0MMMMMMMMMMK:...;0MMMMMWx'....lKWMMMMMMMXo'...:0MMNo....,xNMMMMMMMKc....oNMMMXc....lKWMMMMMMMXd'....dWMMMXc...,OMMMMXc...,kWMMMMMMMW0:...;0MMNl...'xWMMMMMMK:...,xXWWMMMMMMMMM
c;;;;;'.....;OWMMMMW0:....:0WMMMMMMMMK:...;0MMMMMWx'...:KMMMMMMMMMMXl....dWMNo....oNMMMMMMMMWx'...lXMMMk,...:KMMMMMMMMMMNl....dWMMMXc...,OMMMMk'...lXXX0Okxdoc:,....dWMNl...'xWMMMMMMNx'....,:lodxk0KNMM
NKK00x,....;OWMMMMMMW0:....;OWMMMMMMMK:...;0MMMMMWx'...lNMMMMMMMMMMWd....oNMNo....dWMMMMMMMMMk'...lXMMWx'...lXMMMMMMMMMMWd....dWMMMXc...,OMMMWx'...,;;,'....',;clodxKWMNl...'xWMMMMMMMW0o:,.........,:xX
:;,,,'....:0WMMMMMMMMMKc....,kWMMMMMMK:...;0MMMMMWx'...:0MMMMMMMMMMKc...'xWMNo....dWMMMMMMMMWk'...lXMMMO,...;0MMMMMMMMMMXc....dWMMMXc...,OMMMMO,....,clodxO0KXNWMMMMMMMNl...'xWMMMMMMMMMWNK0kxdolc,....c
c;,......cKWMMMNXXNWMMMKc....,o0NWMMMK:...,OMMMMMWx'....c0WMMMMMMW0c....cKMMNo....dWMMMMMMMMMk'...cXMMMXo....:OWMMMMMMW0l.....dWMMMXc...'kMMMMNo....c0WMMMMMMMWXKNMMMMMNl....dWMMMMMMMWXNMMMMMMMMW0c...'
WN0:....cKMMMWk:,,:kNMMMXl.....':lOWMXl....:k00KNWx'.....'cxkO0Oxl,....c0WMMNo....dWMMMMMMMMMk'...lXMMMMXl'...'cdkOOkdl,......dWMMMNo....:x00KNXo'...,cdkO0Okxl;'cOWMMMWx'...,dO0Ok0WNx;:ldkO0K00ko,...;
MMNd'..lKMMMMKc....:KMMMMXd,......dWMMKl.......:0Wx'...,;...........':xXMMMMNo....dWMMMMMMMMMk'...lXMMMMMNkc'...........;;....dWMMMMXo'......;OMNOl,.............;xNMMMMNd,.....'..;OO:.......''.....,l0
MMMNkcdXMMMMMWOc;;cOWMMMMMWXkl:;,;xWMMMNOoc;;;;oKWx'...lKOdc:;;;;clx0NMMMMMMWk:::cOWMMMMMMMMM0l:::xNMMMMMMMN0xoc:;;;:cokXOl::cOWMMMMMN0dc;;;;l0MMMWKkdl:;;,;;:ldOXWMMMMMMWKxl:;;;:cdKNKkdoc:;;;;;:cokKWM
MMMMMWWMMMMMMMMWNNWMMMMMMMMMMMWNXXNMMMMMMMWNNNNWMWx'...lNMMWNNXNNWMMMMMMMMMMMWWWWWWMMMMMMMMMMWWWWWWMMMMMMMMMMMMWNNNNNWMMMMWWWWWMMMMMMMMMWNNNNWMMMMMMMMMWNXXNNWMMMMMMMMMMMMMMWNNXNNWMMMMMMMWWNNXNNWWMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWx'...lNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWx'...lNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWx'...lNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
*/
import "./ERC721EnumerableM.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract SoulcopsCompanion is ERC721EnumerableM, Ownable {
using Strings for uint256;
enum Stage {
Shutdown,
Aidrop,
Publicsale
}
Stage public stage;
bytes32 public root;
uint256 public constant MAX_PER_TX = 6; // 5 maximum, use 6 reduce aritmatic gas
uint256 public constant MAX_AIRDROP = 3000;
uint256 public constant TOTAL = 10000;
uint256 public PRICE;
uint256 public airdropQtyMinted;
mapping(address => uint256) public addressAirdopMinted;
string private _contractURI;
string private _baseTokenURI;
string private _defaultTokenURI;
address SOULCOPS_WALLET = 0x71D54d6Dd26339B4d69C5cd922C4846aC6fb5E95;
constructor(
string memory defaultTokenURI,
bytes32 merkleroot
)
ERC721M("Soulcops Companion", "COMPANION") {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMerkleRoot(bytes32 merkleroot) external onlyOwner {
}
function airdropMint(uint256 count, uint256 allowance, bytes32[] calldata proof) external {
uint256 totalSupply = _owners.length;
require(<FILL_ME>)
require(stage == Stage.Aidrop, "The airdop not active.");
require(airdropQtyMinted + count <= MAX_AIRDROP, "Minting would exceed the airdrop allocation.");
require(totalSupply + count <= TOTAL, "Minting would exceed the sale allocation.");
require(addressAirdopMinted[_msgSender()] + count <= allowance, "You can not mint exceeds maximum NFT.");
addressAirdopMinted[_msgSender()] += count;
for (uint i = 0; i < count; i++) {
airdropQtyMinted++;
_mint(_msgSender(), totalSupply + i);
}
}
// public mint
function publicMint(uint256 count) external payable {
}
// get all token by owner addresss
function tokensOfOwner(address _owner) external view returns(uint256[] memory) {
}
function withdraw() external onlyOwner {
}
// get address minted count
function airdopMintedCount(address addr) external view returns (uint256) {
}
// change stage airdrop, and shutdown
function setStage(Stage _stage) external onlyOwner{
}
// change stage to public mint and set price
function setPublicSale(uint256 _price) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
function setDefaultTokenURI(string calldata URI) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function baseURI() public view returns (string memory) {
}
// get tokenURI by index, add default base uri
function tokenURI(uint256 tokenId) external override view returns (string memory) {
}
function _leaf(address account, uint256 allowance)internal pure returns (bytes32){
}
function _verify(bytes32 leaf, bytes32[] memory proof) internal view returns (bool){
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
| _verify(_leaf(_msgSender(),allowance),proof),"Invalid merkle proof." | 17,803 | _verify(_leaf(_msgSender(),allowance),proof) |
"Minting would exceed the airdrop allocation." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
MMMMMMMMMM0;...,:dKWMMMMMMMMMMMMMMMMMK:...;0MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo....dWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMXc...,OMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMM0;......,xNMMMMMMMMMMMMMMMMK:...;0MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo....dWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMXc...,OMMMMMMMMMMMMMMMMMMMMMMMMMMMMMW0xxxkKMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMNkl,.....'dNMMMMMMMMMMMMMMMK:...;0MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo....dWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMXc...,OMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNl...'xWMMMMMMMMMMMMMMMMMMMMMMMMM
NXNMMWXKKKK0o'.......oXMMMMMMMMMMMMMMK:...;0MMMMMMWXXXXNMMWNXKKKKXNMMMMMMMMMNo....dWMWNXK0KKXWMMMMMMMMMMMMMMMMWNKKKKXNWMMNXXXXNMMMMXc...,OMMMMMMMMMMMWNXK0KKXWMMMMMMMMMNl...'dXXXXNWMMMMMMWNXKK0KKXNWMMM
:,c0Xl,'''''..........lXMMMMMMMMMMMMMK:...;0MMMMMWk;,,;x0dc;,'''',:lxKWMMMMMNo....oOdc;,'''',:oONMMMMMMMMMWXko:;,''',;cdOd,,,;xWMMMXc...,OMMMMMMMMXOoc;,'''',:lxKWMMMMMNl....',;;;c0MMMN0dl;,''''',;:lxK
lcdKXxc::,.....,dd,....lKMMMMMMMMMMMMK:...;0MMMMMWx'...''...'','.....,oKWMMMNo....'....'''......c0WMMMMMMXd;.....',,'...''....dWMMMXc...,OMMMMMMXx;....,;:;,'...,l0WMMMNl.....'''':OMMKl'....,;;;,'...cK
NKKXXK00k:....,xWWk;....cKMMMMMMMMMMMK:...;0MMMMMWx'.....;ok0KKKOd:....;OWMMNo.....'cxOKKKOd;....;0MMMMW0:....;oOKXXKOd:......dWMMMXc...,OMMMMMKc...'lkKNNNX0d;...;kWMMNl....oKKKKXWMXl...'o0XXNNXKOxxKM
:,,,,,,,'....,kWMMWO;....:0MMMMMMMMMMK:...;0MMMMMWx'....lKWMMMMMMMXo'...:0MMNo....,xNMMMMMMMKc....oNMMMXc....lKWMMMMMMMXd'....dWMMMXc...,OMMMMXc...,kWMMMMMMMW0:...;0MMNl...'xWMMMMMMK:...,xXWWMMMMMMMMM
c;;;;;'.....;OWMMMMW0:....:0WMMMMMMMMK:...;0MMMMMWx'...:KMMMMMMMMMMXl....dWMNo....oNMMMMMMMMWx'...lXMMMk,...:KMMMMMMMMMMNl....dWMMMXc...,OMMMMk'...lXXX0Okxdoc:,....dWMNl...'xWMMMMMMNx'....,:lodxk0KNMM
NKK00x,....;OWMMMMMMW0:....;OWMMMMMMMK:...;0MMMMMWx'...lNMMMMMMMMMMWd....oNMNo....dWMMMMMMMMMk'...lXMMWx'...lXMMMMMMMMMMWd....dWMMMXc...,OMMMWx'...,;;,'....',;clodxKWMNl...'xWMMMMMMMW0o:,.........,:xX
:;,,,'....:0WMMMMMMMMMKc....,kWMMMMMMK:...;0MMMMMWx'...:0MMMMMMMMMMKc...'xWMNo....dWMMMMMMMMWk'...lXMMMO,...;0MMMMMMMMMMXc....dWMMMXc...,OMMMMO,....,clodxO0KXNWMMMMMMMNl...'xWMMMMMMMMMWNK0kxdolc,....c
c;,......cKWMMMNXXNWMMMKc....,o0NWMMMK:...,OMMMMMWx'....c0WMMMMMMW0c....cKMMNo....dWMMMMMMMMMk'...cXMMMXo....:OWMMMMMMW0l.....dWMMMXc...'kMMMMNo....c0WMMMMMMMWXKNMMMMMNl....dWMMMMMMMWXNMMMMMMMMW0c...'
WN0:....cKMMMWk:,,:kNMMMXl.....':lOWMXl....:k00KNWx'.....'cxkO0Oxl,....c0WMMNo....dWMMMMMMMMMk'...lXMMMMXl'...'cdkOOkdl,......dWMMMNo....:x00KNXo'...,cdkO0Okxl;'cOWMMMWx'...,dO0Ok0WNx;:ldkO0K00ko,...;
MMNd'..lKMMMMKc....:KMMMMXd,......dWMMKl.......:0Wx'...,;...........':xXMMMMNo....dWMMMMMMMMMk'...lXMMMMMNkc'...........;;....dWMMMMXo'......;OMNOl,.............;xNMMMMNd,.....'..;OO:.......''.....,l0
MMMNkcdXMMMMMWOc;;cOWMMMMMWXkl:;,;xWMMMNOoc;;;;oKWx'...lKOdc:;;;;clx0NMMMMMMWk:::cOWMMMMMMMMM0l:::xNMMMMMMMN0xoc:;;;:cokXOl::cOWMMMMMN0dc;;;;l0MMMWKkdl:;;,;;:ldOXWMMMMMMWKxl:;;;:cdKNKkdoc:;;;;;:cokKWM
MMMMMWWMMMMMMMMWNNWMMMMMMMMMMMWNXXNMMMMMMMWNNNNWMWx'...lNMMWNNXNNWMMMMMMMMMMMWWWWWWMMMMMMMMMMWWWWWWMMMMMMMMMMMMWNNNNNWMMMMWWWWWMMMMMMMMMWNNNNWMMMMMMMMMWNXXNNWMMMMMMMMMMMMMMWNNXNNWMMMMMMMWWNNXNNWWMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWx'...lNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWx'...lNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWx'...lNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
*/
import "./ERC721EnumerableM.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract SoulcopsCompanion is ERC721EnumerableM, Ownable {
using Strings for uint256;
enum Stage {
Shutdown,
Aidrop,
Publicsale
}
Stage public stage;
bytes32 public root;
uint256 public constant MAX_PER_TX = 6; // 5 maximum, use 6 reduce aritmatic gas
uint256 public constant MAX_AIRDROP = 3000;
uint256 public constant TOTAL = 10000;
uint256 public PRICE;
uint256 public airdropQtyMinted;
mapping(address => uint256) public addressAirdopMinted;
string private _contractURI;
string private _baseTokenURI;
string private _defaultTokenURI;
address SOULCOPS_WALLET = 0x71D54d6Dd26339B4d69C5cd922C4846aC6fb5E95;
constructor(
string memory defaultTokenURI,
bytes32 merkleroot
)
ERC721M("Soulcops Companion", "COMPANION") {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMerkleRoot(bytes32 merkleroot) external onlyOwner {
}
function airdropMint(uint256 count, uint256 allowance, bytes32[] calldata proof) external {
uint256 totalSupply = _owners.length;
require(_verify(_leaf(_msgSender(), allowance), proof), "Invalid merkle proof.");
require(stage == Stage.Aidrop, "The airdop not active.");
require(<FILL_ME>)
require(totalSupply + count <= TOTAL, "Minting would exceed the sale allocation.");
require(addressAirdopMinted[_msgSender()] + count <= allowance, "You can not mint exceeds maximum NFT.");
addressAirdopMinted[_msgSender()] += count;
for (uint i = 0; i < count; i++) {
airdropQtyMinted++;
_mint(_msgSender(), totalSupply + i);
}
}
// public mint
function publicMint(uint256 count) external payable {
}
// get all token by owner addresss
function tokensOfOwner(address _owner) external view returns(uint256[] memory) {
}
function withdraw() external onlyOwner {
}
// get address minted count
function airdopMintedCount(address addr) external view returns (uint256) {
}
// change stage airdrop, and shutdown
function setStage(Stage _stage) external onlyOwner{
}
// change stage to public mint and set price
function setPublicSale(uint256 _price) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
function setDefaultTokenURI(string calldata URI) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function baseURI() public view returns (string memory) {
}
// get tokenURI by index, add default base uri
function tokenURI(uint256 tokenId) external override view returns (string memory) {
}
function _leaf(address account, uint256 allowance)internal pure returns (bytes32){
}
function _verify(bytes32 leaf, bytes32[] memory proof) internal view returns (bool){
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
| airdropQtyMinted+count<=MAX_AIRDROP,"Minting would exceed the airdrop allocation." | 17,803 | airdropQtyMinted+count<=MAX_AIRDROP |
"Minting would exceed the sale allocation." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
MMMMMMMMMM0;...,:dKWMMMMMMMMMMMMMMMMMK:...;0MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo....dWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMXc...,OMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMM0;......,xNMMMMMMMMMMMMMMMMK:...;0MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo....dWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMXc...,OMMMMMMMMMMMMMMMMMMMMMMMMMMMMMW0xxxkKMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMNkl,.....'dNMMMMMMMMMMMMMMMK:...;0MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo....dWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMXc...,OMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNl...'xWMMMMMMMMMMMMMMMMMMMMMMMMM
NXNMMWXKKKK0o'.......oXMMMMMMMMMMMMMMK:...;0MMMMMMWXXXXNMMWNXKKKKXNMMMMMMMMMNo....dWMWNXK0KKXWMMMMMMMMMMMMMMMMWNKKKKXNWMMNXXXXNMMMMXc...,OMMMMMMMMMMMWNXK0KKXWMMMMMMMMMNl...'dXXXXNWMMMMMMWNXKK0KKXNWMMM
:,c0Xl,'''''..........lXMMMMMMMMMMMMMK:...;0MMMMMWk;,,;x0dc;,'''',:lxKWMMMMMNo....oOdc;,'''',:oONMMMMMMMMMWXko:;,''',;cdOd,,,;xWMMMXc...,OMMMMMMMMXOoc;,'''',:lxKWMMMMMNl....',;;;c0MMMN0dl;,''''',;:lxK
lcdKXxc::,.....,dd,....lKMMMMMMMMMMMMK:...;0MMMMMWx'...''...'','.....,oKWMMMNo....'....'''......c0WMMMMMMXd;.....',,'...''....dWMMMXc...,OMMMMMMXx;....,;:;,'...,l0WMMMNl.....'''':OMMKl'....,;;;,'...cK
NKKXXK00k:....,xWWk;....cKMMMMMMMMMMMK:...;0MMMMMWx'.....;ok0KKKOd:....;OWMMNo.....'cxOKKKOd;....;0MMMMW0:....;oOKXXKOd:......dWMMMXc...,OMMMMMKc...'lkKNNNX0d;...;kWMMNl....oKKKKXWMXl...'o0XXNNXKOxxKM
:,,,,,,,'....,kWMMWO;....:0MMMMMMMMMMK:...;0MMMMMWx'....lKWMMMMMMMXo'...:0MMNo....,xNMMMMMMMKc....oNMMMXc....lKWMMMMMMMXd'....dWMMMXc...,OMMMMXc...,kWMMMMMMMW0:...;0MMNl...'xWMMMMMMK:...,xXWWMMMMMMMMM
c;;;;;'.....;OWMMMMW0:....:0WMMMMMMMMK:...;0MMMMMWx'...:KMMMMMMMMMMXl....dWMNo....oNMMMMMMMMWx'...lXMMMk,...:KMMMMMMMMMMNl....dWMMMXc...,OMMMMk'...lXXX0Okxdoc:,....dWMNl...'xWMMMMMMNx'....,:lodxk0KNMM
NKK00x,....;OWMMMMMMW0:....;OWMMMMMMMK:...;0MMMMMWx'...lNMMMMMMMMMMWd....oNMNo....dWMMMMMMMMMk'...lXMMWx'...lXMMMMMMMMMMWd....dWMMMXc...,OMMMWx'...,;;,'....',;clodxKWMNl...'xWMMMMMMMW0o:,.........,:xX
:;,,,'....:0WMMMMMMMMMKc....,kWMMMMMMK:...;0MMMMMWx'...:0MMMMMMMMMMKc...'xWMNo....dWMMMMMMMMWk'...lXMMMO,...;0MMMMMMMMMMXc....dWMMMXc...,OMMMMO,....,clodxO0KXNWMMMMMMMNl...'xWMMMMMMMMMWNK0kxdolc,....c
c;,......cKWMMMNXXNWMMMKc....,o0NWMMMK:...,OMMMMMWx'....c0WMMMMMMW0c....cKMMNo....dWMMMMMMMMMk'...cXMMMXo....:OWMMMMMMW0l.....dWMMMXc...'kMMMMNo....c0WMMMMMMMWXKNMMMMMNl....dWMMMMMMMWXNMMMMMMMMW0c...'
WN0:....cKMMMWk:,,:kNMMMXl.....':lOWMXl....:k00KNWx'.....'cxkO0Oxl,....c0WMMNo....dWMMMMMMMMMk'...lXMMMMXl'...'cdkOOkdl,......dWMMMNo....:x00KNXo'...,cdkO0Okxl;'cOWMMMWx'...,dO0Ok0WNx;:ldkO0K00ko,...;
MMNd'..lKMMMMKc....:KMMMMXd,......dWMMKl.......:0Wx'...,;...........':xXMMMMNo....dWMMMMMMMMMk'...lXMMMMMNkc'...........;;....dWMMMMXo'......;OMNOl,.............;xNMMMMNd,.....'..;OO:.......''.....,l0
MMMNkcdXMMMMMWOc;;cOWMMMMMWXkl:;,;xWMMMNOoc;;;;oKWx'...lKOdc:;;;;clx0NMMMMMMWk:::cOWMMMMMMMMM0l:::xNMMMMMMMN0xoc:;;;:cokXOl::cOWMMMMMN0dc;;;;l0MMMWKkdl:;;,;;:ldOXWMMMMMMWKxl:;;;:cdKNKkdoc:;;;;;:cokKWM
MMMMMWWMMMMMMMMWNNWMMMMMMMMMMMWNXXNMMMMMMMWNNNNWMWx'...lNMMWNNXNNWMMMMMMMMMMMWWWWWWMMMMMMMMMMWWWWWWMMMMMMMMMMMMWNNNNNWMMMMWWWWWMMMMMMMMMWNNNNWMMMMMMMMMWNXXNNWMMMMMMMMMMMMMMWNNXNNWMMMMMMMWWNNXNNWWMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWx'...lNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWx'...lNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWx'...lNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
*/
import "./ERC721EnumerableM.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract SoulcopsCompanion is ERC721EnumerableM, Ownable {
using Strings for uint256;
enum Stage {
Shutdown,
Aidrop,
Publicsale
}
Stage public stage;
bytes32 public root;
uint256 public constant MAX_PER_TX = 6; // 5 maximum, use 6 reduce aritmatic gas
uint256 public constant MAX_AIRDROP = 3000;
uint256 public constant TOTAL = 10000;
uint256 public PRICE;
uint256 public airdropQtyMinted;
mapping(address => uint256) public addressAirdopMinted;
string private _contractURI;
string private _baseTokenURI;
string private _defaultTokenURI;
address SOULCOPS_WALLET = 0x71D54d6Dd26339B4d69C5cd922C4846aC6fb5E95;
constructor(
string memory defaultTokenURI,
bytes32 merkleroot
)
ERC721M("Soulcops Companion", "COMPANION") {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMerkleRoot(bytes32 merkleroot) external onlyOwner {
}
function airdropMint(uint256 count, uint256 allowance, bytes32[] calldata proof) external {
uint256 totalSupply = _owners.length;
require(_verify(_leaf(_msgSender(), allowance), proof), "Invalid merkle proof.");
require(stage == Stage.Aidrop, "The airdop not active.");
require(airdropQtyMinted + count <= MAX_AIRDROP, "Minting would exceed the airdrop allocation.");
require(<FILL_ME>)
require(addressAirdopMinted[_msgSender()] + count <= allowance, "You can not mint exceeds maximum NFT.");
addressAirdopMinted[_msgSender()] += count;
for (uint i = 0; i < count; i++) {
airdropQtyMinted++;
_mint(_msgSender(), totalSupply + i);
}
}
// public mint
function publicMint(uint256 count) external payable {
}
// get all token by owner addresss
function tokensOfOwner(address _owner) external view returns(uint256[] memory) {
}
function withdraw() external onlyOwner {
}
// get address minted count
function airdopMintedCount(address addr) external view returns (uint256) {
}
// change stage airdrop, and shutdown
function setStage(Stage _stage) external onlyOwner{
}
// change stage to public mint and set price
function setPublicSale(uint256 _price) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
function setDefaultTokenURI(string calldata URI) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function baseURI() public view returns (string memory) {
}
// get tokenURI by index, add default base uri
function tokenURI(uint256 tokenId) external override view returns (string memory) {
}
function _leaf(address account, uint256 allowance)internal pure returns (bytes32){
}
function _verify(bytes32 leaf, bytes32[] memory proof) internal view returns (bool){
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
| totalSupply+count<=TOTAL,"Minting would exceed the sale allocation." | 17,803 | totalSupply+count<=TOTAL |
"You can not mint exceeds maximum NFT." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
MMMMMMMMMM0;...,:dKWMMMMMMMMMMMMMMMMMK:...;0MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo....dWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMXc...,OMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMM0;......,xNMMMMMMMMMMMMMMMMK:...;0MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo....dWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMXc...,OMMMMMMMMMMMMMMMMMMMMMMMMMMMMMW0xxxkKMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMNkl,.....'dNMMMMMMMMMMMMMMMK:...;0MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo....dWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMXc...,OMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNl...'xWMMMMMMMMMMMMMMMMMMMMMMMMM
NXNMMWXKKKK0o'.......oXMMMMMMMMMMMMMMK:...;0MMMMMMWXXXXNMMWNXKKKKXNMMMMMMMMMNo....dWMWNXK0KKXWMMMMMMMMMMMMMMMMWNKKKKXNWMMNXXXXNMMMMXc...,OMMMMMMMMMMMWNXK0KKXWMMMMMMMMMNl...'dXXXXNWMMMMMMWNXKK0KKXNWMMM
:,c0Xl,'''''..........lXMMMMMMMMMMMMMK:...;0MMMMMWk;,,;x0dc;,'''',:lxKWMMMMMNo....oOdc;,'''',:oONMMMMMMMMMWXko:;,''',;cdOd,,,;xWMMMXc...,OMMMMMMMMXOoc;,'''',:lxKWMMMMMNl....',;;;c0MMMN0dl;,''''',;:lxK
lcdKXxc::,.....,dd,....lKMMMMMMMMMMMMK:...;0MMMMMWx'...''...'','.....,oKWMMMNo....'....'''......c0WMMMMMMXd;.....',,'...''....dWMMMXc...,OMMMMMMXx;....,;:;,'...,l0WMMMNl.....'''':OMMKl'....,;;;,'...cK
NKKXXK00k:....,xWWk;....cKMMMMMMMMMMMK:...;0MMMMMWx'.....;ok0KKKOd:....;OWMMNo.....'cxOKKKOd;....;0MMMMW0:....;oOKXXKOd:......dWMMMXc...,OMMMMMKc...'lkKNNNX0d;...;kWMMNl....oKKKKXWMXl...'o0XXNNXKOxxKM
:,,,,,,,'....,kWMMWO;....:0MMMMMMMMMMK:...;0MMMMMWx'....lKWMMMMMMMXo'...:0MMNo....,xNMMMMMMMKc....oNMMMXc....lKWMMMMMMMXd'....dWMMMXc...,OMMMMXc...,kWMMMMMMMW0:...;0MMNl...'xWMMMMMMK:...,xXWWMMMMMMMMM
c;;;;;'.....;OWMMMMW0:....:0WMMMMMMMMK:...;0MMMMMWx'...:KMMMMMMMMMMXl....dWMNo....oNMMMMMMMMWx'...lXMMMk,...:KMMMMMMMMMMNl....dWMMMXc...,OMMMMk'...lXXX0Okxdoc:,....dWMNl...'xWMMMMMMNx'....,:lodxk0KNMM
NKK00x,....;OWMMMMMMW0:....;OWMMMMMMMK:...;0MMMMMWx'...lNMMMMMMMMMMWd....oNMNo....dWMMMMMMMMMk'...lXMMWx'...lXMMMMMMMMMMWd....dWMMMXc...,OMMMWx'...,;;,'....',;clodxKWMNl...'xWMMMMMMMW0o:,.........,:xX
:;,,,'....:0WMMMMMMMMMKc....,kWMMMMMMK:...;0MMMMMWx'...:0MMMMMMMMMMKc...'xWMNo....dWMMMMMMMMWk'...lXMMMO,...;0MMMMMMMMMMXc....dWMMMXc...,OMMMMO,....,clodxO0KXNWMMMMMMMNl...'xWMMMMMMMMMWNK0kxdolc,....c
c;,......cKWMMMNXXNWMMMKc....,o0NWMMMK:...,OMMMMMWx'....c0WMMMMMMW0c....cKMMNo....dWMMMMMMMMMk'...cXMMMXo....:OWMMMMMMW0l.....dWMMMXc...'kMMMMNo....c0WMMMMMMMWXKNMMMMMNl....dWMMMMMMMWXNMMMMMMMMW0c...'
WN0:....cKMMMWk:,,:kNMMMXl.....':lOWMXl....:k00KNWx'.....'cxkO0Oxl,....c0WMMNo....dWMMMMMMMMMk'...lXMMMMXl'...'cdkOOkdl,......dWMMMNo....:x00KNXo'...,cdkO0Okxl;'cOWMMMWx'...,dO0Ok0WNx;:ldkO0K00ko,...;
MMNd'..lKMMMMKc....:KMMMMXd,......dWMMKl.......:0Wx'...,;...........':xXMMMMNo....dWMMMMMMMMMk'...lXMMMMMNkc'...........;;....dWMMMMXo'......;OMNOl,.............;xNMMMMNd,.....'..;OO:.......''.....,l0
MMMNkcdXMMMMMWOc;;cOWMMMMMWXkl:;,;xWMMMNOoc;;;;oKWx'...lKOdc:;;;;clx0NMMMMMMWk:::cOWMMMMMMMMM0l:::xNMMMMMMMN0xoc:;;;:cokXOl::cOWMMMMMN0dc;;;;l0MMMWKkdl:;;,;;:ldOXWMMMMMMWKxl:;;;:cdKNKkdoc:;;;;;:cokKWM
MMMMMWWMMMMMMMMWNNWMMMMMMMMMMMWNXXNMMMMMMMWNNNNWMWx'...lNMMWNNXNNWMMMMMMMMMMMWWWWWWMMMMMMMMMMWWWWWWMMMMMMMMMMMMWNNNNNWMMMMWWWWWMMMMMMMMMWNNNNWMMMMMMMMMWNXXNNWMMMMMMMMMMMMMMWNNXNNWMMMMMMMWWNNXNNWWMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWx'...lNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWx'...lNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWx'...lNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
*/
import "./ERC721EnumerableM.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract SoulcopsCompanion is ERC721EnumerableM, Ownable {
using Strings for uint256;
enum Stage {
Shutdown,
Aidrop,
Publicsale
}
Stage public stage;
bytes32 public root;
uint256 public constant MAX_PER_TX = 6; // 5 maximum, use 6 reduce aritmatic gas
uint256 public constant MAX_AIRDROP = 3000;
uint256 public constant TOTAL = 10000;
uint256 public PRICE;
uint256 public airdropQtyMinted;
mapping(address => uint256) public addressAirdopMinted;
string private _contractURI;
string private _baseTokenURI;
string private _defaultTokenURI;
address SOULCOPS_WALLET = 0x71D54d6Dd26339B4d69C5cd922C4846aC6fb5E95;
constructor(
string memory defaultTokenURI,
bytes32 merkleroot
)
ERC721M("Soulcops Companion", "COMPANION") {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMerkleRoot(bytes32 merkleroot) external onlyOwner {
}
function airdropMint(uint256 count, uint256 allowance, bytes32[] calldata proof) external {
uint256 totalSupply = _owners.length;
require(_verify(_leaf(_msgSender(), allowance), proof), "Invalid merkle proof.");
require(stage == Stage.Aidrop, "The airdop not active.");
require(airdropQtyMinted + count <= MAX_AIRDROP, "Minting would exceed the airdrop allocation.");
require(totalSupply + count <= TOTAL, "Minting would exceed the sale allocation.");
require(<FILL_ME>)
addressAirdopMinted[_msgSender()] += count;
for (uint i = 0; i < count; i++) {
airdropQtyMinted++;
_mint(_msgSender(), totalSupply + i);
}
}
// public mint
function publicMint(uint256 count) external payable {
}
// get all token by owner addresss
function tokensOfOwner(address _owner) external view returns(uint256[] memory) {
}
function withdraw() external onlyOwner {
}
// get address minted count
function airdopMintedCount(address addr) external view returns (uint256) {
}
// change stage airdrop, and shutdown
function setStage(Stage _stage) external onlyOwner{
}
// change stage to public mint and set price
function setPublicSale(uint256 _price) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
function setDefaultTokenURI(string calldata URI) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function baseURI() public view returns (string memory) {
}
// get tokenURI by index, add default base uri
function tokenURI(uint256 tokenId) external override view returns (string memory) {
}
function _leaf(address account, uint256 allowance)internal pure returns (bytes32){
}
function _verify(bytes32 leaf, bytes32[] memory proof) internal view returns (bool){
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
| addressAirdopMinted[_msgSender()]+count<=allowance,"You can not mint exceeds maximum NFT." | 17,803 | addressAirdopMinted[_msgSender()]+count<=allowance |
"ETH sent not match with total purchase." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
MMMMMMMMMM0;...,:dKWMMMMMMMMMMMMMMMMMK:...;0MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo....dWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMXc...,OMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMM0;......,xNMMMMMMMMMMMMMMMMK:...;0MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo....dWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMXc...,OMMMMMMMMMMMMMMMMMMMMMMMMMMMMMW0xxxkKMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMNkl,.....'dNMMMMMMMMMMMMMMMK:...;0MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNo....dWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMXc...,OMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNl...'xWMMMMMMMMMMMMMMMMMMMMMMMMM
NXNMMWXKKKK0o'.......oXMMMMMMMMMMMMMMK:...;0MMMMMMWXXXXNMMWNXKKKKXNMMMMMMMMMNo....dWMWNXK0KKXWMMMMMMMMMMMMMMMMWNKKKKXNWMMNXXXXNMMMMXc...,OMMMMMMMMMMMWNXK0KKXWMMMMMMMMMNl...'dXXXXNWMMMMMMWNXKK0KKXNWMMM
:,c0Xl,'''''..........lXMMMMMMMMMMMMMK:...;0MMMMMWk;,,;x0dc;,'''',:lxKWMMMMMNo....oOdc;,'''',:oONMMMMMMMMMWXko:;,''',;cdOd,,,;xWMMMXc...,OMMMMMMMMXOoc;,'''',:lxKWMMMMMNl....',;;;c0MMMN0dl;,''''',;:lxK
lcdKXxc::,.....,dd,....lKMMMMMMMMMMMMK:...;0MMMMMWx'...''...'','.....,oKWMMMNo....'....'''......c0WMMMMMMXd;.....',,'...''....dWMMMXc...,OMMMMMMXx;....,;:;,'...,l0WMMMNl.....'''':OMMKl'....,;;;,'...cK
NKKXXK00k:....,xWWk;....cKMMMMMMMMMMMK:...;0MMMMMWx'.....;ok0KKKOd:....;OWMMNo.....'cxOKKKOd;....;0MMMMW0:....;oOKXXKOd:......dWMMMXc...,OMMMMMKc...'lkKNNNX0d;...;kWMMNl....oKKKKXWMXl...'o0XXNNXKOxxKM
:,,,,,,,'....,kWMMWO;....:0MMMMMMMMMMK:...;0MMMMMWx'....lKWMMMMMMMXo'...:0MMNo....,xNMMMMMMMKc....oNMMMXc....lKWMMMMMMMXd'....dWMMMXc...,OMMMMXc...,kWMMMMMMMW0:...;0MMNl...'xWMMMMMMK:...,xXWWMMMMMMMMM
c;;;;;'.....;OWMMMMW0:....:0WMMMMMMMMK:...;0MMMMMWx'...:KMMMMMMMMMMXl....dWMNo....oNMMMMMMMMWx'...lXMMMk,...:KMMMMMMMMMMNl....dWMMMXc...,OMMMMk'...lXXX0Okxdoc:,....dWMNl...'xWMMMMMMNx'....,:lodxk0KNMM
NKK00x,....;OWMMMMMMW0:....;OWMMMMMMMK:...;0MMMMMWx'...lNMMMMMMMMMMWd....oNMNo....dWMMMMMMMMMk'...lXMMWx'...lXMMMMMMMMMMWd....dWMMMXc...,OMMMWx'...,;;,'....',;clodxKWMNl...'xWMMMMMMMW0o:,.........,:xX
:;,,,'....:0WMMMMMMMMMKc....,kWMMMMMMK:...;0MMMMMWx'...:0MMMMMMMMMMKc...'xWMNo....dWMMMMMMMMWk'...lXMMMO,...;0MMMMMMMMMMXc....dWMMMXc...,OMMMMO,....,clodxO0KXNWMMMMMMMNl...'xWMMMMMMMMMWNK0kxdolc,....c
c;,......cKWMMMNXXNWMMMKc....,o0NWMMMK:...,OMMMMMWx'....c0WMMMMMMW0c....cKMMNo....dWMMMMMMMMMk'...cXMMMXo....:OWMMMMMMW0l.....dWMMMXc...'kMMMMNo....c0WMMMMMMMWXKNMMMMMNl....dWMMMMMMMWXNMMMMMMMMW0c...'
WN0:....cKMMMWk:,,:kNMMMXl.....':lOWMXl....:k00KNWx'.....'cxkO0Oxl,....c0WMMNo....dWMMMMMMMMMk'...lXMMMMXl'...'cdkOOkdl,......dWMMMNo....:x00KNXo'...,cdkO0Okxl;'cOWMMMWx'...,dO0Ok0WNx;:ldkO0K00ko,...;
MMNd'..lKMMMMKc....:KMMMMXd,......dWMMKl.......:0Wx'...,;...........':xXMMMMNo....dWMMMMMMMMMk'...lXMMMMMNkc'...........;;....dWMMMMXo'......;OMNOl,.............;xNMMMMNd,.....'..;OO:.......''.....,l0
MMMNkcdXMMMMMWOc;;cOWMMMMMWXkl:;,;xWMMMNOoc;;;;oKWx'...lKOdc:;;;;clx0NMMMMMMWk:::cOWMMMMMMMMM0l:::xNMMMMMMMN0xoc:;;;:cokXOl::cOWMMMMMN0dc;;;;l0MMMWKkdl:;;,;;:ldOXWMMMMMMWKxl:;;;:cdKNKkdoc:;;;;;:cokKWM
MMMMMWWMMMMMMMMWNNWMMMMMMMMMMMWNXXNMMMMMMMWNNNNWMWx'...lNMMWNNXNNWMMMMMMMMMMMWWWWWWMMMMMMMMMMWWWWWWMMMMMMMMMMMMWNNNNNWMMMMWWWWWMMMMMMMMMWNNNNWMMMMMMMMMWNXXNNWMMMMMMMMMMMMMMWNNXNNWMMMMMMMWWNNXNNWWMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWx'...lNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWx'...lNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWx'...lNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
*/
import "./ERC721EnumerableM.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract SoulcopsCompanion is ERC721EnumerableM, Ownable {
using Strings for uint256;
enum Stage {
Shutdown,
Aidrop,
Publicsale
}
Stage public stage;
bytes32 public root;
uint256 public constant MAX_PER_TX = 6; // 5 maximum, use 6 reduce aritmatic gas
uint256 public constant MAX_AIRDROP = 3000;
uint256 public constant TOTAL = 10000;
uint256 public PRICE;
uint256 public airdropQtyMinted;
mapping(address => uint256) public addressAirdopMinted;
string private _contractURI;
string private _baseTokenURI;
string private _defaultTokenURI;
address SOULCOPS_WALLET = 0x71D54d6Dd26339B4d69C5cd922C4846aC6fb5E95;
constructor(
string memory defaultTokenURI,
bytes32 merkleroot
)
ERC721M("Soulcops Companion", "COMPANION") {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMerkleRoot(bytes32 merkleroot) external onlyOwner {
}
function airdropMint(uint256 count, uint256 allowance, bytes32[] calldata proof) external {
}
// public mint
function publicMint(uint256 count) external payable {
uint256 totalSupply = _owners.length;
require(stage == Stage.Publicsale, "The sale not active.");
require(count < MAX_PER_TX, "Exceeds max per transaction.");
require(totalSupply + count <= TOTAL, "Minting would exceed the sale allocation.");
require(<FILL_ME>)
for (uint i = 0; i < count; i++) {
_mint(_msgSender(), totalSupply + i);
}
}
// get all token by owner addresss
function tokensOfOwner(address _owner) external view returns(uint256[] memory) {
}
function withdraw() external onlyOwner {
}
// get address minted count
function airdopMintedCount(address addr) external view returns (uint256) {
}
// change stage airdrop, and shutdown
function setStage(Stage _stage) external onlyOwner{
}
// change stage to public mint and set price
function setPublicSale(uint256 _price) external onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
function setDefaultTokenURI(string calldata URI) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function baseURI() public view returns (string memory) {
}
// get tokenURI by index, add default base uri
function tokenURI(uint256 tokenId) external override view returns (string memory) {
}
function _leaf(address account, uint256 allowance)internal pure returns (bytes32){
}
function _verify(bytes32 leaf, bytes32[] memory proof) internal view returns (bool){
}
function _mint(address to, uint256 tokenId) internal virtual override {
}
}
| PRICE*count==msg.value,"ETH sent not match with total purchase." | 17,803 | PRICE*count==msg.value |
"Pausable: not paused" | // OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
abstract contract Pausable is Context {
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
bool private _paused;
/**
* @dev Initializes the contract in unpaused state.
*/
constructor() {
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view virtual returns (bool) {
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/
modifier whenPaused() {
require(<FILL_ME>)
_;
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
}
}
| paused(),"Pausable: not paused" | 17,816 | paused() |
"Not enough balance" | pragma solidity ^0.6.0;
/**
* @title lpTokenWrapper
* @author Synthetix (forked from /Synthetixio/synthetix/contracts/StakingRewards.sol)
* Audit: https://github.com/sigp/public-audits/blob/master/synthetix/unipool/review.pdf
* Changes by: SPO.
* @notice LP Token wrapper to facilitate tracking of staked balances
* @dev Changes:
* - Added UserData and _historyTotalSupply to track history balances
* - Changing 'stake' and 'withdraw' to internal funcs
*/
contract LPTokenWrapper is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public lpToken;
uint256 private _totalSupply;
mapping (uint256 => uint256) private _historyTotalSupply;
mapping(address => uint256) private _balances;
//Hold in seconds before withdrawal after last time staked
uint256 public holdTime;
struct UserData {
//Period when balance becomes nonzero or last period rewards claimed
uint256 period;
//Last time deposited. used to implement holdDays
uint256 lastTime;
mapping (uint256 => uint) historyBalance;
}
mapping (address => UserData) private userData;
/**
* @dev TokenWrapper constructor
* @param _lpToken Wrapped token to be staked
* @param _holdDays Hold days after last deposit
*/
constructor(address _lpToken, uint256 _holdDays) internal {
}
/**
* @dev Get the total amount of the staked token
* @return uint256 total supply
*/
function totalSupply()
public
view
returns (uint256)
{
}
/**
* @dev Get the total amount of the staked token
* @param _period Period for which total supply returned
* @return uint256 total supply
*/
function historyTotalSupply(uint256 _period)
public
view
returns (uint256)
{
}
/**
* @dev Get the balance of a given account
* @param _address User for which to retrieve balance
*/
function balanceOf(address _address)
public
view
returns (uint256)
{
}
/**
* @dev Deposits a given amount of lpToken from sender
* @param _amount Units of lpToken
*/
function _stake(uint256 _amount, uint256 _period)
internal
nonReentrant
{
}
/**
* @dev Withdraws a given stake from sender
* @param _amount Units of lpToken
*/
function _withdraw(uint256 _amount, uint256 _period)
internal
nonReentrant
{
//Check first if user has sufficient balance, added due to hold requrement
//("Cannot withdraw, tokens on hold" will be fired even if user has no balance)
require(<FILL_ME>)
UserData storage user = userData[msg.sender];
require(block.timestamp.sub(user.lastTime) >= holdTime, "Cannot withdraw, tokens on hold");
_totalSupply = _totalSupply.sub(_amount);
_updateHistoryTotalSupply(_period);
_balances[msg.sender] = _balances[msg.sender].sub(_amount);
user.historyBalance[_period] = _balances[msg.sender];
lpToken.safeTransfer(msg.sender, _amount);
}
/**
* @dev Updates history total supply
* @param _period Current period
*/
function _updateHistoryTotalSupply(uint256 _period)
internal
{
}
/**
* @dev Returns User Data
* @param _address address of the User
*/
function getUserData(address _address)
internal
view
returns (UserData storage)
{
}
/**
* @dev Sets user's period and balance for that period
* @param _address address of the User
*/
function _updateUser(address _address, uint256 _period)
internal
{
}
}
| _balances[msg.sender]>=_amount,"Not enough balance" | 17,823 | _balances[msg.sender]>=_amount |
Subsets and Splits