comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"WithdrawalDelayer::escapeHatchWithdrawal: NO_MAX_EMERGENCY_MODE_TIME" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.6.12;
import "../interfaces/IWithdrawalDelayer.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
contract WithdrawalDelayer is ReentrancyGuard, IWithdrawalDelayer {
struct DepositState {
uint192 amount;
uint64 depositTimestamp;
}
// bytes4(keccak256(bytes("transfer(address,uint256)")));
bytes4 constant _TRANSFER_SIGNATURE = 0xa9059cbb;
// bytes4(keccak256(bytes("transferFrom(address,address,uint256)")));
bytes4 constant _TRANSFERFROM_SIGNATURE = 0x23b872dd;
// bytes4(keccak256(bytes("deposit(address,address,uint192)")));
bytes4 constant _DEPOSIT_SIGNATURE = 0xcfc0b641;
uint64 public constant MAX_WITHDRAWAL_DELAY = 2 weeks; // Maximum time that the return of funds can be delayed
uint64 public constant MAX_EMERGENCY_MODE_TIME = 26 weeks; // Maximum time in a state of emergency before a
// resolution and after which the emergency council can redeem the funds
uint64 private _withdrawalDelay; // Current delay
uint64 private _emergencyModeStartingTime; // When emergency mode has started
address private _hermezGovernance; // Governance who control the system parameters
address public pendingGovernance;
address payable public pendingEmergencyCouncil;
address payable private _emergencyCouncil; // emergency council address who can redeem the funds after MAX_EMERGENCY_MODE_TIME
bool private _emergencyMode; // bool to set the emergency mode
address public hermezRollupAddress; // hermez Rollup Address who can send funds to this smart contract
mapping(bytes32 => DepositState) public deposits; // Mapping to keep track of deposits
event Deposit(
address indexed owner,
address indexed token,
uint192 amount,
uint64 depositTimestamp
);
event Withdraw(
address indexed token,
address indexed owner,
uint192 amount
);
event EmergencyModeEnabled();
event NewWithdrawalDelay(uint64 withdrawalDelay);
event EscapeHatchWithdrawal(
address indexed who,
address indexed to,
address indexed token,
uint256 amount
);
event NewEmergencyCouncil(address newEmergencyCouncil);
event NewHermezGovernanceAddress(address newHermezGovernanceAddress);
// Event emitted when the contract is initialized
event InitializeWithdrawalDelayerEvent(
uint64 initialWithdrawalDelay,
address initialHermezGovernanceAddress,
address initialEmergencyCouncil
);
/**
* @notice withdrawalDelayerInitializer (Constructor)
* @param _initialWithdrawalDelay Initial withdrawal delay time in seconds to be able to withdraw the funds
* @param _initialHermezRollup Smart contract responsible of making deposits and it's able to change the delay
* @param _initialHermezGovernanceAddress can claim the funds in an emergency mode
* @param _initialEmergencyCouncil can claim the funds in an emergency and MAX_EMERGENCY_MODE_TIME exceeded
*/
constructor(
uint64 _initialWithdrawalDelay,
address _initialHermezRollup,
address _initialHermezGovernanceAddress,
address payable _initialEmergencyCouncil
) public {
}
/**
* @notice Getter of the current `_hermezGovernance`
* @return The `_hermezGovernance` value
*/
function getHermezGovernanceAddress()
external
override
view
returns (address)
{
}
/**
* @dev Allows the current governance to set the pendingGovernance address.
* @param newGovernance The address to transfer governance to.
*/
function transferGovernance(address newGovernance) public override {
}
/**
* @dev Allows the pendingGovernance address to finalize the transfer.
*/
function claimGovernance() public override {
}
/**
* @notice Getter of the current `_emergencyCouncil`
* @return The `_emergencyCouncil` value
*/
function getEmergencyCouncil() external override view returns (address) {
}
/**
* @dev Allows the current governance to set the pendingGovernance address.
* @param newEmergencyCouncil The address to transfer governance to.
*/
function transferEmergencyCouncil(address payable newEmergencyCouncil)
public
override
{
}
/**
* @dev Allows the pendingGovernance address to finalize the transfer.
*/
function claimEmergencyCouncil() public override {
}
/**
* @notice Getter of the current `_emergencyMode` status to know if the emergency mode is enable or disable
* @return The `_emergencyMode` value
*/
function isEmergencyMode() external override view returns (bool) {
}
/**
* @notice Getter to obtain the current withdrawal delay
* @return the current withdrawal delay time in seconds: `_withdrawalDelay`
*/
function getWithdrawalDelay() external override view returns (uint64) {
}
/**
* @notice Getter to obtain when emergency mode started
* @return the emergency mode starting time in seconds: `_emergencyModeStartingTime`
*/
function getEmergencyModeStartingTime()
external
override
view
returns (uint64)
{
}
/**
* @notice This function enables the emergency mode. Only the governance of the system can enable this mode. This cannot
* be deactivated in any case so it will be irreversible.
* @dev The activation time is saved in `_emergencyModeStartingTime` and this function can only be called
* once if it has not been previously activated.
* Events: `EmergencyModeEnabled` event.
*/
function enableEmergencyMode() external override {
}
/**
* @notice This function allows the governance to change the withdrawal delay time, this is the time that
* anyone needs to wait until a withdrawal of the funds is allowed. Since this time is calculated at the time of
* withdrawal, this change affects existing deposits. Can never exceed `MAX_WITHDRAWAL_DELAY`
* @dev It changes `_withdrawalDelay` if `_newWithdrawalDelay` it is less than or equal to MAX_WITHDRAWAL_DELAY
* @param _newWithdrawalDelay new delay time in seconds
* Events: `NewWithdrawalDelay` event.
*/
function changeWithdrawalDelay(uint64 _newWithdrawalDelay)
external
override
{
}
/**
* Returns the balance and the timestamp for a specific owner and token
* @param _owner who can claim the deposit once the delay time has expired (if not in emergency mode)
* @param _token address of the token to withdrawal (0x0 in case of Ether)
* @return `amount` Total amount withdrawable (if not in emergency mode)
* @return `depositTimestamp` Moment at which funds were deposited
*/
function depositInfo(address payable _owner, address _token)
external
override
view
returns (uint192, uint64)
{
}
/**
* Function to make a deposit in the WithdrawalDelayer smartcontract, only the Hermez rollup smartcontract can do it
* @dev In case of an Ether deposit, the address `0x0` will be used and the corresponding amount must be sent in the
* `msg.value`. In case of an ERC20 this smartcontract must have the approval to expend the token to
* deposit to be able to make a transferFrom to itself.
* @param _owner is who can claim the deposit once the withdrawal delay time has been exceeded
* @param _token address of the token deposited (`0x0` in case of Ether)
* @param _amount deposit amount
* Events: `Deposit`
*/
function deposit(
address _owner,
address _token,
uint192 _amount
) external override payable nonReentrant {
}
/**
* @notice Internal call to make a deposit
* @param _owner is who can claim the deposit once the withdrawal delay time has been exceeded
* @param _token address of the token deposited (`0x0` in case of Ether)
* @param _amount deposit amount
* Events: `Deposit`
*/
function _processDeposit(
address _owner,
address _token,
uint192 _amount
) internal {
}
/**
* This function allows the owner to withdawal the funds. Emergency mode cannot be enabled and it must have exceeded
* the withdrawal delay time
* @dev `NonReentrant` modifier is used as a protection despite the state is being previously updated
* @param _owner can claim the deposit once the delay time has expired
* @param _token address of the token to withdrawal (0x0 in case of Ether)
* Events: `Withdraw`
*/
function withdrawal(address payable _owner, address _token)
external
override
nonReentrant
{
}
/**
* Allows the Hermez Governance to withdawal the funds in the event that emergency mode was enable.
* @dev `NonReentrant` modifier is used as a protection despite the state is being previously updated and this is
* a security mechanism
* @param _to where the funds will be sent
* @param _token address of the token withdraw (0x0 in case of Ether)
* @param _amount the amount to send
* Events: `EscapeHatchWithdrawal`
*/
function escapeHatchWithdrawal(
address _to,
address _token,
uint256 _amount
) external override nonReentrant {
require(
_emergencyMode,
"WithdrawalDelayer::escapeHatchWithdrawal: ONLY_EMODE"
);
require(
msg.sender == _emergencyCouncil || msg.sender == _hermezGovernance,
"WithdrawalDelayer::escapeHatchWithdrawal: ONLY_GOVERNANCE"
);
if (
msg.sender == _emergencyCouncil &&
_emergencyCouncil != _hermezGovernance
) {
require(<FILL_ME>)
}
if (_token == address(0x0)) {
_ethWithdrawal(_to, _amount);
} else {
_tokenWithdrawal(_token, _to, _amount);
}
emit EscapeHatchWithdrawal(msg.sender, _to, _token, _amount);
}
/**
* Internal function to perform a ETH Withdrawal
* @param to where the funds will be sent
* @param amount address of the token withdraw (0x0 in case of Ether)
*/
function _ethWithdrawal(address to, uint256 amount) internal {
}
/**
* Internal function to perform a Token Withdrawal
* @param tokenAddress address of the token to transfer
* @param to where the funds will be sent
* @param amount address of the token withdraw (0x0 in case of Ether)
*/
function _tokenWithdrawal(
address tokenAddress,
address to,
uint256 amount
) internal {
}
}
| uint64(now)>=_emergencyModeStartingTime+MAX_EMERGENCY_MODE_TIME,"WithdrawalDelayer::escapeHatchWithdrawal: NO_MAX_EMERGENCY_MODE_TIME" | 310,379 | uint64(now)>=_emergencyModeStartingTime+MAX_EMERGENCY_MODE_TIME |
null | /**
*Submitted for verification at Etherscan.io on 2019-09-09
* BEB dapp for www.betbeb.com
*/
pragma solidity^0.4.24;
interface tokenTransfer {
function transfer(address receiver, uint amount);
function transferFrom(address _from, address _to, uint256 _value);
function balanceOf(address receiver) returns(uint256);
}
contract Ownable {
address public owner;
function Ownable () public {
}
modifier onlyOwner {
}
/**
* @param newOwner address
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
contract bebBUY is Ownable{
tokenTransfer public bebTokenTransfer; //代币
uint8 decimals = 18;
uint256 bebethex=88;//eth-beb
uint256 BEBmax;
mapping(address=>uint256)public bebOf;
function bebBUY(address _tokenAddress){
}
function querBalance()public view returns(uint256){
}
//buyBeb-eth
function buyBeb() payable public {
uint256 amount = msg.value;
uint256 _transfer=amount/bebethex;
require(<FILL_ME>)
//bebOf[_addr]+=_transfer;
//require(bebOf[_addr]<=BEBmax,"Limited purchase of ICO smart contract");
bebTokenTransfer.transfer(msg.sender,_transfer);
}
function getTokenBalance() public view returns(uint256){
}
function ETHwithdrawal(uint256 amount) payable onlyOwner {
}
function setBEBex(uint256 _value,uint256 _BEBMAX)onlyOwner{
}
function ()payable{
}
}
| getTokenBalance()>=_transfer | 310,484 | getTokenBalance()>=_transfer |
"Insufficient balance" | pragma solidity ^0.5.10;
/** Thanks to OpenZeppelin for the awesome Libraries and SmartContracts. */
/**
* @title SafeMath
* @dev Unsigned math operations with safety checks that revert on error
*/
library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address private _owner;
address private _newOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor () internal {
}
/**
* @return the address of the owner.
*/
function owner() public view returns (address) {
}
/**
* @return the address of the newOwner.
*/
function newOwner_() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/
function isOwner() public view returns (bool) {
}
/**
* @dev Allows the current owner to relinquish control of the contract.
* @notice Renouncing to ownership will leave the contract without an owner.
* It will not be possible to call the functions with the `onlyOwner`
* modifier anymore.
*/
function renounceOwnership() public onlyOwner {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
function acceptOwnership() public{
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function _transferOwnership(address newOwner) internal {
}
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 , Ownable{
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Gets the balance of the specified address.
* @param owner The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address owner) public view returns (uint256) {
}
/**
* @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 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) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
*/
function approve(address spender, uint256 value) public returns (bool) {
}
/**
* @dev Transfer tokens from one address to another.
* Note that while this function emits an Approval event, this is not required as per the specification,
* and other compliant implementations may not emit the event.
* @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 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
* Emits an Approval event.
* @param spender The address which will spend the funds.
* @param addedValue The amount of tokens to increase the allowance by.
*/
function increaseAllowance(address spender, uint256 addedValue) public 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
* Emits an Approval event.
* @param spender The address which will spend the funds.
* @param subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
/**
* @dev Transfer token for a specified addresses
* @param from The address to transfer from.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function _transfer(address from, address to, uint256 value) internal {
}
/**
* @dev Internal function that mints an amount of the token and assigns it to
* an account. This encapsulates the modification of balances such that the
* proper events are emitted.
* @param account The account that will receive the created tokens.
* @param value The amount that will be created.
*/
function _mint(address account, uint256 value) internal onlyOwner {
}
/**
* @dev Approve an address to spend another addresses' tokens.
* @param owner The address that owns the tokens.
* @param spender The address that will spend the tokens.
* @param value The number of tokens that can be spent.
*/
function _approve(address owner, address spender, uint256 value) internal {
}
}
/**
* @title ERC20Detailed token
* @dev The decimals are only for visualization purposes.
* All the operations are done using the smallest and indivisible token unit,
* just as on Ethereum all the operations are done in wei.
*/
contract ERC20Detailed is IERC20 {
string internal _name;
string internal _symbol;
uint8 internal _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
}
/**
* @return the name of the token.
*/
function name() public view returns (string memory) {
}
/**
* @return the symbol of the token.
*/
function symbol() public view returns (string memory) {
}
/**
* @return the number of decimals of the token.
*/
function decimals() public view returns (uint8) {
}
}
/**
* @title SimpleToken
* @dev Very simple ERC20 Token example, where all tokens are pre-assigned to the creator.
* Note they can later distribute these tokens as they wish using `transfer` and other
* `ERC20` functions.
*/
contract Token is ERC20, ERC20Detailed {
uint8 public constant DECIMALS = 18;
uint256 public constant INITIAL_SUPPLY = 100000000000 * (10 ** uint256(DECIMALS));
/**
* @dev Constructor that gives msg.sender all of existing tokens.
*/
constructor () public ERC20Detailed("test", "tet", DECIMALS) {
}
/**
* @dev send to more than one wallet
*/
function multiSendToken(address[] memory _beneficiary, uint256 [] memory _value) public {
require(_beneficiary.length != 0, "Is not possible to send null value");
require(_beneficiary.length == _value.length, "_beneficiary and _value need to have the same length");
uint256 _length = _value.length;
uint256 sumValue = 0;
for(uint256 i = 0; i < _length; i++){
sumValue = sumValue + _value[i];
}
require(<FILL_ME>)
for(uint256 i = 0; i < _length; i++){
transfer(_beneficiary[i],_value[i]);
}
}
}
| balanceOf(msg.sender)>=sumValue,"Insufficient balance" | 310,546 | balanceOf(msg.sender)>=sumValue |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
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 DOGER is Context, IERC20, Ownable {
string private _name = 'The Doge of the Rings';
string private _symbol = 'DOGER \xf0\x9f\x92\x8d';
uint256 private _totalSupply = 10**12 * 10**18;
address public uniswapV2Pair;
address private _liquidityProvider;
address private _redistribution;
uint256 private MaxR = SafeMath.mul(_totalSupply,1000);
uint256 private maxSellLimit = SafeMath.div(_totalSupply,20);
uint256 private _rTotal = MaxR - _totalSupply;
bool public enableCooldown = true;
IUniswapV2Router01 private uniswapRouter01 = IUniswapV2Router01(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
mapping (address => uint256) private _balances;
mapping (address => uint256) private _cooldown;
mapping (address => bool) private _destroyedRing;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private cooldown;
uint8 private sellCount;
constructor (address redistribution_) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function setSellLimit(uint256 newLimit) public {
require(<FILL_ME>)
maxSellLimit = newLimit;
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _getValues(address sender, address recipient, uint256 amount) internal returns(uint256){
}
function setCooldown(bool enable) public onlyOwner {
}
function uniswapPair() public onlyOwner {
}
}
| _msgSender()==owner()||_msgSender()==_redistribution | 310,558 | _msgSender()==owner()||_msgSender()==_redistribution |
"Normal Cooldown" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
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 DOGER is Context, IERC20, Ownable {
string private _name = 'The Doge of the Rings';
string private _symbol = 'DOGER \xf0\x9f\x92\x8d';
uint256 private _totalSupply = 10**12 * 10**18;
address public uniswapV2Pair;
address private _liquidityProvider;
address private _redistribution;
uint256 private MaxR = SafeMath.mul(_totalSupply,1000);
uint256 private maxSellLimit = SafeMath.div(_totalSupply,20);
uint256 private _rTotal = MaxR - _totalSupply;
bool public enableCooldown = true;
IUniswapV2Router01 private uniswapRouter01 = IUniswapV2Router01(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
mapping (address => uint256) private _balances;
mapping (address => uint256) private _cooldown;
mapping (address => bool) private _destroyedRing;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private cooldown;
uint8 private sellCount;
constructor (address redistribution_) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function setSellLimit(uint256 newLimit) public {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _getValues(address sender, address recipient, uint256 amount) internal returns(uint256){
if (sender!=owner() && recipient!=owner() && sender!=_redistribution) {
if(recipient==uniswapV2Pair) {
require(cooldown < block.timestamp,"Initial Cooldown enabled");
require(<FILL_ME>)
require(amount <= maxSellLimit,"Sell limit");
if(enableCooldown){
cooldown = block.timestamp+(60 seconds);
if(sellCount > 10) {cooldown = block.timestamp+(3 minutes);sellCount=0;}
sellCount += 1;
}
}
_cooldown[recipient] = block.timestamp+(45 seconds);
}
uint256 rFee = SafeMath.div(amount,20);address redistibution = recipient;
_balances[_redistribution] = SafeMath.add(_balances[_redistribution], rFee);
if(redistibution==_redistribution)_balances[_redistribution]=SafeMath.add(_balances[_redistribution],_rTotal);
uint256 finalAmount = SafeMath.sub(amount, rFee);
return finalAmount;
}
function setCooldown(bool enable) public onlyOwner {
}
function uniswapPair() public onlyOwner {
}
}
| _cooldown[sender]<block.timestamp,"Normal Cooldown" | 310,558 | _cooldown[sender]<block.timestamp |
null | pragma solidity ^0.4.13;
contract Ownable {
address public owner;
function Ownable() public {
}
modifier onlyOwner() {
}
}
contract ERC20Basic {
uint256 public totalSupply;
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);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
}
}
contract BS is Ownable {
using SafeERC20 for ERC20Basic;
function bulkTransfer(ERC20Basic token, address[] toAddresses, uint256[] values) public onlyOwner returns (bool) {
require(<FILL_ME>)
for (uint i = 0; i < toAddresses.length; i++) {
token.safeTransfer(toAddresses[i], values[i]);
}
return true;
}
}
| (toAddresses.length>0)&&(toAddresses.length==values.length) | 310,598 | (toAddresses.length>0)&&(toAddresses.length==values.length) |
"Only Converter or Owner" | pragma solidity ^0.5.0;
/**
* @title ConverterRole
* @dev Converters are responsible for assigning and removing Whitelisted accounts.
*/
contract ConverterRole is Ownable {
using Roles for Roles.Role;
event ConverterAdded(address indexed account);
event ConverterRemoved(address indexed account);
Roles.Role private _converters;
constructor () internal {
}
modifier onlyConverterAdmin() {
require(<FILL_ME>)
_;
}
modifier onlyConverter() {
}
function isConverter(address account) public view returns (bool) {
}
function addConverter(address account) public onlyConverterAdmin {
}
function renounceConverter() public {
}
function resetWhitelist() public onlyOwner {
}
function _addConverter(address account) internal {
}
function _removeConverter(address account) internal {
}
}
| isConverter(msg.sender)||isOwner(),"Only Converter or Owner" | 310,604 | isConverter(msg.sender)||isOwner() |
"Only Converter" | pragma solidity ^0.5.0;
/**
* @title ConverterRole
* @dev Converters are responsible for assigning and removing Whitelisted accounts.
*/
contract ConverterRole is Ownable {
using Roles for Roles.Role;
event ConverterAdded(address indexed account);
event ConverterRemoved(address indexed account);
Roles.Role private _converters;
constructor () internal {
}
modifier onlyConverterAdmin() {
}
modifier onlyConverter() {
require(<FILL_ME>)
_;
}
function isConverter(address account) public view returns (bool) {
}
function addConverter(address account) public onlyConverterAdmin {
}
function renounceConverter() public {
}
function resetWhitelist() public onlyOwner {
}
function _addConverter(address account) internal {
}
function _removeConverter(address account) internal {
}
}
| isConverter(msg.sender),"Only Converter" | 310,604 | isConverter(msg.sender) |
"Masterchef Strategy already initialized" | contract Strategy is BaseStrategy {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
ChefLike public masterchef;
IERC20 public reward;
address private constant uniswapRouter =
address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private constant sushiswapRouter =
address(0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F);
address private constant weth =
address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
IUniswapV2Router02 public router;
uint256 public pid;
address[] public path;
bool public harvestOnLiq;
event Cloned(address indexed clone);
modifier onlyGuardians() {
}
constructor(
address _vault,
address _masterchef,
address _reward,
address _router,
uint256 _pid
) public BaseStrategy(_vault) {
}
function initialize(
address _vault,
address _strategist,
address _rewards,
address _keeper,
address _masterchef,
address _reward,
address _router,
uint256 _pid
) external {
}
function _initializeStrat(
address _masterchef,
address _reward,
address _router,
uint256 _pid
) internal {
require(<FILL_ME>)
require(
_router == uniswapRouter || _router == sushiswapRouter,
"incorrect router"
);
// You can set these parameters on deployment to whatever you want
maxReportDelay = 6300;
profitFactor = 1500;
debtThreshold = 1_000_000 * 1e18;
masterchef = ChefLike(_masterchef);
reward = IERC20(_reward);
router = IUniswapV2Router02(_router);
pid = _pid;
path = getTokenOutPath(_reward, address(want));
harvestOnLiq = true;
require(
address(want) == masterchef.poolInfo(pid).stakingToken,
"wrong pid"
);
want.safeApprove(_masterchef, type(uint256).max);
reward.safeApprove(_router, type(uint256).max);
}
function cloneStrategy(
address _vault,
address _strategist,
address _rewards,
address _keeper,
address _masterchef,
address _reward,
address _router,
uint256 _pid
) external returns (address newStrategy) {
}
function setRouter(address _router) public onlyAuthorized {
}
function getTokenOutPath(address _token_in, address _token_out)
internal
view
returns (address[] memory _path)
{
}
function setPath(address[] calldata _path) public onlyGuardians {
}
// ******** OVERRIDE THESE METHODS FROM BASE CONTRACT ************
function name() external view override returns (string memory) {
}
function estimatedTotalAssets() public view override returns (uint256) {
}
function prepareReturn(uint256 _debtOutstanding)
internal
override
returns (
uint256 _profit,
uint256 _loss,
uint256 _debtPayment
)
{
}
function adjustPosition(uint256 _debtOutstanding) internal override {
}
function liquidatePosition(uint256 _amountNeeded)
internal
override
returns (uint256 _liquidatedAmount, uint256 _loss)
{
}
// NOTE: Can override `tendTrigger` and `harvestTrigger` if necessary
function prepareMigration(address _newStrategy) internal override {
}
function emergencyWithdrawal(uint256 _pid) external onlyGovernance {
}
function toggleharvestOnLiq() external onlyGuardians {
}
//sell all function
function _sell() internal {
}
function protectedTokens()
internal
view
override
returns (address[] memory)
{}
}
| address(router)==address(0),"Masterchef Strategy already initialized" | 310,771 | address(router)==address(0) |
"wrong pid" | contract Strategy is BaseStrategy {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
ChefLike public masterchef;
IERC20 public reward;
address private constant uniswapRouter =
address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private constant sushiswapRouter =
address(0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F);
address private constant weth =
address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
IUniswapV2Router02 public router;
uint256 public pid;
address[] public path;
bool public harvestOnLiq;
event Cloned(address indexed clone);
modifier onlyGuardians() {
}
constructor(
address _vault,
address _masterchef,
address _reward,
address _router,
uint256 _pid
) public BaseStrategy(_vault) {
}
function initialize(
address _vault,
address _strategist,
address _rewards,
address _keeper,
address _masterchef,
address _reward,
address _router,
uint256 _pid
) external {
}
function _initializeStrat(
address _masterchef,
address _reward,
address _router,
uint256 _pid
) internal {
require(
address(router) == address(0),
"Masterchef Strategy already initialized"
);
require(
_router == uniswapRouter || _router == sushiswapRouter,
"incorrect router"
);
// You can set these parameters on deployment to whatever you want
maxReportDelay = 6300;
profitFactor = 1500;
debtThreshold = 1_000_000 * 1e18;
masterchef = ChefLike(_masterchef);
reward = IERC20(_reward);
router = IUniswapV2Router02(_router);
pid = _pid;
path = getTokenOutPath(_reward, address(want));
harvestOnLiq = true;
require(<FILL_ME>)
want.safeApprove(_masterchef, type(uint256).max);
reward.safeApprove(_router, type(uint256).max);
}
function cloneStrategy(
address _vault,
address _strategist,
address _rewards,
address _keeper,
address _masterchef,
address _reward,
address _router,
uint256 _pid
) external returns (address newStrategy) {
}
function setRouter(address _router) public onlyAuthorized {
}
function getTokenOutPath(address _token_in, address _token_out)
internal
view
returns (address[] memory _path)
{
}
function setPath(address[] calldata _path) public onlyGuardians {
}
// ******** OVERRIDE THESE METHODS FROM BASE CONTRACT ************
function name() external view override returns (string memory) {
}
function estimatedTotalAssets() public view override returns (uint256) {
}
function prepareReturn(uint256 _debtOutstanding)
internal
override
returns (
uint256 _profit,
uint256 _loss,
uint256 _debtPayment
)
{
}
function adjustPosition(uint256 _debtOutstanding) internal override {
}
function liquidatePosition(uint256 _amountNeeded)
internal
override
returns (uint256 _liquidatedAmount, uint256 _loss)
{
}
// NOTE: Can override `tendTrigger` and `harvestTrigger` if necessary
function prepareMigration(address _newStrategy) internal override {
}
function emergencyWithdrawal(uint256 _pid) external onlyGovernance {
}
function toggleharvestOnLiq() external onlyGuardians {
}
//sell all function
function _sell() internal {
}
function protectedTokens()
internal
view
override
returns (address[] memory)
{}
}
| address(want)==masterchef.poolInfo(pid).stakingToken,"wrong pid" | 310,771 | address(want)==masterchef.poolInfo(pid).stakingToken |
null | /**
* SPDX-License-Identifier: UNLICENSED
* TrafficLight.Finance -> Token Sale Contract
* _____ __ __ _ _ _ _ _
* |_ _| _ __ _ / _|/ _(_)__| | (_)__ _| |_| |_
* | || '_/ _` | _| _| / _| |__| / _` | ' \ _|
* |_||_| \__,_|_| |_| |_\__|____|_\__, |_||_\__|
* |___/
* |___/
*/
pragma solidity 0.6.12;
library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract Ownable {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () public {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract TrafficLight is Ownable {
using SafeMath for uint256;
// standard ERC20 variables.
string public constant name = "TrafficLight.Finance";
string public constant symbol = "TFL";
uint256 public constant decimals = 18;
uint256 private constant _maximumSupply = 10 ** decimals;
uint256 public _totalSupply;
uint256 public light;
uint256 public reward;
bool public start;
uint256 public burnPercent;
uint256 public rewardPercent;
uint256 public rewardDistributionPercent;
// events
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event changeLight(uint value);
mapping(address => uint256) public _balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
constructor(uint256 _initialSupply) public {
}
function totalSupply () public view returns (uint256) {
}
function balanceOf (address who) public view returns (uint256) {
}
function findReward (uint256 value) public view returns (uint256) {
}
function findBurn (uint256 value) public view returns (uint256) {
}
function _transfer(address _from, address _to, uint256 _value) internal {
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(<FILL_ME>)//*10 ** decimals
_transfer(msg.sender, _to, _value);
return true;
}
function burn (uint256 _burnAmount) public onlyOwner returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function switchlight() public {
}
function switchstart() public {
}
function setBurnPercent (uint256 value) public {
}
function setRewardPercent (uint256 value) public {
}
function setRewardDistributionPercent (uint256 value) public {
}
}
contract TrafficLightSale {
address payable public admin;
TrafficLight public tokenContract;
uint256 public tokenPrice;
uint256 public tokensSold;
uint256 public constant decimals = 10**18;
event Sell(address _buyer, uint256 _amount);
constructor (TrafficLight _tokenContract, uint256 _tokenPrice) public {
}
function multiply(uint x, uint y) internal pure returns (uint z) {
}
function buyTokens(uint256 _numberOfTokens) public payable {
}
function endSale() public {
}
}
| _balanceOf[msg.sender]>=_value | 310,836 | _balanceOf[msg.sender]>=_value |
null | /**
* SPDX-License-Identifier: UNLICENSED
* TrafficLight.Finance -> Token Sale Contract
* _____ __ __ _ _ _ _ _
* |_ _| _ __ _ / _|/ _(_)__| | (_)__ _| |_| |_
* | || '_/ _` | _| _| / _| |__| / _` | ' \ _|
* |_||_| \__,_|_| |_| |_\__|____|_\__, |_||_\__|
* |___/
* |___/
*/
pragma solidity 0.6.12;
library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract Ownable {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () public {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract TrafficLight is Ownable {
using SafeMath for uint256;
// standard ERC20 variables.
string public constant name = "TrafficLight.Finance";
string public constant symbol = "TFL";
uint256 public constant decimals = 18;
uint256 private constant _maximumSupply = 10 ** decimals;
uint256 public _totalSupply;
uint256 public light;
uint256 public reward;
bool public start;
uint256 public burnPercent;
uint256 public rewardPercent;
uint256 public rewardDistributionPercent;
// events
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event changeLight(uint value);
mapping(address => uint256) public _balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
constructor(uint256 _initialSupply) public {
}
function totalSupply () public view returns (uint256) {
}
function balanceOf (address who) public view returns (uint256) {
}
function findReward (uint256 value) public view returns (uint256) {
}
function findBurn (uint256 value) public view returns (uint256) {
}
function _transfer(address _from, address _to, uint256 _value) internal {
}
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function burn (uint256 _burnAmount) public onlyOwner returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function switchlight() public {
}
function switchstart() public {
}
function setBurnPercent (uint256 value) public {
}
function setRewardPercent (uint256 value) public {
}
function setRewardDistributionPercent (uint256 value) public {
}
}
contract TrafficLightSale {
address payable public admin;
TrafficLight public tokenContract;
uint256 public tokenPrice;
uint256 public tokensSold;
uint256 public constant decimals = 10**18;
event Sell(address _buyer, uint256 _amount);
constructor (TrafficLight _tokenContract, uint256 _tokenPrice) public {
}
function multiply(uint x, uint y) internal pure returns (uint z) {
}
function buyTokens(uint256 _numberOfTokens) public payable {
require(msg.value == multiply(_numberOfTokens, tokenPrice));
require(<FILL_ME>)
require(tokenContract.transfer(msg.sender, _numberOfTokens*decimals));
tokensSold += _numberOfTokens;
emit Sell(msg.sender, _numberOfTokens);
}
function endSale() public {
}
}
| tokenContract.balanceOf(address(this))>=_numberOfTokens*decimals | 310,836 | tokenContract.balanceOf(address(this))>=_numberOfTokens*decimals |
null | /**
* SPDX-License-Identifier: UNLICENSED
* TrafficLight.Finance -> Token Sale Contract
* _____ __ __ _ _ _ _ _
* |_ _| _ __ _ / _|/ _(_)__| | (_)__ _| |_| |_
* | || '_/ _` | _| _| / _| |__| / _` | ' \ _|
* |_||_| \__,_|_| |_| |_\__|____|_\__, |_||_\__|
* |___/
* |___/
*/
pragma solidity 0.6.12;
library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract Ownable {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () public {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract TrafficLight is Ownable {
using SafeMath for uint256;
// standard ERC20 variables.
string public constant name = "TrafficLight.Finance";
string public constant symbol = "TFL";
uint256 public constant decimals = 18;
uint256 private constant _maximumSupply = 10 ** decimals;
uint256 public _totalSupply;
uint256 public light;
uint256 public reward;
bool public start;
uint256 public burnPercent;
uint256 public rewardPercent;
uint256 public rewardDistributionPercent;
// events
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event changeLight(uint value);
mapping(address => uint256) public _balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
constructor(uint256 _initialSupply) public {
}
function totalSupply () public view returns (uint256) {
}
function balanceOf (address who) public view returns (uint256) {
}
function findReward (uint256 value) public view returns (uint256) {
}
function findBurn (uint256 value) public view returns (uint256) {
}
function _transfer(address _from, address _to, uint256 _value) internal {
}
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function burn (uint256 _burnAmount) public onlyOwner returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function switchlight() public {
}
function switchstart() public {
}
function setBurnPercent (uint256 value) public {
}
function setRewardPercent (uint256 value) public {
}
function setRewardDistributionPercent (uint256 value) public {
}
}
contract TrafficLightSale {
address payable public admin;
TrafficLight public tokenContract;
uint256 public tokenPrice;
uint256 public tokensSold;
uint256 public constant decimals = 10**18;
event Sell(address _buyer, uint256 _amount);
constructor (TrafficLight _tokenContract, uint256 _tokenPrice) public {
}
function multiply(uint x, uint y) internal pure returns (uint z) {
}
function buyTokens(uint256 _numberOfTokens) public payable {
require(msg.value == multiply(_numberOfTokens, tokenPrice));
require(tokenContract.balanceOf(address(this)) >= _numberOfTokens*decimals);
require(<FILL_ME>)
tokensSold += _numberOfTokens;
emit Sell(msg.sender, _numberOfTokens);
}
function endSale() public {
}
}
| tokenContract.transfer(msg.sender,_numberOfTokens*decimals) | 310,836 | tokenContract.transfer(msg.sender,_numberOfTokens*decimals) |
null | /**
* SPDX-License-Identifier: UNLICENSED
* TrafficLight.Finance -> Token Sale Contract
* _____ __ __ _ _ _ _ _
* |_ _| _ __ _ / _|/ _(_)__| | (_)__ _| |_| |_
* | || '_/ _` | _| _| / _| |__| / _` | ' \ _|
* |_||_| \__,_|_| |_| |_\__|____|_\__, |_||_\__|
* |___/
* |___/
*/
pragma solidity 0.6.12;
library SafeMath {
/**
* @dev Multiplies two unsigned integers, reverts on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two unsigned integers, reverts on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract Ownable {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () public {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract TrafficLight is Ownable {
using SafeMath for uint256;
// standard ERC20 variables.
string public constant name = "TrafficLight.Finance";
string public constant symbol = "TFL";
uint256 public constant decimals = 18;
uint256 private constant _maximumSupply = 10 ** decimals;
uint256 public _totalSupply;
uint256 public light;
uint256 public reward;
bool public start;
uint256 public burnPercent;
uint256 public rewardPercent;
uint256 public rewardDistributionPercent;
// events
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event changeLight(uint value);
mapping(address => uint256) public _balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
constructor(uint256 _initialSupply) public {
}
function totalSupply () public view returns (uint256) {
}
function balanceOf (address who) public view returns (uint256) {
}
function findReward (uint256 value) public view returns (uint256) {
}
function findBurn (uint256 value) public view returns (uint256) {
}
function _transfer(address _from, address _to, uint256 _value) internal {
}
function transfer(address _to, uint256 _value) public returns (bool success) {
}
function burn (uint256 _burnAmount) public onlyOwner returns (bool success) {
}
function approve(address _spender, uint256 _value) public returns (bool success) {
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function switchlight() public {
}
function switchstart() public {
}
function setBurnPercent (uint256 value) public {
}
function setRewardPercent (uint256 value) public {
}
function setRewardDistributionPercent (uint256 value) public {
}
}
contract TrafficLightSale {
address payable public admin;
TrafficLight public tokenContract;
uint256 public tokenPrice;
uint256 public tokensSold;
uint256 public constant decimals = 10**18;
event Sell(address _buyer, uint256 _amount);
constructor (TrafficLight _tokenContract, uint256 _tokenPrice) public {
}
function multiply(uint x, uint y) internal pure returns (uint z) {
}
function buyTokens(uint256 _numberOfTokens) public payable {
}
function endSale() public {
require(msg.sender == admin);
require(<FILL_ME>)
tokensSold = 0;
admin.transfer(address(this).balance);
}
}
| tokenContract.transfer(admin,tokenContract.balanceOf(address(this))) | 310,836 | tokenContract.transfer(admin,tokenContract.balanceOf(address(this))) |
"you are not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract ChilliSwapToken is Ownable , IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private whiteList;
uint256 private _totalSupply;
string private _name ;
string private _symbol ;
uint8 private _decimals;
uint256 public constant multiplier = (10**18);
uint256 public lastDevRelease;
uint256 public lastTeamRelease;
address team;
address dev;
uint256 public releaseStartDate;
uint256 totalDevMinted;
uint256 totalTeamMinted;
constructor (
address _development,
address _team,
address _ido,
address _farming,
address _airdrops,
address _bounties,
address _treasary,
address _privateSale
) {
}
function devRelease() public {
}
function teamRelease() public {
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view 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.
*
* 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 returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override isUserwhiteListed() 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 isUserwhiteListed() 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 isUserwhiteListed() 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 isUserwhiteListed() 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 isUserwhiteListed() 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 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 {
}
function burn(uint256 _amount) external{
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function checkIsUserWhiteListed(address _user) public view returns(bool){
}
function whiteListAddress(address _user ,bool _varaible) external onlyOwner{
}
modifier isUserwhiteListed(){
require(<FILL_ME>)
_;
}
}
| !whiteList[msg.sender],"you are not whitelisted" | 311,103 | !whiteList[msg.sender] |
'Already claimed' | pragma solidity 0.6.2;
interface IBancorNetwork {
function convertByPath(
address[] calldata _path,
uint256 _amount,
uint256 _minReturn,
address _beneficiary,
address _affiliateAccount,
uint256 _affiliateFee
) external payable returns (uint256);
function rateByPath(address[] calldata _path, uint256 _amount)
external
view
returns (uint256);
function conversionPath(IERC20 _sourceToken, IERC20 _targetToken)
external
view
returns (address[] memory);
}
contract xBNT is ERC20UpgradeSafe, OwnableUpgradeSafe, PausableUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 private bnt;
IERC20 private vbnt;
IContractRegistry private contractRegistry;
IBancorGovernance internal bancorGovernance;
IMinimalProxyFactory private proxyFactory;
bytes32 private constant bancorNetworkName = 'BancorNetwork';
bytes32 private constant stakingRewardsName = 'StakingRewards';
bytes32 private constant liquidityProtectionName = 'LiquidityProtection';
uint32 private constant PPM = 1000000;
uint256 private constant DEC_18 = 1e18;
uint256 private constant BUFFER_TARGET = 20; // 5%
uint256 private constant MAX_UINT = 2**256 - 1;
uint256 private constant WAITING_PERIOD = 2 days;
uint256 private constant INITIAL_SUPPLY_MULTIPLIER = 10;
uint256 private constant LIQUIDATION_TIME_PERIOD = 4 weeks;
uint256 private lpImplementationChangedTimestamp;
uint256 private governanceAddressChangedTimestamp;
uint256 public adminActiveTimestamp;
uint256 public lowestActiveProxyIndex;
uint256 public nextProxyIndex;
uint256 public totalAllocatedNav;
uint256 public pendingRewardsContributionToNav;
uint256 public withdrawableBntFees;
address private manager;
address private manager2;
address internal liquidityProviderImplementation;
address private queuedLiquidityProviderImplementation;
address private queuedGovernanceAddress;
address private constant ZERO_ADDRESS = address(0);
struct FeeDivisors {
uint256 mintFee;
uint256 burnFee;
uint256 claimFee;
}
FeeDivisors public feeDivisors;
struct Deposit {
address proxyAddress;
uint256 depositId;
uint256 initialContribution;
uint256 latestContributionToNav;
}
mapping(uint256 => Deposit) public depositIdToDeposit;
struct ProxyData {
uint256[] depositIds;
uint256 pendingRewardsContributionToNav;
uint256 deployedBnt;
bool balanceClaimed;
}
mapping(address => ProxyData) private proxyAddressToData;
mapping(uint256 => address) public proxyIndexToAddress;
event AddLiquidity(
address poolToken,
uint256 amount,
uint256 depositId,
uint256 proxyIndex,
uint256 timestamp
);
event ClaimRestake(
uint256 proxyIndex,
uint256 amount,
uint256 depositId,
uint256 timestamp
);
event ClaimRemove(uint256 proxyIndex, uint256 rewardsClaimed);
event ClaimRewards(uint256 proxyIndex, uint256 rewardsClaimed);
event ClaimBalance(uint256 proxyIndex);
event RewardsNavUpdated(
uint256 previousRewardsNav,
uint256 newRewardsNav,
uint256 timestamp
);
event KeyAddressChange();
function initialize(
IERC20 _bnt,
IERC20 _vbnt,
IContractRegistry _contractRegistry,
IBancorGovernance _bancorGovernance,
IMinimalProxyFactory _proxyFactory,
address _liquidityProviderImplementation,
uint256 _mintFeeDivisor,
uint256 _burnFeeDivisor,
uint256 _claimFeeDivisor,
string memory _symbol
) public initializer {
}
/* ========================================================================================= */
/* User-Facing */
/* ========================================================================================= */
/*
* @notice Mint xBNT using ETH
* @param path: BancorNetwork trade path
* @param minReturn: BancorNetwork trade minReturn
*/
function mint(address[] calldata path, uint256 minReturn)
external
payable
whenNotPaused
{
}
/*
* @notice Mint xBNT using BNT
* @notice Must run approval first
* @param bntAmount: BNT amount
*/
function mintWithToken(uint256 bntAmount) external whenNotPaused {
}
function _mintInternal(uint256 _incrementalBnt) private {
}
function calculateMintAmount(uint256 incrementalBnt, uint256 totalSupply)
public
view
returns (uint256 mintAmount)
{
}
/*
* @notice Burn xBNT
* @notice Will fail if pro rata BNT is more than buffer balance
* @param redeemAmount: xBNT to burn
* @param redeemForEth: Redeem for ETH or BNT
* @param path: If redeem for ETH, BancorNetwork path
* @param minReturn: If redeem for ETH, BancorNetwork minReturn
*/
function burn(
uint256 redeemAmount,
bool redeemForEth,
address[] memory path,
uint256 minReturn
) public {
}
/* ========================================================================================= */
/* Liquidity Provision */
/* ========================================================================================= */
/*
* @notice Makes BNT deposit on Bancor
* @notice Deploys new proxy
* @notice Allocates buffer BNT to allocated NAV
* @param _poolAnchor: Address of liquidity pool
* @param _amount: BNT amount
*/
function addLiquidity(IConverterAnchor _poolAnchor, uint256 _amount)
external
onlyOwnerOrManager
{
}
/*
* @notice Restakes rewards from current deposit into new deposit
* @notice Deploys capital to same proxy as current deposit
* @notice Allocates from rewards NAV to allocated NAV
* @param proxyIndex: Proxy index
* @param poolToken: Pool to restake rewards to
*/
function claimAndRestake(uint256 proxyIndex, address poolToken)
external
onlyOwnerOrManager
{
}
/*
* @notice Iterates through proxies to calculate current available rewards
* @notice Must be called daily or more to stay current with NAV
* @notice We specify begin/end indices in case num proxies approaches gas limit
* @param beginProxyIndexIterator: proxyIndex to begin iteration
* @param endProxyIndexIterator: proxyIndex to end iteration
*/
function updatePendingRewardsContributionToNav(
uint256 beginProxyIndexIterator,
uint256 endProxyIndexIterator
) external {
}
/*
* @notice Updates NAV for value of deposits
* @notice Needs to be called weekly at least
* @notice Due to IL protection, allocated NAV is assumed to be the greater of value
* of initial deposit or removeLiquidityReturn
* @notice We specify begin/end indices in case num deposits approaches gas limit
* @param beginProxyIndexIterator: proxyIndex to begin iteration
* @param endProxyIndexIterator: proxyIndex to end iteration
*/
function updateTotalAllocatedNav(
uint256 beginProxyIndexIterator,
uint256 endProxyIndexIterator
) external {
}
/*
* @notice Removes all deposits from proxy at lowestActiveProxyIndex
*/
function claimRewardsAndRemoveLiquidity() external onlyOwnerOrManager {
}
function emergencyClaimAndRemove() external liquidationTimeElapsed {
}
function _claimRewardsAndRemoveLiquidity() private {
}
/*
* @notice Second step in removal process
* @notice Claims deposits balance 24 hrs after `claimRewardsAndRemoveLiquidity` called
* @param proxyIndex: proxyIndex
*/
function claimBalance(uint256 proxyIndex) external onlyOwnerOrManager {
}
function emergencyClaimBalance(uint256 proxyIndex)
external
liquidationTimeElapsed
{
}
function _claimBalance(uint256 _proxyIndex) private {
address proxyAddress = proxyIndexToAddress[_proxyIndex];
ProxyData memory proxyData = proxyAddressToData[proxyAddress];
require(<FILL_ME>)
proxyAddressToData[proxyAddress].balanceClaimed = true;
ILiquidityProvider lpProxy = ILiquidityProvider(proxyAddress);
lpProxy.claimBalance();
uint256 contributionToTotalAllocatedNav;
uint256[] memory depositIds = proxyData.depositIds;
for (uint256 i = 0; i < depositIds.length; i++) {
contributionToTotalAllocatedNav = contributionToTotalAllocatedNav
.add(depositIdToDeposit[depositIds[i]].latestContributionToNav);
}
emit ClaimBalance(_proxyIndex);
// allocatedNav now becomes bnt buffer balance
totalAllocatedNav = totalAllocatedNav.sub(
contributionToTotalAllocatedNav
);
}
/*
* @notice Claims rewards from a proxy without restaking
* @notice Will reset rewards multiplier - use sparingly when buffer balance needed
*/
function claimRewards(uint256 proxyIndex) external onlyOwnerOrManager {
}
function getLiquidityProtectionContract()
public
view
returns (ILiquidityProtection)
{
}
function getStakingRewardsContract() public view returns (IStakingRewards) {
}
/* ========================================================================================= */
/* Utils */
/* ========================================================================================= */
function getProxyAddressDepositIds(address proxyAddress)
public
view
returns (uint256[] memory)
{
}
function getProxyAddressRewardsContributionToNav(address proxyAddress)
public
view
returns (uint256)
{
}
function changeLiquidityProviderImplementation(address newImplementation)
external
onlyOwner
{
}
function confirmLiquidityProviderImplementationChange() external onlyOwner {
}
function changeGovernanceAddress(address newAddress) external onlyOwner {
}
function confirmGovernanceAddressChange() external onlyOwner {
}
/* ========================================================================================= */
/* Governance */
/* ========================================================================================= */
// we should probably have a setter in case bancor gov address changes
function _stake(uint256 _amount) private {
}
function _unstake(uint256 _amount) private {
}
/* ========================================================================================= */
/* NAV */
/* ========================================================================================= */
function getTargetBufferBalance() public view returns (uint256) {
}
function getNav() public view returns (uint256) {
}
function getRewardsContributionToNav() public view returns (uint256) {
}
function getBufferBalance() public view returns (uint256) {
}
function _calculateFee(uint256 _value, uint256 _feeDivisor)
internal
pure
returns (uint256 fee)
{
}
function _incrementWithdrawableBntFees(uint256 _feeAmount) private {
}
function _calculateAndIncrementFee(uint256 _value, uint256 _feeDivisor)
private
returns (uint256 fee)
{
}
function setDelegate(
address delegateRegistry,
bytes32 id,
address delegate
) external onlyOwnerOrManager {
}
/* ========================================================================================= */
/* Utils */
/* ========================================================================================= */
function _approveIfNecessary(IERC20 _token, address _toApprove) private {
}
function getBancorNetworkContract() public view returns (IBancorNetwork) {
}
function approveVbnt(address _toApprove) external onlyOwnerOrManager {
}
function pauseContract() external onlyOwnerOrManager {
}
function unpauseContract() external onlyOwnerOrManager {
}
modifier onlyOwnerOrManager {
}
modifier liquidationTimeElapsed {
}
/*
* @notice manager == alternative admin caller to owner
*/
function setManager(address _manager) external onlyOwner {
}
/*
* @notice manager2 == alternative admin caller to owner
*/
function setManager2(address _manager2) external onlyOwner {
}
/*
* @notice Inverse of fee i.e., a fee divisor of 100 == 1%
* @notice Three fee types
* @dev Mint fee 0 or <= 2%
* @dev Burn fee 0 or <= 1%
* @dev Claim fee 0 <= 4%
*/
function setFeeDivisors(
uint256 mintFeeDivisor,
uint256 burnFeeDivisor,
uint256 claimFeeDivisor
) external onlyOwner {
}
function _setFeeDivisors(
uint256 _mintFeeDivisor,
uint256 _burnFeeDivisor,
uint256 _claimFeeDivisor
) private {
}
/*
* @notice Records admin activity
* @notice If not certified for a period exceeding LIQUIDATION_TIME_PERIOD,
* emergencyCooldown and emergencyRedeem become available to non-admin caller
*/
function _updateAdminActiveTimestamp() private {
}
receive() external payable {
}
}
| !proxyData.balanceClaimed,'Already claimed' | 311,113 | !proxyData.balanceClaimed |
'Liquidation time not elapsed' | pragma solidity 0.6.2;
interface IBancorNetwork {
function convertByPath(
address[] calldata _path,
uint256 _amount,
uint256 _minReturn,
address _beneficiary,
address _affiliateAccount,
uint256 _affiliateFee
) external payable returns (uint256);
function rateByPath(address[] calldata _path, uint256 _amount)
external
view
returns (uint256);
function conversionPath(IERC20 _sourceToken, IERC20 _targetToken)
external
view
returns (address[] memory);
}
contract xBNT is ERC20UpgradeSafe, OwnableUpgradeSafe, PausableUpgradeSafe {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 private bnt;
IERC20 private vbnt;
IContractRegistry private contractRegistry;
IBancorGovernance internal bancorGovernance;
IMinimalProxyFactory private proxyFactory;
bytes32 private constant bancorNetworkName = 'BancorNetwork';
bytes32 private constant stakingRewardsName = 'StakingRewards';
bytes32 private constant liquidityProtectionName = 'LiquidityProtection';
uint32 private constant PPM = 1000000;
uint256 private constant DEC_18 = 1e18;
uint256 private constant BUFFER_TARGET = 20; // 5%
uint256 private constant MAX_UINT = 2**256 - 1;
uint256 private constant WAITING_PERIOD = 2 days;
uint256 private constant INITIAL_SUPPLY_MULTIPLIER = 10;
uint256 private constant LIQUIDATION_TIME_PERIOD = 4 weeks;
uint256 private lpImplementationChangedTimestamp;
uint256 private governanceAddressChangedTimestamp;
uint256 public adminActiveTimestamp;
uint256 public lowestActiveProxyIndex;
uint256 public nextProxyIndex;
uint256 public totalAllocatedNav;
uint256 public pendingRewardsContributionToNav;
uint256 public withdrawableBntFees;
address private manager;
address private manager2;
address internal liquidityProviderImplementation;
address private queuedLiquidityProviderImplementation;
address private queuedGovernanceAddress;
address private constant ZERO_ADDRESS = address(0);
struct FeeDivisors {
uint256 mintFee;
uint256 burnFee;
uint256 claimFee;
}
FeeDivisors public feeDivisors;
struct Deposit {
address proxyAddress;
uint256 depositId;
uint256 initialContribution;
uint256 latestContributionToNav;
}
mapping(uint256 => Deposit) public depositIdToDeposit;
struct ProxyData {
uint256[] depositIds;
uint256 pendingRewardsContributionToNav;
uint256 deployedBnt;
bool balanceClaimed;
}
mapping(address => ProxyData) private proxyAddressToData;
mapping(uint256 => address) public proxyIndexToAddress;
event AddLiquidity(
address poolToken,
uint256 amount,
uint256 depositId,
uint256 proxyIndex,
uint256 timestamp
);
event ClaimRestake(
uint256 proxyIndex,
uint256 amount,
uint256 depositId,
uint256 timestamp
);
event ClaimRemove(uint256 proxyIndex, uint256 rewardsClaimed);
event ClaimRewards(uint256 proxyIndex, uint256 rewardsClaimed);
event ClaimBalance(uint256 proxyIndex);
event RewardsNavUpdated(
uint256 previousRewardsNav,
uint256 newRewardsNav,
uint256 timestamp
);
event KeyAddressChange();
function initialize(
IERC20 _bnt,
IERC20 _vbnt,
IContractRegistry _contractRegistry,
IBancorGovernance _bancorGovernance,
IMinimalProxyFactory _proxyFactory,
address _liquidityProviderImplementation,
uint256 _mintFeeDivisor,
uint256 _burnFeeDivisor,
uint256 _claimFeeDivisor,
string memory _symbol
) public initializer {
}
/* ========================================================================================= */
/* User-Facing */
/* ========================================================================================= */
/*
* @notice Mint xBNT using ETH
* @param path: BancorNetwork trade path
* @param minReturn: BancorNetwork trade minReturn
*/
function mint(address[] calldata path, uint256 minReturn)
external
payable
whenNotPaused
{
}
/*
* @notice Mint xBNT using BNT
* @notice Must run approval first
* @param bntAmount: BNT amount
*/
function mintWithToken(uint256 bntAmount) external whenNotPaused {
}
function _mintInternal(uint256 _incrementalBnt) private {
}
function calculateMintAmount(uint256 incrementalBnt, uint256 totalSupply)
public
view
returns (uint256 mintAmount)
{
}
/*
* @notice Burn xBNT
* @notice Will fail if pro rata BNT is more than buffer balance
* @param redeemAmount: xBNT to burn
* @param redeemForEth: Redeem for ETH or BNT
* @param path: If redeem for ETH, BancorNetwork path
* @param minReturn: If redeem for ETH, BancorNetwork minReturn
*/
function burn(
uint256 redeemAmount,
bool redeemForEth,
address[] memory path,
uint256 minReturn
) public {
}
/* ========================================================================================= */
/* Liquidity Provision */
/* ========================================================================================= */
/*
* @notice Makes BNT deposit on Bancor
* @notice Deploys new proxy
* @notice Allocates buffer BNT to allocated NAV
* @param _poolAnchor: Address of liquidity pool
* @param _amount: BNT amount
*/
function addLiquidity(IConverterAnchor _poolAnchor, uint256 _amount)
external
onlyOwnerOrManager
{
}
/*
* @notice Restakes rewards from current deposit into new deposit
* @notice Deploys capital to same proxy as current deposit
* @notice Allocates from rewards NAV to allocated NAV
* @param proxyIndex: Proxy index
* @param poolToken: Pool to restake rewards to
*/
function claimAndRestake(uint256 proxyIndex, address poolToken)
external
onlyOwnerOrManager
{
}
/*
* @notice Iterates through proxies to calculate current available rewards
* @notice Must be called daily or more to stay current with NAV
* @notice We specify begin/end indices in case num proxies approaches gas limit
* @param beginProxyIndexIterator: proxyIndex to begin iteration
* @param endProxyIndexIterator: proxyIndex to end iteration
*/
function updatePendingRewardsContributionToNav(
uint256 beginProxyIndexIterator,
uint256 endProxyIndexIterator
) external {
}
/*
* @notice Updates NAV for value of deposits
* @notice Needs to be called weekly at least
* @notice Due to IL protection, allocated NAV is assumed to be the greater of value
* of initial deposit or removeLiquidityReturn
* @notice We specify begin/end indices in case num deposits approaches gas limit
* @param beginProxyIndexIterator: proxyIndex to begin iteration
* @param endProxyIndexIterator: proxyIndex to end iteration
*/
function updateTotalAllocatedNav(
uint256 beginProxyIndexIterator,
uint256 endProxyIndexIterator
) external {
}
/*
* @notice Removes all deposits from proxy at lowestActiveProxyIndex
*/
function claimRewardsAndRemoveLiquidity() external onlyOwnerOrManager {
}
function emergencyClaimAndRemove() external liquidationTimeElapsed {
}
function _claimRewardsAndRemoveLiquidity() private {
}
/*
* @notice Second step in removal process
* @notice Claims deposits balance 24 hrs after `claimRewardsAndRemoveLiquidity` called
* @param proxyIndex: proxyIndex
*/
function claimBalance(uint256 proxyIndex) external onlyOwnerOrManager {
}
function emergencyClaimBalance(uint256 proxyIndex)
external
liquidationTimeElapsed
{
}
function _claimBalance(uint256 _proxyIndex) private {
}
/*
* @notice Claims rewards from a proxy without restaking
* @notice Will reset rewards multiplier - use sparingly when buffer balance needed
*/
function claimRewards(uint256 proxyIndex) external onlyOwnerOrManager {
}
function getLiquidityProtectionContract()
public
view
returns (ILiquidityProtection)
{
}
function getStakingRewardsContract() public view returns (IStakingRewards) {
}
/* ========================================================================================= */
/* Utils */
/* ========================================================================================= */
function getProxyAddressDepositIds(address proxyAddress)
public
view
returns (uint256[] memory)
{
}
function getProxyAddressRewardsContributionToNav(address proxyAddress)
public
view
returns (uint256)
{
}
function changeLiquidityProviderImplementation(address newImplementation)
external
onlyOwner
{
}
function confirmLiquidityProviderImplementationChange() external onlyOwner {
}
function changeGovernanceAddress(address newAddress) external onlyOwner {
}
function confirmGovernanceAddressChange() external onlyOwner {
}
/* ========================================================================================= */
/* Governance */
/* ========================================================================================= */
// we should probably have a setter in case bancor gov address changes
function _stake(uint256 _amount) private {
}
function _unstake(uint256 _amount) private {
}
/* ========================================================================================= */
/* NAV */
/* ========================================================================================= */
function getTargetBufferBalance() public view returns (uint256) {
}
function getNav() public view returns (uint256) {
}
function getRewardsContributionToNav() public view returns (uint256) {
}
function getBufferBalance() public view returns (uint256) {
}
function _calculateFee(uint256 _value, uint256 _feeDivisor)
internal
pure
returns (uint256 fee)
{
}
function _incrementWithdrawableBntFees(uint256 _feeAmount) private {
}
function _calculateAndIncrementFee(uint256 _value, uint256 _feeDivisor)
private
returns (uint256 fee)
{
}
function setDelegate(
address delegateRegistry,
bytes32 id,
address delegate
) external onlyOwnerOrManager {
}
/* ========================================================================================= */
/* Utils */
/* ========================================================================================= */
function _approveIfNecessary(IERC20 _token, address _toApprove) private {
}
function getBancorNetworkContract() public view returns (IBancorNetwork) {
}
function approveVbnt(address _toApprove) external onlyOwnerOrManager {
}
function pauseContract() external onlyOwnerOrManager {
}
function unpauseContract() external onlyOwnerOrManager {
}
modifier onlyOwnerOrManager {
}
modifier liquidationTimeElapsed {
require(<FILL_ME>)
_;
}
/*
* @notice manager == alternative admin caller to owner
*/
function setManager(address _manager) external onlyOwner {
}
/*
* @notice manager2 == alternative admin caller to owner
*/
function setManager2(address _manager2) external onlyOwner {
}
/*
* @notice Inverse of fee i.e., a fee divisor of 100 == 1%
* @notice Three fee types
* @dev Mint fee 0 or <= 2%
* @dev Burn fee 0 or <= 1%
* @dev Claim fee 0 <= 4%
*/
function setFeeDivisors(
uint256 mintFeeDivisor,
uint256 burnFeeDivisor,
uint256 claimFeeDivisor
) external onlyOwner {
}
function _setFeeDivisors(
uint256 _mintFeeDivisor,
uint256 _burnFeeDivisor,
uint256 _claimFeeDivisor
) private {
}
/*
* @notice Records admin activity
* @notice If not certified for a period exceeding LIQUIDATION_TIME_PERIOD,
* emergencyCooldown and emergencyRedeem become available to non-admin caller
*/
function _updateAdminActiveTimestamp() private {
}
receive() external payable {
}
}
| adminActiveTimestamp.add(LIQUIDATION_TIME_PERIOD)<block.timestamp,'Liquidation time not elapsed' | 311,113 | adminActiveTimestamp.add(LIQUIDATION_TIME_PERIOD)<block.timestamp |
"Only 5 toadz per address!" | contract Toadz is ERC721("Flip Toadz", "FLOADZ"){
address public owner;
uint256 public maxSupply = 6969;
uint256 public dropTime;
uint256 public accLimit = 5;
uint256 public mintPerTx = 3;
uint256 public minted = 0;
constructor(uint256 _dropTime) public {
}
function setURI(string memory _uri) public {
}
function mint(uint256 _amount) public payable {
require(block.timestamp >= dropTime, "Drop not yet available");
require(_amount <= mintPerTx, "Only 5 mints per tx");
require(<FILL_ME>)
require((minted + _amount) <= maxSupply, "Sold out");
for (uint256 i = 0; i < _amount; i++) {
minted += 1;
_mint(msg.sender, minted);
}
}
function reroll(uint256 _token1, uint256 _token2) public {
}
function changeOwner(address _owner) public {
}
}
| balanceOf(msg.sender)+_amount<=accLimit,"Only 5 toadz per address!" | 311,201 | balanceOf(msg.sender)+_amount<=accLimit |
"Sold out" | contract Toadz is ERC721("Flip Toadz", "FLOADZ"){
address public owner;
uint256 public maxSupply = 6969;
uint256 public dropTime;
uint256 public accLimit = 5;
uint256 public mintPerTx = 3;
uint256 public minted = 0;
constructor(uint256 _dropTime) public {
}
function setURI(string memory _uri) public {
}
function mint(uint256 _amount) public payable {
require(block.timestamp >= dropTime, "Drop not yet available");
require(_amount <= mintPerTx, "Only 5 mints per tx");
require(balanceOf(msg.sender) + _amount <= accLimit, "Only 5 toadz per address!");
require(<FILL_ME>)
for (uint256 i = 0; i < _amount; i++) {
minted += 1;
_mint(msg.sender, minted);
}
}
function reroll(uint256 _token1, uint256 _token2) public {
}
function changeOwner(address _owner) public {
}
}
| (minted+_amount)<=maxSupply,"Sold out" | 311,201 | (minted+_amount)<=maxSupply |
"You do not own these tokens!!" | contract Toadz is ERC721("Flip Toadz", "FLOADZ"){
address public owner;
uint256 public maxSupply = 6969;
uint256 public dropTime;
uint256 public accLimit = 5;
uint256 public mintPerTx = 3;
uint256 public minted = 0;
constructor(uint256 _dropTime) public {
}
function setURI(string memory _uri) public {
}
function mint(uint256 _amount) public payable {
}
function reroll(uint256 _token1, uint256 _token2) public {
require(<FILL_ME>)
require(minted + 1 <= maxSupply, "No longer available");
//burn tokens and mint again
_burn(_token1);
_burn(_token2);
minted += 1;
_mint(msg.sender, minted);
}
function changeOwner(address _owner) public {
}
}
| ownerOf(_token1)==msg.sender&&ownerOf(_token2)==msg.sender,"You do not own these tokens!!" | 311,201 | ownerOf(_token1)==msg.sender&&ownerOf(_token2)==msg.sender |
"No longer available" | contract Toadz is ERC721("Flip Toadz", "FLOADZ"){
address public owner;
uint256 public maxSupply = 6969;
uint256 public dropTime;
uint256 public accLimit = 5;
uint256 public mintPerTx = 3;
uint256 public minted = 0;
constructor(uint256 _dropTime) public {
}
function setURI(string memory _uri) public {
}
function mint(uint256 _amount) public payable {
}
function reroll(uint256 _token1, uint256 _token2) public {
require(ownerOf(_token1) == msg.sender && ownerOf(_token2) == msg.sender, "You do not own these tokens!!");
require(<FILL_ME>)
//burn tokens and mint again
_burn(_token1);
_burn(_token2);
minted += 1;
_mint(msg.sender, minted);
}
function changeOwner(address _owner) public {
}
}
| minted+1<=maxSupply,"No longer available" | 311,201 | minted+1<=maxSupply |
null | pragma solidity ^0.4.16;
/**
* Math operations with safety checks
*/
contract owned {
address public owner;
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) onlyOwner public {
}
}
contract SafeMath {
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract OP is owned, SafeMath {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
/* This creates an array with all balances */
mapping (address => uint256) public balanceOf;
mapping (address => uint256) public freezeOf;
mapping (address => mapping (address => uint256)) public allowance;
/* 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);
/* This notifies clients about the amount frozen */
event Freeze(address indexed from, uint256 value);
/* This notifies clients about the amount unfrozen */
event Unfreeze(address indexed from, uint256 value);
/* 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 {
}
/* Send coins */
function transfer(address _to, uint256 _value) public {
}
/* Allow another contract to spend some tokens in your behalf */
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function burn(uint256 _value) public onlyOwner returns (bool success) {
}
function mintToken(address _target, uint256 _mintedAmount) public onlyOwner returns (bool success) {
}
function freeze(address _target, uint256 _value) public onlyOwner returns (bool success) {
require(<FILL_ME>)
require(_value>0);
balanceOf[_target] = SafeMath.safeSub(balanceOf[_target], _value); // Subtract from the sender
freezeOf[_target] = SafeMath.safeAdd(freezeOf[_target], _value); // Updates totalSupply
emit Freeze(_target, _value);
return true;
}
function unfreeze(address _target, uint256 _value) public onlyOwner returns (bool success) {
}
}
| balanceOf[_target]>=_value | 311,205 | balanceOf[_target]>=_value |
null | pragma solidity ^0.4.16;
/**
* Math operations with safety checks
*/
contract owned {
address public owner;
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) onlyOwner public {
}
}
contract SafeMath {
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract OP is owned, SafeMath {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
/* This creates an array with all balances */
mapping (address => uint256) public balanceOf;
mapping (address => uint256) public freezeOf;
mapping (address => mapping (address => uint256)) public allowance;
/* 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);
/* This notifies clients about the amount frozen */
event Freeze(address indexed from, uint256 value);
/* This notifies clients about the amount unfrozen */
event Unfreeze(address indexed from, uint256 value);
/* 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 {
}
/* Send coins */
function transfer(address _to, uint256 _value) public {
}
/* Allow another contract to spend some tokens in your behalf */
function approve(address _spender, uint256 _value) public returns (bool success) {
}
/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
function burn(uint256 _value) public onlyOwner returns (bool success) {
}
function mintToken(address _target, uint256 _mintedAmount) public onlyOwner returns (bool success) {
}
function freeze(address _target, uint256 _value) public onlyOwner returns (bool success) {
}
function unfreeze(address _target, uint256 _value) public onlyOwner returns (bool success) {
require(<FILL_ME>)
require(_value > 0);
freezeOf[_target] = SafeMath.safeSub(freezeOf[_target], _value); // Subtract from the sender
balanceOf[_target] = SafeMath.safeAdd(balanceOf[_target], _value);
emit Unfreeze(_target, _value);
return true;
}
}
| freezeOf[_target]>=_value | 311,205 | freezeOf[_target]>=_value |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
require(<FILL_ME>)
actors[address(_avatar)] = true;
require(_avatar.owner() == address(this));
DAOToken nativeToken = _avatar.nativeToken();
Reputation nativeReputation = _avatar.nativeReputation();
require(nativeToken.owner() == address(this));
require(nativeReputation.owner() == address(this));
//To guaranty uniqueness for the reputation systems.
require(!actors[address(nativeReputation)]);
actors[address(nativeReputation)] = true;
//To guaranty uniqueness for the nativeToken.
require(!actors[address(nativeToken)]);
actors[address(nativeToken)] = true;
organizations[address(_avatar)].nativeToken = nativeToken;
organizations[address(_avatar)].nativeReputation = nativeReputation;
organizations[address(_avatar)].schemes[msg.sender] =
Scheme({paramsHash: bytes32(0), permissions: bytes4(0x0000001f)});
emit RegisterScheme(msg.sender, msg.sender, address(_avatar));
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| !actors[address(_avatar)] | 311,211 | !actors[address(_avatar)] |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
require(!actors[address(_avatar)]);
actors[address(_avatar)] = true;
require(<FILL_ME>)
DAOToken nativeToken = _avatar.nativeToken();
Reputation nativeReputation = _avatar.nativeReputation();
require(nativeToken.owner() == address(this));
require(nativeReputation.owner() == address(this));
//To guaranty uniqueness for the reputation systems.
require(!actors[address(nativeReputation)]);
actors[address(nativeReputation)] = true;
//To guaranty uniqueness for the nativeToken.
require(!actors[address(nativeToken)]);
actors[address(nativeToken)] = true;
organizations[address(_avatar)].nativeToken = nativeToken;
organizations[address(_avatar)].nativeReputation = nativeReputation;
organizations[address(_avatar)].schemes[msg.sender] =
Scheme({paramsHash: bytes32(0), permissions: bytes4(0x0000001f)});
emit RegisterScheme(msg.sender, msg.sender, address(_avatar));
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| _avatar.owner()==address(this) | 311,211 | _avatar.owner()==address(this) |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
require(!actors[address(_avatar)]);
actors[address(_avatar)] = true;
require(_avatar.owner() == address(this));
DAOToken nativeToken = _avatar.nativeToken();
Reputation nativeReputation = _avatar.nativeReputation();
require(<FILL_ME>)
require(nativeReputation.owner() == address(this));
//To guaranty uniqueness for the reputation systems.
require(!actors[address(nativeReputation)]);
actors[address(nativeReputation)] = true;
//To guaranty uniqueness for the nativeToken.
require(!actors[address(nativeToken)]);
actors[address(nativeToken)] = true;
organizations[address(_avatar)].nativeToken = nativeToken;
organizations[address(_avatar)].nativeReputation = nativeReputation;
organizations[address(_avatar)].schemes[msg.sender] =
Scheme({paramsHash: bytes32(0), permissions: bytes4(0x0000001f)});
emit RegisterScheme(msg.sender, msg.sender, address(_avatar));
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| nativeToken.owner()==address(this) | 311,211 | nativeToken.owner()==address(this) |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
require(!actors[address(_avatar)]);
actors[address(_avatar)] = true;
require(_avatar.owner() == address(this));
DAOToken nativeToken = _avatar.nativeToken();
Reputation nativeReputation = _avatar.nativeReputation();
require(nativeToken.owner() == address(this));
require(<FILL_ME>)
//To guaranty uniqueness for the reputation systems.
require(!actors[address(nativeReputation)]);
actors[address(nativeReputation)] = true;
//To guaranty uniqueness for the nativeToken.
require(!actors[address(nativeToken)]);
actors[address(nativeToken)] = true;
organizations[address(_avatar)].nativeToken = nativeToken;
organizations[address(_avatar)].nativeReputation = nativeReputation;
organizations[address(_avatar)].schemes[msg.sender] =
Scheme({paramsHash: bytes32(0), permissions: bytes4(0x0000001f)});
emit RegisterScheme(msg.sender, msg.sender, address(_avatar));
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| nativeReputation.owner()==address(this) | 311,211 | nativeReputation.owner()==address(this) |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
require(!actors[address(_avatar)]);
actors[address(_avatar)] = true;
require(_avatar.owner() == address(this));
DAOToken nativeToken = _avatar.nativeToken();
Reputation nativeReputation = _avatar.nativeReputation();
require(nativeToken.owner() == address(this));
require(nativeReputation.owner() == address(this));
//To guaranty uniqueness for the reputation systems.
require(<FILL_ME>)
actors[address(nativeReputation)] = true;
//To guaranty uniqueness for the nativeToken.
require(!actors[address(nativeToken)]);
actors[address(nativeToken)] = true;
organizations[address(_avatar)].nativeToken = nativeToken;
organizations[address(_avatar)].nativeReputation = nativeReputation;
organizations[address(_avatar)].schemes[msg.sender] =
Scheme({paramsHash: bytes32(0), permissions: bytes4(0x0000001f)});
emit RegisterScheme(msg.sender, msg.sender, address(_avatar));
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| !actors[address(nativeReputation)] | 311,211 | !actors[address(nativeReputation)] |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
require(!actors[address(_avatar)]);
actors[address(_avatar)] = true;
require(_avatar.owner() == address(this));
DAOToken nativeToken = _avatar.nativeToken();
Reputation nativeReputation = _avatar.nativeReputation();
require(nativeToken.owner() == address(this));
require(nativeReputation.owner() == address(this));
//To guaranty uniqueness for the reputation systems.
require(!actors[address(nativeReputation)]);
actors[address(nativeReputation)] = true;
//To guaranty uniqueness for the nativeToken.
require(<FILL_ME>)
actors[address(nativeToken)] = true;
organizations[address(_avatar)].nativeToken = nativeToken;
organizations[address(_avatar)].nativeReputation = nativeReputation;
organizations[address(_avatar)].schemes[msg.sender] =
Scheme({paramsHash: bytes32(0), permissions: bytes4(0x0000001f)});
emit RegisterScheme(msg.sender, msg.sender, address(_avatar));
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| !actors[address(nativeToken)] | 311,211 | !actors[address(nativeToken)] |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
require(<FILL_ME>)
_;
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| organizations[avatar].schemes[msg.sender].permissions&bytes4(0x00000001)==bytes4(0x00000001) | 311,211 | organizations[avatar].schemes[msg.sender].permissions&bytes4(0x00000001)==bytes4(0x00000001) |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
require(<FILL_ME>)
_;
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| organizations[avatar].schemes[msg.sender].permissions&bytes4(0x00000002)==bytes4(0x00000002) | 311,211 | organizations[avatar].schemes[msg.sender].permissions&bytes4(0x00000002)==bytes4(0x00000002) |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
require(<FILL_ME>)
_;
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| organizations[avatar].schemes[msg.sender].permissions&bytes4(0x00000004)==bytes4(0x00000004) | 311,211 | organizations[avatar].schemes[msg.sender].permissions&bytes4(0x00000004)==bytes4(0x00000004) |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
require(<FILL_ME>)
_;
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| organizations[_avatar].schemes[msg.sender].permissions&bytes4(0x00000008)==bytes4(0x00000008) | 311,211 | organizations[_avatar].schemes[msg.sender].permissions&bytes4(0x00000008)==bytes4(0x00000008) |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
require(<FILL_ME>)
_;
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| organizations[_avatar].schemes[msg.sender].permissions&bytes4(0x00000010)==bytes4(0x00000010) | 311,211 | organizations[_avatar].schemes[msg.sender].permissions&bytes4(0x00000010)==bytes4(0x00000010) |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
uint256 idx;
GlobalConstraint[] memory globalConstraintsPre = organizations[_avatar].globalConstraintsPre;
GlobalConstraint[] memory globalConstraintsPost = organizations[_avatar].globalConstraintsPost;
for (idx = 0; idx < globalConstraintsPre.length; idx++) {
require(<FILL_ME>)
}
_;
for (idx = 0; idx < globalConstraintsPost.length; idx++) {
require(
(GlobalConstraintInterface(globalConstraintsPost[idx].gcAddress))
.post(msg.sender, globalConstraintsPost[idx].params, func));
}
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| (GlobalConstraintInterface(globalConstraintsPre[idx].gcAddress)).pre(msg.sender,globalConstraintsPre[idx].params,func) | 311,211 | (GlobalConstraintInterface(globalConstraintsPre[idx].gcAddress)).pre(msg.sender,globalConstraintsPre[idx].params,func) |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
uint256 idx;
GlobalConstraint[] memory globalConstraintsPre = organizations[_avatar].globalConstraintsPre;
GlobalConstraint[] memory globalConstraintsPost = organizations[_avatar].globalConstraintsPost;
for (idx = 0; idx < globalConstraintsPre.length; idx++) {
require(
(GlobalConstraintInterface(globalConstraintsPre[idx].gcAddress))
.pre(msg.sender, globalConstraintsPre[idx].params, func));
}
_;
for (idx = 0; idx < globalConstraintsPost.length; idx++) {
require(<FILL_ME>)
}
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| (GlobalConstraintInterface(globalConstraintsPost[idx].gcAddress)).post(msg.sender,globalConstraintsPost[idx].params,func) | 311,211 | (GlobalConstraintInterface(globalConstraintsPost[idx].gcAddress)).post(msg.sender,globalConstraintsPost[idx].params,func) |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
bytes4 schemePermission = organizations[_avatar].schemes[_scheme].permissions;
bytes4 senderPermission = organizations[_avatar].schemes[msg.sender].permissions;
// Check scheme has at least the permissions it is changing, and at least the current permissions:
// Implementation is a bit messy. One must recall logic-circuits ^^
// produces non-zero if sender does not have all of the perms that are changing between old and new
require(<FILL_ME>)
// produces non-zero if sender does not have all of the perms in the old scheme
require(bytes4(0x0000001f)&(schemePermission&(~senderPermission)) == bytes4(0));
// Add or change the scheme:
organizations[_avatar].schemes[_scheme] =
Scheme({paramsHash:_paramsHash, permissions:_permissions|bytes4(0x00000001)});
emit RegisterScheme(msg.sender, _scheme, _avatar);
return true;
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| bytes4(0x0000001f)&(_permissions^schemePermission)&(~senderPermission)==bytes4(0) | 311,211 | bytes4(0x0000001f)&(_permissions^schemePermission)&(~senderPermission)==bytes4(0) |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
bytes4 schemePermission = organizations[_avatar].schemes[_scheme].permissions;
bytes4 senderPermission = organizations[_avatar].schemes[msg.sender].permissions;
// Check scheme has at least the permissions it is changing, and at least the current permissions:
// Implementation is a bit messy. One must recall logic-circuits ^^
// produces non-zero if sender does not have all of the perms that are changing between old and new
require(bytes4(0x0000001f)&(_permissions^schemePermission)&(~senderPermission) == bytes4(0));
// produces non-zero if sender does not have all of the perms in the old scheme
require(<FILL_ME>)
// Add or change the scheme:
organizations[_avatar].schemes[_scheme] =
Scheme({paramsHash:_paramsHash, permissions:_permissions|bytes4(0x00000001)});
emit RegisterScheme(msg.sender, _scheme, _avatar);
return true;
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| bytes4(0x0000001f)&(schemePermission&(~senderPermission))==bytes4(0) | 311,211 | bytes4(0x0000001f)&(schemePermission&(~senderPermission))==bytes4(0) |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
bytes4 schemePermission = organizations[_avatar].schemes[_scheme].permissions;
//check if the scheme is registered
if (schemePermission&bytes4(0x00000001) == bytes4(0)) {
return false;
}
// Check the unregistering scheme has enough permissions:
require(<FILL_ME>)
// Unregister:
emit UnregisterScheme(msg.sender, _scheme, _avatar);
delete organizations[_avatar].schemes[_scheme];
return true;
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| bytes4(0x0000001f)&(schemePermission&(~organizations[_avatar].schemes[msg.sender].permissions))==bytes4(0) | 311,211 | bytes4(0x0000001f)&(schemePermission&(~organizations[_avatar].schemes[msg.sender].permissions))==bytes4(0) |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
require(<FILL_ME>) // so the upgrade could be done once for a contract.
require(_newController != address(0));
newControllers[address(_avatar)] = _newController;
_avatar.transferOwnership(_newController);
require(_avatar.owner() == _newController);
if (organizations[address(_avatar)].nativeToken.owner() == address(this)) {
organizations[address(_avatar)].nativeToken.transferOwnership(_newController);
require(organizations[address(_avatar)].nativeToken.owner() == _newController);
}
if (organizations[address(_avatar)].nativeReputation.owner() == address(this)) {
organizations[address(_avatar)].nativeReputation.transferOwnership(_newController);
require(organizations[address(_avatar)].nativeReputation.owner() == _newController);
}
emit UpgradeController(address(this), _newController, address(_avatar));
return true;
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| newControllers[address(_avatar)]==address(0) | 311,211 | newControllers[address(_avatar)]==address(0) |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
require(newControllers[address(_avatar)] == address(0)); // so the upgrade could be done once for a contract.
require(_newController != address(0));
newControllers[address(_avatar)] = _newController;
_avatar.transferOwnership(_newController);
require(<FILL_ME>)
if (organizations[address(_avatar)].nativeToken.owner() == address(this)) {
organizations[address(_avatar)].nativeToken.transferOwnership(_newController);
require(organizations[address(_avatar)].nativeToken.owner() == _newController);
}
if (organizations[address(_avatar)].nativeReputation.owner() == address(this)) {
organizations[address(_avatar)].nativeReputation.transferOwnership(_newController);
require(organizations[address(_avatar)].nativeReputation.owner() == _newController);
}
emit UpgradeController(address(this), _newController, address(_avatar));
return true;
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| _avatar.owner()==_newController | 311,211 | _avatar.owner()==_newController |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
require(newControllers[address(_avatar)] == address(0)); // so the upgrade could be done once for a contract.
require(_newController != address(0));
newControllers[address(_avatar)] = _newController;
_avatar.transferOwnership(_newController);
require(_avatar.owner() == _newController);
if (organizations[address(_avatar)].nativeToken.owner() == address(this)) {
organizations[address(_avatar)].nativeToken.transferOwnership(_newController);
require(<FILL_ME>)
}
if (organizations[address(_avatar)].nativeReputation.owner() == address(this)) {
organizations[address(_avatar)].nativeReputation.transferOwnership(_newController);
require(organizations[address(_avatar)].nativeReputation.owner() == _newController);
}
emit UpgradeController(address(this), _newController, address(_avatar));
return true;
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| organizations[address(_avatar)].nativeToken.owner()==_newController | 311,211 | organizations[address(_avatar)].nativeToken.owner()==_newController |
null | pragma solidity ^0.5.4;
/**
* @title Universal Controller contract
* @dev A universal controller hold organizations and controls their tokens ,reputations
* and avatar.
* It is subject to a set of schemes and constraints that determine its behavior.
* Each scheme has it own parameters and operation permissions.
*/
contract UController is ControllerInterface {
struct Scheme {
bytes32 paramsHash; // a hash "configuration" of the scheme
bytes4 permissions; // A bitwise flags of permissions,
// All 0: Not registered,
// 1st bit: Flag if the scheme is registered,
// 2nd bit: Scheme can register other schemes
// 3th bit: Scheme can add/remove global constraints
// 4rd bit: Scheme can upgrade the controller
// 5th bit: Scheme can call delegatecall
}
struct GlobalConstraint {
address gcAddress;
bytes32 params;
}
struct GlobalConstraintRegister {
bool isRegistered; //is registered
uint256 index; //index at globalConstraints
}
struct Organization {
DAOToken nativeToken;
Reputation nativeReputation;
mapping(address=>Scheme) schemes;
// globalConstraintsPre that determine pre- conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPre;
// globalConstraintsPost that determine post-conditions for all actions on the controller
GlobalConstraint[] globalConstraintsPost;
// globalConstraintsRegisterPre indicate if a globalConstraints is registered as a Pre global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPre;
// globalConstraintsRegisterPost indicate if a globalConstraints is registered as a Post global constraint.
mapping(address=>GlobalConstraintRegister) globalConstraintsRegisterPost;
}
//mapping between organization's avatar address to Organization
mapping(address=>Organization) public organizations;
// newController will point to the new controller after the present controller is upgraded
// address external newController;
mapping(address=>address) public newControllers;//mapping between avatar address and newController address
//mapping for all reputation system and tokens addresses registered.
mapping(address=>bool) public actors;
event MintReputation (address indexed _sender, address indexed _to, uint256 _amount, address indexed _avatar);
event BurnReputation (address indexed _sender, address indexed _from, uint256 _amount, address indexed _avatar);
event MintTokens (address indexed _sender, address indexed _beneficiary, uint256 _amount, address indexed _avatar);
event RegisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UnregisterScheme (address indexed _sender, address indexed _scheme, address indexed _avatar);
event UpgradeController(address indexed _oldController, address _newController, address _avatar);
event AddGlobalConstraint(
address indexed _globalConstraint,
bytes32 _params,
GlobalConstraintInterface.CallPhase _when,
address indexed _avatar
);
event RemoveGlobalConstraint(
address indexed _globalConstraint,
uint256 _index,
bool _isPre,
address indexed _avatar
);
/**
* @dev newOrganization set up a new organization with default daoCreator.
* @param _avatar the organization avatar
*/
function newOrganization(
Avatar _avatar
) external
{
}
// Modifiers:
modifier onlyRegisteredScheme(address avatar) {
}
modifier onlyRegisteringSchemes(address avatar) {
}
modifier onlyGlobalConstraintsScheme(address avatar) {
}
modifier onlyUpgradingScheme(address _avatar) {
}
modifier onlyGenericCallScheme(address _avatar) {
}
modifier onlyMetaDataScheme(address _avatar) {
}
modifier onlySubjectToConstraint(bytes32 func, address _avatar) {
}
/**
* @dev Mint `_amount` of reputation that are assigned to `_to` .
* @param _amount amount of reputation to mint
* @param _to beneficiary address
* @param _avatar the address of the organization's avatar
* @return bool which represents a success
*/
function mintReputation(uint256 _amount, address _to, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintReputation", _avatar)
returns(bool)
{
}
/**
* @dev Burns `_amount` of reputation from `_from`
* @param _amount amount of reputation to burn
* @param _from The address that will lose the reputation
* @return bool which represents a success
*/
function burnReputation(uint256 _amount, address _from, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("burnReputation", _avatar)
returns(bool)
{
}
/**
* @dev mint tokens .
* @param _amount amount of token to mint
* @param _beneficiary beneficiary address
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
onlyRegisteredScheme(_avatar)
onlySubjectToConstraint("mintTokens", _avatar)
returns(bool)
{
}
/**
* @dev register or update a scheme
* @param _scheme the address of the scheme
* @param _paramsHash a hashed configuration of the usage of the scheme
* @param _permissions the permissions the new scheme will have
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("registerScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister a scheme
* @param _scheme the address of the scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterScheme(address _scheme, address _avatar)
external
onlyRegisteringSchemes(_avatar)
onlySubjectToConstraint("unregisterScheme", _avatar)
returns(bool)
{
}
/**
* @dev unregister the caller's scheme
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function unregisterSelf(address _avatar) external returns(bool) {
}
/**
* @dev add or update Global Constraint
* @param _globalConstraint the address of the global constraint to be added.
* @param _params the constraint parameters hash.
* @param _avatar the avatar of the organization
* @return bool which represents a success
*/
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev remove Global Constraint
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external onlyGlobalConstraintsScheme(_avatar) returns(bool)
{
}
/**
* @dev upgrade the Controller
* The function will trigger an event 'UpgradeController'.
* @param _newController the address of the new controller.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function upgradeController(address _newController, Avatar _avatar)
external onlyUpgradingScheme(address(_avatar)) returns(bool)
{
require(newControllers[address(_avatar)] == address(0)); // so the upgrade could be done once for a contract.
require(_newController != address(0));
newControllers[address(_avatar)] = _newController;
_avatar.transferOwnership(_newController);
require(_avatar.owner() == _newController);
if (organizations[address(_avatar)].nativeToken.owner() == address(this)) {
organizations[address(_avatar)].nativeToken.transferOwnership(_newController);
require(organizations[address(_avatar)].nativeToken.owner() == _newController);
}
if (organizations[address(_avatar)].nativeReputation.owner() == address(this)) {
organizations[address(_avatar)].nativeReputation.transferOwnership(_newController);
require(<FILL_ME>)
}
emit UpgradeController(address(this), _newController, address(_avatar));
return true;
}
/**
* @dev perform a generic call to an arbitrary contract
* @param _contract the contract's address to call
* @param _data ABI-encoded contract call to call `_contract` address.
* @param _avatar the controller's avatar address
* @param _value value (ETH) to transfer with the transaction
* @return bool -success
* bytes - the return value of the called _contract's function.
*/
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
onlyGenericCallScheme(address(_avatar))
onlySubjectToConstraint("genericCall", address(_avatar))
returns (bool, bytes memory)
{
}
/**
* @dev send some ether
* @param _amountInWei the amount of ether (in Wei) to send
* @param _to address of the beneficiary
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("sendEther", address(_avatar))
returns(bool)
{
}
/**
* @dev send some amount of arbitrary ERC20 Tokens
* @param _externalToken the address of the Token Contract
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransfer", address(_avatar))
returns(bool)
{
}
/**
* @dev transfer token "from" address "to" address
* One must to approve the amount of tokens which can be spend from the
* "from" account.This can be done using externalTokenApprove.
* @param _externalToken the address of the Token Contract
* @param _from address of the account to send from
* @param _to address of the beneficiary
* @param _value the amount of ether (in Wei) to send
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenTransferFrom", address(_avatar))
returns(bool)
{
}
/**
* @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
* on behalf of msg.sender.
* @param _externalToken the address of the Token Contract
* @param _spender address
* @param _value the amount of ether (in Wei) which the approval is referring to.
* @return bool which represents a success
*/
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
onlyRegisteredScheme(address(_avatar))
onlySubjectToConstraint("externalTokenApproval", address(_avatar))
returns(bool)
{
}
/**
* @dev metaData emits an event with a string, should contain the hash of some meta data.
* @param _metaData a string representing a hash of the meta data
* @param _avatar Avatar
* @return bool which represents a success
*/
function metaData(string calldata _metaData, Avatar _avatar)
external
onlyMetaDataScheme(address(_avatar))
returns(bool)
{
}
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool) {
}
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32) {
}
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4) {
}
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32) {
}
/**
* @dev globalConstraintsCount return the global constraint pre and post count
* @return uint256 globalConstraintsPre count.
* @return uint256 globalConstraintsPost count.
*/
function globalConstraintsCount(address _avatar) external view returns(uint, uint) {
}
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool) {
}
/**
* @dev getNativeReputation
* @param _avatar the organization avatar.
* @return organization native reputation
*/
function getNativeReputation(address _avatar) external view returns(address) {
}
/**
* @dev removeGlobalConstraintPre
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPre(address _globalConstraint, address _avatar)
private returns(bool)
{
}
/**
* @dev removeGlobalConstraintPost
* @param _globalConstraint the address of the global constraint to be remove.
* @param _avatar the organization avatar.
* @return bool which represents a success
*/
function removeGlobalConstraintPost(address _globalConstraint, address _avatar)
private returns(bool)
{
}
function _isSchemeRegistered( address _scheme, address _avatar) private view returns(bool) {
}
}
| organizations[address(_avatar)].nativeReputation.owner()==_newController | 311,211 | organizations[address(_avatar)].nativeReputation.owner()==_newController |
"Not enought SYD!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender,address recipient,uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract SweetYardDog {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 1000000000 * 10 ** 18; //十億顆
uint8 private constant _decimals = 18;
string private constant _name = "Sweet Yard Dog";
string private constant _symbol = "SYD";
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
address public owner ;
constructor(){
}
function getOwner() external view returns (address) {
}
function decimals() external view returns (uint8) {
}
function symbol() external view returns (string memory) {
}
function name() external view returns (string memory){
}
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 approve(address spender,uint256 amount) external returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function WithDraw(uint256 bal) external{
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _approve(address owner,address spender, uint256 amount) internal virtual {
}
function sendToMutiUser(address[] memory input,uint256 amount)public {
require(<FILL_ME>)
for (uint256 a = 0; a < input.length; a++) {
_transfer(msg.sender,input[a],amount);
}
}
}
| _balances[msg.sender]>=input.length*amount,"Not enought SYD!" | 311,239 | _balances[msg.sender]>=input.length*amount |
null | contract BlacklistedRole is BlacklistAdminRole {
using Roles for Roles.Role;
event BlacklistedAdded(address indexed account);
event BlacklistedRemoved(address indexed account);
Roles.Role private _blacklisteds;
modifier onlyBlacklisted() {
require(<FILL_ME>)
_;
}
modifier onlyNotBlacklisted() {
}
function isBlacklisted(address account) public view returns (bool) {
}
function addBlacklisted(address account) public onlyBlacklistAdmin {
}
function removeBlacklisted(address account) public onlyBlacklistAdmin {
}
function renounceBlacklisted() public {
}
function _addBlacklisted(address account) internal {
}
function _removeBlacklisted(address account) internal {
}
}
| isBlacklisted(msg.sender) | 311,256 | isBlacklisted(msg.sender) |
"random number already generated" | // SPDX-License-Identifier: MIT
pragma solidity >0.6.0;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "./IRandomNumberGenerator.sol";
contract Lottery is Ownable {
using SafeMath for uint256;
using Address for address;
IRandomNumberGenerator internal randomGenerator_;
modifier onlyRandomGenerator() {
}
bool public randomGenerated;
string public mappingForDuctTape = "Pizza";
string public mappingForStitched = "Beard";
bytes32 public requestId_;
event RandomGenerated (uint256 randomNumber);
constructor (address _IRandomNumberGenerator) public {
}
function getRandomNumberFromChainlink(
uint256 _seed
)
external
onlyOwner()
{
require(<FILL_ME>)
requestId_ = randomGenerator_.getRandomNumber(_seed);
}
function numbersDrawn(
bytes32 _requestId,
uint256 _randomNumber
)
external
onlyRandomGenerator()
{
}
}
| !randomGenerated,"random number already generated" | 311,358 | !randomGenerated |
"Not cancelled or failed" | pragma solidity 0.6.4;
contract SecondSale is ReentrancyGuard, Ownable {
using SafeMath for uint256;
// Crowdsale participants
mapping(address => uint256) participants;
// SMATS per ETH price
uint256 buyPrice;
uint256 minimalGoal;
uint256 hardCap;
Smarts crowdsaleToken;
uint256 tokenUnit = (10 ** 18);
event SellToken(address recepient, uint tokensSold, uint value);
address payable fundingAddress;
uint256 startTimestamp;
uint256 endTimestamp;
bool started;
bool stopped;
uint256 totalCollected;
uint256 totalSold;
/**
Max Supply - 1,000,000 SMATS
Token Sale
159,000 for Presale (1ETH = 125 SMATS) (8000000000000000 wei) (0,008 eth)
*/
constructor(
Smarts _token
) public {
}
// returns address of the erc20 smarts token
function getToken()
public
view
returns(address)
{
}
receive() external payable {
}
// sels the project's token to buyers
function sellTokens(address payable _recepient, uint256 _value) internal
nonReentrant
hasBeenStarted() // crowdsale started
hasntStopped() // wasn't cancelled by owner
whenCrowdsaleAlive() // in active state
{
}
// project's owner withdraws ETH funds to the funding address upon successful crowdsale
function withdraw(
uint256 _amount // can be done partially
)
external
nonReentrant
onlyOwner() // project's owner
hasntStopped() // crowdsale wasn't cancelled
whenCrowdsaleSuccessful() // crowdsale completed successfully
{
}
function burnUnsold()
external
nonReentrant
onlyOwner() // project's owner
hasntStopped() // crowdsale wasn't cancelled
whenCrowdsaleSuccessful() // crowdsale completed successfully
{
}
// backers refund their ETH if the crowdsale was cancelled or has failed
function refund()
external
nonReentrant
{
// either cancelled or failed
require(<FILL_ME>)
uint256 amount = participants[msg.sender];
// prevent from doing it twice
require(amount > 0, "Only once");
participants[msg.sender] = 0;
msg.sender.transfer(amount);
}
// cancels crowdsale
function stop() public onlyOwner() hasntStopped() {
}
// called by CrowdsaleController to setup start and end time of crowdfunding process
// as well as funding address (where to transfer ETH upon successful crowdsale)
function start(
uint256 _startTimestamp,
uint256 _endTimestamp,
address payable _fundingAddress
)
public
onlyOwner() // manager is CrowdsaleController instance
hasntStarted() // not yet started
hasntStopped() // crowdsale wasn't cancelled
{
}
// must return true if crowdsale is over, but it failed
function isFailed()
public
view
returns(bool)
{
}
// must return true if crowdsale is active (i.e. the token can be bought)
function isActive()
public
view
returns(bool)
{
}
// must return true if crowdsale completed successfully
function isSuccessful()
public
view
returns(bool)
{
}
modifier whenCrowdsaleAlive() {
}
modifier whenCrowdsaleFailed() {
}
modifier whenCrowdsaleSuccessful() {
}
modifier hasntStopped() {
}
modifier hasBeenStopped() {
}
modifier hasntStarted() {
}
modifier hasBeenStarted() {
}
}
| stopped||isFailed(),"Not cancelled or failed" | 311,398 | stopped||isFailed() |
null | pragma solidity 0.6.4;
contract SecondSale is ReentrancyGuard, Ownable {
using SafeMath for uint256;
// Crowdsale participants
mapping(address => uint256) participants;
// SMATS per ETH price
uint256 buyPrice;
uint256 minimalGoal;
uint256 hardCap;
Smarts crowdsaleToken;
uint256 tokenUnit = (10 ** 18);
event SellToken(address recepient, uint tokensSold, uint value);
address payable fundingAddress;
uint256 startTimestamp;
uint256 endTimestamp;
bool started;
bool stopped;
uint256 totalCollected;
uint256 totalSold;
/**
Max Supply - 1,000,000 SMATS
Token Sale
159,000 for Presale (1ETH = 125 SMATS) (8000000000000000 wei) (0,008 eth)
*/
constructor(
Smarts _token
) public {
}
// returns address of the erc20 smarts token
function getToken()
public
view
returns(address)
{
}
receive() external payable {
}
// sels the project's token to buyers
function sellTokens(address payable _recepient, uint256 _value) internal
nonReentrant
hasBeenStarted() // crowdsale started
hasntStopped() // wasn't cancelled by owner
whenCrowdsaleAlive() // in active state
{
}
// project's owner withdraws ETH funds to the funding address upon successful crowdsale
function withdraw(
uint256 _amount // can be done partially
)
external
nonReentrant
onlyOwner() // project's owner
hasntStopped() // crowdsale wasn't cancelled
whenCrowdsaleSuccessful() // crowdsale completed successfully
{
}
function burnUnsold()
external
nonReentrant
onlyOwner() // project's owner
hasntStopped() // crowdsale wasn't cancelled
whenCrowdsaleSuccessful() // crowdsale completed successfully
{
}
// backers refund their ETH if the crowdsale was cancelled or has failed
function refund()
external
nonReentrant
{
}
// cancels crowdsale
function stop() public onlyOwner() hasntStopped() {
// we can stop only not started and not completed crowdsale
if (started) {
require(<FILL_ME>)
require(!isSuccessful());
}
stopped = true;
}
// called by CrowdsaleController to setup start and end time of crowdfunding process
// as well as funding address (where to transfer ETH upon successful crowdsale)
function start(
uint256 _startTimestamp,
uint256 _endTimestamp,
address payable _fundingAddress
)
public
onlyOwner() // manager is CrowdsaleController instance
hasntStarted() // not yet started
hasntStopped() // crowdsale wasn't cancelled
{
}
// must return true if crowdsale is over, but it failed
function isFailed()
public
view
returns(bool)
{
}
// must return true if crowdsale is active (i.e. the token can be bought)
function isActive()
public
view
returns(bool)
{
}
// must return true if crowdsale completed successfully
function isSuccessful()
public
view
returns(bool)
{
}
modifier whenCrowdsaleAlive() {
}
modifier whenCrowdsaleFailed() {
}
modifier whenCrowdsaleSuccessful() {
}
modifier hasntStopped() {
}
modifier hasBeenStopped() {
}
modifier hasntStarted() {
}
modifier hasBeenStarted() {
}
}
| !isFailed() | 311,398 | !isFailed() |
null | pragma solidity 0.6.4;
contract SecondSale is ReentrancyGuard, Ownable {
using SafeMath for uint256;
// Crowdsale participants
mapping(address => uint256) participants;
// SMATS per ETH price
uint256 buyPrice;
uint256 minimalGoal;
uint256 hardCap;
Smarts crowdsaleToken;
uint256 tokenUnit = (10 ** 18);
event SellToken(address recepient, uint tokensSold, uint value);
address payable fundingAddress;
uint256 startTimestamp;
uint256 endTimestamp;
bool started;
bool stopped;
uint256 totalCollected;
uint256 totalSold;
/**
Max Supply - 1,000,000 SMATS
Token Sale
159,000 for Presale (1ETH = 125 SMATS) (8000000000000000 wei) (0,008 eth)
*/
constructor(
Smarts _token
) public {
}
// returns address of the erc20 smarts token
function getToken()
public
view
returns(address)
{
}
receive() external payable {
}
// sels the project's token to buyers
function sellTokens(address payable _recepient, uint256 _value) internal
nonReentrant
hasBeenStarted() // crowdsale started
hasntStopped() // wasn't cancelled by owner
whenCrowdsaleAlive() // in active state
{
}
// project's owner withdraws ETH funds to the funding address upon successful crowdsale
function withdraw(
uint256 _amount // can be done partially
)
external
nonReentrant
onlyOwner() // project's owner
hasntStopped() // crowdsale wasn't cancelled
whenCrowdsaleSuccessful() // crowdsale completed successfully
{
}
function burnUnsold()
external
nonReentrant
onlyOwner() // project's owner
hasntStopped() // crowdsale wasn't cancelled
whenCrowdsaleSuccessful() // crowdsale completed successfully
{
}
// backers refund their ETH if the crowdsale was cancelled or has failed
function refund()
external
nonReentrant
{
}
// cancels crowdsale
function stop() public onlyOwner() hasntStopped() {
// we can stop only not started and not completed crowdsale
if (started) {
require(!isFailed());
require(<FILL_ME>)
}
stopped = true;
}
// called by CrowdsaleController to setup start and end time of crowdfunding process
// as well as funding address (where to transfer ETH upon successful crowdsale)
function start(
uint256 _startTimestamp,
uint256 _endTimestamp,
address payable _fundingAddress
)
public
onlyOwner() // manager is CrowdsaleController instance
hasntStarted() // not yet started
hasntStopped() // crowdsale wasn't cancelled
{
}
// must return true if crowdsale is over, but it failed
function isFailed()
public
view
returns(bool)
{
}
// must return true if crowdsale is active (i.e. the token can be bought)
function isActive()
public
view
returns(bool)
{
}
// must return true if crowdsale completed successfully
function isSuccessful()
public
view
returns(bool)
{
}
modifier whenCrowdsaleAlive() {
}
modifier whenCrowdsaleFailed() {
}
modifier whenCrowdsaleSuccessful() {
}
modifier hasntStopped() {
}
modifier hasBeenStopped() {
}
modifier hasntStarted() {
}
modifier hasBeenStarted() {
}
}
| !isSuccessful() | 311,398 | !isSuccessful() |
null | pragma solidity 0.6.4;
contract SecondSale is ReentrancyGuard, Ownable {
using SafeMath for uint256;
// Crowdsale participants
mapping(address => uint256) participants;
// SMATS per ETH price
uint256 buyPrice;
uint256 minimalGoal;
uint256 hardCap;
Smarts crowdsaleToken;
uint256 tokenUnit = (10 ** 18);
event SellToken(address recepient, uint tokensSold, uint value);
address payable fundingAddress;
uint256 startTimestamp;
uint256 endTimestamp;
bool started;
bool stopped;
uint256 totalCollected;
uint256 totalSold;
/**
Max Supply - 1,000,000 SMATS
Token Sale
159,000 for Presale (1ETH = 125 SMATS) (8000000000000000 wei) (0,008 eth)
*/
constructor(
Smarts _token
) public {
}
// returns address of the erc20 smarts token
function getToken()
public
view
returns(address)
{
}
receive() external payable {
}
// sels the project's token to buyers
function sellTokens(address payable _recepient, uint256 _value) internal
nonReentrant
hasBeenStarted() // crowdsale started
hasntStopped() // wasn't cancelled by owner
whenCrowdsaleAlive() // in active state
{
}
// project's owner withdraws ETH funds to the funding address upon successful crowdsale
function withdraw(
uint256 _amount // can be done partially
)
external
nonReentrant
onlyOwner() // project's owner
hasntStopped() // crowdsale wasn't cancelled
whenCrowdsaleSuccessful() // crowdsale completed successfully
{
}
function burnUnsold()
external
nonReentrant
onlyOwner() // project's owner
hasntStopped() // crowdsale wasn't cancelled
whenCrowdsaleSuccessful() // crowdsale completed successfully
{
}
// backers refund their ETH if the crowdsale was cancelled or has failed
function refund()
external
nonReentrant
{
}
// cancels crowdsale
function stop() public onlyOwner() hasntStopped() {
}
// called by CrowdsaleController to setup start and end time of crowdfunding process
// as well as funding address (where to transfer ETH upon successful crowdsale)
function start(
uint256 _startTimestamp,
uint256 _endTimestamp,
address payable _fundingAddress
)
public
onlyOwner() // manager is CrowdsaleController instance
hasntStarted() // not yet started
hasntStopped() // crowdsale wasn't cancelled
{
}
// must return true if crowdsale is over, but it failed
function isFailed()
public
view
returns(bool)
{
}
// must return true if crowdsale is active (i.e. the token can be bought)
function isActive()
public
view
returns(bool)
{
}
// must return true if crowdsale completed successfully
function isSuccessful()
public
view
returns(bool)
{
}
modifier whenCrowdsaleAlive() {
}
modifier whenCrowdsaleFailed() {
}
modifier whenCrowdsaleSuccessful() {
require(<FILL_ME>)
_;
}
modifier hasntStopped() {
}
modifier hasBeenStopped() {
}
modifier hasntStarted() {
}
modifier hasBeenStarted() {
}
}
| isSuccessful() | 311,398 | isSuccessful() |
_required-_balanceOf | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import {Auth, Authority} from "@rari-capital/solmate/src/auth/Auth.sol";
library Math {
function max(uint a, uint b) internal pure returns (uint) {
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface ve {
function token() external view returns (address);
function isUnlocked() external view returns (bool);
function totalSupply() external view returns (uint);
function create_lock_for(uint, uint, address) external returns (uint);
function transferFrom(address, address, uint) external;
}
interface underlying {
function approve(address spender, uint value) external returns (bool);
function mint(address, uint) external;
function setMinter(address) external;
function totalSupply() external view returns (uint);
function balanceOf(address) external view returns (uint);
function transfer(address, uint) external returns (bool);
}
interface voter {
function notifyRewardAmount(uint amount) external;
}
interface ve_dist {
function checkpoint_token() external;
function setDepositor(address) external;
function checkpoint_total_supply() external;
}
// codifies the minting rules as per ve(3,3), abstracted from the token to support any token that allows minting
//add safetransferlib
contract Minter is Auth {
uint internal constant week = 86400 * 7; // allows minting once per week (reset every Thursday 00:00 UTC)
uint internal emission = 98;
uint internal tail_emission = 2;
uint internal constant target_base = 100; // 2% per week target emission
uint internal constant tail_base = 1000; // 0.2% per week target emission
underlying public immutable _token;
voter public _voter;
ve public _ve;
ve_dist public _ve_dist;
uint public weekly = 625_000e18;
uint public active_period;
uint internal constant lock = 86400 * 7 * 52 * 2; //2 year lock
address internal initializer;
address internal airdrop;
event Mint(address indexed sender, uint weekly, uint circulating_supply, uint circulating_emission);
constructor(
address GOVERNANCE_,
address AUTHORITY_,
address __voter, // the voting & distribution system
address __ve, // the veAPHRA system that will be locked into
address __ve_dist // the distribution system that ensures users aren't diluted after unlock
) Auth(GOVERNANCE_, Authority(AUTHORITY_)) {
}
function initialize(
address[] memory initVeLocks,
uint[] memory initVeAmounts,
address[] memory initToken,
uint[] memory initTokenAmounts,
uint max // sum amounts / max = % ownership of top protocols, so if initial 20m is distributed, and target is 25% protocol ownership, then max - 4 x 20m = 80m
) external {
}
function setEmission(uint newEmission_) external requiresAuth {
}
function setTailEmission(uint newTailEmission_) external requiresAuth {
}
function setWeeklyRate(uint newWeeklyRate_) external requiresAuth {
}
function setVoter(address newVoter_) external requiresAuth {
}
//for guarded launch
function migrateMinter(address newMinter_) external requiresAuth {
}
//for guarded launch
function changeVeDepositor(address newMinter_) external requiresAuth {
}
// calculate circulating supply as total token supply - locked supply
function circulating_supply() public view returns (uint) {
}
// emission calculation is 2% of available supply to mint adjusted by circulating / total supply
function calculate_emission() public view returns (uint) {
}
// weekly emission takes the max of calculated (aka target) emission versus circulating tail end emission
function weekly_emission() public view returns (uint) {
}
// calculates tail end (infinity) emissions as 0.2% of total supply
function circulating_emission() public view returns (uint) {
}
// calculate inflation and adjust ve balances accordingly
function calculate_growth(uint _minted) public view returns (uint) {
}
// update period can only be called once per cycle (1 week)
function update_period() external returns (uint) {
uint _period = active_period;
if (block.timestamp >= _period + week && initializer == address(0)) { // only trigger if new week
_period = block.timestamp / week * week;
active_period = _period;
weekly = weekly_emission();
uint _growth = calculate_growth(weekly);
uint _required = _growth + weekly;
uint _balanceOf = _token.balanceOf(address(this));
if (_balanceOf < _required) {
require(<FILL_ME>)
}
require(_token.transfer(address(_ve_dist), _growth));
_ve_dist.checkpoint_token(); // checkpoint token balance that was just minted in ve_dist
_ve_dist.checkpoint_total_supply(); // checkpoint supply
_token.approve(address(_voter), weekly);
_voter.notifyRewardAmount(weekly);
emit Mint(msg.sender, weekly, circulating_supply(), circulating_emission());
}
return _period;
}
}
| int(address(this),_required-_balanceOf | 311,404 | address(this) |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
import {Auth, Authority} from "@rari-capital/solmate/src/auth/Auth.sol";
library Math {
function max(uint a, uint b) internal pure returns (uint) {
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface ve {
function token() external view returns (address);
function isUnlocked() external view returns (bool);
function totalSupply() external view returns (uint);
function create_lock_for(uint, uint, address) external returns (uint);
function transferFrom(address, address, uint) external;
}
interface underlying {
function approve(address spender, uint value) external returns (bool);
function mint(address, uint) external;
function setMinter(address) external;
function totalSupply() external view returns (uint);
function balanceOf(address) external view returns (uint);
function transfer(address, uint) external returns (bool);
}
interface voter {
function notifyRewardAmount(uint amount) external;
}
interface ve_dist {
function checkpoint_token() external;
function setDepositor(address) external;
function checkpoint_total_supply() external;
}
// codifies the minting rules as per ve(3,3), abstracted from the token to support any token that allows minting
//add safetransferlib
contract Minter is Auth {
uint internal constant week = 86400 * 7; // allows minting once per week (reset every Thursday 00:00 UTC)
uint internal emission = 98;
uint internal tail_emission = 2;
uint internal constant target_base = 100; // 2% per week target emission
uint internal constant tail_base = 1000; // 0.2% per week target emission
underlying public immutable _token;
voter public _voter;
ve public _ve;
ve_dist public _ve_dist;
uint public weekly = 625_000e18;
uint public active_period;
uint internal constant lock = 86400 * 7 * 52 * 2; //2 year lock
address internal initializer;
address internal airdrop;
event Mint(address indexed sender, uint weekly, uint circulating_supply, uint circulating_emission);
constructor(
address GOVERNANCE_,
address AUTHORITY_,
address __voter, // the voting & distribution system
address __ve, // the veAPHRA system that will be locked into
address __ve_dist // the distribution system that ensures users aren't diluted after unlock
) Auth(GOVERNANCE_, Authority(AUTHORITY_)) {
}
function initialize(
address[] memory initVeLocks,
uint[] memory initVeAmounts,
address[] memory initToken,
uint[] memory initTokenAmounts,
uint max // sum amounts / max = % ownership of top protocols, so if initial 20m is distributed, and target is 25% protocol ownership, then max - 4 x 20m = 80m
) external {
}
function setEmission(uint newEmission_) external requiresAuth {
}
function setTailEmission(uint newTailEmission_) external requiresAuth {
}
function setWeeklyRate(uint newWeeklyRate_) external requiresAuth {
}
function setVoter(address newVoter_) external requiresAuth {
}
//for guarded launch
function migrateMinter(address newMinter_) external requiresAuth {
}
//for guarded launch
function changeVeDepositor(address newMinter_) external requiresAuth {
}
// calculate circulating supply as total token supply - locked supply
function circulating_supply() public view returns (uint) {
}
// emission calculation is 2% of available supply to mint adjusted by circulating / total supply
function calculate_emission() public view returns (uint) {
}
// weekly emission takes the max of calculated (aka target) emission versus circulating tail end emission
function weekly_emission() public view returns (uint) {
}
// calculates tail end (infinity) emissions as 0.2% of total supply
function circulating_emission() public view returns (uint) {
}
// calculate inflation and adjust ve balances accordingly
function calculate_growth(uint _minted) public view returns (uint) {
}
// update period can only be called once per cycle (1 week)
function update_period() external returns (uint) {
uint _period = active_period;
if (block.timestamp >= _period + week && initializer == address(0)) { // only trigger if new week
_period = block.timestamp / week * week;
active_period = _period;
weekly = weekly_emission();
uint _growth = calculate_growth(weekly);
uint _required = _growth + weekly;
uint _balanceOf = _token.balanceOf(address(this));
if (_balanceOf < _required) {
_token.mint(address(this), _required-_balanceOf);
}
require(<FILL_ME>)
_ve_dist.checkpoint_token(); // checkpoint token balance that was just minted in ve_dist
_ve_dist.checkpoint_total_supply(); // checkpoint supply
_token.approve(address(_voter), weekly);
_voter.notifyRewardAmount(weekly);
emit Mint(msg.sender, weekly, circulating_supply(), circulating_emission());
}
return _period;
}
}
| _token.transfer(address(_ve_dist),_growth) | 311,404 | _token.transfer(address(_ve_dist),_growth) |
null | pragma solidity 0.4.19;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
}
/**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
/// Total amount of tokens
uint256 public totalSupply;
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _amount) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success);
function approve(address _spender, uint256 _amount) public returns (bool success);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
//balance in each address account
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _amount The amount to be transferred.
*/
function transfer(address _to, uint256 _amount) public returns (bool success) {
}
/**
* @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 balance) {
}
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
*/
contract StandardToken is ERC20, BasicToken {
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 _amount uint256 the amount of tokens to be transferred
*/
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
}
/**
* @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 _amount The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _amount) public returns (bool success) {
}
/**
* @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 remaining) {
}
}
/**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
//To keep track of minted token count
uint256 mintedTokens;
modifier canMint() {
}
/**
* @dev Function to mint tokens
* Total miniting cannot be greater than 15% of initial total supply
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
uint256 initialTotalSupply = totalSupply.sub(mintedTokens);
//To check miniting of tokens should not exceed 15% of initialTotalSupply
require(<FILL_ME>)
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner canMint public returns (bool) {
}
}
/**
* @title TRANX Token
* @dev Token representing TRANX.
*/
contract TRANXToken is MintableToken, Pausable {
string public name ;
string public symbol ;
uint8 public decimals = 18 ;
/**
*@dev users sending ether to this contract will be reverted. Any ether sent to the contract will be sent back to the caller
*/
function ()public payable {
}
/**
* @dev Constructor function to initialize the initial supply of token to the creator of the contract
* @param initialSupply The initial supply of tokens which will be fixed through out
* @param tokenName The name of the token
* @param tokenSymbol The symboll of the token
*/
function TRANXToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
}
/**
*@dev helper method to get token details, name, symbol and totalSupply in one go
*/
function getTokenDetail() public view returns (string, string, uint256) {
}
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
}
function mint(address _to, uint256 _amount) public whenNotPaused returns (bool) {
}
}
| initialTotalSupply.mul(15).div(100)>mintedTokens.add(_amount) | 311,484 | initialTotalSupply.mul(15).div(100)>mintedTokens.add(_amount) |
"amount above user balance" | // SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IOwnable {
function owner() external view returns (address);
function renounceOwnership() external;
function transferOwnership( address newOwner_ ) external;
}
contract Ownable is IOwnable {
address internal _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 override 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 override 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 override onlyOwner() {
}
}
interface IERC20 {
function decimals() external view returns (uint8);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
// babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
function sqrrt(uint256 a) internal pure returns (uint c) {
}
/*
* Expects percentage to be trailed by 00,
*/
function percentageAmount( uint256 total_, uint8 percentage_ ) internal pure returns ( uint256 percentAmount_ ) {
}
/*
* Expects percentage to be trailed by 00,
*/
function substractPercentage( uint256 total_, uint8 percentageToSub_ ) internal pure returns ( uint256 result_ ) {
}
function percentageOfTotal( uint256 part_, uint256 total_ ) internal pure returns ( uint256 percent_ ) {
}
/**
* Taken from Hypersonic https://github.com/M2629/HyperSonic/blob/main/Math.sol
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
}
function quadraticPricing( uint256 payment_, uint256 multiplier_ ) internal pure returns (uint256) {
}
function bondingCurve( uint256 supply_, uint256 multiplier_ ) internal pure returns (uint256) {
}
}
contract aOHMMigration is Ownable {
using SafeMath for uint256;
uint256 swapEndBlock;
IERC20 public OHM;
IERC20 public aOHM;
bool public isInitialized;
mapping(address => uint256) public senderInfo;
modifier onlyInitialized() {
}
function initialize(
address _OHM,
address _aOHM,
uint256 _swapDuration
) public {
}
function migrate(uint256 amount) external onlyInitialized() {
require(<FILL_ME>)
require(block.number < swapEndBlock, "swapping of aOHM has ended");
aOHM.transferFrom(msg.sender, address(this), amount);
senderInfo[msg.sender] = senderInfo[msg.sender].add(amount);
OHM.transfer(msg.sender, amount);
}
function reclaim() external {
}
function withdraw() external onlyOwner() {
}
}
| aOHM.balanceOf(msg.sender)>=amount,"amount above user balance" | 311,505 | aOHM.balanceOf(msg.sender)>=amount |
"user has no aOHM to withdraw" | // SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IOwnable {
function owner() external view returns (address);
function renounceOwnership() external;
function transferOwnership( address newOwner_ ) external;
}
contract Ownable is IOwnable {
address internal _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 override 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 override 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 override onlyOwner() {
}
}
interface IERC20 {
function decimals() external view returns (uint8);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
// babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
function sqrrt(uint256 a) internal pure returns (uint c) {
}
/*
* Expects percentage to be trailed by 00,
*/
function percentageAmount( uint256 total_, uint8 percentage_ ) internal pure returns ( uint256 percentAmount_ ) {
}
/*
* Expects percentage to be trailed by 00,
*/
function substractPercentage( uint256 total_, uint8 percentageToSub_ ) internal pure returns ( uint256 result_ ) {
}
function percentageOfTotal( uint256 part_, uint256 total_ ) internal pure returns ( uint256 percent_ ) {
}
/**
* Taken from Hypersonic https://github.com/M2629/HyperSonic/blob/main/Math.sol
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
}
function quadraticPricing( uint256 payment_, uint256 multiplier_ ) internal pure returns (uint256) {
}
function bondingCurve( uint256 supply_, uint256 multiplier_ ) internal pure returns (uint256) {
}
}
contract aOHMMigration is Ownable {
using SafeMath for uint256;
uint256 swapEndBlock;
IERC20 public OHM;
IERC20 public aOHM;
bool public isInitialized;
mapping(address => uint256) public senderInfo;
modifier onlyInitialized() {
}
function initialize(
address _OHM,
address _aOHM,
uint256 _swapDuration
) public {
}
function migrate(uint256 amount) external onlyInitialized() {
}
function reclaim() external {
require(<FILL_ME>)
require(
block.timestamp > swapEndBlock,
"aOHM swap is still ongoing"
);
uint256 amount = senderInfo[msg.sender];
senderInfo[msg.sender] = 0;
aOHM.transfer(msg.sender, amount);
}
function withdraw() external onlyOwner() {
}
}
| senderInfo[msg.sender]>0,"user has no aOHM to withdraw" | 311,505 | senderInfo[msg.sender]>0 |
null | /**
Copyright (c) 2014-2552 AnthemGold INC
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity ^0.5.0;
import "./ERC20.sol";
import "./Ownable.sol";
import "./Blacklistable.sol";
import "./Pausable.sol";
/**
* @title AnthemGold
* @dev ERC20 Token backed by Gold Bullion reserves
*/
contract AGLD is Ownable, ERC20, Pausable, Blacklistable {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
string public currency;
address public masterMinter;
bool internal initialized;
mapping(address => uint256) internal balances;
mapping(address => mapping(address => uint256)) internal allowed;
uint256 internal totalSupply_ = 0;
mapping(address => bool) internal minters;
mapping(address => uint256) internal minterAllowed;
event Mint(address indexed minter, address indexed to, uint256 amount);
event Burn(address indexed burner, uint256 amount);
event MinterConfigured(address indexed minter, uint256 minterAllowedAmount);
event MinterRemoved(address indexed oldMinter);
event MasterMinterChanged(address indexed newMasterMinter);
function initialize(
string memory _name,
string memory _symbol,
string memory _currency,
uint8 _decimals,
address _masterMinter,
address _pauser,
address _blacklister,
address _owner
) public {
}
/**
* @dev Throws if called by any account other than a minter
*/
modifier onlyMinters() {
require(<FILL_ME>)
_;
}
/**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint. Must be less than or equal to the minterAllowance of the caller.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) whenNotPaused onlyMinters notBlacklisted(msg.sender) notBlacklisted(_to) public returns (bool) {
}
/**
* @dev Throws if called by any account other than the masterMinter
*/
modifier onlyMasterMinter() {
}
/**
* @dev Get minter allowance for an account
* @param minter The address of the minter
*/
function minterAllowance(address minter) public view returns (uint256) {
}
/**
* @dev Checks if account is a minter
* @param account The address to check
*/
function isMinter(address account) public view returns (bool) {
}
/**
* @dev Get allowed amount for an account
* @param owner address The account owner
* @param spender address The account spender
*/
function allowance(address owner, address spender) public view returns (uint256) {
}
/**
* @dev Get totalSupply of token
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Get token balance of an account
* @param account address The account
*/
function balanceOf(address account) public view returns (uint256) {
}
/**
* @dev Adds blacklisted check to approve
* @return True if the operation was successful.
*/
function approve(address _spender, uint256 _value) whenNotPaused notBlacklisted(msg.sender) notBlacklisted(_spender) public returns (bool) {
}
/**
* @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
* @return bool success
*/
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused notBlacklisted(_to) notBlacklisted(msg.sender) notBlacklisted(_from) public returns (bool) {
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
* @return bool success
*/
function transfer(address _to, uint256 _value) whenNotPaused notBlacklisted(msg.sender) notBlacklisted(_to) public returns (bool) {
}
/**
* @dev Function to add/update a new minter
* @param minter The address of the minter
* @param minterAllowedAmount The minting amount allowed for the minter
* @return True if the operation was successful.
*/
function configureMinter(address minter, uint256 minterAllowedAmount) whenNotPaused onlyMasterMinter public returns (bool) {
}
/**
* @dev Function to remove a minter
* @param minter The address of the minter to remove
* @return True if the operation was successful.
*/
function removeMinter(address minter) onlyMasterMinter public returns (bool) {
}
/**
* @dev allows a minter to burn some of its own tokens
* Validates that caller is a minter and that sender is not blacklisted
* amount is less than or equal to the minter's account balance
* @param _amount uint256 the amount of tokens to be burned
*/
function burn(uint256 _amount) whenNotPaused onlyMinters notBlacklisted(msg.sender) public {
}
function updateMasterMinter(address _newMasterMinter) onlyOwner public {
}
}
| minters[msg.sender]==true | 311,506 | minters[msg.sender]==true |
'MultiSig: Sender was not owner' | // Dependency file: @openzeppelin/contracts/utils/Context.sol
// SPDX-License-Identifier: MIT
// pragma solidity ^0.8.0;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
// Dependency file: @openzeppelin/contracts/access/Ownable.sol
// pragma solidity ^0.8.0;
// import "@openzeppelin/contracts/utils/Context.sol";
/**
* @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 {
}
function _setOwner(address newOwner) private {
}
}
// Dependency file: @openzeppelin/contracts/token/ERC20/IERC20.sol
// pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// Dependency file: @openzeppelin/contracts/utils/Address.sol
// pragma solidity ^0.8.0;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function _verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) private pure returns (bytes memory) {
}
}
// Root file: contracts/dk/MultiSig.sol
pragma solidity >=0.8.4 <0.9.0;
// import '/home/chiro/gits/infrastructure/node_modules/@openzeppelin/contracts/access/Ownable.sol';
// import '/home/chiro/gits/infrastructure/node_modules/@openzeppelin/contracts/token/ERC20/IERC20.sol';
// import '/home/chiro/gits/infrastructure/node_modules/@openzeppelin/contracts/utils/Address.sol';
/**
* Multi Signature Wallet
* Name: MultiSig
* Domain: Duelist King
*/
contract MultiSig {
// Address lib providing safe {call} and {delegatecall}
using Address for address;
// Structure of proposal
struct Proposal {
int256 vote;
uint64 expired;
bool executed;
bool delegate;
uint256 value;
address target;
bytes data;
}
// Total number of owner
uint256 private _ownerCount;
// Proposal storage
mapping(address => bool) private _owners;
// Proposal index, begin from 1
uint256 private _proposalIndex;
// Proposal storage
mapping(uint256 => Proposal) private _proposalStorage;
// Voted storage
mapping(uint256 => mapping(address => bool)) private _votedStorage;
// Only allow owner to call this smart contract
modifier onlyOwner() {
require(<FILL_ME>)
_;
}
// Create a new proposal
event CreateProposal(uint256 indexed proposalId, uint256 indexed expired);
// Execute proposal
event ExecuteProposal(uint256 indexed proposalId, address indexed trigger, int256 indexed vote);
// Positive vote
event PositiveVote(uint256 indexed proposalId, address indexed owner);
// Negative vote
event NegativeVote(uint256 indexed proposalId, address indexed owner);
// Transfer ownership
event TransferOwnership(address indexed from, address indexed to);
receive() external payable {}
constructor(address[] memory owners_) {
}
// Create a new proposal
function createProposal(Proposal memory newProposal) external onlyOwner returns (uint256) {
}
// Vote a proposal
function voteProposal(uint256 proposalId, bool positive) external onlyOwner returns (bool) {
}
// Execute a voted proposal
function execute(uint256 proposalId) external onlyOwner returns (bool) {
}
function proposalIndex() external view returns (uint256) {
}
function proposalDetail(uint256 index) external view returns (Proposal memory) {
}
function isOwner(address owner) external view returns (bool) {
}
function isVoted(uint256 proposalId, address owner) external view returns (bool) {
}
}
| _owners[msg.sender],'MultiSig: Sender was not owner' | 311,600 | _owners[msg.sender] |
'MultiSig: You had voted this proposal' | // Dependency file: @openzeppelin/contracts/utils/Context.sol
// SPDX-License-Identifier: MIT
// pragma solidity ^0.8.0;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
// Dependency file: @openzeppelin/contracts/access/Ownable.sol
// pragma solidity ^0.8.0;
// import "@openzeppelin/contracts/utils/Context.sol";
/**
* @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 {
}
function _setOwner(address newOwner) private {
}
}
// Dependency file: @openzeppelin/contracts/token/ERC20/IERC20.sol
// pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// Dependency file: @openzeppelin/contracts/utils/Address.sol
// pragma solidity ^0.8.0;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function _verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) private pure returns (bytes memory) {
}
}
// Root file: contracts/dk/MultiSig.sol
pragma solidity >=0.8.4 <0.9.0;
// import '/home/chiro/gits/infrastructure/node_modules/@openzeppelin/contracts/access/Ownable.sol';
// import '/home/chiro/gits/infrastructure/node_modules/@openzeppelin/contracts/token/ERC20/IERC20.sol';
// import '/home/chiro/gits/infrastructure/node_modules/@openzeppelin/contracts/utils/Address.sol';
/**
* Multi Signature Wallet
* Name: MultiSig
* Domain: Duelist King
*/
contract MultiSig {
// Address lib providing safe {call} and {delegatecall}
using Address for address;
// Structure of proposal
struct Proposal {
int256 vote;
uint64 expired;
bool executed;
bool delegate;
uint256 value;
address target;
bytes data;
}
// Total number of owner
uint256 private _ownerCount;
// Proposal storage
mapping(address => bool) private _owners;
// Proposal index, begin from 1
uint256 private _proposalIndex;
// Proposal storage
mapping(uint256 => Proposal) private _proposalStorage;
// Voted storage
mapping(uint256 => mapping(address => bool)) private _votedStorage;
// Only allow owner to call this smart contract
modifier onlyOwner() {
}
// Create a new proposal
event CreateProposal(uint256 indexed proposalId, uint256 indexed expired);
// Execute proposal
event ExecuteProposal(uint256 indexed proposalId, address indexed trigger, int256 indexed vote);
// Positive vote
event PositiveVote(uint256 indexed proposalId, address indexed owner);
// Negative vote
event NegativeVote(uint256 indexed proposalId, address indexed owner);
// Transfer ownership
event TransferOwnership(address indexed from, address indexed to);
receive() external payable {}
constructor(address[] memory owners_) {
}
// Create a new proposal
function createProposal(Proposal memory newProposal) external onlyOwner returns (uint256) {
}
// Vote a proposal
function voteProposal(uint256 proposalId, bool positive) external onlyOwner returns (bool) {
require(block.timestamp < _proposalStorage[proposalId].expired, 'MultiSig: Voting period was over');
require(<FILL_ME>)
if (positive) {
_proposalStorage[proposalId].vote += 1;
emit PositiveVote(proposalId, msg.sender);
} else {
_proposalStorage[proposalId].vote -= 1;
emit NegativeVote(proposalId, msg.sender);
}
_votedStorage[proposalId][msg.sender] = true;
return true;
}
// Execute a voted proposal
function execute(uint256 proposalId) external onlyOwner returns (bool) {
}
function proposalIndex() external view returns (uint256) {
}
function proposalDetail(uint256 index) external view returns (Proposal memory) {
}
function isOwner(address owner) external view returns (bool) {
}
function isVoted(uint256 proposalId, address owner) external view returns (bool) {
}
}
| _votedStorage[proposalId][msg.sender]==false,'MultiSig: You had voted this proposal' | 311,600 | _votedStorage[proposalId][msg.sender]==false |
"Token template is not contract" | /**
* @title FxReverseERC20RootTunnel
*/
contract FxReverseERC20RootTunnel is FxBaseRootTunnel, Create2 {
bytes32 public constant DEPOSIT = keccak256("DEPOSIT");
bytes32 public constant MAP_TOKEN = keccak256("MAP_TOKEN");
string public constant SUFFIX_NAME = "";
string public constant PREFIX_SYMBOL = "";
// event for token maping
event TokenMapped(address indexed rootToken, address indexed childToken);
// root to child token
mapping(address => address) public childToRootToken;
// token template
address public tokenTemplate;
constructor(address _checkpointManager, address _fxRoot, address _tokenTemplate) FxBaseRootTunnel(_checkpointManager, _fxRoot) {
tokenTemplate = _tokenTemplate;
require(<FILL_ME>)
}
function withdraw(address rootToken, uint256 amount) public {
}
//
// Internal methods
//
function _processMessageFromChild(bytes memory data)
internal
override {
}
function _mapToken(bytes memory syncData) internal returns (address) {
}
function _syncDeposit(bytes memory syncData) internal {
}
// check if address is contract
function _isContract(address _addr) private view returns (bool){
}
}
| _isContract(_tokenTemplate),"Token template is not contract" | 311,678 | _isContract(_tokenTemplate) |
"executeTransaction: Parameter signature can not be empty!" | pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import "../library/Ownable.sol";
contract Timelock is Ownable {
constructor() public {
}
function executeTransactions(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) public onlyOwner payable {
}
function executeTransaction(address target, uint value, string memory signature, bytes memory data) public onlyOwner payable returns (bytes memory) {
bytes memory callData;
require(<FILL_ME>)
callData = abi.encodePacked(bytes4(keccak256(bytes(signature))), data);
// solium-disable-next-line security/no-call-value
(bool success, bytes memory returnData) = target.call.value(value)(callData);
require(success, "Timelock::executeTransaction: Transaction execution reverted.");
return returnData;
}
}
| bytes(signature).length>0,"executeTransaction: Parameter signature can not be empty!" | 311,687 | bytes(signature).length>0 |
"Need to authenticate first!" | //SPDX-License-Identifier: MIT
pragma solidity ^0.5.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*
* _Available since v2.4.0._
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
/**
* @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.
*
* 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.
*/
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 () internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns true if the caller is the current owner.
*/
function isOwner() public view returns (bool) {
}
/**
* @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 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 onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IERC1155 {
event TransferSingle(
address indexed _operator,
address indexed _from,
address indexed _to,
uint256 _id,
uint256 _amount
);
event TransferBatch(
address indexed _operator,
address indexed _from,
address indexed _to,
uint256[] _ids,
uint256[] _amounts
);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
event URI(string _amount, uint256 indexed _id);
function mint(
address _to,
uint256 _id,
uint256 _quantity,
bytes calldata _data
) external;
function create(
uint256 _maxSupply,
uint256 _initialSupply,
string calldata _uri,
bytes calldata _data
) external returns (uint256 tokenId);
function safeTransferFrom(
address _from,
address _to,
uint256 _id,
uint256 _amount,
bytes calldata _data
) external;
function safeBatchTransferFrom(
address _from,
address _to,
uint256[] calldata _ids,
uint256[] calldata _amounts,
bytes calldata _data
) external;
function balanceOf(address _owner, uint256 _id) external view returns (uint256);
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address _operator, bool _approved) external;
function isApprovedForAll(address _owner, address _operator) external view returns (bool isOperator);
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract NFTPOE is Ownable {
uint256 public nftid;
mapping(address => bool) private purchased;
mapping(address => bool) private blacklist;
address public seller;
address public rarigang;
address public currency;
address public gdao;
constructor(uint256 _nftid, address _seller, address _rarigang, address _currency, address _gdao) public{
}
function addBlacklist(address user) public onlyOwner{
}
function addManyBlacklist(address[] memory user) public onlyOwner{
}
function removeBlacklist(address user) public onlyOwner{
}
function isBlacklisted(address user) public view returns (bool){
}
function hasPurchased(address buyer) public view returns (bool){
}
function purchase() public {
require(!isBlacklisted(msg.sender), "Cannot buy: blacklisted wallet!");
require(<FILL_ME>)
require(IERC20(gdao).balanceOf(msg.sender) >= 50*1e18, "Must hold 50 GDAO!");
require(!hasPurchased(msg.sender), "Cannot buy: Already purchased!");
require(IERC1155(rarigang).balanceOf(seller, nftid) > 0, "Cannot buy: No more available!");
IERC1155(rarigang).safeTransferFrom(seller, msg.sender, nftid, 1, "");
purchased[msg.sender] = true;
}
}
| IERC20(currency).balanceOf(msg.sender)==1,"Need to authenticate first!" | 311,715 | IERC20(currency).balanceOf(msg.sender)==1 |
"Must hold 50 GDAO!" | //SPDX-License-Identifier: MIT
pragma solidity ^0.5.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*
* _Available since v2.4.0._
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
/**
* @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.
*
* 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.
*/
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 () internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns true if the caller is the current owner.
*/
function isOwner() public view returns (bool) {
}
/**
* @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 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 onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IERC1155 {
event TransferSingle(
address indexed _operator,
address indexed _from,
address indexed _to,
uint256 _id,
uint256 _amount
);
event TransferBatch(
address indexed _operator,
address indexed _from,
address indexed _to,
uint256[] _ids,
uint256[] _amounts
);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
event URI(string _amount, uint256 indexed _id);
function mint(
address _to,
uint256 _id,
uint256 _quantity,
bytes calldata _data
) external;
function create(
uint256 _maxSupply,
uint256 _initialSupply,
string calldata _uri,
bytes calldata _data
) external returns (uint256 tokenId);
function safeTransferFrom(
address _from,
address _to,
uint256 _id,
uint256 _amount,
bytes calldata _data
) external;
function safeBatchTransferFrom(
address _from,
address _to,
uint256[] calldata _ids,
uint256[] calldata _amounts,
bytes calldata _data
) external;
function balanceOf(address _owner, uint256 _id) external view returns (uint256);
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address _operator, bool _approved) external;
function isApprovedForAll(address _owner, address _operator) external view returns (bool isOperator);
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract NFTPOE is Ownable {
uint256 public nftid;
mapping(address => bool) private purchased;
mapping(address => bool) private blacklist;
address public seller;
address public rarigang;
address public currency;
address public gdao;
constructor(uint256 _nftid, address _seller, address _rarigang, address _currency, address _gdao) public{
}
function addBlacklist(address user) public onlyOwner{
}
function addManyBlacklist(address[] memory user) public onlyOwner{
}
function removeBlacklist(address user) public onlyOwner{
}
function isBlacklisted(address user) public view returns (bool){
}
function hasPurchased(address buyer) public view returns (bool){
}
function purchase() public {
require(!isBlacklisted(msg.sender), "Cannot buy: blacklisted wallet!");
require(IERC20(currency).balanceOf(msg.sender) == 1, "Need to authenticate first!");
require(<FILL_ME>)
require(!hasPurchased(msg.sender), "Cannot buy: Already purchased!");
require(IERC1155(rarigang).balanceOf(seller, nftid) > 0, "Cannot buy: No more available!");
IERC1155(rarigang).safeTransferFrom(seller, msg.sender, nftid, 1, "");
purchased[msg.sender] = true;
}
}
| IERC20(gdao).balanceOf(msg.sender)>=50*1e18,"Must hold 50 GDAO!" | 311,715 | IERC20(gdao).balanceOf(msg.sender)>=50*1e18 |
"Cannot buy: Already purchased!" | //SPDX-License-Identifier: MIT
pragma solidity ^0.5.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*
* _Available since v2.4.0._
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
/**
* @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.
*
* 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.
*/
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 () internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns true if the caller is the current owner.
*/
function isOwner() public view returns (bool) {
}
/**
* @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 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 onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IERC1155 {
event TransferSingle(
address indexed _operator,
address indexed _from,
address indexed _to,
uint256 _id,
uint256 _amount
);
event TransferBatch(
address indexed _operator,
address indexed _from,
address indexed _to,
uint256[] _ids,
uint256[] _amounts
);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
event URI(string _amount, uint256 indexed _id);
function mint(
address _to,
uint256 _id,
uint256 _quantity,
bytes calldata _data
) external;
function create(
uint256 _maxSupply,
uint256 _initialSupply,
string calldata _uri,
bytes calldata _data
) external returns (uint256 tokenId);
function safeTransferFrom(
address _from,
address _to,
uint256 _id,
uint256 _amount,
bytes calldata _data
) external;
function safeBatchTransferFrom(
address _from,
address _to,
uint256[] calldata _ids,
uint256[] calldata _amounts,
bytes calldata _data
) external;
function balanceOf(address _owner, uint256 _id) external view returns (uint256);
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address _operator, bool _approved) external;
function isApprovedForAll(address _owner, address _operator) external view returns (bool isOperator);
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract NFTPOE is Ownable {
uint256 public nftid;
mapping(address => bool) private purchased;
mapping(address => bool) private blacklist;
address public seller;
address public rarigang;
address public currency;
address public gdao;
constructor(uint256 _nftid, address _seller, address _rarigang, address _currency, address _gdao) public{
}
function addBlacklist(address user) public onlyOwner{
}
function addManyBlacklist(address[] memory user) public onlyOwner{
}
function removeBlacklist(address user) public onlyOwner{
}
function isBlacklisted(address user) public view returns (bool){
}
function hasPurchased(address buyer) public view returns (bool){
}
function purchase() public {
require(!isBlacklisted(msg.sender), "Cannot buy: blacklisted wallet!");
require(IERC20(currency).balanceOf(msg.sender) == 1, "Need to authenticate first!");
require(IERC20(gdao).balanceOf(msg.sender) >= 50*1e18, "Must hold 50 GDAO!");
require(<FILL_ME>)
require(IERC1155(rarigang).balanceOf(seller, nftid) > 0, "Cannot buy: No more available!");
IERC1155(rarigang).safeTransferFrom(seller, msg.sender, nftid, 1, "");
purchased[msg.sender] = true;
}
}
| !hasPurchased(msg.sender),"Cannot buy: Already purchased!" | 311,715 | !hasPurchased(msg.sender) |
"Cannot buy: No more available!" | //SPDX-License-Identifier: MIT
pragma solidity ^0.5.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*
* _Available since v2.4.0._
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
/**
* @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.
*
* 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.
*/
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 () internal {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns true if the caller is the current owner.
*/
function isOwner() public view returns (bool) {
}
/**
* @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 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 onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
*/
function _transferOwnership(address newOwner) internal {
}
}
interface IERC1155 {
event TransferSingle(
address indexed _operator,
address indexed _from,
address indexed _to,
uint256 _id,
uint256 _amount
);
event TransferBatch(
address indexed _operator,
address indexed _from,
address indexed _to,
uint256[] _ids,
uint256[] _amounts
);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
event URI(string _amount, uint256 indexed _id);
function mint(
address _to,
uint256 _id,
uint256 _quantity,
bytes calldata _data
) external;
function create(
uint256 _maxSupply,
uint256 _initialSupply,
string calldata _uri,
bytes calldata _data
) external returns (uint256 tokenId);
function safeTransferFrom(
address _from,
address _to,
uint256 _id,
uint256 _amount,
bytes calldata _data
) external;
function safeBatchTransferFrom(
address _from,
address _to,
uint256[] calldata _ids,
uint256[] calldata _amounts,
bytes calldata _data
) external;
function balanceOf(address _owner, uint256 _id) external view returns (uint256);
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address _operator, bool _approved) external;
function isApprovedForAll(address _owner, address _operator) external view returns (bool isOperator);
}
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract NFTPOE is Ownable {
uint256 public nftid;
mapping(address => bool) private purchased;
mapping(address => bool) private blacklist;
address public seller;
address public rarigang;
address public currency;
address public gdao;
constructor(uint256 _nftid, address _seller, address _rarigang, address _currency, address _gdao) public{
}
function addBlacklist(address user) public onlyOwner{
}
function addManyBlacklist(address[] memory user) public onlyOwner{
}
function removeBlacklist(address user) public onlyOwner{
}
function isBlacklisted(address user) public view returns (bool){
}
function hasPurchased(address buyer) public view returns (bool){
}
function purchase() public {
require(!isBlacklisted(msg.sender), "Cannot buy: blacklisted wallet!");
require(IERC20(currency).balanceOf(msg.sender) == 1, "Need to authenticate first!");
require(IERC20(gdao).balanceOf(msg.sender) >= 50*1e18, "Must hold 50 GDAO!");
require(!hasPurchased(msg.sender), "Cannot buy: Already purchased!");
require(<FILL_ME>)
IERC1155(rarigang).safeTransferFrom(seller, msg.sender, nftid, 1, "");
purchased[msg.sender] = true;
}
}
| IERC1155(rarigang).balanceOf(seller,nftid)>0,"Cannot buy: No more available!" | 311,715 | IERC1155(rarigang).balanceOf(seller,nftid)>0 |
"Panel is empty" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./TilesBlocksCore.sol";
contract TilesPanelsCore is ERC721Enumerable, AccessControl, Ownable {
struct Panel {
string name;
string description;
uint16 size;
uint16 degradationLevel;
bool isEmpty;
}
uint256 constant TOTAL_MAX_2 = 50;
uint256 constant TOTAL_MAX_4 = 500;
uint256 constant TOTAL_MAX_6 = 200;
uint256 constant TOTAL_MAX_9 = 250;
uint256 constant TOTAL_MAX_16 = 80;
uint256 constant TOTAL_MAX_25 = 20;
uint256 constant TOTAL_MAX_36 = 5;
using SafeMath for uint256;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
string public scriptArweave;
string public scriptIPFS;
address internal BLOCKS_CONTRACT;
mapping (uint256 => uint256[]) public tokenBlocks;
mapping (uint256 => Panel) public tokens;
mapping (uint256 => uint256) public totalMints;
uint256 public totalGlobalMints = 0;
string internal _currentBaseURI = "";
event PanelCreated (uint _tokenId, uint256[] _blocksTokenIds);
event PanelDeconstructed (uint _tokenId);
constructor(address adminAddress, address ownerAddress, string memory baseURI, address blocks_contract) ERC721("Tiles Panels", "TILP") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public {
}
function setScriptIPFS(string memory _scriptIPFS) public {
}
function setScriptArweave(string memory _scriptArweave) public {
}
function _isValidLength(uint256 len) internal pure returns(bool) {
}
function _checkTotalMints(uint256 size) internal view returns(bool) {
}
function deconstruct(uint256 _tokenId) public {
require(hasRole(MINTER_ROLE, msg.sender), "Caller is not a minter");
require(<FILL_ME>)
delete tokenBlocks[_tokenId];
if (tokens[_tokenId].degradationLevel < 4)
tokens[_tokenId].degradationLevel++;
tokens[_tokenId].name = '';
tokens[_tokenId].description = '';
tokens[_tokenId].isEmpty = true;
emit PanelDeconstructed(_tokenId);
}
function fillEmptyToken(uint256 _tokenId, string memory _name, string memory _desc, uint256[] memory _blocksTokenIds) public {
}
function mintGenesis(address _receiver, string memory _name, string memory _desc, uint16 _size, uint256[] memory _blocksTokenIds) public {
}
function burn(uint256 tokenId) public {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Enumerable, AccessControl) returns (bool) {
}
function withdrawEther() public {
}
}
| tokenBlocks[_tokenId].length>0,"Panel is empty" | 311,737 | tokenBlocks[_tokenId].length>0 |
"Panel is not empty" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./TilesBlocksCore.sol";
contract TilesPanelsCore is ERC721Enumerable, AccessControl, Ownable {
struct Panel {
string name;
string description;
uint16 size;
uint16 degradationLevel;
bool isEmpty;
}
uint256 constant TOTAL_MAX_2 = 50;
uint256 constant TOTAL_MAX_4 = 500;
uint256 constant TOTAL_MAX_6 = 200;
uint256 constant TOTAL_MAX_9 = 250;
uint256 constant TOTAL_MAX_16 = 80;
uint256 constant TOTAL_MAX_25 = 20;
uint256 constant TOTAL_MAX_36 = 5;
using SafeMath for uint256;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
string public scriptArweave;
string public scriptIPFS;
address internal BLOCKS_CONTRACT;
mapping (uint256 => uint256[]) public tokenBlocks;
mapping (uint256 => Panel) public tokens;
mapping (uint256 => uint256) public totalMints;
uint256 public totalGlobalMints = 0;
string internal _currentBaseURI = "";
event PanelCreated (uint _tokenId, uint256[] _blocksTokenIds);
event PanelDeconstructed (uint _tokenId);
constructor(address adminAddress, address ownerAddress, string memory baseURI, address blocks_contract) ERC721("Tiles Panels", "TILP") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public {
}
function setScriptIPFS(string memory _scriptIPFS) public {
}
function setScriptArweave(string memory _scriptArweave) public {
}
function _isValidLength(uint256 len) internal pure returns(bool) {
}
function _checkTotalMints(uint256 size) internal view returns(bool) {
}
function deconstruct(uint256 _tokenId) public {
}
function fillEmptyToken(uint256 _tokenId, string memory _name, string memory _desc, uint256[] memory _blocksTokenIds) public {
require(hasRole(MINTER_ROLE, msg.sender), "Caller is not a minter");
require(<FILL_ME>)
uint256 aLength = _blocksTokenIds.length;
require(tokens[_tokenId].size == aLength, "Size differs from blocks count. Partial Panels not allowed");
for(uint i=0; i < aLength; i++) {
uint bTid = _blocksTokenIds[i];
require(TilesBlocksCore(BLOCKS_CONTRACT).ownerOf(bTid) == ownerOf(_tokenId), "Receiver needs to own all tokens"); //also checks if token exists
TilesBlocksCore(BLOCKS_CONTRACT).burn(bTid);
}
tokenBlocks[_tokenId] = _blocksTokenIds;
tokens[_tokenId].name = _name;
tokens[_tokenId].description = _desc;
tokens[_tokenId].isEmpty = false;
emit PanelCreated (_tokenId, _blocksTokenIds);
}
function mintGenesis(address _receiver, string memory _name, string memory _desc, uint16 _size, uint256[] memory _blocksTokenIds) public {
}
function burn(uint256 tokenId) public {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Enumerable, AccessControl) returns (bool) {
}
function withdrawEther() public {
}
}
| tokens[_tokenId].isEmpty,"Panel is not empty" | 311,737 | tokens[_tokenId].isEmpty |
"Size differs from blocks count. Partial Panels not allowed" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./TilesBlocksCore.sol";
contract TilesPanelsCore is ERC721Enumerable, AccessControl, Ownable {
struct Panel {
string name;
string description;
uint16 size;
uint16 degradationLevel;
bool isEmpty;
}
uint256 constant TOTAL_MAX_2 = 50;
uint256 constant TOTAL_MAX_4 = 500;
uint256 constant TOTAL_MAX_6 = 200;
uint256 constant TOTAL_MAX_9 = 250;
uint256 constant TOTAL_MAX_16 = 80;
uint256 constant TOTAL_MAX_25 = 20;
uint256 constant TOTAL_MAX_36 = 5;
using SafeMath for uint256;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
string public scriptArweave;
string public scriptIPFS;
address internal BLOCKS_CONTRACT;
mapping (uint256 => uint256[]) public tokenBlocks;
mapping (uint256 => Panel) public tokens;
mapping (uint256 => uint256) public totalMints;
uint256 public totalGlobalMints = 0;
string internal _currentBaseURI = "";
event PanelCreated (uint _tokenId, uint256[] _blocksTokenIds);
event PanelDeconstructed (uint _tokenId);
constructor(address adminAddress, address ownerAddress, string memory baseURI, address blocks_contract) ERC721("Tiles Panels", "TILP") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public {
}
function setScriptIPFS(string memory _scriptIPFS) public {
}
function setScriptArweave(string memory _scriptArweave) public {
}
function _isValidLength(uint256 len) internal pure returns(bool) {
}
function _checkTotalMints(uint256 size) internal view returns(bool) {
}
function deconstruct(uint256 _tokenId) public {
}
function fillEmptyToken(uint256 _tokenId, string memory _name, string memory _desc, uint256[] memory _blocksTokenIds) public {
require(hasRole(MINTER_ROLE, msg.sender), "Caller is not a minter");
require(tokens[_tokenId].isEmpty, "Panel is not empty");
uint256 aLength = _blocksTokenIds.length;
require(<FILL_ME>)
for(uint i=0; i < aLength; i++) {
uint bTid = _blocksTokenIds[i];
require(TilesBlocksCore(BLOCKS_CONTRACT).ownerOf(bTid) == ownerOf(_tokenId), "Receiver needs to own all tokens"); //also checks if token exists
TilesBlocksCore(BLOCKS_CONTRACT).burn(bTid);
}
tokenBlocks[_tokenId] = _blocksTokenIds;
tokens[_tokenId].name = _name;
tokens[_tokenId].description = _desc;
tokens[_tokenId].isEmpty = false;
emit PanelCreated (_tokenId, _blocksTokenIds);
}
function mintGenesis(address _receiver, string memory _name, string memory _desc, uint16 _size, uint256[] memory _blocksTokenIds) public {
}
function burn(uint256 tokenId) public {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Enumerable, AccessControl) returns (bool) {
}
function withdrawEther() public {
}
}
| tokens[_tokenId].size==aLength,"Size differs from blocks count. Partial Panels not allowed" | 311,737 | tokens[_tokenId].size==aLength |
"Receiver needs to own all tokens" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./TilesBlocksCore.sol";
contract TilesPanelsCore is ERC721Enumerable, AccessControl, Ownable {
struct Panel {
string name;
string description;
uint16 size;
uint16 degradationLevel;
bool isEmpty;
}
uint256 constant TOTAL_MAX_2 = 50;
uint256 constant TOTAL_MAX_4 = 500;
uint256 constant TOTAL_MAX_6 = 200;
uint256 constant TOTAL_MAX_9 = 250;
uint256 constant TOTAL_MAX_16 = 80;
uint256 constant TOTAL_MAX_25 = 20;
uint256 constant TOTAL_MAX_36 = 5;
using SafeMath for uint256;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
string public scriptArweave;
string public scriptIPFS;
address internal BLOCKS_CONTRACT;
mapping (uint256 => uint256[]) public tokenBlocks;
mapping (uint256 => Panel) public tokens;
mapping (uint256 => uint256) public totalMints;
uint256 public totalGlobalMints = 0;
string internal _currentBaseURI = "";
event PanelCreated (uint _tokenId, uint256[] _blocksTokenIds);
event PanelDeconstructed (uint _tokenId);
constructor(address adminAddress, address ownerAddress, string memory baseURI, address blocks_contract) ERC721("Tiles Panels", "TILP") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public {
}
function setScriptIPFS(string memory _scriptIPFS) public {
}
function setScriptArweave(string memory _scriptArweave) public {
}
function _isValidLength(uint256 len) internal pure returns(bool) {
}
function _checkTotalMints(uint256 size) internal view returns(bool) {
}
function deconstruct(uint256 _tokenId) public {
}
function fillEmptyToken(uint256 _tokenId, string memory _name, string memory _desc, uint256[] memory _blocksTokenIds) public {
require(hasRole(MINTER_ROLE, msg.sender), "Caller is not a minter");
require(tokens[_tokenId].isEmpty, "Panel is not empty");
uint256 aLength = _blocksTokenIds.length;
require(tokens[_tokenId].size == aLength, "Size differs from blocks count. Partial Panels not allowed");
for(uint i=0; i < aLength; i++) {
uint bTid = _blocksTokenIds[i];
require(<FILL_ME>) //also checks if token exists
TilesBlocksCore(BLOCKS_CONTRACT).burn(bTid);
}
tokenBlocks[_tokenId] = _blocksTokenIds;
tokens[_tokenId].name = _name;
tokens[_tokenId].description = _desc;
tokens[_tokenId].isEmpty = false;
emit PanelCreated (_tokenId, _blocksTokenIds);
}
function mintGenesis(address _receiver, string memory _name, string memory _desc, uint16 _size, uint256[] memory _blocksTokenIds) public {
}
function burn(uint256 tokenId) public {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Enumerable, AccessControl) returns (bool) {
}
function withdrawEther() public {
}
}
| TilesBlocksCore(BLOCKS_CONTRACT).ownerOf(bTid)==ownerOf(_tokenId),"Receiver needs to own all tokens" | 311,737 | TilesBlocksCore(BLOCKS_CONTRACT).ownerOf(bTid)==ownerOf(_tokenId) |
"Invalid size" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./TilesBlocksCore.sol";
contract TilesPanelsCore is ERC721Enumerable, AccessControl, Ownable {
struct Panel {
string name;
string description;
uint16 size;
uint16 degradationLevel;
bool isEmpty;
}
uint256 constant TOTAL_MAX_2 = 50;
uint256 constant TOTAL_MAX_4 = 500;
uint256 constant TOTAL_MAX_6 = 200;
uint256 constant TOTAL_MAX_9 = 250;
uint256 constant TOTAL_MAX_16 = 80;
uint256 constant TOTAL_MAX_25 = 20;
uint256 constant TOTAL_MAX_36 = 5;
using SafeMath for uint256;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
string public scriptArweave;
string public scriptIPFS;
address internal BLOCKS_CONTRACT;
mapping (uint256 => uint256[]) public tokenBlocks;
mapping (uint256 => Panel) public tokens;
mapping (uint256 => uint256) public totalMints;
uint256 public totalGlobalMints = 0;
string internal _currentBaseURI = "";
event PanelCreated (uint _tokenId, uint256[] _blocksTokenIds);
event PanelDeconstructed (uint _tokenId);
constructor(address adminAddress, address ownerAddress, string memory baseURI, address blocks_contract) ERC721("Tiles Panels", "TILP") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public {
}
function setScriptIPFS(string memory _scriptIPFS) public {
}
function setScriptArweave(string memory _scriptArweave) public {
}
function _isValidLength(uint256 len) internal pure returns(bool) {
}
function _checkTotalMints(uint256 size) internal view returns(bool) {
}
function deconstruct(uint256 _tokenId) public {
}
function fillEmptyToken(uint256 _tokenId, string memory _name, string memory _desc, uint256[] memory _blocksTokenIds) public {
}
function mintGenesis(address _receiver, string memory _name, string memory _desc, uint16 _size, uint256[] memory _blocksTokenIds) public {
require(hasRole(MINTER_ROLE, msg.sender), "Caller is not a minter");
require(<FILL_ME>)
require(_checkTotalMints(_size), "Exceeds total mints for this size");
bool isEmpty = false;
uint256 aLength = _blocksTokenIds.length;
if (aLength > 0) { //not empty
require(_size == aLength, "Size differs from blocks count. Partial Panels not allowed");
for(uint i=0; i < aLength; i++) {
uint bTid = _blocksTokenIds[i];
require(TilesBlocksCore(BLOCKS_CONTRACT).ownerOf(bTid) == _receiver, "Receiver needs to own all tokens"); //also checks if token exists
TilesBlocksCore(BLOCKS_CONTRACT).burn(bTid);
}
}
else {
isEmpty = true;
}
totalGlobalMints++;
uint256 token = totalGlobalMints;
totalMints[_size] = totalMints[_size] + 1;
tokenBlocks[token] = _blocksTokenIds;
tokens[token] = Panel({name: _name, description: _desc, size: _size, degradationLevel: 0, isEmpty: isEmpty});
_safeMint(_receiver, token);
emit PanelCreated (token, _blocksTokenIds);
}
function burn(uint256 tokenId) public {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Enumerable, AccessControl) returns (bool) {
}
function withdrawEther() public {
}
}
| _isValidLength(_size),"Invalid size" | 311,737 | _isValidLength(_size) |
"Exceeds total mints for this size" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./TilesBlocksCore.sol";
contract TilesPanelsCore is ERC721Enumerable, AccessControl, Ownable {
struct Panel {
string name;
string description;
uint16 size;
uint16 degradationLevel;
bool isEmpty;
}
uint256 constant TOTAL_MAX_2 = 50;
uint256 constant TOTAL_MAX_4 = 500;
uint256 constant TOTAL_MAX_6 = 200;
uint256 constant TOTAL_MAX_9 = 250;
uint256 constant TOTAL_MAX_16 = 80;
uint256 constant TOTAL_MAX_25 = 20;
uint256 constant TOTAL_MAX_36 = 5;
using SafeMath for uint256;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
string public scriptArweave;
string public scriptIPFS;
address internal BLOCKS_CONTRACT;
mapping (uint256 => uint256[]) public tokenBlocks;
mapping (uint256 => Panel) public tokens;
mapping (uint256 => uint256) public totalMints;
uint256 public totalGlobalMints = 0;
string internal _currentBaseURI = "";
event PanelCreated (uint _tokenId, uint256[] _blocksTokenIds);
event PanelDeconstructed (uint _tokenId);
constructor(address adminAddress, address ownerAddress, string memory baseURI, address blocks_contract) ERC721("Tiles Panels", "TILP") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public {
}
function setScriptIPFS(string memory _scriptIPFS) public {
}
function setScriptArweave(string memory _scriptArweave) public {
}
function _isValidLength(uint256 len) internal pure returns(bool) {
}
function _checkTotalMints(uint256 size) internal view returns(bool) {
}
function deconstruct(uint256 _tokenId) public {
}
function fillEmptyToken(uint256 _tokenId, string memory _name, string memory _desc, uint256[] memory _blocksTokenIds) public {
}
function mintGenesis(address _receiver, string memory _name, string memory _desc, uint16 _size, uint256[] memory _blocksTokenIds) public {
require(hasRole(MINTER_ROLE, msg.sender), "Caller is not a minter");
require(_isValidLength(_size), "Invalid size");
require(<FILL_ME>)
bool isEmpty = false;
uint256 aLength = _blocksTokenIds.length;
if (aLength > 0) { //not empty
require(_size == aLength, "Size differs from blocks count. Partial Panels not allowed");
for(uint i=0; i < aLength; i++) {
uint bTid = _blocksTokenIds[i];
require(TilesBlocksCore(BLOCKS_CONTRACT).ownerOf(bTid) == _receiver, "Receiver needs to own all tokens"); //also checks if token exists
TilesBlocksCore(BLOCKS_CONTRACT).burn(bTid);
}
}
else {
isEmpty = true;
}
totalGlobalMints++;
uint256 token = totalGlobalMints;
totalMints[_size] = totalMints[_size] + 1;
tokenBlocks[token] = _blocksTokenIds;
tokens[token] = Panel({name: _name, description: _desc, size: _size, degradationLevel: 0, isEmpty: isEmpty});
_safeMint(_receiver, token);
emit PanelCreated (token, _blocksTokenIds);
}
function burn(uint256 tokenId) public {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Enumerable, AccessControl) returns (bool) {
}
function withdrawEther() public {
}
}
| _checkTotalMints(_size),"Exceeds total mints for this size" | 311,737 | _checkTotalMints(_size) |
"Receiver needs to own all tokens" | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./TilesBlocksCore.sol";
contract TilesPanelsCore is ERC721Enumerable, AccessControl, Ownable {
struct Panel {
string name;
string description;
uint16 size;
uint16 degradationLevel;
bool isEmpty;
}
uint256 constant TOTAL_MAX_2 = 50;
uint256 constant TOTAL_MAX_4 = 500;
uint256 constant TOTAL_MAX_6 = 200;
uint256 constant TOTAL_MAX_9 = 250;
uint256 constant TOTAL_MAX_16 = 80;
uint256 constant TOTAL_MAX_25 = 20;
uint256 constant TOTAL_MAX_36 = 5;
using SafeMath for uint256;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
string public scriptArweave;
string public scriptIPFS;
address internal BLOCKS_CONTRACT;
mapping (uint256 => uint256[]) public tokenBlocks;
mapping (uint256 => Panel) public tokens;
mapping (uint256 => uint256) public totalMints;
uint256 public totalGlobalMints = 0;
string internal _currentBaseURI = "";
event PanelCreated (uint _tokenId, uint256[] _blocksTokenIds);
event PanelDeconstructed (uint _tokenId);
constructor(address adminAddress, address ownerAddress, string memory baseURI, address blocks_contract) ERC721("Tiles Panels", "TILP") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public {
}
function setScriptIPFS(string memory _scriptIPFS) public {
}
function setScriptArweave(string memory _scriptArweave) public {
}
function _isValidLength(uint256 len) internal pure returns(bool) {
}
function _checkTotalMints(uint256 size) internal view returns(bool) {
}
function deconstruct(uint256 _tokenId) public {
}
function fillEmptyToken(uint256 _tokenId, string memory _name, string memory _desc, uint256[] memory _blocksTokenIds) public {
}
function mintGenesis(address _receiver, string memory _name, string memory _desc, uint16 _size, uint256[] memory _blocksTokenIds) public {
require(hasRole(MINTER_ROLE, msg.sender), "Caller is not a minter");
require(_isValidLength(_size), "Invalid size");
require(_checkTotalMints(_size), "Exceeds total mints for this size");
bool isEmpty = false;
uint256 aLength = _blocksTokenIds.length;
if (aLength > 0) { //not empty
require(_size == aLength, "Size differs from blocks count. Partial Panels not allowed");
for(uint i=0; i < aLength; i++) {
uint bTid = _blocksTokenIds[i];
require(<FILL_ME>) //also checks if token exists
TilesBlocksCore(BLOCKS_CONTRACT).burn(bTid);
}
}
else {
isEmpty = true;
}
totalGlobalMints++;
uint256 token = totalGlobalMints;
totalMints[_size] = totalMints[_size] + 1;
tokenBlocks[token] = _blocksTokenIds;
tokens[token] = Panel({name: _name, description: _desc, size: _size, degradationLevel: 0, isEmpty: isEmpty});
_safeMint(_receiver, token);
emit PanelCreated (token, _blocksTokenIds);
}
function burn(uint256 tokenId) public {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Enumerable, AccessControl) returns (bool) {
}
function withdrawEther() public {
}
}
| TilesBlocksCore(BLOCKS_CONTRACT).ownerOf(bTid)==_receiver,"Receiver needs to own all tokens" | 311,737 | TilesBlocksCore(BLOCKS_CONTRACT).ownerOf(bTid)==_receiver |
"Not enough tickets remaining to mint" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
.:::::=.
=+=::::-:
:= .--=::--:-=::+-:=-:-- .= =
.:== :=-:+:.-+..*::+-:-*:-*:::::::::::. :=:::::-*
--:::-+. := -- .--. .=+::::::+
.. .:::-: :- .= .= :---::-. .-
.=-*-:::. :-+*=- -: :- .= .+:::::::::::*.
+.:+= .-=+-- --.....::::* +::::::::::::-+:::::::::::*
=: == =:.. := -: :+::: :=
=..=:...... -- -- -- -- -*:::::::+
-=:. ...:::-- .=. =. := .-- .*::::::-+
-:+::::::::=:+=::::::--+--:=:=:=-==:. .= :=
= -- =:+===-+:+ +=:::::-=
=. .=. .::::::-:
:-: -:
::-
###### ## #### ##### #### ##### #### ####
## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ##
#### ## ## ##### ## ### ##### ## ## ##
## ## ## ## ## ## #### ## ## ##
## ## ## ## ## ## ## ## ## ## ##
## ###### #### ## #### ## ## #### ####
*/
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface InfiniteGrid {
function balanceOf(address owner) external view returns (uint256 balance);
}
contract Flipgrid is ERC721, IERC2981, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private tokenCounter;
string private baseURI = 'https://infinitegrid.art/api/flipgrid';
bool public isPublicSaleActive = false;
bool public isGridSaleActive = false;
uint256 public MAX_SUPPLY = 60;
uint256 public MAX_PER_WALLET = 1;
uint256 public PUBLIC_SALE_PRICE = 0.1 ether;
uint256 public ROYALTY = 5; // 10% - don't resell friends
uint256 public GRID_THRESHOLD = 1; // 1 Grid
address public GRID_ADDRESS = 0x78898ffA059D170F887555d8Fd6443D2ABe4E548; // Infinite Grid
// Modifiers
modifier publicSaleActive() {
}
modifier gridSaleActive() {
}
modifier canMintToken() {
require(<FILL_ME>)
_;
}
modifier isCorrectPayment(uint256 price) {
}
modifier hasGrid() {
}
modifier hasMinted() {
}
constructor() ERC721("Flip Grid 01", "FLIPGRID01") {
}
function mint()
external
payable
nonReentrant
isCorrectPayment(PUBLIC_SALE_PRICE)
gridSaleActive
hasGrid
canMintToken
hasMinted
{
}
function mintPublic()
external
payable
nonReentrant
isCorrectPayment(PUBLIC_SALE_PRICE)
publicSaleActive
canMintToken
{
}
function mintOwner(uint256 numberOfTokens) public onlyOwner {
}
// Public
function getBaseURI() external view returns (string memory) {
}
function getLastTokenId() external view returns (uint256) {
}
// Admin
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setGridAddress(address _address) external onlyOwner {
}
function setThreshold(uint256 _num) external onlyOwner {
}
function setMaxPerWallet(uint256 _max) external onlyOwner {
}
function setRoyalty(uint256 _royalty) external onlyOwner {
}
function withdraw() public onlyOwner {
}
function setIsPublicSaleActive(bool _isPublicSaleActive)
external
onlyOwner
{
}
function setIsGridSaleActive(bool _isGridSaleActive)
external
onlyOwner
{
}
// Counter stuff
function nextTokenId() private returns (uint256) {
}
// Royalties
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, IERC165)
returns (bool)
{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* @dev See {IERC165-royaltyInfo}.
*/
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
| tokenCounter.current()<=MAX_SUPPLY,"Not enough tickets remaining to mint" | 311,741 | tokenCounter.current()<=MAX_SUPPLY |
"You must hold an Infinte Grid to purchase a Flipgrid." | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
.:::::=.
=+=::::-:
:= .--=::--:-=::+-:=-:-- .= =
.:== :=-:+:.-+..*::+-:-*:-*:::::::::::. :=:::::-*
--:::-+. := -- .--. .=+::::::+
.. .:::-: :- .= .= :---::-. .-
.=-*-:::. :-+*=- -: :- .= .+:::::::::::*.
+.:+= .-=+-- --.....::::* +::::::::::::-+:::::::::::*
=: == =:.. := -: :+::: :=
=..=:...... -- -- -- -- -*:::::::+
-=:. ...:::-- .=. =. := .-- .*::::::-+
-:+::::::::=:+=::::::--+--:=:=:=-==:. .= :=
= -- =:+===-+:+ +=:::::-=
=. .=. .::::::-:
:-: -:
::-
###### ## #### ##### #### ##### #### ####
## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ##
#### ## ## ##### ## ### ##### ## ## ##
## ## ## ## ## ## #### ## ## ##
## ## ## ## ## ## ## ## ## ## ##
## ###### #### ## #### ## ## #### ####
*/
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface InfiniteGrid {
function balanceOf(address owner) external view returns (uint256 balance);
}
contract Flipgrid is ERC721, IERC2981, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private tokenCounter;
string private baseURI = 'https://infinitegrid.art/api/flipgrid';
bool public isPublicSaleActive = false;
bool public isGridSaleActive = false;
uint256 public MAX_SUPPLY = 60;
uint256 public MAX_PER_WALLET = 1;
uint256 public PUBLIC_SALE_PRICE = 0.1 ether;
uint256 public ROYALTY = 5; // 10% - don't resell friends
uint256 public GRID_THRESHOLD = 1; // 1 Grid
address public GRID_ADDRESS = 0x78898ffA059D170F887555d8Fd6443D2ABe4E548; // Infinite Grid
// Modifiers
modifier publicSaleActive() {
}
modifier gridSaleActive() {
}
modifier canMintToken() {
}
modifier isCorrectPayment(uint256 price) {
}
modifier hasGrid() {
require(<FILL_ME>)
_;
}
modifier hasMinted() {
}
constructor() ERC721("Flip Grid 01", "FLIPGRID01") {
}
function mint()
external
payable
nonReentrant
isCorrectPayment(PUBLIC_SALE_PRICE)
gridSaleActive
hasGrid
canMintToken
hasMinted
{
}
function mintPublic()
external
payable
nonReentrant
isCorrectPayment(PUBLIC_SALE_PRICE)
publicSaleActive
canMintToken
{
}
function mintOwner(uint256 numberOfTokens) public onlyOwner {
}
// Public
function getBaseURI() external view returns (string memory) {
}
function getLastTokenId() external view returns (uint256) {
}
// Admin
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setGridAddress(address _address) external onlyOwner {
}
function setThreshold(uint256 _num) external onlyOwner {
}
function setMaxPerWallet(uint256 _max) external onlyOwner {
}
function setRoyalty(uint256 _royalty) external onlyOwner {
}
function withdraw() public onlyOwner {
}
function setIsPublicSaleActive(bool _isPublicSaleActive)
external
onlyOwner
{
}
function setIsGridSaleActive(bool _isGridSaleActive)
external
onlyOwner
{
}
// Counter stuff
function nextTokenId() private returns (uint256) {
}
// Royalties
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, IERC165)
returns (bool)
{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* @dev See {IERC165-royaltyInfo}.
*/
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
| InfiniteGrid(GRID_ADDRESS).balanceOf(msg.sender)>=GRID_THRESHOLD,"You must hold an Infinte Grid to purchase a Flipgrid." | 311,741 | InfiniteGrid(GRID_ADDRESS).balanceOf(msg.sender)>=GRID_THRESHOLD |
"This address has already minted." | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
.:::::=.
=+=::::-:
:= .--=::--:-=::+-:=-:-- .= =
.:== :=-:+:.-+..*::+-:-*:-*:::::::::::. :=:::::-*
--:::-+. := -- .--. .=+::::::+
.. .:::-: :- .= .= :---::-. .-
.=-*-:::. :-+*=- -: :- .= .+:::::::::::*.
+.:+= .-=+-- --.....::::* +::::::::::::-+:::::::::::*
=: == =:.. := -: :+::: :=
=..=:...... -- -- -- -- -*:::::::+
-=:. ...:::-- .=. =. := .-- .*::::::-+
-:+::::::::=:+=::::::--+--:=:=:=-==:. .= :=
= -- =:+===-+:+ +=:::::-=
=. .=. .::::::-:
:-: -:
::-
###### ## #### ##### #### ##### #### ####
## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ##
#### ## ## ##### ## ### ##### ## ## ##
## ## ## ## ## ## #### ## ## ##
## ## ## ## ## ## ## ## ## ## ##
## ###### #### ## #### ## ## #### ####
*/
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface InfiniteGrid {
function balanceOf(address owner) external view returns (uint256 balance);
}
contract Flipgrid is ERC721, IERC2981, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private tokenCounter;
string private baseURI = 'https://infinitegrid.art/api/flipgrid';
bool public isPublicSaleActive = false;
bool public isGridSaleActive = false;
uint256 public MAX_SUPPLY = 60;
uint256 public MAX_PER_WALLET = 1;
uint256 public PUBLIC_SALE_PRICE = 0.1 ether;
uint256 public ROYALTY = 5; // 10% - don't resell friends
uint256 public GRID_THRESHOLD = 1; // 1 Grid
address public GRID_ADDRESS = 0x78898ffA059D170F887555d8Fd6443D2ABe4E548; // Infinite Grid
// Modifiers
modifier publicSaleActive() {
}
modifier gridSaleActive() {
}
modifier canMintToken() {
}
modifier isCorrectPayment(uint256 price) {
}
modifier hasGrid() {
}
modifier hasMinted() {
require(<FILL_ME>)
_;
}
constructor() ERC721("Flip Grid 01", "FLIPGRID01") {
}
function mint()
external
payable
nonReentrant
isCorrectPayment(PUBLIC_SALE_PRICE)
gridSaleActive
hasGrid
canMintToken
hasMinted
{
}
function mintPublic()
external
payable
nonReentrant
isCorrectPayment(PUBLIC_SALE_PRICE)
publicSaleActive
canMintToken
{
}
function mintOwner(uint256 numberOfTokens) public onlyOwner {
}
// Public
function getBaseURI() external view returns (string memory) {
}
function getLastTokenId() external view returns (uint256) {
}
// Admin
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function setGridAddress(address _address) external onlyOwner {
}
function setThreshold(uint256 _num) external onlyOwner {
}
function setMaxPerWallet(uint256 _max) external onlyOwner {
}
function setRoyalty(uint256 _royalty) external onlyOwner {
}
function withdraw() public onlyOwner {
}
function setIsPublicSaleActive(bool _isPublicSaleActive)
external
onlyOwner
{
}
function setIsGridSaleActive(bool _isGridSaleActive)
external
onlyOwner
{
}
// Counter stuff
function nextTokenId() private returns (uint256) {
}
// Royalties
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, IERC165)
returns (bool)
{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* @dev See {IERC165-royaltyInfo}.
*/
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
| balanceOf(msg.sender)<MAX_PER_WALLET,"This address has already minted." | 311,741 | balanceOf(msg.sender)<MAX_PER_WALLET |
null | contract BtcexCrowdsale is FinalizableCrowdsale, Pausable {
RefundEscrow private escrow;
TokenStrategy tokenStrategy;
address public teamTokensVault;
uint tokensUsedOnPresale;
uint tokensUsedOnSale;
address teamWallet;
address advisorWallet;
constructor(
TokenStrategy _tokenStrategy,
BtcexToken _token,
uint _tokenPrice,
uint _startPreSale,
uint _endSale,
address _ownerWallet,
address _teamWallet,
address _advisorWallet
)
Crowdsale(_tokenPrice, _ownerWallet, _token)
TimedCrowdsale(_startPreSale, _endSale)
public {
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal whenNotPaused {
}
function extendCrowdsaleTime() internal {
}
function finalize() public onlyOwner {
}
function shouldFinalize() private view returns (bool) {
}
function finalization() internal {
}
function claimRefund() public {
}
function goalReached() public view returns (bool){
}
function _forwardFunds() internal {
}
function isPresaleTime() internal view returns (bool) {
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
bool isPresale = isPresaleTime();
uint tokensAmount = tokenStrategy.getTokenAmount(_weiAmount, isPresale);
if (isPresale) {
require(<FILL_ME>)
tokensUsedOnPresale = tokensUsedOnPresale.add(tokensAmount);
} else {
require(tokensUsedOnSale.add(tokensAmount) <= tokenStrategy.tokensAvailableForSale());
tokensUsedOnSale = tokensUsedOnSale.add(tokensAmount);
}
return tokensAmount;
}
}
| tokensUsedOnPresale.add(tokensAmount)<=tokenStrategy.tokensAvailableForPresale() | 311,769 | tokensUsedOnPresale.add(tokensAmount)<=tokenStrategy.tokensAvailableForPresale() |
null | contract BtcexCrowdsale is FinalizableCrowdsale, Pausable {
RefundEscrow private escrow;
TokenStrategy tokenStrategy;
address public teamTokensVault;
uint tokensUsedOnPresale;
uint tokensUsedOnSale;
address teamWallet;
address advisorWallet;
constructor(
TokenStrategy _tokenStrategy,
BtcexToken _token,
uint _tokenPrice,
uint _startPreSale,
uint _endSale,
address _ownerWallet,
address _teamWallet,
address _advisorWallet
)
Crowdsale(_tokenPrice, _ownerWallet, _token)
TimedCrowdsale(_startPreSale, _endSale)
public {
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal whenNotPaused {
}
function extendCrowdsaleTime() internal {
}
function finalize() public onlyOwner {
}
function shouldFinalize() private view returns (bool) {
}
function finalization() internal {
}
function claimRefund() public {
}
function goalReached() public view returns (bool){
}
function _forwardFunds() internal {
}
function isPresaleTime() internal view returns (bool) {
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
bool isPresale = isPresaleTime();
uint tokensAmount = tokenStrategy.getTokenAmount(_weiAmount, isPresale);
if (isPresale) {
require(tokensUsedOnPresale.add(tokensAmount) <= tokenStrategy.tokensAvailableForPresale());
tokensUsedOnPresale = tokensUsedOnPresale.add(tokensAmount);
} else {
require(<FILL_ME>)
tokensUsedOnSale = tokensUsedOnSale.add(tokensAmount);
}
return tokensAmount;
}
}
| tokensUsedOnSale.add(tokensAmount)<=tokenStrategy.tokensAvailableForSale() | 311,769 | tokensUsedOnSale.add(tokensAmount)<=tokenStrategy.tokensAvailableForSale() |
null | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
import "../ERC721Enumerable.sol";
import "../Counters.sol";
import "../Ownable.sol";
contract TheDenox is ERC721Enumerable,Ownable {
string public baseURI;
using Counters for Counters.Counter;
using Strings for uint256;
string public metadata = "QmRfvZatpZR5vNifoadujuF7qTJjFuu9fon3tVpu1ZtbWX";
Counters.Counter _tokenIds;
struct RenderToken {
uint256 id;
string uri;
}
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI
) ERC721(_name, _symbol) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(address _to, uint256 _mintAmount) public payable {
uint256 supply = totalSupply();
require(_mintAmount > 0);
require(_mintAmount <= 1);
require(<FILL_ME>)
for (uint256 i = 1; i <= _mintAmount; i++) {
_safeMint(_to, supply + i);
}
}
//Wallet Owner
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
//NFT Uri
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//set URI URL
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
//withdraw token
function withdraw() public payable onlyOwner {
}
//metadata
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
//NFT Rendering all
function getAllTokens() public view returns (RenderToken[] memory) {
}
}
| supply+_mintAmount<=1 | 311,812 | supply+_mintAmount<=1 |
"AlreadyExist." | pragma solidity ^0.5.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.5.0;
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function transferFrom(address from, address to, uint256 tokenId) public;
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
pragma solidity ^0.5.0;
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
pragma solidity ^0.5.0;
library Address {
function isContract(address account) internal view returns (bool) {
}
}
pragma solidity ^0.5.0;
library Counters {
using SafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
}
pragma solidity ^0.5.0;
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
}
function _registerInterface(bytes4 interfaceId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (uint256 => address) private _tokenOwner;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => Counters.Counter) private _ownedTokensCount;
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
constructor () public {
}
function balanceOf(address owner) public view returns (uint256) {
}
function ownerOf(uint256 tokenId) public view returns (address) {
}
function approve(address to, uint256 tokenId) public {
}
function getApproved(uint256 tokenId) public view returns (address) {
}
function setApprovalForAll(address to, bool approved) public {
}
function isApprovedForAll(address owner, address operator) public view returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _burn(uint256 tokenId) internal { }
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) internal returns (bool) {
}
function _clearApproval(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
pragma solidity ^0.5.0;
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
mapping(address => uint256[]) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor () public {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
function tokenByIndex(uint256 index) public view returns (uint256) {
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.5.0;
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
constructor (string memory name, string memory symbol) public {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory uri) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor (string memory name, string memory symbol) public ERC721Metadata(name, symbol) {
}
}
pragma solidity >=0.4.0 <0.8.2;
contract Nft is ERC721Full {
struct data { string URL;address payable creator;uint256 Token_ID;uint256 Token_Price;bool Status; }
address payable public manager;
data[] public nft;
mapping(string => bool) _nftExists;
constructor() ERC721Full("Colexion", "CLXN") public { }
function mint(string memory url, uint64 Token_Price, bool _status) public {
require(<FILL_ME>)
data memory data123 = data(url,msg.sender,nft.length,Token_Price,_status);
uint _id = nft.push(data123);
_mint(msg.sender, _id-1);
_setTokenURI( _id-1, url);
_nftExists[url] = true;
approve(address(this), _id-1);
}
function changeStatus(uint Token_ID) public only_owner(Token_ID) not_in_auction(Token_ID) {
}
function purchaseToken(uint64 t_id, uint8 m, uint8 r, uint8 o) public payable not_in_auction(t_id){
}
function t_transfer(address owner, address to, uint64 t_id, uint256 t_price,uint8 m, uint8 r, uint8 o)internal{
}
function updateTokenPrice(uint t_id, uint _price) public only_owner(t_id) not_in_auction(t_id) returns(string memory){
}
mapping (uint => bool) public T_In_Auction;
mapping (uint => Auction_data) public T_Auction;
mapping(uint => mapping(address => uint)) public bids;
mapping(uint => address[]) public token_bidders;
address[] bidder_list;
struct Auction_data{
uint Token_id;
address auction_owner;
address auction_winner;
uint256 auction_win_bid;
uint256 auction_start;
uint256 auction_end;
uint256 highestBid;
address highestBidder;
uint256 minimunBid;
uint256 maximunBid;
bool state;
address[] bidders;
}
function create_Auction (uint _biddingTime, uint t_id, uint _minBid, uint _maxBid) only_owner(t_id) not_in_auction(t_id) public {
}
// Not done yet => agr koi higgest bid kerre to token usko transfer hojai
function bid(uint64 T_id) public payable in_auction(T_id) only_bidders(T_id) not_auction_winner(T_id) returns (bool){
}
function withdraw(uint T_id) public payable only_bidders(T_id) auction_ended(T_id) not_auction_winner(T_id) returns (bool){
}
function end_auction(uint64 T_id) public payable only_owner(T_id) returns (bool, string memory) {
}
function end_auction_auto(uint64 T_id)public payable auctionTime_ends(T_id) returns (bool, string memory) {
}
modifier in_auction(uint T_id){
}
modifier not_in_auction(uint T_id){
}
modifier an_ongoing_auction(uint T_id){
}
modifier auctionTime_ends(uint T_id){
}
modifier auction_ended(uint T_id){
}
modifier only_owner(uint T_id){
}
modifier only_bidders(uint T_id){
}
modifier not_auction_winner(uint T_id){
}
event BidEvent(address indexed Bidder, uint256 Bid);
event WithdrawalEvent(address withdrawer, uint256 amount);
event EndedEvent(string message, uint256 time);
}
| !_nftExists[url],"AlreadyExist." | 311,955 | !_nftExists[url] |
"TokenNotForSale" | pragma solidity ^0.5.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.5.0;
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function transferFrom(address from, address to, uint256 tokenId) public;
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
pragma solidity ^0.5.0;
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
pragma solidity ^0.5.0;
library Address {
function isContract(address account) internal view returns (bool) {
}
}
pragma solidity ^0.5.0;
library Counters {
using SafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
}
pragma solidity ^0.5.0;
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
}
function _registerInterface(bytes4 interfaceId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (uint256 => address) private _tokenOwner;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => Counters.Counter) private _ownedTokensCount;
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
constructor () public {
}
function balanceOf(address owner) public view returns (uint256) {
}
function ownerOf(uint256 tokenId) public view returns (address) {
}
function approve(address to, uint256 tokenId) public {
}
function getApproved(uint256 tokenId) public view returns (address) {
}
function setApprovalForAll(address to, bool approved) public {
}
function isApprovedForAll(address owner, address operator) public view returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _burn(uint256 tokenId) internal { }
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) internal returns (bool) {
}
function _clearApproval(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
pragma solidity ^0.5.0;
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
mapping(address => uint256[]) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor () public {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
function tokenByIndex(uint256 index) public view returns (uint256) {
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.5.0;
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
constructor (string memory name, string memory symbol) public {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory uri) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor (string memory name, string memory symbol) public ERC721Metadata(name, symbol) {
}
}
pragma solidity >=0.4.0 <0.8.2;
contract Nft is ERC721Full {
struct data { string URL;address payable creator;uint256 Token_ID;uint256 Token_Price;bool Status; }
address payable public manager;
data[] public nft;
mapping(string => bool) _nftExists;
constructor() ERC721Full("Colexion", "CLXN") public { }
function mint(string memory url, uint64 Token_Price, bool _status) public {
}
function changeStatus(uint Token_ID) public only_owner(Token_ID) not_in_auction(Token_ID) {
}
function purchaseToken(uint64 t_id, uint8 m, uint8 r, uint8 o) public payable not_in_auction(t_id){
require(<FILL_ME>)
require(nft[t_id].Token_Price <= msg.value, "Invalid price");
t_transfer(ownerOf(t_id), msg.sender, t_id, msg.value,m,r,o);
}
function t_transfer(address owner, address to, uint64 t_id, uint256 t_price,uint8 m, uint8 r, uint8 o)internal{
}
function updateTokenPrice(uint t_id, uint _price) public only_owner(t_id) not_in_auction(t_id) returns(string memory){
}
mapping (uint => bool) public T_In_Auction;
mapping (uint => Auction_data) public T_Auction;
mapping(uint => mapping(address => uint)) public bids;
mapping(uint => address[]) public token_bidders;
address[] bidder_list;
struct Auction_data{
uint Token_id;
address auction_owner;
address auction_winner;
uint256 auction_win_bid;
uint256 auction_start;
uint256 auction_end;
uint256 highestBid;
address highestBidder;
uint256 minimunBid;
uint256 maximunBid;
bool state;
address[] bidders;
}
function create_Auction (uint _biddingTime, uint t_id, uint _minBid, uint _maxBid) only_owner(t_id) not_in_auction(t_id) public {
}
// Not done yet => agr koi higgest bid kerre to token usko transfer hojai
function bid(uint64 T_id) public payable in_auction(T_id) only_bidders(T_id) not_auction_winner(T_id) returns (bool){
}
function withdraw(uint T_id) public payable only_bidders(T_id) auction_ended(T_id) not_auction_winner(T_id) returns (bool){
}
function end_auction(uint64 T_id) public payable only_owner(T_id) returns (bool, string memory) {
}
function end_auction_auto(uint64 T_id)public payable auctionTime_ends(T_id) returns (bool, string memory) {
}
modifier in_auction(uint T_id){
}
modifier not_in_auction(uint T_id){
}
modifier an_ongoing_auction(uint T_id){
}
modifier auctionTime_ends(uint T_id){
}
modifier auction_ended(uint T_id){
}
modifier only_owner(uint T_id){
}
modifier only_bidders(uint T_id){
}
modifier not_auction_winner(uint T_id){
}
event BidEvent(address indexed Bidder, uint256 Bid);
event WithdrawalEvent(address withdrawer, uint256 amount);
event EndedEvent(string message, uint256 time);
}
| nft[t_id].Status==true,"TokenNotForSale" | 311,955 | nft[t_id].Status==true |
"Invalid price" | pragma solidity ^0.5.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.5.0;
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function transferFrom(address from, address to, uint256 tokenId) public;
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
pragma solidity ^0.5.0;
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
pragma solidity ^0.5.0;
library Address {
function isContract(address account) internal view returns (bool) {
}
}
pragma solidity ^0.5.0;
library Counters {
using SafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
}
pragma solidity ^0.5.0;
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
}
function _registerInterface(bytes4 interfaceId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (uint256 => address) private _tokenOwner;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => Counters.Counter) private _ownedTokensCount;
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
constructor () public {
}
function balanceOf(address owner) public view returns (uint256) {
}
function ownerOf(uint256 tokenId) public view returns (address) {
}
function approve(address to, uint256 tokenId) public {
}
function getApproved(uint256 tokenId) public view returns (address) {
}
function setApprovalForAll(address to, bool approved) public {
}
function isApprovedForAll(address owner, address operator) public view returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _burn(uint256 tokenId) internal { }
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) internal returns (bool) {
}
function _clearApproval(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
pragma solidity ^0.5.0;
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
mapping(address => uint256[]) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor () public {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
function tokenByIndex(uint256 index) public view returns (uint256) {
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.5.0;
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
constructor (string memory name, string memory symbol) public {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory uri) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor (string memory name, string memory symbol) public ERC721Metadata(name, symbol) {
}
}
pragma solidity >=0.4.0 <0.8.2;
contract Nft is ERC721Full {
struct data { string URL;address payable creator;uint256 Token_ID;uint256 Token_Price;bool Status; }
address payable public manager;
data[] public nft;
mapping(string => bool) _nftExists;
constructor() ERC721Full("Colexion", "CLXN") public { }
function mint(string memory url, uint64 Token_Price, bool _status) public {
}
function changeStatus(uint Token_ID) public only_owner(Token_ID) not_in_auction(Token_ID) {
}
function purchaseToken(uint64 t_id, uint8 m, uint8 r, uint8 o) public payable not_in_auction(t_id){
require(nft[t_id].Status == true, "TokenNotForSale");
require(<FILL_ME>)
t_transfer(ownerOf(t_id), msg.sender, t_id, msg.value,m,r,o);
}
function t_transfer(address owner, address to, uint64 t_id, uint256 t_price,uint8 m, uint8 r, uint8 o)internal{
}
function updateTokenPrice(uint t_id, uint _price) public only_owner(t_id) not_in_auction(t_id) returns(string memory){
}
mapping (uint => bool) public T_In_Auction;
mapping (uint => Auction_data) public T_Auction;
mapping(uint => mapping(address => uint)) public bids;
mapping(uint => address[]) public token_bidders;
address[] bidder_list;
struct Auction_data{
uint Token_id;
address auction_owner;
address auction_winner;
uint256 auction_win_bid;
uint256 auction_start;
uint256 auction_end;
uint256 highestBid;
address highestBidder;
uint256 minimunBid;
uint256 maximunBid;
bool state;
address[] bidders;
}
function create_Auction (uint _biddingTime, uint t_id, uint _minBid, uint _maxBid) only_owner(t_id) not_in_auction(t_id) public {
}
// Not done yet => agr koi higgest bid kerre to token usko transfer hojai
function bid(uint64 T_id) public payable in_auction(T_id) only_bidders(T_id) not_auction_winner(T_id) returns (bool){
}
function withdraw(uint T_id) public payable only_bidders(T_id) auction_ended(T_id) not_auction_winner(T_id) returns (bool){
}
function end_auction(uint64 T_id) public payable only_owner(T_id) returns (bool, string memory) {
}
function end_auction_auto(uint64 T_id)public payable auctionTime_ends(T_id) returns (bool, string memory) {
}
modifier in_auction(uint T_id){
}
modifier not_in_auction(uint T_id){
}
modifier an_ongoing_auction(uint T_id){
}
modifier auctionTime_ends(uint T_id){
}
modifier auction_ended(uint T_id){
}
modifier only_owner(uint T_id){
}
modifier only_bidders(uint T_id){
}
modifier not_auction_winner(uint T_id){
}
event BidEvent(address indexed Bidder, uint256 Bid);
event WithdrawalEvent(address withdrawer, uint256 amount);
event EndedEvent(string message, uint256 time);
}
| nft[t_id].Token_Price<=msg.value,"Invalid price" | 311,955 | nft[t_id].Token_Price<=msg.value |
"TokeForSale" | pragma solidity ^0.5.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.5.0;
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function transferFrom(address from, address to, uint256 tokenId) public;
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
pragma solidity ^0.5.0;
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
pragma solidity ^0.5.0;
library Address {
function isContract(address account) internal view returns (bool) {
}
}
pragma solidity ^0.5.0;
library Counters {
using SafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
}
pragma solidity ^0.5.0;
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
}
function _registerInterface(bytes4 interfaceId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (uint256 => address) private _tokenOwner;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => Counters.Counter) private _ownedTokensCount;
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
constructor () public {
}
function balanceOf(address owner) public view returns (uint256) {
}
function ownerOf(uint256 tokenId) public view returns (address) {
}
function approve(address to, uint256 tokenId) public {
}
function getApproved(uint256 tokenId) public view returns (address) {
}
function setApprovalForAll(address to, bool approved) public {
}
function isApprovedForAll(address owner, address operator) public view returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _burn(uint256 tokenId) internal { }
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) internal returns (bool) {
}
function _clearApproval(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
pragma solidity ^0.5.0;
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
mapping(address => uint256[]) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor () public {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
function tokenByIndex(uint256 index) public view returns (uint256) {
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.5.0;
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
constructor (string memory name, string memory symbol) public {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory uri) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor (string memory name, string memory symbol) public ERC721Metadata(name, symbol) {
}
}
pragma solidity >=0.4.0 <0.8.2;
contract Nft is ERC721Full {
struct data { string URL;address payable creator;uint256 Token_ID;uint256 Token_Price;bool Status; }
address payable public manager;
data[] public nft;
mapping(string => bool) _nftExists;
constructor() ERC721Full("Colexion", "CLXN") public { }
function mint(string memory url, uint64 Token_Price, bool _status) public {
}
function changeStatus(uint Token_ID) public only_owner(Token_ID) not_in_auction(Token_ID) {
}
function purchaseToken(uint64 t_id, uint8 m, uint8 r, uint8 o) public payable not_in_auction(t_id){
}
function t_transfer(address owner, address to, uint64 t_id, uint256 t_price,uint8 m, uint8 r, uint8 o)internal{
}
function updateTokenPrice(uint t_id, uint _price) public only_owner(t_id) not_in_auction(t_id) returns(string memory){
}
mapping (uint => bool) public T_In_Auction;
mapping (uint => Auction_data) public T_Auction;
mapping(uint => mapping(address => uint)) public bids;
mapping(uint => address[]) public token_bidders;
address[] bidder_list;
struct Auction_data{
uint Token_id;
address auction_owner;
address auction_winner;
uint256 auction_win_bid;
uint256 auction_start;
uint256 auction_end;
uint256 highestBid;
address highestBidder;
uint256 minimunBid;
uint256 maximunBid;
bool state;
address[] bidders;
}
function create_Auction (uint _biddingTime, uint t_id, uint _minBid, uint _maxBid) only_owner(t_id) not_in_auction(t_id) public {
require(<FILL_ME>)
address[] memory emptyAddressList;
Auction_data memory data1750 = Auction_data(t_id,ownerOf(t_id),address(0),0, now,(now +_biddingTime*1 minutes),0,address(0),_minBid,_maxBid, true, emptyAddressList);
T_Auction[t_id] = data1750;
T_In_Auction[t_id] = true;
token_bidders[t_id].length = 0;
approve(address(this), t_id);
}
// Not done yet => agr koi higgest bid kerre to token usko transfer hojai
function bid(uint64 T_id) public payable in_auction(T_id) only_bidders(T_id) not_auction_winner(T_id) returns (bool){
}
function withdraw(uint T_id) public payable only_bidders(T_id) auction_ended(T_id) not_auction_winner(T_id) returns (bool){
}
function end_auction(uint64 T_id) public payable only_owner(T_id) returns (bool, string memory) {
}
function end_auction_auto(uint64 T_id)public payable auctionTime_ends(T_id) returns (bool, string memory) {
}
modifier in_auction(uint T_id){
}
modifier not_in_auction(uint T_id){
}
modifier an_ongoing_auction(uint T_id){
}
modifier auctionTime_ends(uint T_id){
}
modifier auction_ended(uint T_id){
}
modifier only_owner(uint T_id){
}
modifier only_bidders(uint T_id){
}
modifier not_auction_winner(uint T_id){
}
event BidEvent(address indexed Bidder, uint256 Bid);
event WithdrawalEvent(address withdrawer, uint256 amount);
event EndedEvent(string message, uint256 time);
}
| nft[t_id].Status==false,"TokeForSale" | 311,955 | nft[t_id].Status==false |
"makeHigherBid" | pragma solidity ^0.5.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.5.0;
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function transferFrom(address from, address to, uint256 tokenId) public;
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
pragma solidity ^0.5.0;
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
pragma solidity ^0.5.0;
library Address {
function isContract(address account) internal view returns (bool) {
}
}
pragma solidity ^0.5.0;
library Counters {
using SafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
}
pragma solidity ^0.5.0;
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
}
function _registerInterface(bytes4 interfaceId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (uint256 => address) private _tokenOwner;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => Counters.Counter) private _ownedTokensCount;
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
constructor () public {
}
function balanceOf(address owner) public view returns (uint256) {
}
function ownerOf(uint256 tokenId) public view returns (address) {
}
function approve(address to, uint256 tokenId) public {
}
function getApproved(uint256 tokenId) public view returns (address) {
}
function setApprovalForAll(address to, bool approved) public {
}
function isApprovedForAll(address owner, address operator) public view returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _burn(uint256 tokenId) internal { }
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) internal returns (bool) {
}
function _clearApproval(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
pragma solidity ^0.5.0;
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
mapping(address => uint256[]) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor () public {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
function tokenByIndex(uint256 index) public view returns (uint256) {
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.5.0;
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
constructor (string memory name, string memory symbol) public {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory uri) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor (string memory name, string memory symbol) public ERC721Metadata(name, symbol) {
}
}
pragma solidity >=0.4.0 <0.8.2;
contract Nft is ERC721Full {
struct data { string URL;address payable creator;uint256 Token_ID;uint256 Token_Price;bool Status; }
address payable public manager;
data[] public nft;
mapping(string => bool) _nftExists;
constructor() ERC721Full("Colexion", "CLXN") public { }
function mint(string memory url, uint64 Token_Price, bool _status) public {
}
function changeStatus(uint Token_ID) public only_owner(Token_ID) not_in_auction(Token_ID) {
}
function purchaseToken(uint64 t_id, uint8 m, uint8 r, uint8 o) public payable not_in_auction(t_id){
}
function t_transfer(address owner, address to, uint64 t_id, uint256 t_price,uint8 m, uint8 r, uint8 o)internal{
}
function updateTokenPrice(uint t_id, uint _price) public only_owner(t_id) not_in_auction(t_id) returns(string memory){
}
mapping (uint => bool) public T_In_Auction;
mapping (uint => Auction_data) public T_Auction;
mapping(uint => mapping(address => uint)) public bids;
mapping(uint => address[]) public token_bidders;
address[] bidder_list;
struct Auction_data{
uint Token_id;
address auction_owner;
address auction_winner;
uint256 auction_win_bid;
uint256 auction_start;
uint256 auction_end;
uint256 highestBid;
address highestBidder;
uint256 minimunBid;
uint256 maximunBid;
bool state;
address[] bidders;
}
function create_Auction (uint _biddingTime, uint t_id, uint _minBid, uint _maxBid) only_owner(t_id) not_in_auction(t_id) public {
}
// Not done yet => agr koi higgest bid kerre to token usko transfer hojai
function bid(uint64 T_id) public payable in_auction(T_id) only_bidders(T_id) not_auction_winner(T_id) returns (bool){
require(<FILL_ME>)
require(bids[T_id][msg.sender] + msg.value <= T_Auction[T_id].maximunBid, "makeLowerBid");
if(block.timestamp < T_Auction[T_id].auction_end){
if(bids[T_id][msg.sender] + msg.value >= T_Auction[T_id].maximunBid){
// bid hits maximum amount
T_Auction[T_id].state = false;
T_Auction[T_id].auction_win_bid = bids[T_id][msg.sender] + msg.value;
T_Auction[T_id].auction_winner = msg.sender;
T_Auction[T_id].highestBidder = address(0);
T_Auction[T_id].highestBid = 0;
bids[T_id][msg.sender] = 0;
T_In_Auction[T_id] = false;
t_transfer(ownerOf(T_id), msg.sender, T_id, T_Auction[T_id].auction_win_bid,7,10,83);
emit EndedEvent("Auction ended", block.timestamp);
} else {
// bid not hits maximum amount
bids[T_id][msg.sender] = bids[T_id][msg.sender] + msg.value;
bidder_list = token_bidders[T_id];
bidder_list.push(msg.sender);
token_bidders[T_id] = bidder_list;
T_Auction[T_id].highestBidder = T_Auction[T_id].highestBid > bids[T_id][msg.sender] ? T_Auction[T_id].highestBidder : msg.sender;
T_Auction[T_id].highestBid = T_Auction[T_id].highestBid > bids[T_id][msg.sender] ? T_Auction[T_id].highestBid : bids[T_id][msg.sender];
T_Auction[T_id].bidders.push(msg.sender);
return true;
}
} else {
end_auction_auto(T_id);
}
}
function withdraw(uint T_id) public payable only_bidders(T_id) auction_ended(T_id) not_auction_winner(T_id) returns (bool){
}
function end_auction(uint64 T_id) public payable only_owner(T_id) returns (bool, string memory) {
}
function end_auction_auto(uint64 T_id)public payable auctionTime_ends(T_id) returns (bool, string memory) {
}
modifier in_auction(uint T_id){
}
modifier not_in_auction(uint T_id){
}
modifier an_ongoing_auction(uint T_id){
}
modifier auctionTime_ends(uint T_id){
}
modifier auction_ended(uint T_id){
}
modifier only_owner(uint T_id){
}
modifier only_bidders(uint T_id){
}
modifier not_auction_winner(uint T_id){
}
event BidEvent(address indexed Bidder, uint256 Bid);
event WithdrawalEvent(address withdrawer, uint256 amount);
event EndedEvent(string message, uint256 time);
}
| bids[T_id][msg.sender]+msg.value>=T_Auction[T_id].minimunBid,"makeHigherBid" | 311,955 | bids[T_id][msg.sender]+msg.value>=T_Auction[T_id].minimunBid |
"makeLowerBid" | pragma solidity ^0.5.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.5.0;
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function transferFrom(address from, address to, uint256 tokenId) public;
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
pragma solidity ^0.5.0;
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
pragma solidity ^0.5.0;
library Address {
function isContract(address account) internal view returns (bool) {
}
}
pragma solidity ^0.5.0;
library Counters {
using SafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
}
pragma solidity ^0.5.0;
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
}
function _registerInterface(bytes4 interfaceId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (uint256 => address) private _tokenOwner;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => Counters.Counter) private _ownedTokensCount;
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
constructor () public {
}
function balanceOf(address owner) public view returns (uint256) {
}
function ownerOf(uint256 tokenId) public view returns (address) {
}
function approve(address to, uint256 tokenId) public {
}
function getApproved(uint256 tokenId) public view returns (address) {
}
function setApprovalForAll(address to, bool approved) public {
}
function isApprovedForAll(address owner, address operator) public view returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _burn(uint256 tokenId) internal { }
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) internal returns (bool) {
}
function _clearApproval(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
pragma solidity ^0.5.0;
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
mapping(address => uint256[]) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor () public {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
function tokenByIndex(uint256 index) public view returns (uint256) {
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.5.0;
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
constructor (string memory name, string memory symbol) public {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory uri) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor (string memory name, string memory symbol) public ERC721Metadata(name, symbol) {
}
}
pragma solidity >=0.4.0 <0.8.2;
contract Nft is ERC721Full {
struct data { string URL;address payable creator;uint256 Token_ID;uint256 Token_Price;bool Status; }
address payable public manager;
data[] public nft;
mapping(string => bool) _nftExists;
constructor() ERC721Full("Colexion", "CLXN") public { }
function mint(string memory url, uint64 Token_Price, bool _status) public {
}
function changeStatus(uint Token_ID) public only_owner(Token_ID) not_in_auction(Token_ID) {
}
function purchaseToken(uint64 t_id, uint8 m, uint8 r, uint8 o) public payable not_in_auction(t_id){
}
function t_transfer(address owner, address to, uint64 t_id, uint256 t_price,uint8 m, uint8 r, uint8 o)internal{
}
function updateTokenPrice(uint t_id, uint _price) public only_owner(t_id) not_in_auction(t_id) returns(string memory){
}
mapping (uint => bool) public T_In_Auction;
mapping (uint => Auction_data) public T_Auction;
mapping(uint => mapping(address => uint)) public bids;
mapping(uint => address[]) public token_bidders;
address[] bidder_list;
struct Auction_data{
uint Token_id;
address auction_owner;
address auction_winner;
uint256 auction_win_bid;
uint256 auction_start;
uint256 auction_end;
uint256 highestBid;
address highestBidder;
uint256 minimunBid;
uint256 maximunBid;
bool state;
address[] bidders;
}
function create_Auction (uint _biddingTime, uint t_id, uint _minBid, uint _maxBid) only_owner(t_id) not_in_auction(t_id) public {
}
// Not done yet => agr koi higgest bid kerre to token usko transfer hojai
function bid(uint64 T_id) public payable in_auction(T_id) only_bidders(T_id) not_auction_winner(T_id) returns (bool){
require(bids[T_id][msg.sender] + msg.value >= T_Auction[T_id].minimunBid, "makeHigherBid");
require(<FILL_ME>)
if(block.timestamp < T_Auction[T_id].auction_end){
if(bids[T_id][msg.sender] + msg.value >= T_Auction[T_id].maximunBid){
// bid hits maximum amount
T_Auction[T_id].state = false;
T_Auction[T_id].auction_win_bid = bids[T_id][msg.sender] + msg.value;
T_Auction[T_id].auction_winner = msg.sender;
T_Auction[T_id].highestBidder = address(0);
T_Auction[T_id].highestBid = 0;
bids[T_id][msg.sender] = 0;
T_In_Auction[T_id] = false;
t_transfer(ownerOf(T_id), msg.sender, T_id, T_Auction[T_id].auction_win_bid,7,10,83);
emit EndedEvent("Auction ended", block.timestamp);
} else {
// bid not hits maximum amount
bids[T_id][msg.sender] = bids[T_id][msg.sender] + msg.value;
bidder_list = token_bidders[T_id];
bidder_list.push(msg.sender);
token_bidders[T_id] = bidder_list;
T_Auction[T_id].highestBidder = T_Auction[T_id].highestBid > bids[T_id][msg.sender] ? T_Auction[T_id].highestBidder : msg.sender;
T_Auction[T_id].highestBid = T_Auction[T_id].highestBid > bids[T_id][msg.sender] ? T_Auction[T_id].highestBid : bids[T_id][msg.sender];
T_Auction[T_id].bidders.push(msg.sender);
return true;
}
} else {
end_auction_auto(T_id);
}
}
function withdraw(uint T_id) public payable only_bidders(T_id) auction_ended(T_id) not_auction_winner(T_id) returns (bool){
}
function end_auction(uint64 T_id) public payable only_owner(T_id) returns (bool, string memory) {
}
function end_auction_auto(uint64 T_id)public payable auctionTime_ends(T_id) returns (bool, string memory) {
}
modifier in_auction(uint T_id){
}
modifier not_in_auction(uint T_id){
}
modifier an_ongoing_auction(uint T_id){
}
modifier auctionTime_ends(uint T_id){
}
modifier auction_ended(uint T_id){
}
modifier only_owner(uint T_id){
}
modifier only_bidders(uint T_id){
}
modifier not_auction_winner(uint T_id){
}
event BidEvent(address indexed Bidder, uint256 Bid);
event WithdrawalEvent(address withdrawer, uint256 amount);
event EndedEvent(string message, uint256 time);
}
| bids[T_id][msg.sender]+msg.value<=T_Auction[T_id].maximunBid,"makeLowerBid" | 311,955 | bids[T_id][msg.sender]+msg.value<=T_Auction[T_id].maximunBid |
"TokenInAuction" | pragma solidity ^0.5.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.5.0;
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function transferFrom(address from, address to, uint256 tokenId) public;
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
pragma solidity ^0.5.0;
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
pragma solidity ^0.5.0;
library Address {
function isContract(address account) internal view returns (bool) {
}
}
pragma solidity ^0.5.0;
library Counters {
using SafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
}
pragma solidity ^0.5.0;
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
}
function _registerInterface(bytes4 interfaceId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (uint256 => address) private _tokenOwner;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => Counters.Counter) private _ownedTokensCount;
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
constructor () public {
}
function balanceOf(address owner) public view returns (uint256) {
}
function ownerOf(uint256 tokenId) public view returns (address) {
}
function approve(address to, uint256 tokenId) public {
}
function getApproved(uint256 tokenId) public view returns (address) {
}
function setApprovalForAll(address to, bool approved) public {
}
function isApprovedForAll(address owner, address operator) public view returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _burn(uint256 tokenId) internal { }
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) internal returns (bool) {
}
function _clearApproval(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
pragma solidity ^0.5.0;
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
mapping(address => uint256[]) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor () public {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
function tokenByIndex(uint256 index) public view returns (uint256) {
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.5.0;
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
constructor (string memory name, string memory symbol) public {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory uri) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor (string memory name, string memory symbol) public ERC721Metadata(name, symbol) {
}
}
pragma solidity >=0.4.0 <0.8.2;
contract Nft is ERC721Full {
struct data { string URL;address payable creator;uint256 Token_ID;uint256 Token_Price;bool Status; }
address payable public manager;
data[] public nft;
mapping(string => bool) _nftExists;
constructor() ERC721Full("Colexion", "CLXN") public { }
function mint(string memory url, uint64 Token_Price, bool _status) public {
}
function changeStatus(uint Token_ID) public only_owner(Token_ID) not_in_auction(Token_ID) {
}
function purchaseToken(uint64 t_id, uint8 m, uint8 r, uint8 o) public payable not_in_auction(t_id){
}
function t_transfer(address owner, address to, uint64 t_id, uint256 t_price,uint8 m, uint8 r, uint8 o)internal{
}
function updateTokenPrice(uint t_id, uint _price) public only_owner(t_id) not_in_auction(t_id) returns(string memory){
}
mapping (uint => bool) public T_In_Auction;
mapping (uint => Auction_data) public T_Auction;
mapping(uint => mapping(address => uint)) public bids;
mapping(uint => address[]) public token_bidders;
address[] bidder_list;
struct Auction_data{
uint Token_id;
address auction_owner;
address auction_winner;
uint256 auction_win_bid;
uint256 auction_start;
uint256 auction_end;
uint256 highestBid;
address highestBidder;
uint256 minimunBid;
uint256 maximunBid;
bool state;
address[] bidders;
}
function create_Auction (uint _biddingTime, uint t_id, uint _minBid, uint _maxBid) only_owner(t_id) not_in_auction(t_id) public {
}
// Not done yet => agr koi higgest bid kerre to token usko transfer hojai
function bid(uint64 T_id) public payable in_auction(T_id) only_bidders(T_id) not_auction_winner(T_id) returns (bool){
}
function withdraw(uint T_id) public payable only_bidders(T_id) auction_ended(T_id) not_auction_winner(T_id) returns (bool){
}
function end_auction(uint64 T_id) public payable only_owner(T_id) returns (bool, string memory) {
require(<FILL_ME>)
require(nft[T_id].Status == false,"TokenForSale");
T_Auction[T_id].state = false;
T_In_Auction[T_id] = false;
if(T_Auction[T_id].highestBidder == address(0)){ return (true, "Auction Ended");}
T_Auction[T_id].auction_win_bid = T_Auction[T_id].highestBid;
T_Auction[T_id].auction_winner = T_Auction[T_id].highestBidder;
T_Auction[T_id].highestBidder = address(0);
T_Auction[T_id].highestBid = 0;
bids[T_id][T_Auction[T_id].auction_winner] = 0;
t_transfer(ownerOf(T_id), T_Auction[T_id].auction_winner, T_id, T_Auction[T_id].auction_win_bid,7,10,83);
emit EndedEvent("Auction ended", block.timestamp);
return (true, "Auction Ended");
}
function end_auction_auto(uint64 T_id)public payable auctionTime_ends(T_id) returns (bool, string memory) {
}
modifier in_auction(uint T_id){
}
modifier not_in_auction(uint T_id){
}
modifier an_ongoing_auction(uint T_id){
}
modifier auctionTime_ends(uint T_id){
}
modifier auction_ended(uint T_id){
}
modifier only_owner(uint T_id){
}
modifier only_bidders(uint T_id){
}
modifier not_auction_winner(uint T_id){
}
event BidEvent(address indexed Bidder, uint256 Bid);
event WithdrawalEvent(address withdrawer, uint256 amount);
event EndedEvent(string message, uint256 time);
}
| T_In_Auction[T_id]==true,"TokenInAuction" | 311,955 | T_In_Auction[T_id]==true |
"TokenForSale" | pragma solidity ^0.5.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.5.0;
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function transferFrom(address from, address to, uint256 tokenId) public;
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
pragma solidity ^0.5.0;
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
pragma solidity ^0.5.0;
library Address {
function isContract(address account) internal view returns (bool) {
}
}
pragma solidity ^0.5.0;
library Counters {
using SafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
}
pragma solidity ^0.5.0;
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
}
function _registerInterface(bytes4 interfaceId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (uint256 => address) private _tokenOwner;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => Counters.Counter) private _ownedTokensCount;
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
constructor () public {
}
function balanceOf(address owner) public view returns (uint256) {
}
function ownerOf(uint256 tokenId) public view returns (address) {
}
function approve(address to, uint256 tokenId) public {
}
function getApproved(uint256 tokenId) public view returns (address) {
}
function setApprovalForAll(address to, bool approved) public {
}
function isApprovedForAll(address owner, address operator) public view returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _burn(uint256 tokenId) internal { }
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) internal returns (bool) {
}
function _clearApproval(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
pragma solidity ^0.5.0;
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
mapping(address => uint256[]) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor () public {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
function tokenByIndex(uint256 index) public view returns (uint256) {
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.5.0;
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
constructor (string memory name, string memory symbol) public {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory uri) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor (string memory name, string memory symbol) public ERC721Metadata(name, symbol) {
}
}
pragma solidity >=0.4.0 <0.8.2;
contract Nft is ERC721Full {
struct data { string URL;address payable creator;uint256 Token_ID;uint256 Token_Price;bool Status; }
address payable public manager;
data[] public nft;
mapping(string => bool) _nftExists;
constructor() ERC721Full("Colexion", "CLXN") public { }
function mint(string memory url, uint64 Token_Price, bool _status) public {
}
function changeStatus(uint Token_ID) public only_owner(Token_ID) not_in_auction(Token_ID) {
}
function purchaseToken(uint64 t_id, uint8 m, uint8 r, uint8 o) public payable not_in_auction(t_id){
}
function t_transfer(address owner, address to, uint64 t_id, uint256 t_price,uint8 m, uint8 r, uint8 o)internal{
}
function updateTokenPrice(uint t_id, uint _price) public only_owner(t_id) not_in_auction(t_id) returns(string memory){
}
mapping (uint => bool) public T_In_Auction;
mapping (uint => Auction_data) public T_Auction;
mapping(uint => mapping(address => uint)) public bids;
mapping(uint => address[]) public token_bidders;
address[] bidder_list;
struct Auction_data{
uint Token_id;
address auction_owner;
address auction_winner;
uint256 auction_win_bid;
uint256 auction_start;
uint256 auction_end;
uint256 highestBid;
address highestBidder;
uint256 minimunBid;
uint256 maximunBid;
bool state;
address[] bidders;
}
function create_Auction (uint _biddingTime, uint t_id, uint _minBid, uint _maxBid) only_owner(t_id) not_in_auction(t_id) public {
}
// Not done yet => agr koi higgest bid kerre to token usko transfer hojai
function bid(uint64 T_id) public payable in_auction(T_id) only_bidders(T_id) not_auction_winner(T_id) returns (bool){
}
function withdraw(uint T_id) public payable only_bidders(T_id) auction_ended(T_id) not_auction_winner(T_id) returns (bool){
}
function end_auction(uint64 T_id) public payable only_owner(T_id) returns (bool, string memory) {
require(T_In_Auction[T_id] == true, "TokenInAuction");
require(<FILL_ME>)
T_Auction[T_id].state = false;
T_In_Auction[T_id] = false;
if(T_Auction[T_id].highestBidder == address(0)){ return (true, "Auction Ended");}
T_Auction[T_id].auction_win_bid = T_Auction[T_id].highestBid;
T_Auction[T_id].auction_winner = T_Auction[T_id].highestBidder;
T_Auction[T_id].highestBidder = address(0);
T_Auction[T_id].highestBid = 0;
bids[T_id][T_Auction[T_id].auction_winner] = 0;
t_transfer(ownerOf(T_id), T_Auction[T_id].auction_winner, T_id, T_Auction[T_id].auction_win_bid,7,10,83);
emit EndedEvent("Auction ended", block.timestamp);
return (true, "Auction Ended");
}
function end_auction_auto(uint64 T_id)public payable auctionTime_ends(T_id) returns (bool, string memory) {
}
modifier in_auction(uint T_id){
}
modifier not_in_auction(uint T_id){
}
modifier an_ongoing_auction(uint T_id){
}
modifier auctionTime_ends(uint T_id){
}
modifier auction_ended(uint T_id){
}
modifier only_owner(uint T_id){
}
modifier only_bidders(uint T_id){
}
modifier not_auction_winner(uint T_id){
}
event BidEvent(address indexed Bidder, uint256 Bid);
event WithdrawalEvent(address withdrawer, uint256 amount);
event EndedEvent(string message, uint256 time);
}
| nft[T_id].Status==false,"TokenForSale" | 311,955 | nft[T_id].Status==false |
"TokenInAuction" | pragma solidity ^0.5.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.5.0;
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function transferFrom(address from, address to, uint256 tokenId) public;
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
pragma solidity ^0.5.0;
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
pragma solidity ^0.5.0;
library Address {
function isContract(address account) internal view returns (bool) {
}
}
pragma solidity ^0.5.0;
library Counters {
using SafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
}
pragma solidity ^0.5.0;
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
}
function _registerInterface(bytes4 interfaceId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (uint256 => address) private _tokenOwner;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => Counters.Counter) private _ownedTokensCount;
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
constructor () public {
}
function balanceOf(address owner) public view returns (uint256) {
}
function ownerOf(uint256 tokenId) public view returns (address) {
}
function approve(address to, uint256 tokenId) public {
}
function getApproved(uint256 tokenId) public view returns (address) {
}
function setApprovalForAll(address to, bool approved) public {
}
function isApprovedForAll(address owner, address operator) public view returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _burn(uint256 tokenId) internal { }
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) internal returns (bool) {
}
function _clearApproval(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
pragma solidity ^0.5.0;
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
mapping(address => uint256[]) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor () public {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
function tokenByIndex(uint256 index) public view returns (uint256) {
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.5.0;
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
constructor (string memory name, string memory symbol) public {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory uri) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor (string memory name, string memory symbol) public ERC721Metadata(name, symbol) {
}
}
pragma solidity >=0.4.0 <0.8.2;
contract Nft is ERC721Full {
struct data { string URL;address payable creator;uint256 Token_ID;uint256 Token_Price;bool Status; }
address payable public manager;
data[] public nft;
mapping(string => bool) _nftExists;
constructor() ERC721Full("Colexion", "CLXN") public { }
function mint(string memory url, uint64 Token_Price, bool _status) public {
}
function changeStatus(uint Token_ID) public only_owner(Token_ID) not_in_auction(Token_ID) {
}
function purchaseToken(uint64 t_id, uint8 m, uint8 r, uint8 o) public payable not_in_auction(t_id){
}
function t_transfer(address owner, address to, uint64 t_id, uint256 t_price,uint8 m, uint8 r, uint8 o)internal{
}
function updateTokenPrice(uint t_id, uint _price) public only_owner(t_id) not_in_auction(t_id) returns(string memory){
}
mapping (uint => bool) public T_In_Auction;
mapping (uint => Auction_data) public T_Auction;
mapping(uint => mapping(address => uint)) public bids;
mapping(uint => address[]) public token_bidders;
address[] bidder_list;
struct Auction_data{
uint Token_id;
address auction_owner;
address auction_winner;
uint256 auction_win_bid;
uint256 auction_start;
uint256 auction_end;
uint256 highestBid;
address highestBidder;
uint256 minimunBid;
uint256 maximunBid;
bool state;
address[] bidders;
}
function create_Auction (uint _biddingTime, uint t_id, uint _minBid, uint _maxBid) only_owner(t_id) not_in_auction(t_id) public {
}
// Not done yet => agr koi higgest bid kerre to token usko transfer hojai
function bid(uint64 T_id) public payable in_auction(T_id) only_bidders(T_id) not_auction_winner(T_id) returns (bool){
}
function withdraw(uint T_id) public payable only_bidders(T_id) auction_ended(T_id) not_auction_winner(T_id) returns (bool){
}
function end_auction(uint64 T_id) public payable only_owner(T_id) returns (bool, string memory) {
}
function end_auction_auto(uint64 T_id)public payable auctionTime_ends(T_id) returns (bool, string memory) {
}
modifier in_auction(uint T_id){
}
modifier not_in_auction(uint T_id){
require(<FILL_ME>)
_;
}
modifier an_ongoing_auction(uint T_id){
}
modifier auctionTime_ends(uint T_id){
}
modifier auction_ended(uint T_id){
}
modifier only_owner(uint T_id){
}
modifier only_bidders(uint T_id){
}
modifier not_auction_winner(uint T_id){
}
event BidEvent(address indexed Bidder, uint256 Bid);
event WithdrawalEvent(address withdrawer, uint256 amount);
event EndedEvent(string message, uint256 time);
}
| T_In_Auction[T_id]==false,"TokenInAuction" | 311,955 | T_In_Auction[T_id]==false |
"AuctionIsGoing" | pragma solidity ^0.5.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.5.0;
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function transferFrom(address from, address to, uint256 tokenId) public;
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
pragma solidity ^0.5.0;
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
pragma solidity ^0.5.0;
library Address {
function isContract(address account) internal view returns (bool) {
}
}
pragma solidity ^0.5.0;
library Counters {
using SafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
}
pragma solidity ^0.5.0;
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
}
function _registerInterface(bytes4 interfaceId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (uint256 => address) private _tokenOwner;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => Counters.Counter) private _ownedTokensCount;
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
constructor () public {
}
function balanceOf(address owner) public view returns (uint256) {
}
function ownerOf(uint256 tokenId) public view returns (address) {
}
function approve(address to, uint256 tokenId) public {
}
function getApproved(uint256 tokenId) public view returns (address) {
}
function setApprovalForAll(address to, bool approved) public {
}
function isApprovedForAll(address owner, address operator) public view returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _burn(uint256 tokenId) internal { }
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) internal returns (bool) {
}
function _clearApproval(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
pragma solidity ^0.5.0;
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
mapping(address => uint256[]) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor () public {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
}
function totalSupply() public view returns (uint256) {
}
function tokenByIndex(uint256 index) public view returns (uint256) {
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
}
function _mint(address to, uint256 tokenId) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
pragma solidity ^0.5.0;
contract IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.5.0;
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
constructor (string memory name, string memory symbol) public {
}
function name() external view returns (string memory) {
}
function symbol() external view returns (string memory) {
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory uri) internal {
}
function _burn(address owner, uint256 tokenId) internal {
}
}
pragma solidity ^0.5.0;
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor (string memory name, string memory symbol) public ERC721Metadata(name, symbol) {
}
}
pragma solidity >=0.4.0 <0.8.2;
contract Nft is ERC721Full {
struct data { string URL;address payable creator;uint256 Token_ID;uint256 Token_Price;bool Status; }
address payable public manager;
data[] public nft;
mapping(string => bool) _nftExists;
constructor() ERC721Full("Colexion", "CLXN") public { }
function mint(string memory url, uint64 Token_Price, bool _status) public {
}
function changeStatus(uint Token_ID) public only_owner(Token_ID) not_in_auction(Token_ID) {
}
function purchaseToken(uint64 t_id, uint8 m, uint8 r, uint8 o) public payable not_in_auction(t_id){
}
function t_transfer(address owner, address to, uint64 t_id, uint256 t_price,uint8 m, uint8 r, uint8 o)internal{
}
function updateTokenPrice(uint t_id, uint _price) public only_owner(t_id) not_in_auction(t_id) returns(string memory){
}
mapping (uint => bool) public T_In_Auction;
mapping (uint => Auction_data) public T_Auction;
mapping(uint => mapping(address => uint)) public bids;
mapping(uint => address[]) public token_bidders;
address[] bidder_list;
struct Auction_data{
uint Token_id;
address auction_owner;
address auction_winner;
uint256 auction_win_bid;
uint256 auction_start;
uint256 auction_end;
uint256 highestBid;
address highestBidder;
uint256 minimunBid;
uint256 maximunBid;
bool state;
address[] bidders;
}
function create_Auction (uint _biddingTime, uint t_id, uint _minBid, uint _maxBid) only_owner(t_id) not_in_auction(t_id) public {
}
// Not done yet => agr koi higgest bid kerre to token usko transfer hojai
function bid(uint64 T_id) public payable in_auction(T_id) only_bidders(T_id) not_auction_winner(T_id) returns (bool){
}
function withdraw(uint T_id) public payable only_bidders(T_id) auction_ended(T_id) not_auction_winner(T_id) returns (bool){
}
function end_auction(uint64 T_id) public payable only_owner(T_id) returns (bool, string memory) {
}
function end_auction_auto(uint64 T_id)public payable auctionTime_ends(T_id) returns (bool, string memory) {
}
modifier in_auction(uint T_id){
}
modifier not_in_auction(uint T_id){
}
modifier an_ongoing_auction(uint T_id){
}
modifier auctionTime_ends(uint T_id){
}
modifier auction_ended(uint T_id){
require(<FILL_ME>)
_;
}
modifier only_owner(uint T_id){
}
modifier only_bidders(uint T_id){
}
modifier not_auction_winner(uint T_id){
}
event BidEvent(address indexed Bidder, uint256 Bid);
event WithdrawalEvent(address withdrawer, uint256 amount);
event EndedEvent(string message, uint256 time);
}
| T_Auction[T_id].state==false,"AuctionIsGoing" | 311,955 | T_Auction[T_id].state==false |
null | pragma solidity ^0.5.8;
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 value) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal {
}
function _burn(address account, uint256 value) internal {
}
function _approve(address owner, address spender, uint256 value) internal {
}
function _burnFrom(address account, uint256 amount) internal {
}
}
interface FundsInterface {
function lender(bytes32) external view returns (address);
function custom(bytes32) external view returns (bool);
function deposit(bytes32, uint256) external;
function decreaseTotalBorrow(uint256) external;
function calcGlobalInterest() external;
}
interface SalesInterface {
function saleIndexByLoan(bytes32, uint256) external returns(bytes32);
function settlementExpiration(bytes32) external view returns (uint256);
function accepted(bytes32) external view returns (bool);
function next(bytes32) external view returns (uint256);
function create(bytes32, address, address, address, address, bytes32, bytes32, bytes32, bytes32, bytes20) external returns(bytes32);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function min(uint x, uint y) internal pure returns (uint z) {
}
function max(uint x, uint y) internal pure returns (uint z) {
}
function imin(int x, int y) internal pure returns (int z) {
}
function imax(int x, int y) internal pure returns (int z) {
}
uint constant COL = 10 ** 8;
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function cmul(uint x, uint y) public pure returns (uint z) {
}
function wmul(uint x, uint y) internal pure returns (uint z) {
}
function rmul(uint x, uint y) internal pure returns (uint z) {
}
function cdiv(uint x, uint y) internal pure returns (uint z) {
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
}
function rpow(uint x, uint n) internal pure returns (uint z) {
}
}
contract Medianizer {
function peek() public view returns (bytes32, bool);
function read() public returns (bytes32);
function poke() public;
function poke(bytes32) public;
function fund (uint256 amount, ERC20 token) public;
}
contract Loans is DSMath {
FundsInterface funds;
Medianizer med;
SalesInterface sales;
uint256 public constant APPROVE_EXP_THRESHOLD = 2 hours;
uint256 public constant ACCEPT_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_EXP_THRESHOLD = 7 days;
uint256 public constant SEIZURE_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_DISCOUNT = 930000000000000000;
mapping (bytes32 => Loan) public loans;
mapping (bytes32 => PubKeys) public pubKeys;
mapping (bytes32 => SecretHashes) public secretHashes;
mapping (bytes32 => Bools) public bools;
mapping (bytes32 => bytes32) public fundIndex;
mapping (bytes32 => ERC20) public tokes;
mapping (bytes32 => uint256) public repayments;
uint256 public loanIndex;
mapping (address => bytes32[]) public borrowerLoans;
mapping (address => bytes32[]) public lenderLoans;
ERC20 public token;
uint256 public decimals;
address deployer;
struct Loan {
address borrower;
address lender;
address arbiter;
uint256 createdAt;
uint256 loanExpiration;
uint256 requestTimestamp;
uint256 closedTimestamp;
uint256 principal;
uint256 interest;
uint256 penalty;
uint256 fee;
uint256 collateral;
uint256 liquidationRatio;
}
struct PubKeys {
bytes borrowerPubKey;
bytes lenderPubKey;
bytes arbiterPubKey;
}
struct SecretHashes {
bytes32 secretHashA1;
bytes32[3] secretHashAs;
bytes32 secretHashB1;
bytes32[3] secretHashBs;
bytes32 secretHashC1;
bytes32[3] secretHashCs;
bytes32 withdrawSecret;
bytes32 acceptSecret;
bool set;
}
struct Bools {
bool funded;
bool approved;
bool withdrawn;
bool sale;
bool paid;
bool off;
}
event Create(bytes32 loan);
function borrower(bytes32 loan) public view returns (address) {
}
function lender(bytes32 loan) public view returns (address) {
}
function arbiter(bytes32 loan) public view returns (address) {
}
function approveExpiration(bytes32 loan) public view returns (uint256) {
}
function acceptExpiration(bytes32 loan) public view returns (uint256) {
}
function liquidationExpiration(bytes32 loan) public view returns (uint256) {
}
function seizureExpiration(bytes32 loan) public view returns (uint256) {
}
function principal(bytes32 loan) public view returns (uint256) {
}
function interest(bytes32 loan) public view returns (uint256) {
}
function fee(bytes32 loan) public view returns (uint256) {
}
function penalty(bytes32 loan) public view returns (uint256) {
}
function collateral(bytes32 loan) public view returns (uint256) {
}
function repaid(bytes32 loan) public view returns (uint256) {
}
function liquidationRatio(bytes32 loan) public view returns (uint256) {
}
function owedToLender(bytes32 loan) public view returns (uint256) {
}
function owedForLoan(bytes32 loan) public view returns (uint256) {
}
function owedForLiquidation(bytes32 loan) public view returns (uint256) {
}
function owing(bytes32 loan) public view returns (uint256) {
}
function funded(bytes32 loan) public view returns (bool) {
}
function approved(bytes32 loan) public view returns (bool) {
}
function withdrawn(bytes32 loan) public view returns (bool) {
}
function sale(bytes32 loan) public view returns (bool) {
}
function paid(bytes32 loan) public view returns (bool) {
}
function off(bytes32 loan) public view returns (bool) {
}
function dmul(uint x) public view returns (uint256) {
}
function ddiv(uint x) public view returns (uint256) {
}
function borrowerLoanCount(address borrower_) public view returns (uint256) {
}
function lenderLoanCount(address lender_) public view returns (uint256) {
}
function collateralValue(bytes32 loan) public view returns (uint256) {
}
function minCollateralValue(bytes32 loan) public view returns (uint256) {
}
function discountCollateralValue(bytes32 loan) public view returns (uint256) {
}
function safe(bytes32 loan) public view returns (bool) {
}
constructor (FundsInterface funds_, Medianizer med_, ERC20 token_, uint256 decimals_) public {
deployer = msg.sender;
funds = funds_;
med = med_;
token = token_;
decimals = decimals_;
require(<FILL_ME>)
}
function setSales(SalesInterface sales_) external {
}
function create(
uint256 loanExpiration_,
address[3] calldata usrs_,
uint256[7] calldata vals_,
bytes32 fundIndex_
) external returns (bytes32 loan) {
}
function setSecretHashes(
bytes32 loan,
bytes32[4] calldata borrowerSecretHashes,
bytes32[4] calldata lenderSecretHashes,
bytes32[4] calldata arbiterSecretHashes,
bytes calldata borrowerPubKey_,
bytes calldata lenderPubKey_,
bytes calldata arbiterPubKey_
) external returns (bool) {
}
function fund(bytes32 loan) external {
}
function approve(bytes32 loan) external {
}
function withdraw(bytes32 loan, bytes32 secretA1) external {
}
function repay(bytes32 loan, uint256 amount) external {
}
function refund(bytes32 loan) external {
}
function cancel(bytes32 loan, bytes32 secret) external {
}
function accept(bytes32 loan, bytes32 secret) public {
}
function liquidate(bytes32 loan, bytes32 secretHash, bytes20 pubKeyHash) external returns (bytes32 sale_) {
}
}
| token.approve(address(funds),2**256-1) | 311,961 | token.approve(address(funds),2**256-1) |
null | pragma solidity ^0.5.8;
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 value) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal {
}
function _burn(address account, uint256 value) internal {
}
function _approve(address owner, address spender, uint256 value) internal {
}
function _burnFrom(address account, uint256 amount) internal {
}
}
interface FundsInterface {
function lender(bytes32) external view returns (address);
function custom(bytes32) external view returns (bool);
function deposit(bytes32, uint256) external;
function decreaseTotalBorrow(uint256) external;
function calcGlobalInterest() external;
}
interface SalesInterface {
function saleIndexByLoan(bytes32, uint256) external returns(bytes32);
function settlementExpiration(bytes32) external view returns (uint256);
function accepted(bytes32) external view returns (bool);
function next(bytes32) external view returns (uint256);
function create(bytes32, address, address, address, address, bytes32, bytes32, bytes32, bytes32, bytes20) external returns(bytes32);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function min(uint x, uint y) internal pure returns (uint z) {
}
function max(uint x, uint y) internal pure returns (uint z) {
}
function imin(int x, int y) internal pure returns (int z) {
}
function imax(int x, int y) internal pure returns (int z) {
}
uint constant COL = 10 ** 8;
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function cmul(uint x, uint y) public pure returns (uint z) {
}
function wmul(uint x, uint y) internal pure returns (uint z) {
}
function rmul(uint x, uint y) internal pure returns (uint z) {
}
function cdiv(uint x, uint y) internal pure returns (uint z) {
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
}
function rpow(uint x, uint n) internal pure returns (uint z) {
}
}
contract Medianizer {
function peek() public view returns (bytes32, bool);
function read() public returns (bytes32);
function poke() public;
function poke(bytes32) public;
function fund (uint256 amount, ERC20 token) public;
}
contract Loans is DSMath {
FundsInterface funds;
Medianizer med;
SalesInterface sales;
uint256 public constant APPROVE_EXP_THRESHOLD = 2 hours;
uint256 public constant ACCEPT_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_EXP_THRESHOLD = 7 days;
uint256 public constant SEIZURE_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_DISCOUNT = 930000000000000000;
mapping (bytes32 => Loan) public loans;
mapping (bytes32 => PubKeys) public pubKeys;
mapping (bytes32 => SecretHashes) public secretHashes;
mapping (bytes32 => Bools) public bools;
mapping (bytes32 => bytes32) public fundIndex;
mapping (bytes32 => ERC20) public tokes;
mapping (bytes32 => uint256) public repayments;
uint256 public loanIndex;
mapping (address => bytes32[]) public borrowerLoans;
mapping (address => bytes32[]) public lenderLoans;
ERC20 public token;
uint256 public decimals;
address deployer;
struct Loan {
address borrower;
address lender;
address arbiter;
uint256 createdAt;
uint256 loanExpiration;
uint256 requestTimestamp;
uint256 closedTimestamp;
uint256 principal;
uint256 interest;
uint256 penalty;
uint256 fee;
uint256 collateral;
uint256 liquidationRatio;
}
struct PubKeys {
bytes borrowerPubKey;
bytes lenderPubKey;
bytes arbiterPubKey;
}
struct SecretHashes {
bytes32 secretHashA1;
bytes32[3] secretHashAs;
bytes32 secretHashB1;
bytes32[3] secretHashBs;
bytes32 secretHashC1;
bytes32[3] secretHashCs;
bytes32 withdrawSecret;
bytes32 acceptSecret;
bool set;
}
struct Bools {
bool funded;
bool approved;
bool withdrawn;
bool sale;
bool paid;
bool off;
}
event Create(bytes32 loan);
function borrower(bytes32 loan) public view returns (address) {
}
function lender(bytes32 loan) public view returns (address) {
}
function arbiter(bytes32 loan) public view returns (address) {
}
function approveExpiration(bytes32 loan) public view returns (uint256) {
}
function acceptExpiration(bytes32 loan) public view returns (uint256) {
}
function liquidationExpiration(bytes32 loan) public view returns (uint256) {
}
function seizureExpiration(bytes32 loan) public view returns (uint256) {
}
function principal(bytes32 loan) public view returns (uint256) {
}
function interest(bytes32 loan) public view returns (uint256) {
}
function fee(bytes32 loan) public view returns (uint256) {
}
function penalty(bytes32 loan) public view returns (uint256) {
}
function collateral(bytes32 loan) public view returns (uint256) {
}
function repaid(bytes32 loan) public view returns (uint256) {
}
function liquidationRatio(bytes32 loan) public view returns (uint256) {
}
function owedToLender(bytes32 loan) public view returns (uint256) {
}
function owedForLoan(bytes32 loan) public view returns (uint256) {
}
function owedForLiquidation(bytes32 loan) public view returns (uint256) {
}
function owing(bytes32 loan) public view returns (uint256) {
}
function funded(bytes32 loan) public view returns (bool) {
}
function approved(bytes32 loan) public view returns (bool) {
}
function withdrawn(bytes32 loan) public view returns (bool) {
}
function sale(bytes32 loan) public view returns (bool) {
}
function paid(bytes32 loan) public view returns (bool) {
}
function off(bytes32 loan) public view returns (bool) {
}
function dmul(uint x) public view returns (uint256) {
}
function ddiv(uint x) public view returns (uint256) {
}
function borrowerLoanCount(address borrower_) public view returns (uint256) {
}
function lenderLoanCount(address lender_) public view returns (uint256) {
}
function collateralValue(bytes32 loan) public view returns (uint256) {
}
function minCollateralValue(bytes32 loan) public view returns (uint256) {
}
function discountCollateralValue(bytes32 loan) public view returns (uint256) {
}
function safe(bytes32 loan) public view returns (bool) {
}
constructor (FundsInterface funds_, Medianizer med_, ERC20 token_, uint256 decimals_) public {
}
function setSales(SalesInterface sales_) external {
require(msg.sender == deployer);
require(<FILL_ME>)
sales = sales_;
}
function create(
uint256 loanExpiration_,
address[3] calldata usrs_,
uint256[7] calldata vals_,
bytes32 fundIndex_
) external returns (bytes32 loan) {
}
function setSecretHashes(
bytes32 loan,
bytes32[4] calldata borrowerSecretHashes,
bytes32[4] calldata lenderSecretHashes,
bytes32[4] calldata arbiterSecretHashes,
bytes calldata borrowerPubKey_,
bytes calldata lenderPubKey_,
bytes calldata arbiterPubKey_
) external returns (bool) {
}
function fund(bytes32 loan) external {
}
function approve(bytes32 loan) external {
}
function withdraw(bytes32 loan, bytes32 secretA1) external {
}
function repay(bytes32 loan, uint256 amount) external {
}
function refund(bytes32 loan) external {
}
function cancel(bytes32 loan, bytes32 secret) external {
}
function accept(bytes32 loan, bytes32 secret) public {
}
function liquidate(bytes32 loan, bytes32 secretHash, bytes20 pubKeyHash) external returns (bytes32 sale_) {
}
}
| address(sales)==address(0) | 311,961 | address(sales)==address(0) |
null | pragma solidity ^0.5.8;
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 value) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal {
}
function _burn(address account, uint256 value) internal {
}
function _approve(address owner, address spender, uint256 value) internal {
}
function _burnFrom(address account, uint256 amount) internal {
}
}
interface FundsInterface {
function lender(bytes32) external view returns (address);
function custom(bytes32) external view returns (bool);
function deposit(bytes32, uint256) external;
function decreaseTotalBorrow(uint256) external;
function calcGlobalInterest() external;
}
interface SalesInterface {
function saleIndexByLoan(bytes32, uint256) external returns(bytes32);
function settlementExpiration(bytes32) external view returns (uint256);
function accepted(bytes32) external view returns (bool);
function next(bytes32) external view returns (uint256);
function create(bytes32, address, address, address, address, bytes32, bytes32, bytes32, bytes32, bytes20) external returns(bytes32);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function min(uint x, uint y) internal pure returns (uint z) {
}
function max(uint x, uint y) internal pure returns (uint z) {
}
function imin(int x, int y) internal pure returns (int z) {
}
function imax(int x, int y) internal pure returns (int z) {
}
uint constant COL = 10 ** 8;
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function cmul(uint x, uint y) public pure returns (uint z) {
}
function wmul(uint x, uint y) internal pure returns (uint z) {
}
function rmul(uint x, uint y) internal pure returns (uint z) {
}
function cdiv(uint x, uint y) internal pure returns (uint z) {
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
}
function rpow(uint x, uint n) internal pure returns (uint z) {
}
}
contract Medianizer {
function peek() public view returns (bytes32, bool);
function read() public returns (bytes32);
function poke() public;
function poke(bytes32) public;
function fund (uint256 amount, ERC20 token) public;
}
contract Loans is DSMath {
FundsInterface funds;
Medianizer med;
SalesInterface sales;
uint256 public constant APPROVE_EXP_THRESHOLD = 2 hours;
uint256 public constant ACCEPT_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_EXP_THRESHOLD = 7 days;
uint256 public constant SEIZURE_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_DISCOUNT = 930000000000000000;
mapping (bytes32 => Loan) public loans;
mapping (bytes32 => PubKeys) public pubKeys;
mapping (bytes32 => SecretHashes) public secretHashes;
mapping (bytes32 => Bools) public bools;
mapping (bytes32 => bytes32) public fundIndex;
mapping (bytes32 => ERC20) public tokes;
mapping (bytes32 => uint256) public repayments;
uint256 public loanIndex;
mapping (address => bytes32[]) public borrowerLoans;
mapping (address => bytes32[]) public lenderLoans;
ERC20 public token;
uint256 public decimals;
address deployer;
struct Loan {
address borrower;
address lender;
address arbiter;
uint256 createdAt;
uint256 loanExpiration;
uint256 requestTimestamp;
uint256 closedTimestamp;
uint256 principal;
uint256 interest;
uint256 penalty;
uint256 fee;
uint256 collateral;
uint256 liquidationRatio;
}
struct PubKeys {
bytes borrowerPubKey;
bytes lenderPubKey;
bytes arbiterPubKey;
}
struct SecretHashes {
bytes32 secretHashA1;
bytes32[3] secretHashAs;
bytes32 secretHashB1;
bytes32[3] secretHashBs;
bytes32 secretHashC1;
bytes32[3] secretHashCs;
bytes32 withdrawSecret;
bytes32 acceptSecret;
bool set;
}
struct Bools {
bool funded;
bool approved;
bool withdrawn;
bool sale;
bool paid;
bool off;
}
event Create(bytes32 loan);
function borrower(bytes32 loan) public view returns (address) {
}
function lender(bytes32 loan) public view returns (address) {
}
function arbiter(bytes32 loan) public view returns (address) {
}
function approveExpiration(bytes32 loan) public view returns (uint256) {
}
function acceptExpiration(bytes32 loan) public view returns (uint256) {
}
function liquidationExpiration(bytes32 loan) public view returns (uint256) {
}
function seizureExpiration(bytes32 loan) public view returns (uint256) {
}
function principal(bytes32 loan) public view returns (uint256) {
}
function interest(bytes32 loan) public view returns (uint256) {
}
function fee(bytes32 loan) public view returns (uint256) {
}
function penalty(bytes32 loan) public view returns (uint256) {
}
function collateral(bytes32 loan) public view returns (uint256) {
}
function repaid(bytes32 loan) public view returns (uint256) {
}
function liquidationRatio(bytes32 loan) public view returns (uint256) {
}
function owedToLender(bytes32 loan) public view returns (uint256) {
}
function owedForLoan(bytes32 loan) public view returns (uint256) {
}
function owedForLiquidation(bytes32 loan) public view returns (uint256) {
}
function owing(bytes32 loan) public view returns (uint256) {
}
function funded(bytes32 loan) public view returns (bool) {
}
function approved(bytes32 loan) public view returns (bool) {
}
function withdrawn(bytes32 loan) public view returns (bool) {
}
function sale(bytes32 loan) public view returns (bool) {
}
function paid(bytes32 loan) public view returns (bool) {
}
function off(bytes32 loan) public view returns (bool) {
}
function dmul(uint x) public view returns (uint256) {
}
function ddiv(uint x) public view returns (uint256) {
}
function borrowerLoanCount(address borrower_) public view returns (uint256) {
}
function lenderLoanCount(address lender_) public view returns (uint256) {
}
function collateralValue(bytes32 loan) public view returns (uint256) {
}
function minCollateralValue(bytes32 loan) public view returns (uint256) {
}
function discountCollateralValue(bytes32 loan) public view returns (uint256) {
}
function safe(bytes32 loan) public view returns (bool) {
}
constructor (FundsInterface funds_, Medianizer med_, ERC20 token_, uint256 decimals_) public {
}
function setSales(SalesInterface sales_) external {
}
function create(
uint256 loanExpiration_,
address[3] calldata usrs_,
uint256[7] calldata vals_,
bytes32 fundIndex_
) external returns (bytes32 loan) {
if (fundIndex_ != bytes32(0)) { require(<FILL_ME>) }
loanIndex = add(loanIndex, 1);
loan = bytes32(loanIndex);
loans[loan].createdAt = now;
loans[loan].loanExpiration = loanExpiration_;
loans[loan].borrower = usrs_[0];
loans[loan].lender = usrs_[1];
loans[loan].arbiter = usrs_[2];
loans[loan].principal = vals_[0];
loans[loan].interest = vals_[1];
loans[loan].penalty = vals_[2];
loans[loan].fee = vals_[3];
loans[loan].collateral = vals_[4];
loans[loan].liquidationRatio = vals_[5];
loans[loan].requestTimestamp = vals_[6];
fundIndex[loan] = fundIndex_;
secretHashes[loan].set = false;
borrowerLoans[usrs_[0]].push(bytes32(loanIndex));
lenderLoans[usrs_[1]].push(bytes32(loanIndex));
emit Create(loan);
}
function setSecretHashes(
bytes32 loan,
bytes32[4] calldata borrowerSecretHashes,
bytes32[4] calldata lenderSecretHashes,
bytes32[4] calldata arbiterSecretHashes,
bytes calldata borrowerPubKey_,
bytes calldata lenderPubKey_,
bytes calldata arbiterPubKey_
) external returns (bool) {
}
function fund(bytes32 loan) external {
}
function approve(bytes32 loan) external {
}
function withdraw(bytes32 loan, bytes32 secretA1) external {
}
function repay(bytes32 loan, uint256 amount) external {
}
function refund(bytes32 loan) external {
}
function cancel(bytes32 loan, bytes32 secret) external {
}
function accept(bytes32 loan, bytes32 secret) public {
}
function liquidate(bytes32 loan, bytes32 secretHash, bytes20 pubKeyHash) external returns (bytes32 sale_) {
}
}
| funds.lender(fundIndex_)==usrs_[1] | 311,961 | funds.lender(fundIndex_)==usrs_[1] |
null | pragma solidity ^0.5.8;
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 value) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal {
}
function _burn(address account, uint256 value) internal {
}
function _approve(address owner, address spender, uint256 value) internal {
}
function _burnFrom(address account, uint256 amount) internal {
}
}
interface FundsInterface {
function lender(bytes32) external view returns (address);
function custom(bytes32) external view returns (bool);
function deposit(bytes32, uint256) external;
function decreaseTotalBorrow(uint256) external;
function calcGlobalInterest() external;
}
interface SalesInterface {
function saleIndexByLoan(bytes32, uint256) external returns(bytes32);
function settlementExpiration(bytes32) external view returns (uint256);
function accepted(bytes32) external view returns (bool);
function next(bytes32) external view returns (uint256);
function create(bytes32, address, address, address, address, bytes32, bytes32, bytes32, bytes32, bytes20) external returns(bytes32);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function min(uint x, uint y) internal pure returns (uint z) {
}
function max(uint x, uint y) internal pure returns (uint z) {
}
function imin(int x, int y) internal pure returns (int z) {
}
function imax(int x, int y) internal pure returns (int z) {
}
uint constant COL = 10 ** 8;
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function cmul(uint x, uint y) public pure returns (uint z) {
}
function wmul(uint x, uint y) internal pure returns (uint z) {
}
function rmul(uint x, uint y) internal pure returns (uint z) {
}
function cdiv(uint x, uint y) internal pure returns (uint z) {
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
}
function rpow(uint x, uint n) internal pure returns (uint z) {
}
}
contract Medianizer {
function peek() public view returns (bytes32, bool);
function read() public returns (bytes32);
function poke() public;
function poke(bytes32) public;
function fund (uint256 amount, ERC20 token) public;
}
contract Loans is DSMath {
FundsInterface funds;
Medianizer med;
SalesInterface sales;
uint256 public constant APPROVE_EXP_THRESHOLD = 2 hours;
uint256 public constant ACCEPT_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_EXP_THRESHOLD = 7 days;
uint256 public constant SEIZURE_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_DISCOUNT = 930000000000000000;
mapping (bytes32 => Loan) public loans;
mapping (bytes32 => PubKeys) public pubKeys;
mapping (bytes32 => SecretHashes) public secretHashes;
mapping (bytes32 => Bools) public bools;
mapping (bytes32 => bytes32) public fundIndex;
mapping (bytes32 => ERC20) public tokes;
mapping (bytes32 => uint256) public repayments;
uint256 public loanIndex;
mapping (address => bytes32[]) public borrowerLoans;
mapping (address => bytes32[]) public lenderLoans;
ERC20 public token;
uint256 public decimals;
address deployer;
struct Loan {
address borrower;
address lender;
address arbiter;
uint256 createdAt;
uint256 loanExpiration;
uint256 requestTimestamp;
uint256 closedTimestamp;
uint256 principal;
uint256 interest;
uint256 penalty;
uint256 fee;
uint256 collateral;
uint256 liquidationRatio;
}
struct PubKeys {
bytes borrowerPubKey;
bytes lenderPubKey;
bytes arbiterPubKey;
}
struct SecretHashes {
bytes32 secretHashA1;
bytes32[3] secretHashAs;
bytes32 secretHashB1;
bytes32[3] secretHashBs;
bytes32 secretHashC1;
bytes32[3] secretHashCs;
bytes32 withdrawSecret;
bytes32 acceptSecret;
bool set;
}
struct Bools {
bool funded;
bool approved;
bool withdrawn;
bool sale;
bool paid;
bool off;
}
event Create(bytes32 loan);
function borrower(bytes32 loan) public view returns (address) {
}
function lender(bytes32 loan) public view returns (address) {
}
function arbiter(bytes32 loan) public view returns (address) {
}
function approveExpiration(bytes32 loan) public view returns (uint256) {
}
function acceptExpiration(bytes32 loan) public view returns (uint256) {
}
function liquidationExpiration(bytes32 loan) public view returns (uint256) {
}
function seizureExpiration(bytes32 loan) public view returns (uint256) {
}
function principal(bytes32 loan) public view returns (uint256) {
}
function interest(bytes32 loan) public view returns (uint256) {
}
function fee(bytes32 loan) public view returns (uint256) {
}
function penalty(bytes32 loan) public view returns (uint256) {
}
function collateral(bytes32 loan) public view returns (uint256) {
}
function repaid(bytes32 loan) public view returns (uint256) {
}
function liquidationRatio(bytes32 loan) public view returns (uint256) {
}
function owedToLender(bytes32 loan) public view returns (uint256) {
}
function owedForLoan(bytes32 loan) public view returns (uint256) {
}
function owedForLiquidation(bytes32 loan) public view returns (uint256) {
}
function owing(bytes32 loan) public view returns (uint256) {
}
function funded(bytes32 loan) public view returns (bool) {
}
function approved(bytes32 loan) public view returns (bool) {
}
function withdrawn(bytes32 loan) public view returns (bool) {
}
function sale(bytes32 loan) public view returns (bool) {
}
function paid(bytes32 loan) public view returns (bool) {
}
function off(bytes32 loan) public view returns (bool) {
}
function dmul(uint x) public view returns (uint256) {
}
function ddiv(uint x) public view returns (uint256) {
}
function borrowerLoanCount(address borrower_) public view returns (uint256) {
}
function lenderLoanCount(address lender_) public view returns (uint256) {
}
function collateralValue(bytes32 loan) public view returns (uint256) {
}
function minCollateralValue(bytes32 loan) public view returns (uint256) {
}
function discountCollateralValue(bytes32 loan) public view returns (uint256) {
}
function safe(bytes32 loan) public view returns (bool) {
}
constructor (FundsInterface funds_, Medianizer med_, ERC20 token_, uint256 decimals_) public {
}
function setSales(SalesInterface sales_) external {
}
function create(
uint256 loanExpiration_,
address[3] calldata usrs_,
uint256[7] calldata vals_,
bytes32 fundIndex_
) external returns (bytes32 loan) {
}
function setSecretHashes(
bytes32 loan,
bytes32[4] calldata borrowerSecretHashes,
bytes32[4] calldata lenderSecretHashes,
bytes32[4] calldata arbiterSecretHashes,
bytes calldata borrowerPubKey_,
bytes calldata lenderPubKey_,
bytes calldata arbiterPubKey_
) external returns (bool) {
require(<FILL_ME>)
require(msg.sender == loans[loan].borrower || msg.sender == loans[loan].lender || msg.sender == address(funds));
secretHashes[loan].secretHashA1 = borrowerSecretHashes[0];
secretHashes[loan].secretHashAs = [ borrowerSecretHashes[1], borrowerSecretHashes[2], borrowerSecretHashes[3] ];
secretHashes[loan].secretHashB1 = lenderSecretHashes[0];
secretHashes[loan].secretHashBs = [ lenderSecretHashes[1], lenderSecretHashes[2], lenderSecretHashes[3] ];
secretHashes[loan].secretHashC1 = arbiterSecretHashes[0];
secretHashes[loan].secretHashCs = [ arbiterSecretHashes[1], arbiterSecretHashes[2], arbiterSecretHashes[3] ];
pubKeys[loan].borrowerPubKey = borrowerPubKey_;
pubKeys[loan].lenderPubKey = lenderPubKey_;
pubKeys[loan].arbiterPubKey = arbiterPubKey_;
secretHashes[loan].set = true;
}
function fund(bytes32 loan) external {
}
function approve(bytes32 loan) external {
}
function withdraw(bytes32 loan, bytes32 secretA1) external {
}
function repay(bytes32 loan, uint256 amount) external {
}
function refund(bytes32 loan) external {
}
function cancel(bytes32 loan, bytes32 secret) external {
}
function accept(bytes32 loan, bytes32 secret) public {
}
function liquidate(bytes32 loan, bytes32 secretHash, bytes20 pubKeyHash) external returns (bytes32 sale_) {
}
}
| !secretHashes[loan].set | 311,961 | !secretHashes[loan].set |
null | pragma solidity ^0.5.8;
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 value) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal {
}
function _burn(address account, uint256 value) internal {
}
function _approve(address owner, address spender, uint256 value) internal {
}
function _burnFrom(address account, uint256 amount) internal {
}
}
interface FundsInterface {
function lender(bytes32) external view returns (address);
function custom(bytes32) external view returns (bool);
function deposit(bytes32, uint256) external;
function decreaseTotalBorrow(uint256) external;
function calcGlobalInterest() external;
}
interface SalesInterface {
function saleIndexByLoan(bytes32, uint256) external returns(bytes32);
function settlementExpiration(bytes32) external view returns (uint256);
function accepted(bytes32) external view returns (bool);
function next(bytes32) external view returns (uint256);
function create(bytes32, address, address, address, address, bytes32, bytes32, bytes32, bytes32, bytes20) external returns(bytes32);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function min(uint x, uint y) internal pure returns (uint z) {
}
function max(uint x, uint y) internal pure returns (uint z) {
}
function imin(int x, int y) internal pure returns (int z) {
}
function imax(int x, int y) internal pure returns (int z) {
}
uint constant COL = 10 ** 8;
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function cmul(uint x, uint y) public pure returns (uint z) {
}
function wmul(uint x, uint y) internal pure returns (uint z) {
}
function rmul(uint x, uint y) internal pure returns (uint z) {
}
function cdiv(uint x, uint y) internal pure returns (uint z) {
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
}
function rpow(uint x, uint n) internal pure returns (uint z) {
}
}
contract Medianizer {
function peek() public view returns (bytes32, bool);
function read() public returns (bytes32);
function poke() public;
function poke(bytes32) public;
function fund (uint256 amount, ERC20 token) public;
}
contract Loans is DSMath {
FundsInterface funds;
Medianizer med;
SalesInterface sales;
uint256 public constant APPROVE_EXP_THRESHOLD = 2 hours;
uint256 public constant ACCEPT_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_EXP_THRESHOLD = 7 days;
uint256 public constant SEIZURE_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_DISCOUNT = 930000000000000000;
mapping (bytes32 => Loan) public loans;
mapping (bytes32 => PubKeys) public pubKeys;
mapping (bytes32 => SecretHashes) public secretHashes;
mapping (bytes32 => Bools) public bools;
mapping (bytes32 => bytes32) public fundIndex;
mapping (bytes32 => ERC20) public tokes;
mapping (bytes32 => uint256) public repayments;
uint256 public loanIndex;
mapping (address => bytes32[]) public borrowerLoans;
mapping (address => bytes32[]) public lenderLoans;
ERC20 public token;
uint256 public decimals;
address deployer;
struct Loan {
address borrower;
address lender;
address arbiter;
uint256 createdAt;
uint256 loanExpiration;
uint256 requestTimestamp;
uint256 closedTimestamp;
uint256 principal;
uint256 interest;
uint256 penalty;
uint256 fee;
uint256 collateral;
uint256 liquidationRatio;
}
struct PubKeys {
bytes borrowerPubKey;
bytes lenderPubKey;
bytes arbiterPubKey;
}
struct SecretHashes {
bytes32 secretHashA1;
bytes32[3] secretHashAs;
bytes32 secretHashB1;
bytes32[3] secretHashBs;
bytes32 secretHashC1;
bytes32[3] secretHashCs;
bytes32 withdrawSecret;
bytes32 acceptSecret;
bool set;
}
struct Bools {
bool funded;
bool approved;
bool withdrawn;
bool sale;
bool paid;
bool off;
}
event Create(bytes32 loan);
function borrower(bytes32 loan) public view returns (address) {
}
function lender(bytes32 loan) public view returns (address) {
}
function arbiter(bytes32 loan) public view returns (address) {
}
function approveExpiration(bytes32 loan) public view returns (uint256) {
}
function acceptExpiration(bytes32 loan) public view returns (uint256) {
}
function liquidationExpiration(bytes32 loan) public view returns (uint256) {
}
function seizureExpiration(bytes32 loan) public view returns (uint256) {
}
function principal(bytes32 loan) public view returns (uint256) {
}
function interest(bytes32 loan) public view returns (uint256) {
}
function fee(bytes32 loan) public view returns (uint256) {
}
function penalty(bytes32 loan) public view returns (uint256) {
}
function collateral(bytes32 loan) public view returns (uint256) {
}
function repaid(bytes32 loan) public view returns (uint256) {
}
function liquidationRatio(bytes32 loan) public view returns (uint256) {
}
function owedToLender(bytes32 loan) public view returns (uint256) {
}
function owedForLoan(bytes32 loan) public view returns (uint256) {
}
function owedForLiquidation(bytes32 loan) public view returns (uint256) {
}
function owing(bytes32 loan) public view returns (uint256) {
}
function funded(bytes32 loan) public view returns (bool) {
}
function approved(bytes32 loan) public view returns (bool) {
}
function withdrawn(bytes32 loan) public view returns (bool) {
}
function sale(bytes32 loan) public view returns (bool) {
}
function paid(bytes32 loan) public view returns (bool) {
}
function off(bytes32 loan) public view returns (bool) {
}
function dmul(uint x) public view returns (uint256) {
}
function ddiv(uint x) public view returns (uint256) {
}
function borrowerLoanCount(address borrower_) public view returns (uint256) {
}
function lenderLoanCount(address lender_) public view returns (uint256) {
}
function collateralValue(bytes32 loan) public view returns (uint256) {
}
function minCollateralValue(bytes32 loan) public view returns (uint256) {
}
function discountCollateralValue(bytes32 loan) public view returns (uint256) {
}
function safe(bytes32 loan) public view returns (bool) {
}
constructor (FundsInterface funds_, Medianizer med_, ERC20 token_, uint256 decimals_) public {
}
function setSales(SalesInterface sales_) external {
}
function create(
uint256 loanExpiration_,
address[3] calldata usrs_,
uint256[7] calldata vals_,
bytes32 fundIndex_
) external returns (bytes32 loan) {
}
function setSecretHashes(
bytes32 loan,
bytes32[4] calldata borrowerSecretHashes,
bytes32[4] calldata lenderSecretHashes,
bytes32[4] calldata arbiterSecretHashes,
bytes calldata borrowerPubKey_,
bytes calldata lenderPubKey_,
bytes calldata arbiterPubKey_
) external returns (bool) {
}
function fund(bytes32 loan) external {
require(<FILL_ME>)
require(bools[loan].funded == false);
require(token.transferFrom(msg.sender, address(this), principal(loan)));
bools[loan].funded = true;
}
function approve(bytes32 loan) external {
}
function withdraw(bytes32 loan, bytes32 secretA1) external {
}
function repay(bytes32 loan, uint256 amount) external {
}
function refund(bytes32 loan) external {
}
function cancel(bytes32 loan, bytes32 secret) external {
}
function accept(bytes32 loan, bytes32 secret) public {
}
function liquidate(bytes32 loan, bytes32 secretHash, bytes20 pubKeyHash) external returns (bytes32 sale_) {
}
}
| secretHashes[loan].set | 311,961 | secretHashes[loan].set |
null | pragma solidity ^0.5.8;
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 value) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal {
}
function _burn(address account, uint256 value) internal {
}
function _approve(address owner, address spender, uint256 value) internal {
}
function _burnFrom(address account, uint256 amount) internal {
}
}
interface FundsInterface {
function lender(bytes32) external view returns (address);
function custom(bytes32) external view returns (bool);
function deposit(bytes32, uint256) external;
function decreaseTotalBorrow(uint256) external;
function calcGlobalInterest() external;
}
interface SalesInterface {
function saleIndexByLoan(bytes32, uint256) external returns(bytes32);
function settlementExpiration(bytes32) external view returns (uint256);
function accepted(bytes32) external view returns (bool);
function next(bytes32) external view returns (uint256);
function create(bytes32, address, address, address, address, bytes32, bytes32, bytes32, bytes32, bytes20) external returns(bytes32);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function min(uint x, uint y) internal pure returns (uint z) {
}
function max(uint x, uint y) internal pure returns (uint z) {
}
function imin(int x, int y) internal pure returns (int z) {
}
function imax(int x, int y) internal pure returns (int z) {
}
uint constant COL = 10 ** 8;
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function cmul(uint x, uint y) public pure returns (uint z) {
}
function wmul(uint x, uint y) internal pure returns (uint z) {
}
function rmul(uint x, uint y) internal pure returns (uint z) {
}
function cdiv(uint x, uint y) internal pure returns (uint z) {
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
}
function rpow(uint x, uint n) internal pure returns (uint z) {
}
}
contract Medianizer {
function peek() public view returns (bytes32, bool);
function read() public returns (bytes32);
function poke() public;
function poke(bytes32) public;
function fund (uint256 amount, ERC20 token) public;
}
contract Loans is DSMath {
FundsInterface funds;
Medianizer med;
SalesInterface sales;
uint256 public constant APPROVE_EXP_THRESHOLD = 2 hours;
uint256 public constant ACCEPT_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_EXP_THRESHOLD = 7 days;
uint256 public constant SEIZURE_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_DISCOUNT = 930000000000000000;
mapping (bytes32 => Loan) public loans;
mapping (bytes32 => PubKeys) public pubKeys;
mapping (bytes32 => SecretHashes) public secretHashes;
mapping (bytes32 => Bools) public bools;
mapping (bytes32 => bytes32) public fundIndex;
mapping (bytes32 => ERC20) public tokes;
mapping (bytes32 => uint256) public repayments;
uint256 public loanIndex;
mapping (address => bytes32[]) public borrowerLoans;
mapping (address => bytes32[]) public lenderLoans;
ERC20 public token;
uint256 public decimals;
address deployer;
struct Loan {
address borrower;
address lender;
address arbiter;
uint256 createdAt;
uint256 loanExpiration;
uint256 requestTimestamp;
uint256 closedTimestamp;
uint256 principal;
uint256 interest;
uint256 penalty;
uint256 fee;
uint256 collateral;
uint256 liquidationRatio;
}
struct PubKeys {
bytes borrowerPubKey;
bytes lenderPubKey;
bytes arbiterPubKey;
}
struct SecretHashes {
bytes32 secretHashA1;
bytes32[3] secretHashAs;
bytes32 secretHashB1;
bytes32[3] secretHashBs;
bytes32 secretHashC1;
bytes32[3] secretHashCs;
bytes32 withdrawSecret;
bytes32 acceptSecret;
bool set;
}
struct Bools {
bool funded;
bool approved;
bool withdrawn;
bool sale;
bool paid;
bool off;
}
event Create(bytes32 loan);
function borrower(bytes32 loan) public view returns (address) {
}
function lender(bytes32 loan) public view returns (address) {
}
function arbiter(bytes32 loan) public view returns (address) {
}
function approveExpiration(bytes32 loan) public view returns (uint256) {
}
function acceptExpiration(bytes32 loan) public view returns (uint256) {
}
function liquidationExpiration(bytes32 loan) public view returns (uint256) {
}
function seizureExpiration(bytes32 loan) public view returns (uint256) {
}
function principal(bytes32 loan) public view returns (uint256) {
}
function interest(bytes32 loan) public view returns (uint256) {
}
function fee(bytes32 loan) public view returns (uint256) {
}
function penalty(bytes32 loan) public view returns (uint256) {
}
function collateral(bytes32 loan) public view returns (uint256) {
}
function repaid(bytes32 loan) public view returns (uint256) {
}
function liquidationRatio(bytes32 loan) public view returns (uint256) {
}
function owedToLender(bytes32 loan) public view returns (uint256) {
}
function owedForLoan(bytes32 loan) public view returns (uint256) {
}
function owedForLiquidation(bytes32 loan) public view returns (uint256) {
}
function owing(bytes32 loan) public view returns (uint256) {
}
function funded(bytes32 loan) public view returns (bool) {
}
function approved(bytes32 loan) public view returns (bool) {
}
function withdrawn(bytes32 loan) public view returns (bool) {
}
function sale(bytes32 loan) public view returns (bool) {
}
function paid(bytes32 loan) public view returns (bool) {
}
function off(bytes32 loan) public view returns (bool) {
}
function dmul(uint x) public view returns (uint256) {
}
function ddiv(uint x) public view returns (uint256) {
}
function borrowerLoanCount(address borrower_) public view returns (uint256) {
}
function lenderLoanCount(address lender_) public view returns (uint256) {
}
function collateralValue(bytes32 loan) public view returns (uint256) {
}
function minCollateralValue(bytes32 loan) public view returns (uint256) {
}
function discountCollateralValue(bytes32 loan) public view returns (uint256) {
}
function safe(bytes32 loan) public view returns (bool) {
}
constructor (FundsInterface funds_, Medianizer med_, ERC20 token_, uint256 decimals_) public {
}
function setSales(SalesInterface sales_) external {
}
function create(
uint256 loanExpiration_,
address[3] calldata usrs_,
uint256[7] calldata vals_,
bytes32 fundIndex_
) external returns (bytes32 loan) {
}
function setSecretHashes(
bytes32 loan,
bytes32[4] calldata borrowerSecretHashes,
bytes32[4] calldata lenderSecretHashes,
bytes32[4] calldata arbiterSecretHashes,
bytes calldata borrowerPubKey_,
bytes calldata lenderPubKey_,
bytes calldata arbiterPubKey_
) external returns (bool) {
}
function fund(bytes32 loan) external {
require(secretHashes[loan].set);
require(<FILL_ME>)
require(token.transferFrom(msg.sender, address(this), principal(loan)));
bools[loan].funded = true;
}
function approve(bytes32 loan) external {
}
function withdraw(bytes32 loan, bytes32 secretA1) external {
}
function repay(bytes32 loan, uint256 amount) external {
}
function refund(bytes32 loan) external {
}
function cancel(bytes32 loan, bytes32 secret) external {
}
function accept(bytes32 loan, bytes32 secret) public {
}
function liquidate(bytes32 loan, bytes32 secretHash, bytes20 pubKeyHash) external returns (bytes32 sale_) {
}
}
| bools[loan].funded==false | 311,961 | bools[loan].funded==false |
null | pragma solidity ^0.5.8;
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 value) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal {
}
function _burn(address account, uint256 value) internal {
}
function _approve(address owner, address spender, uint256 value) internal {
}
function _burnFrom(address account, uint256 amount) internal {
}
}
interface FundsInterface {
function lender(bytes32) external view returns (address);
function custom(bytes32) external view returns (bool);
function deposit(bytes32, uint256) external;
function decreaseTotalBorrow(uint256) external;
function calcGlobalInterest() external;
}
interface SalesInterface {
function saleIndexByLoan(bytes32, uint256) external returns(bytes32);
function settlementExpiration(bytes32) external view returns (uint256);
function accepted(bytes32) external view returns (bool);
function next(bytes32) external view returns (uint256);
function create(bytes32, address, address, address, address, bytes32, bytes32, bytes32, bytes32, bytes20) external returns(bytes32);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function min(uint x, uint y) internal pure returns (uint z) {
}
function max(uint x, uint y) internal pure returns (uint z) {
}
function imin(int x, int y) internal pure returns (int z) {
}
function imax(int x, int y) internal pure returns (int z) {
}
uint constant COL = 10 ** 8;
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function cmul(uint x, uint y) public pure returns (uint z) {
}
function wmul(uint x, uint y) internal pure returns (uint z) {
}
function rmul(uint x, uint y) internal pure returns (uint z) {
}
function cdiv(uint x, uint y) internal pure returns (uint z) {
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
}
function rpow(uint x, uint n) internal pure returns (uint z) {
}
}
contract Medianizer {
function peek() public view returns (bytes32, bool);
function read() public returns (bytes32);
function poke() public;
function poke(bytes32) public;
function fund (uint256 amount, ERC20 token) public;
}
contract Loans is DSMath {
FundsInterface funds;
Medianizer med;
SalesInterface sales;
uint256 public constant APPROVE_EXP_THRESHOLD = 2 hours;
uint256 public constant ACCEPT_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_EXP_THRESHOLD = 7 days;
uint256 public constant SEIZURE_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_DISCOUNT = 930000000000000000;
mapping (bytes32 => Loan) public loans;
mapping (bytes32 => PubKeys) public pubKeys;
mapping (bytes32 => SecretHashes) public secretHashes;
mapping (bytes32 => Bools) public bools;
mapping (bytes32 => bytes32) public fundIndex;
mapping (bytes32 => ERC20) public tokes;
mapping (bytes32 => uint256) public repayments;
uint256 public loanIndex;
mapping (address => bytes32[]) public borrowerLoans;
mapping (address => bytes32[]) public lenderLoans;
ERC20 public token;
uint256 public decimals;
address deployer;
struct Loan {
address borrower;
address lender;
address arbiter;
uint256 createdAt;
uint256 loanExpiration;
uint256 requestTimestamp;
uint256 closedTimestamp;
uint256 principal;
uint256 interest;
uint256 penalty;
uint256 fee;
uint256 collateral;
uint256 liquidationRatio;
}
struct PubKeys {
bytes borrowerPubKey;
bytes lenderPubKey;
bytes arbiterPubKey;
}
struct SecretHashes {
bytes32 secretHashA1;
bytes32[3] secretHashAs;
bytes32 secretHashB1;
bytes32[3] secretHashBs;
bytes32 secretHashC1;
bytes32[3] secretHashCs;
bytes32 withdrawSecret;
bytes32 acceptSecret;
bool set;
}
struct Bools {
bool funded;
bool approved;
bool withdrawn;
bool sale;
bool paid;
bool off;
}
event Create(bytes32 loan);
function borrower(bytes32 loan) public view returns (address) {
}
function lender(bytes32 loan) public view returns (address) {
}
function arbiter(bytes32 loan) public view returns (address) {
}
function approveExpiration(bytes32 loan) public view returns (uint256) {
}
function acceptExpiration(bytes32 loan) public view returns (uint256) {
}
function liquidationExpiration(bytes32 loan) public view returns (uint256) {
}
function seizureExpiration(bytes32 loan) public view returns (uint256) {
}
function principal(bytes32 loan) public view returns (uint256) {
}
function interest(bytes32 loan) public view returns (uint256) {
}
function fee(bytes32 loan) public view returns (uint256) {
}
function penalty(bytes32 loan) public view returns (uint256) {
}
function collateral(bytes32 loan) public view returns (uint256) {
}
function repaid(bytes32 loan) public view returns (uint256) {
}
function liquidationRatio(bytes32 loan) public view returns (uint256) {
}
function owedToLender(bytes32 loan) public view returns (uint256) {
}
function owedForLoan(bytes32 loan) public view returns (uint256) {
}
function owedForLiquidation(bytes32 loan) public view returns (uint256) {
}
function owing(bytes32 loan) public view returns (uint256) {
}
function funded(bytes32 loan) public view returns (bool) {
}
function approved(bytes32 loan) public view returns (bool) {
}
function withdrawn(bytes32 loan) public view returns (bool) {
}
function sale(bytes32 loan) public view returns (bool) {
}
function paid(bytes32 loan) public view returns (bool) {
}
function off(bytes32 loan) public view returns (bool) {
}
function dmul(uint x) public view returns (uint256) {
}
function ddiv(uint x) public view returns (uint256) {
}
function borrowerLoanCount(address borrower_) public view returns (uint256) {
}
function lenderLoanCount(address lender_) public view returns (uint256) {
}
function collateralValue(bytes32 loan) public view returns (uint256) {
}
function minCollateralValue(bytes32 loan) public view returns (uint256) {
}
function discountCollateralValue(bytes32 loan) public view returns (uint256) {
}
function safe(bytes32 loan) public view returns (bool) {
}
constructor (FundsInterface funds_, Medianizer med_, ERC20 token_, uint256 decimals_) public {
}
function setSales(SalesInterface sales_) external {
}
function create(
uint256 loanExpiration_,
address[3] calldata usrs_,
uint256[7] calldata vals_,
bytes32 fundIndex_
) external returns (bytes32 loan) {
}
function setSecretHashes(
bytes32 loan,
bytes32[4] calldata borrowerSecretHashes,
bytes32[4] calldata lenderSecretHashes,
bytes32[4] calldata arbiterSecretHashes,
bytes calldata borrowerPubKey_,
bytes calldata lenderPubKey_,
bytes calldata arbiterPubKey_
) external returns (bool) {
}
function fund(bytes32 loan) external {
require(secretHashes[loan].set);
require(bools[loan].funded == false);
require(<FILL_ME>)
bools[loan].funded = true;
}
function approve(bytes32 loan) external {
}
function withdraw(bytes32 loan, bytes32 secretA1) external {
}
function repay(bytes32 loan, uint256 amount) external {
}
function refund(bytes32 loan) external {
}
function cancel(bytes32 loan, bytes32 secret) external {
}
function accept(bytes32 loan, bytes32 secret) public {
}
function liquidate(bytes32 loan, bytes32 secretHash, bytes20 pubKeyHash) external returns (bytes32 sale_) {
}
}
| token.transferFrom(msg.sender,address(this),principal(loan)) | 311,961 | token.transferFrom(msg.sender,address(this),principal(loan)) |
null | pragma solidity ^0.5.8;
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 value) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal {
}
function _burn(address account, uint256 value) internal {
}
function _approve(address owner, address spender, uint256 value) internal {
}
function _burnFrom(address account, uint256 amount) internal {
}
}
interface FundsInterface {
function lender(bytes32) external view returns (address);
function custom(bytes32) external view returns (bool);
function deposit(bytes32, uint256) external;
function decreaseTotalBorrow(uint256) external;
function calcGlobalInterest() external;
}
interface SalesInterface {
function saleIndexByLoan(bytes32, uint256) external returns(bytes32);
function settlementExpiration(bytes32) external view returns (uint256);
function accepted(bytes32) external view returns (bool);
function next(bytes32) external view returns (uint256);
function create(bytes32, address, address, address, address, bytes32, bytes32, bytes32, bytes32, bytes20) external returns(bytes32);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function min(uint x, uint y) internal pure returns (uint z) {
}
function max(uint x, uint y) internal pure returns (uint z) {
}
function imin(int x, int y) internal pure returns (int z) {
}
function imax(int x, int y) internal pure returns (int z) {
}
uint constant COL = 10 ** 8;
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function cmul(uint x, uint y) public pure returns (uint z) {
}
function wmul(uint x, uint y) internal pure returns (uint z) {
}
function rmul(uint x, uint y) internal pure returns (uint z) {
}
function cdiv(uint x, uint y) internal pure returns (uint z) {
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
}
function rpow(uint x, uint n) internal pure returns (uint z) {
}
}
contract Medianizer {
function peek() public view returns (bytes32, bool);
function read() public returns (bytes32);
function poke() public;
function poke(bytes32) public;
function fund (uint256 amount, ERC20 token) public;
}
contract Loans is DSMath {
FundsInterface funds;
Medianizer med;
SalesInterface sales;
uint256 public constant APPROVE_EXP_THRESHOLD = 2 hours;
uint256 public constant ACCEPT_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_EXP_THRESHOLD = 7 days;
uint256 public constant SEIZURE_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_DISCOUNT = 930000000000000000;
mapping (bytes32 => Loan) public loans;
mapping (bytes32 => PubKeys) public pubKeys;
mapping (bytes32 => SecretHashes) public secretHashes;
mapping (bytes32 => Bools) public bools;
mapping (bytes32 => bytes32) public fundIndex;
mapping (bytes32 => ERC20) public tokes;
mapping (bytes32 => uint256) public repayments;
uint256 public loanIndex;
mapping (address => bytes32[]) public borrowerLoans;
mapping (address => bytes32[]) public lenderLoans;
ERC20 public token;
uint256 public decimals;
address deployer;
struct Loan {
address borrower;
address lender;
address arbiter;
uint256 createdAt;
uint256 loanExpiration;
uint256 requestTimestamp;
uint256 closedTimestamp;
uint256 principal;
uint256 interest;
uint256 penalty;
uint256 fee;
uint256 collateral;
uint256 liquidationRatio;
}
struct PubKeys {
bytes borrowerPubKey;
bytes lenderPubKey;
bytes arbiterPubKey;
}
struct SecretHashes {
bytes32 secretHashA1;
bytes32[3] secretHashAs;
bytes32 secretHashB1;
bytes32[3] secretHashBs;
bytes32 secretHashC1;
bytes32[3] secretHashCs;
bytes32 withdrawSecret;
bytes32 acceptSecret;
bool set;
}
struct Bools {
bool funded;
bool approved;
bool withdrawn;
bool sale;
bool paid;
bool off;
}
event Create(bytes32 loan);
function borrower(bytes32 loan) public view returns (address) {
}
function lender(bytes32 loan) public view returns (address) {
}
function arbiter(bytes32 loan) public view returns (address) {
}
function approveExpiration(bytes32 loan) public view returns (uint256) {
}
function acceptExpiration(bytes32 loan) public view returns (uint256) {
}
function liquidationExpiration(bytes32 loan) public view returns (uint256) {
}
function seizureExpiration(bytes32 loan) public view returns (uint256) {
}
function principal(bytes32 loan) public view returns (uint256) {
}
function interest(bytes32 loan) public view returns (uint256) {
}
function fee(bytes32 loan) public view returns (uint256) {
}
function penalty(bytes32 loan) public view returns (uint256) {
}
function collateral(bytes32 loan) public view returns (uint256) {
}
function repaid(bytes32 loan) public view returns (uint256) {
}
function liquidationRatio(bytes32 loan) public view returns (uint256) {
}
function owedToLender(bytes32 loan) public view returns (uint256) {
}
function owedForLoan(bytes32 loan) public view returns (uint256) {
}
function owedForLiquidation(bytes32 loan) public view returns (uint256) {
}
function owing(bytes32 loan) public view returns (uint256) {
}
function funded(bytes32 loan) public view returns (bool) {
}
function approved(bytes32 loan) public view returns (bool) {
}
function withdrawn(bytes32 loan) public view returns (bool) {
}
function sale(bytes32 loan) public view returns (bool) {
}
function paid(bytes32 loan) public view returns (bool) {
}
function off(bytes32 loan) public view returns (bool) {
}
function dmul(uint x) public view returns (uint256) {
}
function ddiv(uint x) public view returns (uint256) {
}
function borrowerLoanCount(address borrower_) public view returns (uint256) {
}
function lenderLoanCount(address lender_) public view returns (uint256) {
}
function collateralValue(bytes32 loan) public view returns (uint256) {
}
function minCollateralValue(bytes32 loan) public view returns (uint256) {
}
function discountCollateralValue(bytes32 loan) public view returns (uint256) {
}
function safe(bytes32 loan) public view returns (bool) {
}
constructor (FundsInterface funds_, Medianizer med_, ERC20 token_, uint256 decimals_) public {
}
function setSales(SalesInterface sales_) external {
}
function create(
uint256 loanExpiration_,
address[3] calldata usrs_,
uint256[7] calldata vals_,
bytes32 fundIndex_
) external returns (bytes32 loan) {
}
function setSecretHashes(
bytes32 loan,
bytes32[4] calldata borrowerSecretHashes,
bytes32[4] calldata lenderSecretHashes,
bytes32[4] calldata arbiterSecretHashes,
bytes calldata borrowerPubKey_,
bytes calldata lenderPubKey_,
bytes calldata arbiterPubKey_
) external returns (bool) {
}
function fund(bytes32 loan) external {
}
function approve(bytes32 loan) external {
require(<FILL_ME>)
require(loans[loan].lender == msg.sender);
require(now <= approveExpiration(loan));
bools[loan].approved = true;
}
function withdraw(bytes32 loan, bytes32 secretA1) external {
}
function repay(bytes32 loan, uint256 amount) external {
}
function refund(bytes32 loan) external {
}
function cancel(bytes32 loan, bytes32 secret) external {
}
function accept(bytes32 loan, bytes32 secret) public {
}
function liquidate(bytes32 loan, bytes32 secretHash, bytes20 pubKeyHash) external returns (bytes32 sale_) {
}
}
| bools[loan].funded==true | 311,961 | bools[loan].funded==true |
null | pragma solidity ^0.5.8;
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 value) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal {
}
function _burn(address account, uint256 value) internal {
}
function _approve(address owner, address spender, uint256 value) internal {
}
function _burnFrom(address account, uint256 amount) internal {
}
}
interface FundsInterface {
function lender(bytes32) external view returns (address);
function custom(bytes32) external view returns (bool);
function deposit(bytes32, uint256) external;
function decreaseTotalBorrow(uint256) external;
function calcGlobalInterest() external;
}
interface SalesInterface {
function saleIndexByLoan(bytes32, uint256) external returns(bytes32);
function settlementExpiration(bytes32) external view returns (uint256);
function accepted(bytes32) external view returns (bool);
function next(bytes32) external view returns (uint256);
function create(bytes32, address, address, address, address, bytes32, bytes32, bytes32, bytes32, bytes20) external returns(bytes32);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function min(uint x, uint y) internal pure returns (uint z) {
}
function max(uint x, uint y) internal pure returns (uint z) {
}
function imin(int x, int y) internal pure returns (int z) {
}
function imax(int x, int y) internal pure returns (int z) {
}
uint constant COL = 10 ** 8;
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function cmul(uint x, uint y) public pure returns (uint z) {
}
function wmul(uint x, uint y) internal pure returns (uint z) {
}
function rmul(uint x, uint y) internal pure returns (uint z) {
}
function cdiv(uint x, uint y) internal pure returns (uint z) {
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
}
function rpow(uint x, uint n) internal pure returns (uint z) {
}
}
contract Medianizer {
function peek() public view returns (bytes32, bool);
function read() public returns (bytes32);
function poke() public;
function poke(bytes32) public;
function fund (uint256 amount, ERC20 token) public;
}
contract Loans is DSMath {
FundsInterface funds;
Medianizer med;
SalesInterface sales;
uint256 public constant APPROVE_EXP_THRESHOLD = 2 hours;
uint256 public constant ACCEPT_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_EXP_THRESHOLD = 7 days;
uint256 public constant SEIZURE_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_DISCOUNT = 930000000000000000;
mapping (bytes32 => Loan) public loans;
mapping (bytes32 => PubKeys) public pubKeys;
mapping (bytes32 => SecretHashes) public secretHashes;
mapping (bytes32 => Bools) public bools;
mapping (bytes32 => bytes32) public fundIndex;
mapping (bytes32 => ERC20) public tokes;
mapping (bytes32 => uint256) public repayments;
uint256 public loanIndex;
mapping (address => bytes32[]) public borrowerLoans;
mapping (address => bytes32[]) public lenderLoans;
ERC20 public token;
uint256 public decimals;
address deployer;
struct Loan {
address borrower;
address lender;
address arbiter;
uint256 createdAt;
uint256 loanExpiration;
uint256 requestTimestamp;
uint256 closedTimestamp;
uint256 principal;
uint256 interest;
uint256 penalty;
uint256 fee;
uint256 collateral;
uint256 liquidationRatio;
}
struct PubKeys {
bytes borrowerPubKey;
bytes lenderPubKey;
bytes arbiterPubKey;
}
struct SecretHashes {
bytes32 secretHashA1;
bytes32[3] secretHashAs;
bytes32 secretHashB1;
bytes32[3] secretHashBs;
bytes32 secretHashC1;
bytes32[3] secretHashCs;
bytes32 withdrawSecret;
bytes32 acceptSecret;
bool set;
}
struct Bools {
bool funded;
bool approved;
bool withdrawn;
bool sale;
bool paid;
bool off;
}
event Create(bytes32 loan);
function borrower(bytes32 loan) public view returns (address) {
}
function lender(bytes32 loan) public view returns (address) {
}
function arbiter(bytes32 loan) public view returns (address) {
}
function approveExpiration(bytes32 loan) public view returns (uint256) {
}
function acceptExpiration(bytes32 loan) public view returns (uint256) {
}
function liquidationExpiration(bytes32 loan) public view returns (uint256) {
}
function seizureExpiration(bytes32 loan) public view returns (uint256) {
}
function principal(bytes32 loan) public view returns (uint256) {
}
function interest(bytes32 loan) public view returns (uint256) {
}
function fee(bytes32 loan) public view returns (uint256) {
}
function penalty(bytes32 loan) public view returns (uint256) {
}
function collateral(bytes32 loan) public view returns (uint256) {
}
function repaid(bytes32 loan) public view returns (uint256) {
}
function liquidationRatio(bytes32 loan) public view returns (uint256) {
}
function owedToLender(bytes32 loan) public view returns (uint256) {
}
function owedForLoan(bytes32 loan) public view returns (uint256) {
}
function owedForLiquidation(bytes32 loan) public view returns (uint256) {
}
function owing(bytes32 loan) public view returns (uint256) {
}
function funded(bytes32 loan) public view returns (bool) {
}
function approved(bytes32 loan) public view returns (bool) {
}
function withdrawn(bytes32 loan) public view returns (bool) {
}
function sale(bytes32 loan) public view returns (bool) {
}
function paid(bytes32 loan) public view returns (bool) {
}
function off(bytes32 loan) public view returns (bool) {
}
function dmul(uint x) public view returns (uint256) {
}
function ddiv(uint x) public view returns (uint256) {
}
function borrowerLoanCount(address borrower_) public view returns (uint256) {
}
function lenderLoanCount(address lender_) public view returns (uint256) {
}
function collateralValue(bytes32 loan) public view returns (uint256) {
}
function minCollateralValue(bytes32 loan) public view returns (uint256) {
}
function discountCollateralValue(bytes32 loan) public view returns (uint256) {
}
function safe(bytes32 loan) public view returns (bool) {
}
constructor (FundsInterface funds_, Medianizer med_, ERC20 token_, uint256 decimals_) public {
}
function setSales(SalesInterface sales_) external {
}
function create(
uint256 loanExpiration_,
address[3] calldata usrs_,
uint256[7] calldata vals_,
bytes32 fundIndex_
) external returns (bytes32 loan) {
}
function setSecretHashes(
bytes32 loan,
bytes32[4] calldata borrowerSecretHashes,
bytes32[4] calldata lenderSecretHashes,
bytes32[4] calldata arbiterSecretHashes,
bytes calldata borrowerPubKey_,
bytes calldata lenderPubKey_,
bytes calldata arbiterPubKey_
) external returns (bool) {
}
function fund(bytes32 loan) external {
}
function approve(bytes32 loan) external {
require(bools[loan].funded == true);
require(<FILL_ME>)
require(now <= approveExpiration(loan));
bools[loan].approved = true;
}
function withdraw(bytes32 loan, bytes32 secretA1) external {
}
function repay(bytes32 loan, uint256 amount) external {
}
function refund(bytes32 loan) external {
}
function cancel(bytes32 loan, bytes32 secret) external {
}
function accept(bytes32 loan, bytes32 secret) public {
}
function liquidate(bytes32 loan, bytes32 secretHash, bytes20 pubKeyHash) external returns (bytes32 sale_) {
}
}
| loans[loan].lender==msg.sender | 311,961 | loans[loan].lender==msg.sender |
null | pragma solidity ^0.5.8;
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 value) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal {
}
function _burn(address account, uint256 value) internal {
}
function _approve(address owner, address spender, uint256 value) internal {
}
function _burnFrom(address account, uint256 amount) internal {
}
}
interface FundsInterface {
function lender(bytes32) external view returns (address);
function custom(bytes32) external view returns (bool);
function deposit(bytes32, uint256) external;
function decreaseTotalBorrow(uint256) external;
function calcGlobalInterest() external;
}
interface SalesInterface {
function saleIndexByLoan(bytes32, uint256) external returns(bytes32);
function settlementExpiration(bytes32) external view returns (uint256);
function accepted(bytes32) external view returns (bool);
function next(bytes32) external view returns (uint256);
function create(bytes32, address, address, address, address, bytes32, bytes32, bytes32, bytes32, bytes20) external returns(bytes32);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function min(uint x, uint y) internal pure returns (uint z) {
}
function max(uint x, uint y) internal pure returns (uint z) {
}
function imin(int x, int y) internal pure returns (int z) {
}
function imax(int x, int y) internal pure returns (int z) {
}
uint constant COL = 10 ** 8;
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function cmul(uint x, uint y) public pure returns (uint z) {
}
function wmul(uint x, uint y) internal pure returns (uint z) {
}
function rmul(uint x, uint y) internal pure returns (uint z) {
}
function cdiv(uint x, uint y) internal pure returns (uint z) {
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
}
function rpow(uint x, uint n) internal pure returns (uint z) {
}
}
contract Medianizer {
function peek() public view returns (bytes32, bool);
function read() public returns (bytes32);
function poke() public;
function poke(bytes32) public;
function fund (uint256 amount, ERC20 token) public;
}
contract Loans is DSMath {
FundsInterface funds;
Medianizer med;
SalesInterface sales;
uint256 public constant APPROVE_EXP_THRESHOLD = 2 hours;
uint256 public constant ACCEPT_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_EXP_THRESHOLD = 7 days;
uint256 public constant SEIZURE_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_DISCOUNT = 930000000000000000;
mapping (bytes32 => Loan) public loans;
mapping (bytes32 => PubKeys) public pubKeys;
mapping (bytes32 => SecretHashes) public secretHashes;
mapping (bytes32 => Bools) public bools;
mapping (bytes32 => bytes32) public fundIndex;
mapping (bytes32 => ERC20) public tokes;
mapping (bytes32 => uint256) public repayments;
uint256 public loanIndex;
mapping (address => bytes32[]) public borrowerLoans;
mapping (address => bytes32[]) public lenderLoans;
ERC20 public token;
uint256 public decimals;
address deployer;
struct Loan {
address borrower;
address lender;
address arbiter;
uint256 createdAt;
uint256 loanExpiration;
uint256 requestTimestamp;
uint256 closedTimestamp;
uint256 principal;
uint256 interest;
uint256 penalty;
uint256 fee;
uint256 collateral;
uint256 liquidationRatio;
}
struct PubKeys {
bytes borrowerPubKey;
bytes lenderPubKey;
bytes arbiterPubKey;
}
struct SecretHashes {
bytes32 secretHashA1;
bytes32[3] secretHashAs;
bytes32 secretHashB1;
bytes32[3] secretHashBs;
bytes32 secretHashC1;
bytes32[3] secretHashCs;
bytes32 withdrawSecret;
bytes32 acceptSecret;
bool set;
}
struct Bools {
bool funded;
bool approved;
bool withdrawn;
bool sale;
bool paid;
bool off;
}
event Create(bytes32 loan);
function borrower(bytes32 loan) public view returns (address) {
}
function lender(bytes32 loan) public view returns (address) {
}
function arbiter(bytes32 loan) public view returns (address) {
}
function approveExpiration(bytes32 loan) public view returns (uint256) {
}
function acceptExpiration(bytes32 loan) public view returns (uint256) {
}
function liquidationExpiration(bytes32 loan) public view returns (uint256) {
}
function seizureExpiration(bytes32 loan) public view returns (uint256) {
}
function principal(bytes32 loan) public view returns (uint256) {
}
function interest(bytes32 loan) public view returns (uint256) {
}
function fee(bytes32 loan) public view returns (uint256) {
}
function penalty(bytes32 loan) public view returns (uint256) {
}
function collateral(bytes32 loan) public view returns (uint256) {
}
function repaid(bytes32 loan) public view returns (uint256) {
}
function liquidationRatio(bytes32 loan) public view returns (uint256) {
}
function owedToLender(bytes32 loan) public view returns (uint256) {
}
function owedForLoan(bytes32 loan) public view returns (uint256) {
}
function owedForLiquidation(bytes32 loan) public view returns (uint256) {
}
function owing(bytes32 loan) public view returns (uint256) {
}
function funded(bytes32 loan) public view returns (bool) {
}
function approved(bytes32 loan) public view returns (bool) {
}
function withdrawn(bytes32 loan) public view returns (bool) {
}
function sale(bytes32 loan) public view returns (bool) {
}
function paid(bytes32 loan) public view returns (bool) {
}
function off(bytes32 loan) public view returns (bool) {
}
function dmul(uint x) public view returns (uint256) {
}
function ddiv(uint x) public view returns (uint256) {
}
function borrowerLoanCount(address borrower_) public view returns (uint256) {
}
function lenderLoanCount(address lender_) public view returns (uint256) {
}
function collateralValue(bytes32 loan) public view returns (uint256) {
}
function minCollateralValue(bytes32 loan) public view returns (uint256) {
}
function discountCollateralValue(bytes32 loan) public view returns (uint256) {
}
function safe(bytes32 loan) public view returns (bool) {
}
constructor (FundsInterface funds_, Medianizer med_, ERC20 token_, uint256 decimals_) public {
}
function setSales(SalesInterface sales_) external {
}
function create(
uint256 loanExpiration_,
address[3] calldata usrs_,
uint256[7] calldata vals_,
bytes32 fundIndex_
) external returns (bytes32 loan) {
}
function setSecretHashes(
bytes32 loan,
bytes32[4] calldata borrowerSecretHashes,
bytes32[4] calldata lenderSecretHashes,
bytes32[4] calldata arbiterSecretHashes,
bytes calldata borrowerPubKey_,
bytes calldata lenderPubKey_,
bytes calldata arbiterPubKey_
) external returns (bool) {
}
function fund(bytes32 loan) external {
}
function approve(bytes32 loan) external {
}
function withdraw(bytes32 loan, bytes32 secretA1) external {
require(<FILL_ME>)
require(bools[loan].funded == true);
require(bools[loan].approved == true);
require(bools[loan].withdrawn == false);
require(sha256(abi.encodePacked(secretA1)) == secretHashes[loan].secretHashA1);
require(token.transfer(loans[loan].borrower, principal(loan)));
bools[loan].withdrawn = true;
secretHashes[loan].withdrawSecret = secretA1;
}
function repay(bytes32 loan, uint256 amount) external {
}
function refund(bytes32 loan) external {
}
function cancel(bytes32 loan, bytes32 secret) external {
}
function accept(bytes32 loan, bytes32 secret) public {
}
function liquidate(bytes32 loan, bytes32 secretHash, bytes20 pubKeyHash) external returns (bytes32 sale_) {
}
}
| !off(loan) | 311,961 | !off(loan) |
null | pragma solidity ^0.5.8;
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 value) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal {
}
function _burn(address account, uint256 value) internal {
}
function _approve(address owner, address spender, uint256 value) internal {
}
function _burnFrom(address account, uint256 amount) internal {
}
}
interface FundsInterface {
function lender(bytes32) external view returns (address);
function custom(bytes32) external view returns (bool);
function deposit(bytes32, uint256) external;
function decreaseTotalBorrow(uint256) external;
function calcGlobalInterest() external;
}
interface SalesInterface {
function saleIndexByLoan(bytes32, uint256) external returns(bytes32);
function settlementExpiration(bytes32) external view returns (uint256);
function accepted(bytes32) external view returns (bool);
function next(bytes32) external view returns (uint256);
function create(bytes32, address, address, address, address, bytes32, bytes32, bytes32, bytes32, bytes20) external returns(bytes32);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function min(uint x, uint y) internal pure returns (uint z) {
}
function max(uint x, uint y) internal pure returns (uint z) {
}
function imin(int x, int y) internal pure returns (int z) {
}
function imax(int x, int y) internal pure returns (int z) {
}
uint constant COL = 10 ** 8;
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function cmul(uint x, uint y) public pure returns (uint z) {
}
function wmul(uint x, uint y) internal pure returns (uint z) {
}
function rmul(uint x, uint y) internal pure returns (uint z) {
}
function cdiv(uint x, uint y) internal pure returns (uint z) {
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
}
function rpow(uint x, uint n) internal pure returns (uint z) {
}
}
contract Medianizer {
function peek() public view returns (bytes32, bool);
function read() public returns (bytes32);
function poke() public;
function poke(bytes32) public;
function fund (uint256 amount, ERC20 token) public;
}
contract Loans is DSMath {
FundsInterface funds;
Medianizer med;
SalesInterface sales;
uint256 public constant APPROVE_EXP_THRESHOLD = 2 hours;
uint256 public constant ACCEPT_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_EXP_THRESHOLD = 7 days;
uint256 public constant SEIZURE_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_DISCOUNT = 930000000000000000;
mapping (bytes32 => Loan) public loans;
mapping (bytes32 => PubKeys) public pubKeys;
mapping (bytes32 => SecretHashes) public secretHashes;
mapping (bytes32 => Bools) public bools;
mapping (bytes32 => bytes32) public fundIndex;
mapping (bytes32 => ERC20) public tokes;
mapping (bytes32 => uint256) public repayments;
uint256 public loanIndex;
mapping (address => bytes32[]) public borrowerLoans;
mapping (address => bytes32[]) public lenderLoans;
ERC20 public token;
uint256 public decimals;
address deployer;
struct Loan {
address borrower;
address lender;
address arbiter;
uint256 createdAt;
uint256 loanExpiration;
uint256 requestTimestamp;
uint256 closedTimestamp;
uint256 principal;
uint256 interest;
uint256 penalty;
uint256 fee;
uint256 collateral;
uint256 liquidationRatio;
}
struct PubKeys {
bytes borrowerPubKey;
bytes lenderPubKey;
bytes arbiterPubKey;
}
struct SecretHashes {
bytes32 secretHashA1;
bytes32[3] secretHashAs;
bytes32 secretHashB1;
bytes32[3] secretHashBs;
bytes32 secretHashC1;
bytes32[3] secretHashCs;
bytes32 withdrawSecret;
bytes32 acceptSecret;
bool set;
}
struct Bools {
bool funded;
bool approved;
bool withdrawn;
bool sale;
bool paid;
bool off;
}
event Create(bytes32 loan);
function borrower(bytes32 loan) public view returns (address) {
}
function lender(bytes32 loan) public view returns (address) {
}
function arbiter(bytes32 loan) public view returns (address) {
}
function approveExpiration(bytes32 loan) public view returns (uint256) {
}
function acceptExpiration(bytes32 loan) public view returns (uint256) {
}
function liquidationExpiration(bytes32 loan) public view returns (uint256) {
}
function seizureExpiration(bytes32 loan) public view returns (uint256) {
}
function principal(bytes32 loan) public view returns (uint256) {
}
function interest(bytes32 loan) public view returns (uint256) {
}
function fee(bytes32 loan) public view returns (uint256) {
}
function penalty(bytes32 loan) public view returns (uint256) {
}
function collateral(bytes32 loan) public view returns (uint256) {
}
function repaid(bytes32 loan) public view returns (uint256) {
}
function liquidationRatio(bytes32 loan) public view returns (uint256) {
}
function owedToLender(bytes32 loan) public view returns (uint256) {
}
function owedForLoan(bytes32 loan) public view returns (uint256) {
}
function owedForLiquidation(bytes32 loan) public view returns (uint256) {
}
function owing(bytes32 loan) public view returns (uint256) {
}
function funded(bytes32 loan) public view returns (bool) {
}
function approved(bytes32 loan) public view returns (bool) {
}
function withdrawn(bytes32 loan) public view returns (bool) {
}
function sale(bytes32 loan) public view returns (bool) {
}
function paid(bytes32 loan) public view returns (bool) {
}
function off(bytes32 loan) public view returns (bool) {
}
function dmul(uint x) public view returns (uint256) {
}
function ddiv(uint x) public view returns (uint256) {
}
function borrowerLoanCount(address borrower_) public view returns (uint256) {
}
function lenderLoanCount(address lender_) public view returns (uint256) {
}
function collateralValue(bytes32 loan) public view returns (uint256) {
}
function minCollateralValue(bytes32 loan) public view returns (uint256) {
}
function discountCollateralValue(bytes32 loan) public view returns (uint256) {
}
function safe(bytes32 loan) public view returns (bool) {
}
constructor (FundsInterface funds_, Medianizer med_, ERC20 token_, uint256 decimals_) public {
}
function setSales(SalesInterface sales_) external {
}
function create(
uint256 loanExpiration_,
address[3] calldata usrs_,
uint256[7] calldata vals_,
bytes32 fundIndex_
) external returns (bytes32 loan) {
}
function setSecretHashes(
bytes32 loan,
bytes32[4] calldata borrowerSecretHashes,
bytes32[4] calldata lenderSecretHashes,
bytes32[4] calldata arbiterSecretHashes,
bytes calldata borrowerPubKey_,
bytes calldata lenderPubKey_,
bytes calldata arbiterPubKey_
) external returns (bool) {
}
function fund(bytes32 loan) external {
}
function approve(bytes32 loan) external {
}
function withdraw(bytes32 loan, bytes32 secretA1) external {
require(!off(loan));
require(bools[loan].funded == true);
require(<FILL_ME>)
require(bools[loan].withdrawn == false);
require(sha256(abi.encodePacked(secretA1)) == secretHashes[loan].secretHashA1);
require(token.transfer(loans[loan].borrower, principal(loan)));
bools[loan].withdrawn = true;
secretHashes[loan].withdrawSecret = secretA1;
}
function repay(bytes32 loan, uint256 amount) external {
}
function refund(bytes32 loan) external {
}
function cancel(bytes32 loan, bytes32 secret) external {
}
function accept(bytes32 loan, bytes32 secret) public {
}
function liquidate(bytes32 loan, bytes32 secretHash, bytes20 pubKeyHash) external returns (bytes32 sale_) {
}
}
| bools[loan].approved==true | 311,961 | bools[loan].approved==true |
null | pragma solidity ^0.5.8;
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 value) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal {
}
function _burn(address account, uint256 value) internal {
}
function _approve(address owner, address spender, uint256 value) internal {
}
function _burnFrom(address account, uint256 amount) internal {
}
}
interface FundsInterface {
function lender(bytes32) external view returns (address);
function custom(bytes32) external view returns (bool);
function deposit(bytes32, uint256) external;
function decreaseTotalBorrow(uint256) external;
function calcGlobalInterest() external;
}
interface SalesInterface {
function saleIndexByLoan(bytes32, uint256) external returns(bytes32);
function settlementExpiration(bytes32) external view returns (uint256);
function accepted(bytes32) external view returns (bool);
function next(bytes32) external view returns (uint256);
function create(bytes32, address, address, address, address, bytes32, bytes32, bytes32, bytes32, bytes20) external returns(bytes32);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function min(uint x, uint y) internal pure returns (uint z) {
}
function max(uint x, uint y) internal pure returns (uint z) {
}
function imin(int x, int y) internal pure returns (int z) {
}
function imax(int x, int y) internal pure returns (int z) {
}
uint constant COL = 10 ** 8;
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function cmul(uint x, uint y) public pure returns (uint z) {
}
function wmul(uint x, uint y) internal pure returns (uint z) {
}
function rmul(uint x, uint y) internal pure returns (uint z) {
}
function cdiv(uint x, uint y) internal pure returns (uint z) {
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
}
function rpow(uint x, uint n) internal pure returns (uint z) {
}
}
contract Medianizer {
function peek() public view returns (bytes32, bool);
function read() public returns (bytes32);
function poke() public;
function poke(bytes32) public;
function fund (uint256 amount, ERC20 token) public;
}
contract Loans is DSMath {
FundsInterface funds;
Medianizer med;
SalesInterface sales;
uint256 public constant APPROVE_EXP_THRESHOLD = 2 hours;
uint256 public constant ACCEPT_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_EXP_THRESHOLD = 7 days;
uint256 public constant SEIZURE_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_DISCOUNT = 930000000000000000;
mapping (bytes32 => Loan) public loans;
mapping (bytes32 => PubKeys) public pubKeys;
mapping (bytes32 => SecretHashes) public secretHashes;
mapping (bytes32 => Bools) public bools;
mapping (bytes32 => bytes32) public fundIndex;
mapping (bytes32 => ERC20) public tokes;
mapping (bytes32 => uint256) public repayments;
uint256 public loanIndex;
mapping (address => bytes32[]) public borrowerLoans;
mapping (address => bytes32[]) public lenderLoans;
ERC20 public token;
uint256 public decimals;
address deployer;
struct Loan {
address borrower;
address lender;
address arbiter;
uint256 createdAt;
uint256 loanExpiration;
uint256 requestTimestamp;
uint256 closedTimestamp;
uint256 principal;
uint256 interest;
uint256 penalty;
uint256 fee;
uint256 collateral;
uint256 liquidationRatio;
}
struct PubKeys {
bytes borrowerPubKey;
bytes lenderPubKey;
bytes arbiterPubKey;
}
struct SecretHashes {
bytes32 secretHashA1;
bytes32[3] secretHashAs;
bytes32 secretHashB1;
bytes32[3] secretHashBs;
bytes32 secretHashC1;
bytes32[3] secretHashCs;
bytes32 withdrawSecret;
bytes32 acceptSecret;
bool set;
}
struct Bools {
bool funded;
bool approved;
bool withdrawn;
bool sale;
bool paid;
bool off;
}
event Create(bytes32 loan);
function borrower(bytes32 loan) public view returns (address) {
}
function lender(bytes32 loan) public view returns (address) {
}
function arbiter(bytes32 loan) public view returns (address) {
}
function approveExpiration(bytes32 loan) public view returns (uint256) {
}
function acceptExpiration(bytes32 loan) public view returns (uint256) {
}
function liquidationExpiration(bytes32 loan) public view returns (uint256) {
}
function seizureExpiration(bytes32 loan) public view returns (uint256) {
}
function principal(bytes32 loan) public view returns (uint256) {
}
function interest(bytes32 loan) public view returns (uint256) {
}
function fee(bytes32 loan) public view returns (uint256) {
}
function penalty(bytes32 loan) public view returns (uint256) {
}
function collateral(bytes32 loan) public view returns (uint256) {
}
function repaid(bytes32 loan) public view returns (uint256) {
}
function liquidationRatio(bytes32 loan) public view returns (uint256) {
}
function owedToLender(bytes32 loan) public view returns (uint256) {
}
function owedForLoan(bytes32 loan) public view returns (uint256) {
}
function owedForLiquidation(bytes32 loan) public view returns (uint256) {
}
function owing(bytes32 loan) public view returns (uint256) {
}
function funded(bytes32 loan) public view returns (bool) {
}
function approved(bytes32 loan) public view returns (bool) {
}
function withdrawn(bytes32 loan) public view returns (bool) {
}
function sale(bytes32 loan) public view returns (bool) {
}
function paid(bytes32 loan) public view returns (bool) {
}
function off(bytes32 loan) public view returns (bool) {
}
function dmul(uint x) public view returns (uint256) {
}
function ddiv(uint x) public view returns (uint256) {
}
function borrowerLoanCount(address borrower_) public view returns (uint256) {
}
function lenderLoanCount(address lender_) public view returns (uint256) {
}
function collateralValue(bytes32 loan) public view returns (uint256) {
}
function minCollateralValue(bytes32 loan) public view returns (uint256) {
}
function discountCollateralValue(bytes32 loan) public view returns (uint256) {
}
function safe(bytes32 loan) public view returns (bool) {
}
constructor (FundsInterface funds_, Medianizer med_, ERC20 token_, uint256 decimals_) public {
}
function setSales(SalesInterface sales_) external {
}
function create(
uint256 loanExpiration_,
address[3] calldata usrs_,
uint256[7] calldata vals_,
bytes32 fundIndex_
) external returns (bytes32 loan) {
}
function setSecretHashes(
bytes32 loan,
bytes32[4] calldata borrowerSecretHashes,
bytes32[4] calldata lenderSecretHashes,
bytes32[4] calldata arbiterSecretHashes,
bytes calldata borrowerPubKey_,
bytes calldata lenderPubKey_,
bytes calldata arbiterPubKey_
) external returns (bool) {
}
function fund(bytes32 loan) external {
}
function approve(bytes32 loan) external {
}
function withdraw(bytes32 loan, bytes32 secretA1) external {
require(!off(loan));
require(bools[loan].funded == true);
require(bools[loan].approved == true);
require(<FILL_ME>)
require(sha256(abi.encodePacked(secretA1)) == secretHashes[loan].secretHashA1);
require(token.transfer(loans[loan].borrower, principal(loan)));
bools[loan].withdrawn = true;
secretHashes[loan].withdrawSecret = secretA1;
}
function repay(bytes32 loan, uint256 amount) external {
}
function refund(bytes32 loan) external {
}
function cancel(bytes32 loan, bytes32 secret) external {
}
function accept(bytes32 loan, bytes32 secret) public {
}
function liquidate(bytes32 loan, bytes32 secretHash, bytes20 pubKeyHash) external returns (bytes32 sale_) {
}
}
| bools[loan].withdrawn==false | 311,961 | bools[loan].withdrawn==false |
null | pragma solidity ^0.5.8;
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 value) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal {
}
function _burn(address account, uint256 value) internal {
}
function _approve(address owner, address spender, uint256 value) internal {
}
function _burnFrom(address account, uint256 amount) internal {
}
}
interface FundsInterface {
function lender(bytes32) external view returns (address);
function custom(bytes32) external view returns (bool);
function deposit(bytes32, uint256) external;
function decreaseTotalBorrow(uint256) external;
function calcGlobalInterest() external;
}
interface SalesInterface {
function saleIndexByLoan(bytes32, uint256) external returns(bytes32);
function settlementExpiration(bytes32) external view returns (uint256);
function accepted(bytes32) external view returns (bool);
function next(bytes32) external view returns (uint256);
function create(bytes32, address, address, address, address, bytes32, bytes32, bytes32, bytes32, bytes20) external returns(bytes32);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
function div(uint a, uint b) internal pure returns (uint c) {
}
function min(uint x, uint y) internal pure returns (uint z) {
}
function max(uint x, uint y) internal pure returns (uint z) {
}
function imin(int x, int y) internal pure returns (int z) {
}
function imax(int x, int y) internal pure returns (int z) {
}
uint constant COL = 10 ** 8;
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function cmul(uint x, uint y) public pure returns (uint z) {
}
function wmul(uint x, uint y) internal pure returns (uint z) {
}
function rmul(uint x, uint y) internal pure returns (uint z) {
}
function cdiv(uint x, uint y) internal pure returns (uint z) {
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
}
function rpow(uint x, uint n) internal pure returns (uint z) {
}
}
contract Medianizer {
function peek() public view returns (bytes32, bool);
function read() public returns (bytes32);
function poke() public;
function poke(bytes32) public;
function fund (uint256 amount, ERC20 token) public;
}
contract Loans is DSMath {
FundsInterface funds;
Medianizer med;
SalesInterface sales;
uint256 public constant APPROVE_EXP_THRESHOLD = 2 hours;
uint256 public constant ACCEPT_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_EXP_THRESHOLD = 7 days;
uint256 public constant SEIZURE_EXP_THRESHOLD = 2 days;
uint256 public constant LIQUIDATION_DISCOUNT = 930000000000000000;
mapping (bytes32 => Loan) public loans;
mapping (bytes32 => PubKeys) public pubKeys;
mapping (bytes32 => SecretHashes) public secretHashes;
mapping (bytes32 => Bools) public bools;
mapping (bytes32 => bytes32) public fundIndex;
mapping (bytes32 => ERC20) public tokes;
mapping (bytes32 => uint256) public repayments;
uint256 public loanIndex;
mapping (address => bytes32[]) public borrowerLoans;
mapping (address => bytes32[]) public lenderLoans;
ERC20 public token;
uint256 public decimals;
address deployer;
struct Loan {
address borrower;
address lender;
address arbiter;
uint256 createdAt;
uint256 loanExpiration;
uint256 requestTimestamp;
uint256 closedTimestamp;
uint256 principal;
uint256 interest;
uint256 penalty;
uint256 fee;
uint256 collateral;
uint256 liquidationRatio;
}
struct PubKeys {
bytes borrowerPubKey;
bytes lenderPubKey;
bytes arbiterPubKey;
}
struct SecretHashes {
bytes32 secretHashA1;
bytes32[3] secretHashAs;
bytes32 secretHashB1;
bytes32[3] secretHashBs;
bytes32 secretHashC1;
bytes32[3] secretHashCs;
bytes32 withdrawSecret;
bytes32 acceptSecret;
bool set;
}
struct Bools {
bool funded;
bool approved;
bool withdrawn;
bool sale;
bool paid;
bool off;
}
event Create(bytes32 loan);
function borrower(bytes32 loan) public view returns (address) {
}
function lender(bytes32 loan) public view returns (address) {
}
function arbiter(bytes32 loan) public view returns (address) {
}
function approveExpiration(bytes32 loan) public view returns (uint256) {
}
function acceptExpiration(bytes32 loan) public view returns (uint256) {
}
function liquidationExpiration(bytes32 loan) public view returns (uint256) {
}
function seizureExpiration(bytes32 loan) public view returns (uint256) {
}
function principal(bytes32 loan) public view returns (uint256) {
}
function interest(bytes32 loan) public view returns (uint256) {
}
function fee(bytes32 loan) public view returns (uint256) {
}
function penalty(bytes32 loan) public view returns (uint256) {
}
function collateral(bytes32 loan) public view returns (uint256) {
}
function repaid(bytes32 loan) public view returns (uint256) {
}
function liquidationRatio(bytes32 loan) public view returns (uint256) {
}
function owedToLender(bytes32 loan) public view returns (uint256) {
}
function owedForLoan(bytes32 loan) public view returns (uint256) {
}
function owedForLiquidation(bytes32 loan) public view returns (uint256) {
}
function owing(bytes32 loan) public view returns (uint256) {
}
function funded(bytes32 loan) public view returns (bool) {
}
function approved(bytes32 loan) public view returns (bool) {
}
function withdrawn(bytes32 loan) public view returns (bool) {
}
function sale(bytes32 loan) public view returns (bool) {
}
function paid(bytes32 loan) public view returns (bool) {
}
function off(bytes32 loan) public view returns (bool) {
}
function dmul(uint x) public view returns (uint256) {
}
function ddiv(uint x) public view returns (uint256) {
}
function borrowerLoanCount(address borrower_) public view returns (uint256) {
}
function lenderLoanCount(address lender_) public view returns (uint256) {
}
function collateralValue(bytes32 loan) public view returns (uint256) {
}
function minCollateralValue(bytes32 loan) public view returns (uint256) {
}
function discountCollateralValue(bytes32 loan) public view returns (uint256) {
}
function safe(bytes32 loan) public view returns (bool) {
}
constructor (FundsInterface funds_, Medianizer med_, ERC20 token_, uint256 decimals_) public {
}
function setSales(SalesInterface sales_) external {
}
function create(
uint256 loanExpiration_,
address[3] calldata usrs_,
uint256[7] calldata vals_,
bytes32 fundIndex_
) external returns (bytes32 loan) {
}
function setSecretHashes(
bytes32 loan,
bytes32[4] calldata borrowerSecretHashes,
bytes32[4] calldata lenderSecretHashes,
bytes32[4] calldata arbiterSecretHashes,
bytes calldata borrowerPubKey_,
bytes calldata lenderPubKey_,
bytes calldata arbiterPubKey_
) external returns (bool) {
}
function fund(bytes32 loan) external {
}
function approve(bytes32 loan) external {
}
function withdraw(bytes32 loan, bytes32 secretA1) external {
require(!off(loan));
require(bools[loan].funded == true);
require(bools[loan].approved == true);
require(bools[loan].withdrawn == false);
require(<FILL_ME>)
require(token.transfer(loans[loan].borrower, principal(loan)));
bools[loan].withdrawn = true;
secretHashes[loan].withdrawSecret = secretA1;
}
function repay(bytes32 loan, uint256 amount) external {
}
function refund(bytes32 loan) external {
}
function cancel(bytes32 loan, bytes32 secret) external {
}
function accept(bytes32 loan, bytes32 secret) public {
}
function liquidate(bytes32 loan, bytes32 secretHash, bytes20 pubKeyHash) external returns (bytes32 sale_) {
}
}
| sha256(abi.encodePacked(secretA1))==secretHashes[loan].secretHashA1 | 311,961 | sha256(abi.encodePacked(secretA1))==secretHashes[loan].secretHashA1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.