pragma solidity ^0.4.20;
contract Divium {
/*=================================
= MODIFIERS =
=================================*/
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// -> change the PoS difficulty (How many tokens it costs to hold a masternode, in case it gets crazy high later)
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[keccak256(_customerAddress)]);
_;
}
// ensures that the first tokens in the contract will be equally distributed
pragma solidity ^0.4.18;
contract Courses {
struct Instructor {
uint age;
string fName;
string lName;
}
mapping(address => Instructor) instructors;
address[] public instructorAccts;
function setInstructor(address _address, uint _age, string _fName, string _lName) public {
var instructor = instructors[_address];
// var inst=Instructor;
// inst.age=_age;
instructor.age=_age;
instructor.fName=_fName;
instructor.lName=_lName;
instructorAccts.push(_address) -1;
}
function getInstructor() view public returns(address[]) {
return instructorAccts;
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract GamesStore {
mapping (uint=>string) GameList;
function set(uint _id, string _value) public {
GameList[_id] = _value;
}
function get(uint _id) public constant returns (string) {
return GameList[_id];
}
function del(uint _id) public {
delete GameList[_id];
}
pragma solidity ^0.4.19;
import "./libraries/SafeMath.sol";
/**
* @dev
*/
contract HidingNameContract is SafeMath {
event DividendsWithdrawn(address beneficiary, int256 ethValue);
event DividendsReinvested(address beneficiary, uint256 tokenAmount);
event TokensPurchased(address beneficiary, uint256 tokenAmount, uint256 ethValue);
event TokensSold(address beneficiary, uint256 tokenAmount, uint256 ethValue);
// constants for token info
string constant public name = "RANDOM Token";
string constant public symbol = "RANDOM";
uint8 constant public decimals = 18;
// constants for pyramid
uint constant minPurchaseAmount = 0.000001 ether;
uint constant maxPurchaseAmount = 1000000 ether;
uint constant divisor = 20;
uint constant scaleFactor = 0x10000000000000000;
uint constant baseNumber = 37;
uint constant maxBetSizeMultiplier = 12500;
int constant crr_n = 1;
int constant crr_d = 2;
int constant price_coeff = -0x296ABF784A358468C;```
pragma solidity ^0.4.19;
import "./libraries/SafeMath.sol";
/**
* @dev
*/
contract HidingNameContract is SafeMath {
event DividendsWithdrawn(address beneficiary, int256 ethValue);
event DividendsReinvested(address beneficiary, uint256 tokenAmount);
event TokensPurchased(address beneficiary, uint256 tokenAmount, uint256 ethValue);
event TokensSold(address beneficiary, uint256 tokenAmount, uint256 ethValue);
// constants for token info
string constant public name = "RANDOM Token";
string constant public symbol = "RANDOM";
uint8 constant public decimals = 18;
// constants for pyramid
uint constant minPurchaseAmount = 0.000001 ether;
uint constant maxPurchaseAmount = 1000000 ether;
uint constant divisor = 20;
uint constant scaleFactor = 0x10000000000000000;
uint constant baseNumber = 37;
uint constant maxBetSizeMultiplier = 12500;
int constant crr_n = 1;
int constant crr_d = 2;
int constant price_coeff = -0x296ABF784A3584pragma solidity ^0.4.18;
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
}
//Working: Player starts the game by entering their name and a pokemon is selected randomly from the database as users first pokemon and require makes sure that the func is called only once.The player starts with only one pokemon in the begining of the game. Mapping and addressing can be used to track the owenship of the pokemon and number of pokemons the owner has.Player Buys/sells pokefood,poekmon eggs and pokemons.Pokemon feeds on pokefood for evolving and player can buy eggs and hatch them for increasing their pokemon count.
pragma solidity ^0.4.19;
contract PokemonFactory {
struct Pokemon {
string name;
string type;
}
Pokemon[] public pokemons;
function _createPokemon(string _name, uint _dna)pragma solidity ^0.4.18;
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= pragma solidity ^0.4.18;
contract MyToken {
string private tokenName = "My Super Awesome Token";
string private tokenSymbol = "MSAT";
// The number of zeros that your token is divisible by
// With the # of decimals being 2, each of our tokens can be divisible 100 times
uint private tokenDecimals = 2;
uint private supplyOfTokens = 500;
mapping(address => uint) private balances;
mapping (address => mapping (address => uint)) private allowed;
function MyToken() public {
// When the contract is first deployed,
// let the creator have all of the tokens
// for them to distribute
balances[msg.sender] = supplyOfTokens;
}
function name() public constant returns (string) {
return tokenName;
}
function symbol() public constant returns (string) {
return tokenSymbol;
}
function decimals() public constant returns (uint) {
return tokenDecimals;
}
function totalSupply() public view returns (uint) {
return supplyOfTokens;
}
function transfer(adpragma solidity ^0.4.18;
contract MyToken {
string private tokenName = "My Super Awesome Token";
string private tokenSymbol = "MSAT";
// The number of zeros that your token is divisible by
// With the # of decimals being 2, each of our tokens can be divisible 100 times
uint private tokenDecimals = 2;
uint private supplyOfTokens = 500;
mapping(address => uint) private balances;
mapping (address => mapping (address => uint)) private allowed;
function name() public constant returns (string) {
return tokenName;
}
function symbol() public constant returns (string) {
return tokenSymbol;
}
function decimals() public constant returns (uint) {
return tokenDecimals;
}
function totalSupply() public view returns (uint) {
return supplyOfTokens;
}
function transfer(address _to, uint _value) public returns (bool) {
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender] - _value;
balances[_to] = balances[_to] + _value;
pragma solidity ^0.4.17;
/**
* A game where a player tries to guess a number between 1 and 10.
* Operator sets the bet amount which the player must send when making a guess.
* Operator must deposit 8 times the bet amount.
* If player guess, they get all the funds.
* Otherwise, the operator gets the funds.
*/
contract GuessTheNumberGame {
event SecretNumberSubmitted(bytes32 secretNumber);
event GuessSubmitted(address player, uint guess);
event ResultSubmitted(uint result);
event PlayerWins();
event OperatorWins();
enum State {
WAITING_SECRET, WAITING_GUESS, WAITING_RESULT, OPERATOR_WIN, PLAYER_WIN
}
address public operator;
address public player;
State public state;
uint256 public bet;
bytes32 public secretNumber;
uint public guess;
uint public result; // This is not strictly needed: can use state instead
modifier byOperator() {
require(msg.sender == operator);
_;
}
modifier by//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract MusicLibrary {
enum Genre {RAP,POP,ROCK}
struct MusicObject {
uint id;
string title;
string url;
Genre genre;
uint duration;
bool banned;
}
mapping (uint => MusicObject) listOfData;
uint listOfDataLength;
function set(uint _id, string _value, string _url, uint _genre, uint _duration) public {
listOfDataLength++;
Genre selectedGenre = Genre(_genre);
listOfData[_id] = MusicObject(_id, _value, _url, selectedGenre, _duration, false);
}
function getGenre(uint _id) public constant returns (string) {
if (uint(listOfData[_id].genre) == 0) {
return "RAP";
}
if (uint(listOfData[_id].genre) == 1) {
return "POP";
} else {
return "ROCK";
}
}
function setBanned(uint _id) public {
listOfData[_id].banned = true;
}
function get(uint _id) public constant returns (string) {//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract MusicLibrary {
enum Genre {RAP,POP,ROCK}
struct MusicObject {
uint id;
string title;
string url;
Genre genre;
uint duration;
bool banned;
}
mapping (uint => MusicObject) listOfData;
uint listOfDataLength;
function set(uint _id, string _value, string _url, uint _genre, uint _duration) public {
listOfDataLength++;
Genre selectedGenre = Genre(_genre);
listOfData[_id] = MusicObject(_id, _value, _url, selectedGenre, _duration, false);
}
function getGenre(uint _id) public constant returns (uint) {
return uint(listOfData[_id].genre);
}
function setBanned(uint _id) public {
listOfData[_id].banned = true;
}
function get(uint _id) public constant returns (string) {
return listOfData[_id].title;
}
function getOnTripStatus(uint _id) public constant returns (bool) {
return listOfData[_id].banned;
}//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleTrips {
struct TripObject {
uint id;
string title;
uint distance;
bool onTrip;
}
mapping (uint => TripObject) listOfData;
uint listOfDataLength;
function set(uint _id, string _value, uint _distance) public {
listOfDataLength++;
listOfData[_id] = TripObject(_id, _value, _distance, false);
}
function setOnTrip(uint _id) public {
listOfData[_id].onTrip = true;
}
function get(uint _id) public constant returns (string) {
return listOfData[_id].title;
}
function getOnTripStatus(uint _id) public constant returns (bool) {
return listOfData[_id].onTrip;
}
function remove(uint _id) public {
delete listOfData[_id];
}
function showOnTrip(uint _id) public constant returns (string) {
if (listOfData[_id].onTrip == true) {
return "Уже в пути";
} else {
return "Едем"//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
struct NewsFeed {
uint id;
string title;
bool readable;
}
// 1. Создать структуру данных под сущность из реального мира
mapping (uint => NewsFeed) listOfData;
uint listOfDataLength;
// Связать функции добавления/удаления/чтения с этой структурой
function set(uint _id, string _value) public {
listOfDataLength++;
listOfData[_id] = NewsFeed(_id, _value, false);
}
function setPublic(uint _id) public {
listOfData[_id].readable = true;
}
function get(uint _id) public constant returns (string) {
return listOfData[_id].title;
}
function getReadable(uint _id) public constant returns (bool) {
return listOfData[_id].readable;
}
function remove(uint _id) public {
delete listOfData[_id];
}
// Создаpragma solidity ^0.4.22;
contract TryNewFeatureContract {
function TryNewFeatureContract() public { // for ~0.4.21
// constructor() public {
// constructorは function なしのconstructorという名前で定義するようになった。
}
function constructor() public pure returns(string) {
// function 識別子をつけた場合はただの関数なので注意。
return string(normalFuctionMessage());
}
function normalFuctionMessage() internal pure returns(bytes) {
bytes memory message = "This is normal 0.4.21..";
return message;
}
function oneIsError(uint _num) returns(uint, string) {
require(_num != 1, "hogehoge");
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.21;
import "github.com/OpenZeppelin/zeppelin-solidity/contracts/math/SafeMath.sol";
contract Assignment2 {
// 기존 버전은 Transaction 단위 없이 ( 입금, 출금 ) 잔액 정보만 존재했음,
// 이를 struct 를 사용하여 deposit_id, 시간, deposit 양, 상태(deposit, return) 정보를 함께 하나의 단위로 저장
// 각 유저는 여러번 deposit 하여 여러 deposit_id 를 가질 수 있고, 각 단위에 대해 deposit_id 를 통해 claim 할 수 있도록 구현
using SafeMath for uint256;
// 원장
struct Ledger {
address deposit_id;
uint time; // time of start burrow
uint256 deposit_amount;
string status;
}
Ledger[] ledgerList;
event Logging(Ledger);
// id별 입금 처리
function() public payable {
// 전송한 ETH(Wei) 양이 0 보다 커야 하는 조건
require(msg.value > 0);
// 원장목록에 존재하는 id면 deposit 양에 받은 값을 pragma solidity ^0.4.21;
import "github.com/OpenZeppelin/zeppelin-solidity/contracts/math/SafeMath.sol";
contract Assignment2 {
// 기존 버전은 Transaction 단위 없이 ( 입금, 출금 ) 잔액 정보만 존재했음,
// 이를 struct 를 사용하여 deposit_id, 시간, deposit 양, 상태(deposit, return) 정보를 함께 하나의 단위로 저장
// 각 유저는 여러번 deposit 하여 여러 deposit_id 를 가질 수 있고, 각 단위에 대해 deposit_id 를 통해 claim 할 수 있도록 구현
using SafeMath for uint256;
// 원장
struct Ledger {
address deposit_id;
uint time; // time of start burrow
uint256 deposit_amount;
string status;
}
Ledger[] ledgerList;
event Logging(Ledger);
// id별 입금 처리
function() public payable {
// 전송한 ETH(Wei) 양이 0 보다 커야 하는 조건
require(msg.value > 0);
// 원장목록에 존재하는 id면 deposit 양에 받은 값을 pragma solidity ^0.4.21;
// File: node_modules/zeppelin-solidity/contracts/math/SafeMath.sol
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
*pragma solidity ^0.4.21;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uintpragma solidity ^0.4.21;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uintpragma solidity ^0.4.21;
import "github.com/OpenZeppelin/zeppelin-solidity/contracts/math/SafeMath.sol";
contract Accounts {
using SafeMath for uint256;
event Logging(address sender, uint _timestamp, uint _amount, bool _state);
event checkBalance(uint bal);
struct account {
mapping(uint => Book[]) books;
}
struct Book {
uint timestamp;
uint amount;
bool state;
}
mapping (address => account) accounts;
function readBook(uint _deposit_id, uint _index) public {
Book storage _books = accounts[msg.sender].books[_deposit_id][_index];
uint book_timestamp = _books.timestamp;
uint book_amount = _books.amount;
bool book_state = _books.state;
emit Logging(msg.sender, book_timestamp, book_amount, book_state);
}
function deposit(uint _deposit_id) public payable {
require(msg.value > 0);
accounts[msg.sender].books[_deposit_id].push(Book(now, msg.value,
pragma solidity ^0.4.21;
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @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);
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);
pragma solidity ^0.4.21;
import "./ERC20Basic.sol";
/**
* @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);
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);
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
import "github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/ERC20/ERC20Basic.sol";
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.21;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.21;
contract Deposit {
struct sDepositInfo
{
uint256 deposit_id;
uint256 deposit;
}
sDepositInfo[] depositArray;
mapping(address => uint256) balances;
function() public payable
{
require( msg.value > 0);
balances[msg.sender] += msg.value;
depositArray.push(sDepositInfo(depositArray.length,msg.value));
}
function myBalance() public view returns(uint256)
{
return balances[msg.sender];
}
function totalDepositAmount() public view returns(uint256)
{
return address(this).balance;
}
function claim(uint256 _deposit_id) public
{
require(_deposit_id <= depositArray.length - 1 &&
_deposit_id == depositArray[_deposit_id].deposit_id &&
depositArray[_deposit_id].deposit > 0 &&
balances[msg.sender] >= depositArray[_deposit_id].deposit );
uint256 _deposit = depositArray[_deposit_id].deposit;
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.21;
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint25//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
pragma solidity ^0.4.18;
contract SimpleTest {
uint8[4] constant tiers = [0, 2 * 1 ether, 20 * 1 ether, 200 * 1 ether, 2000 * 1 ether];
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value * 2;
}
uint value;
function addText(string _text) public {
text = _text;
}
function getText() public constant returns (string) {
return text;
}
function changeText(string _text) public {
text = _text;
}
string text;
pragma solidity ^0.4.19;
/*
TODO:
- нужно обновлять fundsWallet, когда мы обновляем owner в контракте Ownable
- NonPayloadAttackable проверить, на какие функции должна назначаться эта проверка
- добавить удаление реферрала из списка соответствий аффилиатам
- удалить лишние переменные
NOTE:
- реферральная программа работает на стороне веба. приглашенные инвесторы добавляются админом вручную
- сроки сейла не в нормальном времени, а в блоках потому, что так безопасней
- перед продажей не обязательно выпускать токен. можно его выпустить в начале сейла.
- удаление адреса из массива. это дорого? може//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.17;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
// Contract address: 0xf27e34c2b0acc3edd0559a9c3c21a884176a32c2
// Contract name: COVERCOINToken
// Etherscan link: https://etherscan.io/address/0xf27e34c2b0acc3edd0559a9c3c21a884176a32c2#code
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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(cpragma solidity ^0.4.11;
// Интерфейс токена
interface ChangableToken {
function stop();
function start();
function changebuyPrice(uint buyPrice);
function balanceOf(address user) returns (uint256);
}
// Контракт ДАО
contract DAOContract {
// Переменная для хранения токена
ChangableToken public token;
// Минимальное число голосов
uint8 public minVotes = 1;
// Переменная для предложенного названия
uint public proposalbuyPrice;
// Переменная для хранения состояния голосования
bool public voteActive = false;
// Стукрутра для голосов
struct Votes {
int current;
uint numberOfVotes;
}
// Переменная для структуры голосов
Votes public election;
// Функция инициализации ( принимает адрес ток// Указываем версию для компилятора
pragma solidity ^0.4.11;
// Контракт для установки прав
contract OwnableWithDAO{
// Переменная для хранения владельца контракта
address public owner;
// Переменная для хранения адреса DAO
address public daoContract;
// Конструктор, который при создании инициализирует переменную с владельцем
function OwnableWithDAO() {
owner = msg.sender;
}
// Модификатор для защиты от вызовов не создалетя контракта
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
// Модификатор для защиты от вызовов не со стороны DAO
modifier onlyDAO(){
require(msg.sender == daoContract);
_;
}
// Функция для замены// Указываем версию для компилятора
pragma solidity ^0.4.11;
// Объявляем интерфейс
interface MyFirstERC20ICO {
function transfer(address _receiver, uint256 _amount);
function getbuyPrice() returns (uint);
}
// Объявляем контракт
contract MyFirstSafeICO {
// Объявялем переменную для токена
MyFirstERC20ICO public token;
// Функция инициализации
function MyFirstSafeICO(MyFirstERC20ICO _token){
// Присваиваем токен
token = _token;
}
// Функция для прямой отправки эфиров на контракт
function () payable {
_buy(msg.sender, msg.value);
}
// Вызываемая функция для отправки эфиров на контракт, возвращающая количество купленных токенов
function buy() payable returns (uint){
// Получ//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.22;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function sayHelllo() public view returns (string){
return "hello";
}
function get() public constant returns (uint) {
return value;
}
uint value;
// Указываем версию для компилятора
pragma solidity ^0.4.11;
// Контракт для установки прав
contract OwnableWithDAO{
// Переменная для хранения владельца контракта
address public owner;
// Переменная для хранения адреса DAO
address public daoContract;
// Конструктор, который при создании инициализирует переменную с владельцем
function OwnableWithDAO() {
owner = msg.sender;
}
// Модификатор для защиты от вызовов не создалетя контракта
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
// Модификатор для защиты от вызовов не со стороны DAO
modifier onlyDAO(){
require(msg.sender == daoContract);
_;
}
// Функция для замены// Указываем версию для компилятора
pragma solidity ^0.4.11;
// Контракт для установки прав
contract OwnableWithDAO{
// Переменная для хранения владельца контракта
address public owner;
// Переменная для хранения адреса DAO
address public daoContract;
// Конструктор, который при создании инициализирует переменную с владельцем
function OwnableWithDAO() {
owner = msg.sender;
}
// Модификатор для защиты от вызовов не создалетя контракта
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
// Модификатор для защиты от вызовов не со стороны DAO
modifier onlyDAO(){
require(msg.sender == daoContract);
_;
}
// Функция для замены// Contract address: 0xd899b525844aceaf5908c044729d40298fdb89ff
// Contract name: ELOT
// Etherscan link: https://etherscan.io/address/0xd899b525844aceaf5908c044729d40298fdb89ff#code
pragma solidity ^0.4.18;
library SafeMath {
function add(uint a, uint b)
internal
pure
returns (uint c)
{
c = a + b;
require(c >= a);
}
function sub(uint a, uint b)
internal
pure
returns (uint c)
{
require(b <= a);
c = a - b;
}
function mul(uint a, uint b)
internal
pure
returns (uint c)
{
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b)
internal
pure
returns (uint c)
{
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
function totalSupply() public constant returns (uint);
function pragma solidity ^0.4.21;
library SafeMath {
function sub(uint256 a, uint256 b) public pure returns (uint256) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) public pure returns (uint256) {
uint c = a + b;
require(c >= a);
return c;
}
}
contract DepositTransaction {
using SafeMath for uint256;
mapping (address => Transaction[]) public transactions;
mapping (address => uint256) private balances_;
enum State { Deposited, Returned }
struct Transaction {
uint16 deposit_id;
uint256 amount;
uint64 time;
State state;
}
event Deposited(address who, uint16 deposit_id, uint256 amount);
event Returned(address who, uint16 deposit_id, uint256 amount);
function() public payable {
require(msg.sender != address(0));
require(msg.value > 0);
balances_[msg.sender] = balances_[msg.sender].add(msg.value);
Transaction[] storage tran = transact// Contract address: 0xbf7323ca37ce99fcd03af08f0c5ea203ddda3740
// Contract name: MyAdvancedToken
// Etherscan link: https://etherscan.io/address/0xbf7323ca37ce99fcd03af08f0c5ea203ddda3740#code
pragma solidity ^0.4.16;
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
// Public variables of the token
string public name ;
string public symbol ;
uint8 public decimals = 8;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
map// Contract address: 0xce3ec766d9336907862f3cdeb49129c6f6df4702
// Contract name: WilliamCoin
// Etherscan link: https://etherscan.io/address/0xce3ec766d9336907862f3cdeb49129c6f6df4702#code
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// 'ISB' token contract
//
// Deployed to : 0x116312c3471C2e7C34C52782D0399eBE601f3F30
// Symbol : WILLY
// Name : William 好朋友 Foundation Coin
// Total supply: 1000000000000000000
// Decimals : 10
//
// Enjoy.
//
// (c) by Moritz Neto with BokkyPooBah / Bok Consulting Pty Ltd Au 2017. The MIT Licence.
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c pragma solidity ^0.4.11;
// Thanks to OpenZeppeline & TokenMarket for the awesome Libraries.
contract SafeMathLib {
function safeMul(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
uint public totalSupply;
function balanceOf(address wh// Contract address: 0xca6e1c4bce9f720e15c72d81d280734086fd7bd4
// Contract name: ArinToken
// Etherscan link: https://etherscan.io/address/0xca6e1c4bce9f720e15c72d81d280734086fd7bd4#code
pragma solidity ^0.4.18;
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOpragma solidity ^0.4.21;
import "../../node_modules/zeppelin-solidity/contracts/token/ERC20/ERC20.sol";
import "../../node_modules/zeppelin-solidity/contracts/ownership/Ownable.sol";
import "../webshop/Webshop.sol";
contract Escrow is Ownable {
enum PaymentStatus { Pending, Completed, Refunded }
event PaymentCreation(uint indexed orderId, address indexed customer, uint value);
event PaymentCompletion(uint indexed orderId, address indexed customer, uint value, PaymentStatus status);
struct Payment {
address customer;
uint value;
PaymentStatus status;
bool refundApproved;
}
mapping (uint => Payment) public payments;
ERC20 public currency;
address public collectionAddress;
Webshop public webshop;
function Escrow(ERC20 _currency, address _collectionAddress) public {
currency = _currency;
collectionAddress = _collectionAddress;
webshop = Webshop(msg.sender);
}
function createPayment(uint _orderId, address// Указываем версию для компилятора
pragma solidity ^0.4.11;
// Инициализация контракта
contract SimpleDAO {
// Объявляем переменную в которой будет название токена
string public name;
// Объявляем переменную в которой будет символ токена
string public symbol;
// Объявляем переменную в которой будет число нулей токена
uint8 public decimals;
// Объявляем переменную в которой будет храниться общее число токенов
uint256 public totalSupply;
// Объявляем маппинг для хранения балансов пользователей
mapping (address => uint256) public balanceOf;
// Объявляем маппинг для хранения одобренных транзакций
mapping (address => mappi//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
// Создать список данных
mapping (uint => string) listOfData;
// Создать функцию добавления данных в список
function set(uint _id, string _value) public {
listOfData[_id] = _value;
}
// Создать функцию чтения данных из списка
function get(uint _id) public constant returns (string) {
return listOfData[_id];
}
// Создать функцию удаления данных из списка
function remove(uint _id) public {
//listOfData[_id] = "";
delete listOfData[_id];
}
uint value;
}
contract A {
uint[] public amounts; // [1, 2, 3]
function init(uint[] _amounts) {
amounts = _amounts;
}
}
contract Factory {
struct AData {
uint[] amounts;
}
mapping (address => AData) listOfData;
function set(uint[] //Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract CrowdFunding {
struct Funder {
address addr;
uint amount;
}
struct Campaign {
address beneficiary;
uint fundingGoal;
uint numFunders;
uint amount;
mapping (uint => Funder) funders;
}
uint numCampaigns;
mapping (uint => Campaign) campaigns;
function newCampaign(address beneficiary, uint goal) public returns (uint campaignID) {
campaignID = numCampaigns++; // campaignID is return variable
campaigns[campaignID] = Campaign(beneficiary, goal, 0, 0);
}
function contribute(uint campaignID) public payable {
Campaign storage c = campaigns[campaignID];
c.funders[c.numFunders++] = Funder({addr: msg.sender, amount: msg.value});
c.amount += msg.value;
}
function checkGoalReached(uint campaignID) public returns (bool reached) {
Campaign storage c = campa// Contract address: 0x8e1537a4f9b55046c3998c42c821780eceed87ac
// Contract name: ADZbuzzCommunityToken
// Etherscan link: https://etherscan.io/address/0x8e1537a4f9b55046c3998c42c821780eceed87ac#code
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// 'ACT221283' token contract
//
// Deployed to : 0x3f70c0B02879c36162C2C902ECfe9Ac0a8a8a187
// Symbol : ACT221283
// Name : ADZbuzz Cupofjo.com Community Token
// Total supply: 2000000
// Decimals : 8
//
// Enjoy.
//
// (c) by Moritz Neto with BokkyPooBah / Bok Consulting Pty Ltd Au 2017. The MIT Licence.
// (c) by Darwin Jayme with ADZbuzz Ltd. UK (adzbuzz.com) 2018.
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ---------------------------------------------------pragma solidity ^0.4.18;
contract A {
uint public a = 0;
function f() internal {
a = a * 10 + 1;
g();
}
function g() internal {
a = a * 10 + 2;
}
}
contract B is A {
function f() internal {
a = a * 10 + 3;
super.f();
}
function g() internal {
a = a * 10 + 4;
super.g();
}
}
contract C is B {
function fp() public {
super.f(); // a = 3142
}
function fpB() public {
B.f(); // a = 3142
}
function fpA() public {
A.f(); // a = 142
}
function reset() public {
a = 0;
}
pragma solidity ^0.4.18;
contract A {
uint public a = 0;
function f() public {
a = a * 10 + 1;
}
}
contract B is A {
function f() public {
a = a * 10 + 2;
super.f();
}
}
contract C is A {
function f() public {
a = a * 10 + 3;
super.f();
}
}
contract D is B, C {}
// call D.f(), and a becomes 32pragma solidity ^0.4.18;
contract A {
uint public a = 0;
function f() internal {
a = a * 10 + 1;
g();
}
function g() internal {
a = a * 10 + 2;
}
}
contract B is A {
function f() internal {
a = a * 10 + 3;
super.f();
}
function g() internal {
a = a * 10 + 4;
super.g();
}
}
contract C is B {
function fp() public {
super.f(); // a = 3142
}
function fpB() public {
B.f(); // a = 3142
}
function fpA() public {
A.f(); // a = 142
}
function reset() public {
a = 0;
}
pragma solidity ^0.4.18;
contract A {
uint public a = 0;
function f() internal {
a = a * 10 + 1;
g();
}
function g() internal {
a = a * 10 + 2;
}
}
contract B is A {
function f() internal {
a = a * 10 + 3;
super.f();
}
function g() internal {
a = a * 10 + 4;
super.g();
}
}
contract C is B {
function fp() public {
super.f();
}
function fpA() public {
A.f();
}
function fpB() public {
B.f();
}
function reset() public {
a = 0;
}
pragma solidity ^0.4.18;
contract A {
function f() internal {
g();
}
function g() internal {
}
}
contract B is A {
function f() internal {
super.f();
}
function g() internal {
super.g();
}
}
contract C is B {
function fp() public {
super.f();
}
// Contract address: 0x491c9a23db85623eed455a8efdd6aba9b911c5df
// Contract name: HeroNodeToken
// Etherscan link: https://etherscan.io/address/0x491c9a23db85623eed455a8efdd6aba9b911c5df#code
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20 {
function totalSupply() public view returns (uint256);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
function balpragma solidity^0.4.21;
contract ModifierTests {
event PrintParam(uint8 param);
uint8 public param;
function ModifierTests() public {
param = 0;
}
function functionA() public modifierA returns (address) {
param = 0;
return msg.sender;
}
function functionB() public modifierB {
emit PrintParam(param);
param++;
emit PrintParam(param);
}
modifier modifierA() {
_;
require(msg.sender == address(0x0));
}
modifier modifierB() {
_;
require(param <= 1);
_;
require(param <= 1);
}
// Contract address: 0xbad06500aff375ff2b7f1a6e92d1be08ab44ff6d
// Contract name: Batiktoken
// Etherscan link: https://etherscan.io/address/0xbad06500aff375ff2b7f1a6e92d1be08ab44ff6d#code
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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract hometask{
mapping(address => uint8) User;
function addValue(address wallet, uint8 value) {
User[wallet] = value;
}
function getValue(address wallet) constant returns (uint8) {
return User[wallet];
}
function deleteValue(address wallet) constant returns (uint8) {
//не могу понять,как удалить само значение, а не кошелёк
delete wallet;
return User[wallet];
}
if (id < array.length) {
// do something...
} else {
// do other things
pragma solidity ^0.4.19;
import './SafeMath.sol';
import './DogRacingToken.sol';
/**
* DogRacing Crowdsale
*/
contract DogRacingCrowdsale {
using SafeMath for uint256;
DogRacingToken public token; // Token contract address
uint256 public stage1_start; // Crowdsale timing
uint256 public stage2_start;
uint256 public stage3_start;
uint256 public stage4_start;
uint256 public crowdsale_end;
uint256 public stage1_price; // Prices in token millis / ETH
uint256 public stage2_price;
uint256 public stage3_price;
uint256 public stage4_price;
uint256 public hard_cap_wei; // Crowdsale hard cap in wei
address public owner; // Owner address
uint256 public wei_raised; // Total Wei raised by crowdsale
event TokenPurchase(address buyer, uint256 weiAmount, uint256 tokensAmount);
modifier onlyOwner {
require(owner == msg.sender);
_;
}
modifier withinCrowdsaleTime {
require(now >= stage1_start && now < crowdsale_end);
_;
}
modifier afterCrowdsale {
requ//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ValueContract{
string word;
address owner;
// to avoid double code we add this modifier
modifier onlyOwner(){
require(msg.sender==owner);
//must have _;!!
_;
}
//constractor
function ValueContract(string _word) public{
word=_word;
owner=msg.sender;
}
//seter
function setWord(string _word) public payable{
require(msg.value> 1 ether);
word=_word;
}
//geter
function getWord() public view returns(string ){
return word;
}
// seter for the owner so it wont cost him gas
function setWordForFree(string _word) onlyOwner public{
word=_word;
}
//transfer the ownership only by the owner
function transferOwnership(address _owner) onlyOwner public{
owner=_owner;
}
//fallback fucntion
//fucntion () payable{
//}
// Contract address: 0x57ab031f30599bac9afc532f142c1643a3178874
// Contract name: _0xLitecoinToken
// Etherscan link: https://etherscan.io/address/0x57ab031f30599bac9afc532f142c1643a3178874#code
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// '0xLitecoin Token' contract
// Mineable ERC20 Token using Proof Of Work
//
// Symbol : 0xLTC
// Name : 0xLitecoin Token
// Total supply: 84,000,000.00
// Decimals : 8
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
requi// Contract address: 0x170836bdfbbe668480c311f45e416dd9bde303f4
// Contract name: TwoExRush
// Etherscan link: https://etherscan.io/address/0x170836bdfbbe668480c311f45e416dd9bde303f4#code
pragma solidity ^0.4.18;
/*
TWO EX RUSH!
Receive 2x your deposit only after the contract reaches 10 ETH.
The first to withdraw after the 20 ETH is hit wins, the others are stuck holding the bag.
Anti Whale: If you withdraw() and there is not enough ether in the contract to 2x your deposit,
then the transaction fails. This prevents whales and encourages smaller deposits.
i.e: Deposit 1ETH, withdraw() with 1.8 in the contract and it will fail.
*/
contract TwoExRush {
string constant public name = "TwoExRush";
address owner;
address sender;
uint256 withdrawAmount;
uint256 contractATH;
uint256 contractBalance;
mapping(address => uint256) internal balance;
function TwoExRush() public {
owner = msg.sender;
}
// Require goal to be met before allowi// Contract address: 0x7a5ad48978ea7476c4baa65bfb0e1f566bb21855
// Contract name: TokenLSCKcoin
// Etherscan link: https://etherscan.io/address/0x7a5ad48978ea7476c4baa65bfb0e1f566bb21855#code
pragma solidity ^0.4.21;
interface LSCKcoin{ function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract TokenLSCKcoin {
// Public variables of the token
string public name="LSCKcoin";
string public symbol="LSCK";
uint8 public decimals = 8;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
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(a// Contract address: 0x02439eb051fc9ce20a4e0192cd436cfdc44db52a
// Contract name: MANHATTANPROXYLEXINGTONAVE
// Etherscan link: https://etherscan.io/address/0x02439eb051fc9ce20a4e0192cd436cfdc44db52a#code
pragma solidity ^0.4.4;
// ----------------------------------------------------------------------------------------------
// MANHATTAN:PROXY BY KEVIN ABOSCH ©2018
// LEXINGTON AVENUE (10,000 ERC-20 TOKENS)
// VERIFY SMART CONTRACT ADDRESS WITH LIST AT HTTP://MANHATTANPROXY.COM
// ----------------------------------------------------------------------------------------------
contract Token {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value)// Contract address: 0xf310d06a54eda5d5ae204b0aa9b5e207972d80b9
// Contract name: MicoinToken
// Etherscan link: https://etherscan.io/address/0xf310d06a54eda5d5ae204b0aa9b5e207972d80b9#code
pragma solidity ^0.4.16;
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping // Contract address: 0x9ed8d6cf06342d3498d96cf72daadd7994e5367d
// Contract name: Hypes
// Etherscan link: https://etherscan.io/address/0x9ed8d6cf06342d3498d96cf72daadd7994e5367d#code
pragma solidity ^0.4.18;
contract Hypes {
event NewOne(address owner, uint256 cost, uint256 new_price);
struct Hype {
address owner;
uint256 cost;
}
mapping (uint256 => Hype) public hypes;
mapping (address => string) public msgs;
address public ceoAddress;
uint256 public seatPrice = 2500000000000000;
modifier onlyCEO() { require(msg.sender == ceoAddress); _; }
function Hypes() public {
ceoAddress = msg.sender;
hypes[1] = Hype(msg.sender, 0);
hypes[2] = Hype(msg.sender, 0);
hypes[3] = Hype(msg.sender, 0);
hypes[4] = Hype(msg.sender, 0);
hypes[5] = Hype(msg.sender, 0);
hypes[6] = Hype(msg.sender, 0);
hypes[7] = Hype(msg.sender, 0);
hypes[8] = Hype(msg.sender, 0);
hypes[9] = Hype(msg.sender, 0);
msgs[msg.sender] = "Claim this sp// Contract address: 0x2F9233B57baBCF15bAa3Ce736723FdcCd9617abE
// Contract name: CrowdsaleTokenExt
// Etherscan link: https://etherscan.io/address/0x2F9233B57baBCF15bAa3Ce736723FdcCd9617abE#code
// Created using Token Wizard https://github.com/poanetwork/token-wizard by POA Network
pragma solidity ^0.4.11;
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @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 previo// Contract address: 0x5fdbf531dcda48c6f4b25d8e7a44db2edb98b314
// Contract name: CBCK
// Etherscan link: https://etherscan.io/address/0x5fdbf531dcda48c6f4b25d8e7a44db2edb98b314#code
pragma solidity ^0.4.19;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract CBCK {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
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 v// Contract address: 0xc94aeb51b34ebe0a8be941009b65883fd97ecff0
// Contract name: MANHATTANPROXYBRDWY
// Etherscan link: https://etherscan.io/address/0xc94aeb51b34ebe0a8be941009b65883fd97ecff0#code
pragma solidity ^0.4.4;
// ----------------------------------------------------------------------------------------------
// MANHATTAN:PROXY BY KEVIN ABOSCH ©2018
// BROADWAY (10,000 ERC-20 TOKENS)
// VERIFY SMART CONTRACT ADDRESS WITH LIST AT HTTP://MANHATTANPROXY.COM
// ----------------------------------------------------------------------------------------------
contract Token {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool // Contract address: 0xdb059e944ceb7062f62fc619f168036f3bb998d0
// Contract name: HumanStandardToken
// Etherscan link: https://etherscan.io/address/0xdb059e944ceb7062f62fc619f168036f3bb998d0#code
pragma solidity ^0.4.8;
contract Token{
// token总量，默认会为public变量生成一个getter函数接口，名称为totalSupply().
uint256 public totalSupply;
/// 获取账户_owner拥有token的数量
function balanceOf(address _owner) constant returns (uint256 balance);
//从消息发送者账户中往_to账户转数量为_value的token
function transfer(address _to, uint256 _value) returns (bool success);
//从账户_from中往账户_to转数量为_value的token，与approve方法配合使用
function transferFrom(address _from, address _to, uint256 _value) returns
(bool success);
//消息发送账户设置账户_spender能从发送账户中转出数量为_value的token
function approve(address _spender, uint256 _value) returns (bool succe//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ValueContract {
string word;
address owner;
funtion valueContract(string _word) public {
word = _word;
owner = msg.sender;
}
//The owner and only him can give the ownership on the contract!
function transferOwnership(address _newOwner) public {
require(msg.sender == owner);
owner = _newOwner;
}
function setWordFree(string _word) public {
requires(msg.sender == owner);
word = _word;
}
function setWord(string _word) public payable {
require(msg.value == 1 ether);
word = _word;
}
function getWord() public view returns (string) {
return word;
}
pragma solidity 0.4.18;
contract StringBytesPlayground {
// convert a string less than 32 characters long to bytes32
function toBytes32(string _string, uint256 _memoryOffset)
// pure means we are not accessing state nor changing state
pure
public
returns (bytes32)
{
// make sure that the string isn't too long for this function
// will work but will cut off the any characters past the 32nd character
require(bytes(_string).length <= 32);
bytes32 _stringBytes;
// simplest way to convert 32 character long string
assembly {
// load the memory pointer of string with an offset of 32
// 32 passes over non-core data parts of string such as length of text
_stringBytes := mload(add(_string, _memoryOffset))
}
return _stringBytes;
}
// play around with the different data conversions that are happening
// by uncommenting/commenting different returns
function testBytesToChar(bytes32 _data, uint256 _offset)
pure
public
returns (bpragma solidity ^0.4.21;
import "https://github.com/OpenZeppelin/zeppelin-solidity/contracts/token/ERC20/StandardToken.sol";
/**
* @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
* `StandardToken` functions.
*/
contract SimpleToken is StandardToken {
string public constant name = "SimpleToken"; // solium-disable-line uppercase
string public constant symbol = "SIM"; // solium-disable-line uppercase
uint8 public constant decimals = 18; // solium-disable-line uppercase
uint256 public constant INITIAL_SUPPLY = 10000 * (10 ** uint256(decimals));
/**
* @dev Constructor that gives msg.sender all of existing tokens.
*/
function SimpleToken() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
pragma solidity 0.4.18;
contract StringBytesPlayground {
// convert a string less than 32 characters long to bytes32
function toBytes32(string _string, uint256 _memoryOffset)
// pure means we are not accessing state nor changing state
pure
public
returns (bytes32)
{
// make sure that the string isn't too long for this function
// will work but will cut off the any characters past the 32nd character
require(bytes(_string).length <= 32);
bytes32 _stringBytes;
// simplest way to convert 32 character long string
assembly {
// load the memory pointer of string with an offset of 32
// 32 passes over non-core data parts of string such as length of text
_stringBytes := mload(add(_string, _memoryOffset))
}
return _stringBytes;
}
// take bytes32 and return a string
function toShortString(bytes32 _data)
pure
public
returns (string)
{
// create new bytes with a length of 32
// needs to be bytes type rather than bytes//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
// Contract address: 0x0bf0872390a94c15aaa2865a2f9d8dec90b0af6c
// Contract name: Eurovision
// Etherscan link: https://etherscan.io/address/0x0bf0872390a94c15aaa2865a2f9d8dec90b0af6c#code
pragma solidity ^0.4.19;
// <ORACLIZE_API>
/*
Copyright (c) 2015-2016 Oraclize SRL
Copyright (c) 2016 Oraclize LTD
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIEpragma solidity ^0.4.21;
contract Deposit {
using SafeMath for uint256;
uint depositId = 1;
enum DepositStatus { RETURN, DEPOSIT }
event Logging(uint);
struct DepositTx {
uint deposit_id;
uint deposit_time;
uint deposit_amount;
address deposit_sender;
DepositStatus deposit_state;
}
mapping (uint => DepositTx) public deposits;
mapping (address => uint256) balances;
function() public payable {
require(msg.value > 0);
balances[msg.sender] = balances[msg.sender].add(msg.value);
uint currentId = depositId++;
DepositTx memory depositTx = DepositTx({
deposit_id: currentId,
deposit_time: uint(now),
deposit_amount: msg.value,
deposit_sender: msg.sender,
deposit_state: DepositStatus.DEPOSIT
});
deposits[currentId] = depositTx;
emit Logging(currentId);
}
function myBalance() public view returns(uint256)// Contract address: 0x776b9d69519fc786e103e39f1576df88b66b93ee
// Contract name: CryptonewsIndonesia
// Etherscan link: https://etherscan.io/address/0x776b9d69519fc786e103e39f1576df88b66b93ee#code
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
functi//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract SimpleStore {
function set(uint _value) public {
value = _value;
}
function get() public constant returns (uint) {
return value;
}
uint value;
}pragma solidity ^0.4.18;
/**
* @dev SafeMath by openzepplin
*/
contract SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ERC721 {
function ownerOf(uint256) public returns (address);
}
contract ComposableAssetFactory {
// which asset owns which other assets at which address
mapping(uint256 => mapping(address => uint256)) children;
// which address owns which tokens
mapping(uint256 => address) owners;
modifier onlyOwner(uint256 _tokenID) {
require(msg.sender == owners[_tokenID]);
_;
}
function registerOwner(uint256 _tokenID, address _contract) public returns (bool) {
require(owners[_tokenID] == address(0));
ERC721 erc721 = ERC721(_contract);
address owner = erc721.ownerOf(_tokenID);
assert(owner == msg.sender);
owners[_tokenID] = msg.sender;
return true;
}
// change owner of a token
function changeOwner(address _newOwner, uint256 _tokenID) onlyOwner(_tokenID) public returns (bool) {
owners[_tokenID] = _newOwner;
return true;
}
///Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ERC721 {
function ownerOf(uint256) public returns (address);
}
contract ComposableAssetFactory {
// which asset owns which other assets at which address
mapping(uint256 => mapping(address => uint256)) children;
// which address owns which tokens
mapping(uint256 => address) owners;
modifier onlyOwner(uint256 _tokenID) {
require(msg.sender == owners[_tokenID]);
_;
}
function registerOwner(uint256 _tokenID, address _contract) public returns (bool) {
require(owners[_tokenID] == address(0));
ERC721 erc721 = ERC721(_contract);
address owner = erc721.ownerOf(_tokenID);
assert(owner == msg.sender);
owners[_tokenID] = msg.sender;
return true;
}
// change owner of a token
function changeOwner(address _newOwner, uint256 _tokenID) onlyOwner(_tokenID) public returns (bool) {
owners[_tokenID] = _newOwner;
return true;
}
///Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ERC721 {
function ownerOf(uint256) public returns (address);
}
contract ComposableAssetFactory {
// which asset owns which other assets at which address
mapping(uint256 => mapping(address => uint256)) children;
// which address owns which tokens
mapping(uint256 => address) owners;
modifier onlyOwner(uint256 _tokenID) {
require(msg.sender == owners[_tokenID]);
_;
}
function registerOwner(uint256 _tokenID, address _contract) public returns (bool) {
require(owners[_tokenID] == address(0));
ERC721 erc721 = ERC721(_contract);
address owner = erc721.ownerOf(_tokenID);
assert(owner == msg.sender);
owners[_tokenID] = msg.sender;
return true;
}
// change owner of a token
function changeOwner(address _newOwner, uint256 _tokenID) onlyOwner(_tokenID) public returns (bool) {
owners[_tokenID] = _newOwner;
return true;
}
///Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ERC721 {
function ownerOf(uint256) public returns (address);
}
contract ComposableAssetFactory {
// which asset owns which other assets at which address
mapping(uint256 => mapping(address => uint256)) children;
// which address owns which tokens
mapping(uint256 => address) owners;
modifier onlyOwner(uint256 _tokenID) {
require(msg.sender == owners[_tokenID]);
_;
}
function registerOwner(uint256 _tokenID, address _contract) public returns (bool) {
require(owners[_tokenID] == address(0));
ERC721 erc721 = ERC721(_contract);
address owner = erc721.ownerOf(_tokenID);
assert(owner == msg.sender);
owners[_tokenID] = msg.sender;
return true;
}
// change owner of a token
function changeOwner(address _newOwner, uint256 _tokenID) onlyOwner public returns (bool) {
owners[_tokenID] = _newOwner;
return true;
}
// add chil//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ERC721 {
function ownerOf(uint256) public returns (address);
}
contract ComposableAssetFactory {
// which asset owns which other assets at which address
mapping(uint256 => mapping(address => uint256)) children;
// which address owns which tokens
mapping(uint256 => address) owners;
function registerOwner(uint256 _tokenID, address _contract) public returns (bool) {
require(owners[_tokenID] == address(0));
ERC721 erc721 = ERC721(_contract);
address owner = erc721.ownerOf(_tokenID);
assert(owner == msg.sender);
owners[_tokenID] = msg.sender;
return true;
}
// change owner of a token
function changeOwner(address _newOwner, uint256 _tokenID) public returns (bool) {
require(owners[_tokenID] == msg.sender);
owners[_tokenID] = _newOwner;
return true;
}
// add child to a composable asset
function addChild(uint256 _tokenID, //Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract ERC721 {
function ownerOf(uint256) public returns (address);
}
contract ComposableAssetFactory {
// which asset owns which other assets at which address
mapping(uint256 => mapping(address => uint256)) children;
// which address owns which tokens
mapping(uint256 => address) owners;
function registerOwner(uint256 _tokenID, address _contract) public {
require(owners[_tokenID] == address(0));
ERC721 erc721 = ERC721(_contract);
address owner = erc721.ownerOf(_tokenID);
assert(owner == msg.sender);
owners[_tokenID] = msg.sender;
}
// change owner of a token
function changeOwner(address _newOwner, uint256 _tokenID) public {
require(owners[_tokenID] == msg.sender);
owners[_tokenID] = _newOwner;
}
// add child to a composable asset
function addChild(uint256 _tokenID, address _childContract, uint256 _indexOrAmount) public {
repragma solidity ^0.4.21;
contract PredictTheBlockHashChallenge {
address guesser;
bytes32 guess;
uint256 settlementBlockNumber;
function PredictTheBlockHashChallenge() public payable {
require(msg.value == 1 ether);
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function lockInGuess(bytes32 hash) public payable {
require(guesser == 0);
require(msg.value == 1 ether);
guesser = msg.sender;
guess = hash;
settlementBlockNumber = block.number + 1;
}
function settle() public {
require(msg.sender == guesser);
require(block.number > settlementBlockNumber);
bytes32 answer = block.blockhash(settlementBlockNumber);
guesser = 0;
if (guess == answer) {
msg.sender.transfer(2 ether);
}
}
pragma solidity ^0.4.21;
contract PredictTheFutureChallenge {
address guesser;
uint8 guess;
uint256 settlementBlockNumber;
function PredictTheFutureChallenge() public payable {
require(msg.value == 1 ether);
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function lockInGuess(uint8 n) public payable {
require(guesser == 0);
require(msg.value == 1 ether);
guesser = msg.sender;
guess = n;
settlementBlockNumber = block.number + 1;
}
function settle() public {
require(msg.sender == guesser);
require(block.number > settlementBlockNumber);
uint8 answer = uint8(keccak256(block.blockhash(block.number - 1), now)) % 10;
guesser = 0;
if (guess == answer) {
msg.sender.transfer(2 ether);
}
}
pragma solidity ^0.4.21;
contract GuessTheNewNumberChallenge {
function GuessTheNewNumberChallenge() public payable {
require(msg.value == 1 ether);
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function guess(uint8 n) public payable {
require(msg.value == 1 ether);
uint8 answer = uint8(keccak256(block.blockhash(block.number - 1), now));
if (n == answer) {
msg.sender.transfer(2 ether);
}
}
}pragma solidity ^0.4.21;
contract GuessTheRandomNumberChallenge {
uint8 answer;
function GuessTheRandomNumberChallenge() public payable {
require(msg.value == 1 ether);
answer = uint8(keccak256(block.blockhash(block.number - 1), now));
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function guess(uint8 n) public payable {
require(msg.value == 1 ether);
if (n == answer) {
msg.sender.transfer(2 ether);
}
}
pragma solidity ^0.4.21;
contract GuessTheSecretNumberChallenge {
bytes32 answerHash = 0xdb81b4d58595fbbbb592d3661a34cdca14d7ab379441400cbfa1b78bc447c365;
function GuessTheSecretNumberChallenge() public payable {
require(msg.value == 1 ether);
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function guess(uint8 n) public payable {
require(msg.value == 1 ether);
if (keccak256(n) == answerHash) {
msg.sender.transfer(2 ether);
}
}
}
contract GuessTheSecretNumberSolver {
bytes32 answerHash = 0xdb81b4d58595fbbbb592d3661a34cdca14d7ab379441400cbfa1b78bc447c365;
function guess() public view returns(uint8) {
for (uint8 i = 0; i < 2 ** 8; i++) {
if (keccak256(i) == answerHash) {
break;
}
}
return i;
}
function keccak256Uint(uint n) public pure returns(bytes32) {
return keccak256(n);
}
pragma solidity ^0.4.21;
contract GuessTheNumberChallenge {
uint8 answer = 42;
function GuessTheNumberChallenge() public payable {
require(msg.value == 1 ether);
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function guess(uint8 n) public payable {
require(msg.value == 1 ether);
if (n == answer) {
msg.sender.transfer(2 ether);
}
}
// Contract address: 0x5510f1996e210659e135b05d6bf48d6682af23a7
// Contract name: EthereumPrivate
// Etherscan link: https://etherscan.io/address/0x5510f1996e210659e135b05d6bf48d6682af23a7#code
pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract EthereumPrivate {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 8;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
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(addresspragma solidity ^0.4.21;
contract CrowdFunding {
// 投資家
struct Investor {
address addr; // 投資家のアドレス
uint amount; // 投資額
}
// 投資家管理用のマップ（だけど、uintをkeyに持つと配列っぽくつかえる）
// publicのため、getterが自動生成
// cf.investors(0)[1] で投資額にアクセスできる
mapping (uint => Investor) public investors;
address public owner; // コントラクトのオーナー
uint public numInvestors; // 投資家の数（カウンタ）
uint public deadline; // 締切（UnixTime）
string public status; // キャンペーンのステータス
bool public ended; // キェンペーンが終了しているか否か
uint public goalAmount; // 投資の目標額
uint public totalAmount; // 投資の総額
// 関数実行アドレスが、コントラクトオーナーがチェック
modifier onlyOwner() {
pragma solidity ^0.4.21;
contract CrowdFunding {
// 投資家
struct Investor {
address addr; // 投資家のアドレス
uint amount; // 投資額
}
// 投資家管理用のマップ（だけど、uintをkeyに持つと配列っぽくつかえる）
// publicのため、getterが自動生成
// cf.investors(0)[1] で投資額にアクセスできる
mapping (uint => Investor) public investors;
address public owner; // コントラクトのオーナー
uint public numInvestors; // 投資家の数（カウンタ）
uint public deadline; // 締切（UnixTime）
string public status; // キャンペーンのステータス
bool public ended; // キェンペーンが終了しているか否か
uint public goalAmount; // 投資の目標額
uint public totalAmount; // 投資の総額
// 関数実行アドレスが、コントラクトオーナーがチェック
modifier onlyOwner() {
pragma solidity ^0.4.18;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
uint256 public totalSupply;
function bal
/*
Dapp名稱 = V-Box
說明🐳 =
可以製造您的V-Box 或向其他的V-Box付款。V-Box可永遠無限次使用，可以設定兩條文字信息(一條必須付款才可觀看)
及可設定 每次收款金額(以finney計算 1finney = 0.001ETH) 及 V_Fans功能。
由於V-Box是用您自己產生的以太錢包製造出來，所以無需擔心 您在本程式內作出的任何交易 都沒有經過任何第三者。
每一個地址只能製造出一個V-Box，如果您的以太錢包地址已經製造過V-Box，當您再用同一地址製造V-Box時
新的內容將會覆蓋舊內容。 但，此一個V-Box的交易記錄將永遠不會被覆蓋。
本程式會記錄您V-Box的總收款次數 及 每個付款的地址 及 每個地址已付的費用 。
每一個向您V-Box付款的以太錢包地址，將會獲得一個名為 V_Fans / V粉 的標記。
成為 V粉 後 這個以太錢包地址 將永
/*
Dapp名稱 = V-Box
說明🐳 =
可以製造您的V-Box 或向其他的V-Box付款。V-Box可永遠無限次使用，可以設定兩條文字信息(一條必須付款才可觀看)
及可設定 每次收款金額(以finney計算 1finney = 0.001ETH) 及 V_Fans功能。
由於V-Box是用您自己產生的以太錢包製造出來，所以無需擔心 您在本程式內作出的任何交易 都沒有經過任何第三者。
每一個地址只能製造出一個V-Box，如果您的以太錢包地址已經製造過V-Box，當您再用同一地址製造V-Box時
新的內容將會覆蓋舊內容。 但，此一個V-Box的交易記錄將永遠不會被覆蓋。
本程式會記錄您V-Box的總收款次數 及 每個付款的地址 及 每個地址已付的費用 。
每一個向您V-Box付款的以太錢包地址，將會獲得一個名為 V_Fans / V粉 的標記。
成為 V粉 後 這個以太錢包地址 將永pragma solidity ^0.4.16;
contract Address {
function Address() public {
}
// fallback関数（匿名・引数・戻り値を持たない）
function () payable public {}
// アドレス（アカウント）が保持するetherを返す
function getBalance(address _thisAddress) view public returns (uint) {
// address(0) はデプロイされるようとしているコントラクトのアドレス
if (_thisAddress == address(0)) {
_thisAddress = this;
}
return _thisAddress.balance;
}
// 相手アドレスにetherを送金
function transfer(address _to, uint _amount) public {
_to.transfer(_amount);
}
// 相手アドレスにetherを送信（失敗時は処理を全てrevertする）
function send(address _to, uint _amount) public {
if (!_to.send(_amount)) {
revert();
}
}
// 相手アドレスにetherをgasを指定し送信pragma solidity ^0.4.16;
contract Address {
function Address() public {
}
// fallback関数（匿名・引数・戻り値を持たない）
function () payable public {}
// アドレス（アカウント）が保持するetherを返す
function getBalance(address _t) view public returns (uint) {
// address(0) はデプロイされるようとしているコントラクトのアドレス
if (_t == address(0)) {
_t = this;
}
return _t.balance;
}
// 相手アドレスにetherを送金
function transfer(address _to, uint _amount) public {
_to.transfer(_amount);
}
// 相手アドレスにetherを送信（失敗時は処理を全てrevertする）
function send(address _to, uint _amount) public {
if (!_to.send(_amount)) {
revert();
}
}
// 相手アドレスにetherをgasを指定し送信（失敗時は処理を全てrevertすpragma solidity ^0.4.21;
contract HelloEthereum {
string public msg1;
string private msg2;
address public owner;
uint8 private counter;
// constructor
function HelloEthereum(string _msg1) public {
msg1 = _msg1;
owner = msg.sender;
counter = 0;
}
// ownerのみがmsg2をセットできるようにする
function setMsg2(string _msg2) public {
if(owner != msg.sender) {
revert();
} else {
msg2 = _msg2;
}
}
function getMsg2() view public returns(string) {
return msg2;
}
function setCounter() public {
for(uint8 i = 0; i < 3; i++) {
counter++;
}
}
function getCounter() view public returns(uint8) {
return counter;
}
// Contract address: 0x1771e600e72cca46abeab857f301b6bf5a032ca7
// Contract name: Mainsale
// Etherscan link: https://etherscan.io/address/0x1771e600e72cca46abeab857f301b6bf5a032ca7#code
pragma solidity 0.4.18;
// File: contracts/ownership/Ownable.sol
/**
* @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 {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOw//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.19;
import "http://github.com/OpenZeppelin/zeppelin-solidity/contracts/math/SafeMath.sol";
contract Deposit {
using SafeMath for uint256;
mapping (address => uint256) balances;
// callback 함수로서 payable 하여 Account가 ETH 를 전송하면 Contract 에 Deposit 하는 함수
function() public payable {
// 전송한 ETH(Wei) 양이 0 보다 커야 하는 조건
require(msg.value > 0);
// payable 을 통해 받은 ETH(Wei) 를 balances 에 저장 ( 각 account 별로 따로 )
balances[msg.sender].add(msg.value);
}
// Doposit 한 Account 가 자신의 Deposit 양을 리턴하는 view 함수
function myBalance() public view returns(uint256) {
return balances[msg.sender];
}
// 모든 Account 가 Deposit 한 총 ETH(Wei)의 양을 리턴하는 view 함수
// this.balance 사용
function totalDepositAmount() public view returns(uint256) {
return this.//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.19;
contract Deposit {
using SafeMath for uint256;
mapping (address => uint256) balances;
// callback 함수로서 payable 하여 Account가 ETH 를 전송하면 Contract 에 Deposit 하는 함수
function() public payable {
// 전송한 ETH(Wei) 양이 0 보다 커야 하는 조건
require(msg.value > 0);
// payable 을 통해 받은 ETH(Wei) 를 balances 에 저장 ( 각 account 별로 따로 )
balance[msg.sender].add(msg.value);
}
// Doposit 한 Account 가 자신의 Deposit 양을 리턴하는 view 함수
function myBalance() public view returns(uint256) {
return balance[msg.sender];
}
// 모든 Account 가 Deposit 한 총 ETH(Wei)의 양을 리턴하는 view 함수
// this.balance 사용
function totalDepositAmount() public view returns(uint256) {
return this.balance;
}
// 해당 함수를 호출한 Account 의 Deposit ETH(Wei)를 모두 다//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Deposit {
using SafeMath for uint256;
mapping (address => uint256) balances;
uint256 public myBalance_;
// callback 함수로서 payable 하여 Account가 ETH 를 전송하면 Contract 에 Deposit 하는 함수
function() public payable {
// 전송한 ETH(Wei) 양이 0 보다 커야 하는 조건
// payable 을 통해 받은 ETH(Wei) 를 balances 에 저장 ( 각 account 별로 따로 )
if(msg.value > 0) {
balances[address] += msg.value;
}
}
// Doposit 한 Account 가 자신의 Deposit 양을 리턴하는 view 함수
function myBalance() public view returns(uint256) {
return balances[address];
}
// 모든 Account 가 Deposit 한 총 ETH(Wei)의 양을 리턴하는 view 함수
// this.balance 사용
function totalDepositAmount() public view returns(uint256) {
return this.balance;
}
// 해당 함수를 호출한 Account 의 Deposit ET//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Deposit {
using SafeMath for uint256;
mapping (address => uint256) balances;
uint256 public myBalance_;
// callback 함수로서 payable 하여 Account가 ETH 를 전송하면 Contract 에 Deposit 하는 함수
function() public payable {
// 전송한 ETH(Wei) 양이 0 보다 커야 하는 조건
// payable 을 통해 받은 ETH(Wei) 를 balances 에 저장 ( 각 account 별로 따로 )
if(msg.value > 0) {
balances[address] += msg.value;
}
}
// Doposit 한 Account 가 자신의 Deposit 양을 리턴하는 view 함수
function myBalance() public view returns(uint256) {
return balances[address];
}
// 모든 Account 가 Deposit 한 총 ETH(Wei)의 양을 리턴하는 view 함수
// this.balance 사용
function totalDepositAmount() public view returns(uint256) {
return this.balance;
}
// 해당 함수를 호출한 Account 의 Deposit ET
/*早晨
Dapp名稱 = V-Box
說明🐳 =
可以製造您的V-Box 或向其他的V-Box付款。V-Box可永遠無限次使用，可以設定兩條文字信息(一條必須付款才可觀看)
及可設定 每次收款金額(以finney計算 1finney = 0.001ETH) 及 V_Fans功能。
由於V-Box是用您自己產生的以太錢包製造出來，所以無需擔心 您在本程式內作出的任何交易 都沒有經過任何第三者。
每一個地址只能製造出一個V-Box，如果您的以太錢包地址已經製造過V-Box，當您再用同一地址製造V-Box時
新的內容將會覆蓋舊內容。 但，此一個V-Box的交易記錄將永遠不會被覆蓋。
本程式會記錄您V-Box的總收款次數 及 每個付款的地址 及 每個地址已付的費用 。
每一個向您V-Box付款的以太錢包地址，將會獲得一個名為 V_Fans / V粉 的標記。
成為 V粉 後 這個以太錢包地址 pragma solidity ^0.4.19;
import "./Dapp-VBox.sol";//收款箱
import "./前台顯示.sol";//引用其他驗證條件
import "./BigBoss.sol"; //我的權限
contract AdminPage is SetBigBoss,SimpleData,ValueBox {
/*
//大大佬才可取錢
function You_Cant_See_Me_He_He__________Just_Big_Boss_I_Need_Get_Money_GoHome_La_886()external JustBigBoss returns (uint,bool){
msg.sender.transfer(this.balance);
return (msg.sender.balance,true);
}
*/
//轉換大大佬
function You_Cant_See_Me_He_He__________Just_Big_Boss_Change_BigBoss_0_0(address NewBigBossAdd)NeedNot0(NewBigBossAdd) public JustBigBoss returns (address,bool){
IAmBigBossHaHa = NewBigBossAdd;
return (NewBigBossAdd,true);
}
//function SetWho_are_we(string WHOUSME,string IptNewVal) JustBigBoss public { Who_are_we[WHOUSME] = IptNewVal; }
function BigBoss_address_is() constant public returns (address) {return IAmBigBossHaHa;}
//顯示BigBoss地址
/****************pragma solidity ^0.4.19;
contract SetNeed {
//地址不能是0
modifier NeedNot0(address _InputAllAdd) {require(_InputAllAdd != 0x0); _;}
//if (newOwner != address(0)) //再聲明多一次為地址比較好? address(0)
//地址不能是自己
modifier CanNotIsMe(address _InputAllAdd) {require(_InputAllAdd != msg.sender); _;}
}
pragma solidity ^0.4.19;
contract SimpleData {
//顯示本合約地址及ETH存儲量
function Help(
address You_can_input_anyone_ETH_address_i_will_display_she_balance
)
public constant returns (
address This_App_Address_Is,
uint256 she_balance_is_finney
) {
return (
this,
(You_can_input_anyone_ETH_address_i_will_display_she_balance.balance / 1.000 finney)
);
}
//string HI ;
//mapping(string => string) Who_are_we ;
// function DisWho_are_we(string WHOUSME) constant public returns (string This_is_we) {return Who_are_we[WHOUSME];}
//是管時會顯示管理員地址
}
pragma solidity ^0.4.19;
/*
//http://me.tryblockchain.org/%E6%94%AF%E4%BB%98%E7%9B%B8%E5%85%B3.html
//https://mshk.top/2017/11/go-ethereum-1-7-2-mist-0-9-2-token/
//https://ethfans.org/posts/the-anatomy-of-erc721
//http://www.tryblockchain.org/Solidity-Type-Address-%E5%9C%B0%E5%9D%80.html
//https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/ERC721/ERC721.sol
//http://www.blockcode.org/archives/204
//https://github.com/dapperlabs/cryptokitties-bounty/blob/master/contracts/ERC721Draft.sol
//https://ethereum.org/token
//https://ethereum.org/crowdsale
//http://www.tryblockchain.org/Solidity-Type-Address-%E5%9C%B0%E5%9D%80.html
//http://me.tryblockchain.org/%E6%94%AF%E4%BB%98%E7%9B%B8%E5%85%B3.html
//https://ethfiddle.com/09YbyJRfiI
//https://mshk.top/2017/11/go-ethereum-1-7-2-mist-0-9-2-token/
import "./SupplyIncome.sol"; //貢獻者回報
import "./SetBigBoss.sol"; //我的權限
import "./SetNeed.sol"; //其他驗證條件
import "./SimpleData.sol"; import "./基本規則.sol";//引用其他驗證條件
pragma solidity ^0.4.19;
contract SetBigBoss is SetNeed{
address internal IAmBigBossHaHa;
//大大佬才可執行
function SetBigBoss() internal { IAmBigBossHaHa = msg.sender; }
modifier JustBigBoss() {assert(msg.sender == IAmBigBossHaHa); _;}
uint internal Price_ValueBox = 3 finney; //使用收款箱的費用 預設= 3 finney
}
/*
Dapp名稱 = V-Box
說明🐳 =
可以製造您的V-Box 或向其他的V-Box付款。V-Box可永遠無限次使用，可以設定兩條文字信息(一條必須付款才可觀看)
及可設定 每次收款金額(以finney計算 1finney = 0.001ETH) 及 V_Fans功能。
由於V-Box是用您自己產生的以太錢包製造出來，所以無需擔心 您在本程式內作出的任何交易 都沒有經過任何第三者。
每一個地址只能製造出一個V-Box，如果您的以太錢包地址已經製造過V-Box，當您再用同一地址製造V-Box時
新的內容將會覆蓋舊內容。 但，此一個V-Box的交易記錄將永遠不會被覆蓋。
本程式會記錄您V-Box的總收款次數 及 每個付款的地址 及 每個地址已付的費用 。
每一個向您V-Box付款的以太錢包地址，將會獲得一個名為 V_Fans / V粉 的標記。
成為 V粉 後 這個以太錢包地址 將永pragma solidity ^0.4.18;
contract CallToTheUnknown {
// Highest bidder becomes the Leader.
// Vulnerable to DoS attack by an attacker contract which reverts all transactions to it.
address currentLeader;
uint highestBid;
function() payable {
require(msg.value > highestBid);
require(currentLeader.send(highestBid)); // Refund the old leader, if it fails then revert
currentLeader = msg.sender;
highestBid = msg.value;
}
}
contract Pwn {
// call become leader
function becomeLeader(address _address, uint bidAmount) {
_address.call.value(bidAmount);
}
// reverts anytime it receives ether, thus cancelling out the change of the leader
function() payable {
revert();
}
// Так делать не нужно :)
// Указываем версию для компилятора
pragma solidity ^0.4.11;
// Инициализация контракта
contract MyFirstERC20Coin {
// Объявляем переменную в которой будет название токена
string public name;
// Объявляем переменную в которой будет символ токена
string public symbol;
// Объявляем переменную в которой будет число нулей токена
uint8 public decimals;
uint public buyPrice1;
uint public buyPrice2;
uint public buyPrice3;
// Объявляем переменную в которой будет храниться общее число токенов
uint256 public totalSupply;
uint public startTime;
// Объявляем маппинг для хранения балансов пользователей
mapping (address => ui//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.19;
contract Deposit {
// using SafeMath for uint256;
mapping (address => uint256) balances;
// callback 함수로서 payable 하여 Account가 ETH 를 전송하면 Contract 에 Deposit 하는 함
function() public payable {
// 전송한 ETH(Wei) 양이 0 보다 커야 하는 조건
require(msg.value > 0);
// payable 을 통해 받은 ETH(Wei) 를 balances 에 저장 ( 각 account 별로 따로 )
balances[msg.sender] += msg.value;
}
// Doposit 한 Account 가 자신의 Deposit 양을 리턴하는 view 함수
function myBalance() public view returns(uint256) {
return balances[msg.sender];
}
// 모든 Account 가 Deposit 한 총 ETH(Wei)의 양을 리턴하는 view 함수
// this.balance 사용
function totalDepositAmount() public view returns(uint256) {
return this.balance;
}
// 해당 함수를 호출한 Account 의 Deposit ETH(Wei)를 모두 다시 // Contract address: 0xe746f3be8c69b05e3ca38760f1eb8c55d24da2c9
// Contract name: AltExtraHolderContract
// Etherscan link: https://etherscan.io/address/0xe746f3be8c69b05e3ca38760f1eb8c55d24da2c9#code
pragma solidity ^0.4.18;
contract TokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public;
}
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
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);
}
/**
* @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);
function transferFrom(address from, address //Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract hometask{
mapping(address => uint8) User;
function addValue(address wallet, uint8 value) {
User[wallet] = value;
}
function getValue(address wallet) constant returns (uint8) {
return User[wallet];
}
function deleteValue(address wallet) constant returns (uint8) {
//не могу понять,как удалить само значение, а не кошелёк
delete wallet;
return User[wallet];
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract hometask{
mapping(uint32 => uint8) User;
function addValue(uint32 wallet, uint8 value) {
User[wallet] = value;
}
function getValue(uint32 wallet) constant returns (uint8) {
return User[wallet];
}
function deleteValue(uint32 wallet) constant returns (uint8) {
//не могу понять,как удалить само значение, а не кошелёк
delete wallet;
return User[wallet];
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract hometask{
mapping(address => userStruct) private userstructs;
function addValue(uint32 wallet, uint8 value) {
User[wallet] += value;
}
function getValue(uint32 wallet) constant returns (uint8) {
return User[wallet];
}
function deleteValue(uint32 wallet) constant returns (uint8) {
//не получается разобраться,как удалить сами данные,а не кошелёк
delete wallet;
return User[wallet];
}
//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract hometask{
mapping(uint32 => uint8) User;
function addValue(uint32 wallet, uint8 value) {
User[wallet] = value;
}
function getValue(uint32 wallet) constant returns (uint8) {
return User[wallet];
}
function deleteValue(uint32 wallet) constant returns (uint8) {
delete wallet;
return User[wallet];
}
// Contract address: 0xe0658fd31924785a15fd270a97072d57baa1cda9
// Contract name: ADZbuzzCommunityToken
// Etherscan link: https://etherscan.io/address/0xe0658fd31924785a15fd270a97072d57baa1cda9#code
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// 'ACT865934' token contract
//
// Deployed to : 0x3f70c0B02879c36162C2C902ECfe9Ac0a8a8a187
// Symbol : ACT865934
// Name : ADZbuzz 500px.com Community Token
// Total supply: 2000000
// Decimals : 8
//
// Enjoy.
//
// (c) by Moritz Neto with BokkyPooBah / Bok Consulting Pty Ltd Au 2017. The MIT Licence.
// (c) by Darwin Jayme with ADZbuzz Ltd. UK (adzbuzz.com) 2018.
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// -----------------------------------------------------//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint25//Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint25// Contract address: 0xe03070d46c30b30cfc792fa3b586f2b71be89ad1
// Contract name: ReleaseToken
// Etherscan link: https://etherscan.io/address/0xe03070d46c30b30cfc792fa3b586f2b71be89ad1#code
pragma solidity ^0.4.21;
interface itoken {
function freezeAccount(address _target, bool _freeze) external;
function freezeAccountPartialy(address _target, uint256 _value) external;
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
function balanceOf(address _owner) external view returns (uint256 balance);
// function transferOwnership(address newOwner) external;
function allowance(address _owner, address _spender) external view returns (uint256);
function frozenAccount(address _account) external view returns (bool);
function frozenAmount(address _account) external view returns (uint256);
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns// Contract address: 0x62c5a9b7f293ac6a0b92dbe7c6cd083e2a309109
// Contract name: AwesomeToken
// Etherscan link: https://etherscan.io/address/0x62c5a9b7f293ac6a0b92dbe7c6cd083e2a309109#code
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// 'Awesome' token contract
//
// Deployed to : 0xC7A42e69AdfFA67C452eE8Ef561910770C44Bf4F
// Symbol : AWS
// Name : Awesome Token
// Total supply: 100000000
// Decimals : 18
//
// Enjoy.
//
// (c) by Moritz Neto with BokkyPooBah / Bok Consulting Pty Ltd Au 2017. The MIT Licence.
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function// Contract address: 0x790284cc4910343fd936277c002791ed620238d9
// Contract name: ProofOfPassiveDividends
// Etherscan link: https://etherscan.io/address/0x790284cc4910343fd936277c002791ed620238d9#code
pragma solidity ^0.4.21;
/*
*
* _______ _______ _______ ______ ___ _______
| | | | | | | | | | | |
| _ | | _ | | _ | | _ | | | | _ |
| |_| | | | | | | |_| | | | | | | | | | | |
| ___| | |_| | | ___| | |_| | ___ | | | |_| |
| | | | | | | | | | | | | |
|___| |_______| |___| |______| |___| |___| |_______|
*
*
* https://www.popd.io/
* Diff check against PoSC https://www.diffchecker.com/T1Ddu35r
* Launching today
* 9:00 pm Eastern time (EST)
* 6:00 PM Pacific Time (PT)
* 2:00 AM Central European Time (CET)
* 1:00 AM Greenwich Mean Time (GMT)
*
* POPD DApp are managed entirel// Contract address: 0x9bab1811967ea13602192c300974d086328b4a9a
// Contract name: TokenERC20
// Etherscan link: https://etherscan.io/address/0x9bab1811967ea13602192c300974d086328b4a9a#code
pragma solidity ^0.4.21;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
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 f// Contract address: 0xc1a0092a662ff7a33411ef0e283f9d8b7fae62ef
// Contract name: ProofOfPassiveDividends
// Etherscan link: https://etherscan.io/address/0xc1a0092a662ff7a33411ef0e283f9d8b7fae62ef#code
pragma solidity ^0.4.21;
contract ProofOfPassiveDividends {
using SafeMath for uint256;
event Deposit(address user, uint amount);
event Withdraw(address user, uint amount);
event Claim(address user, uint dividends);
event Reinvest(address user, uint dividends);
address owner;
mapping(address => bool) preauthorized;
bool gameStarted;
// deposit tax is 14.2%
uint constant depositTaxDivisor = 7;
// deposit tax is 25%
uint constant withdrawalTaxDivisor = 4;
mapping(address => uint) public investment;
mapping(address => uint) public stake;
uint public totalStake;
uint stakeValue;
mapping(address => uint) dividendCredit;
mapping(address => uint) dividendDebit;
function ProofOfPassiveDividends() public {// Contract address: 0x94fa3c10ed686893b2c714b6a7a94ac920b6057a
// Contract name: TokenERC20
// Etherscan link: https://etherscan.io/address/0x94fa3c10ed686893b2c714b6a7a94ac920b6057a#code
pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 8;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
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// Contract address: 0xae68a9a9d2cb999b5392bea198147127bd3a6d33
// Contract name: ITO
// Etherscan link: https://etherscan.io/address/0xae68a9a9d2cb999b5392bea198147127bd3a6d33#code
pragma solidity ^0.4.18;
/**
* @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 {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transf// Contract address: 0xca35885ddc8f0c6aBe561a0E1DACc05A311cFB4e
// Contract name: PreCrowdFunder
// Etherscan link: https://etherscan.io/address/0xca35885ddc8f0c6aBe561a0E1DACc05A311cFB4e#code
//File: contracts/common/Controlled.sol
pragma solidity ^0.4.21;
contract Controlled {
modifier onlyController { require(msg.sender == controller); _; }
address public controller;
function Controlled() public { controller = msg.sender;}
function changeController(address _newController) public onlyController {
controller = _newController;
}
}
//File: contracts/common/TokenController.sol
pragma solidity ^0.4.21;
contract TokenController {
function proxyPayment(address _owner) public payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
function onApprove(address _owner, address _spender, uint _amount) public returns(bool);
}
//File: contracts/common/ApproveAndCallFallBack.sol
pragma solidity ^0.// Contract address: 0x64dd2974a6a042fbad1665f005da970af3be7203
// Contract name: WXBET
// Etherscan link: https://etherscan.io/address/0x64dd2974a6a042fbad1665f005da970af3be7203#code
/*
Copyright 2018 WXBET Foundation LTD
Licensed under the Apache License, Version 2.0 (the "License");
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.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c// Contract address: 0x4fee2d21aaca705b70f86db48fe4b166482f7700
// Contract name: JUST
// Etherscan link: https://etherscan.io/address/0x4fee2d21aaca705b70f86db48fe4b166482f7700#code
pragma solidity ^0.4.20;
// blaze it fgt ^
/*
* Team JUST presents...
,----, ,----,
,---._ ,/ .`| ,/ .`|
.-- -.' \ .--.--. ,` .' : ,` .' : ,-.
| | : ,--, / / '. ; ; / ; ; / ,--/ /|
: ; | ,'_ /|| : /`. /.'___,/ ,' .'___,/ ,' ,---. ,--. :/ | ,---,
: | .--. | | :; | |--` | : | | : | ' ,'\ : : ' / ,-+-. / |
| : :,'_ /| : . || : ;_ ; |.'; //Write your own contracts here. Currently compiles using solc v0.4.15+commit.bbb8e64f.
pragma solidity ^0.4.18;
contract Lockup {
uint256 canBeWithdrawed;
address owner;
function Lockup() public {
owner = msg.sender;
canBeWithdrawed = now + 10 years;
}
function() payable public {}
function withDraw() public {
require(now > canBeWithdrawed);
owner.transfer(address(this).balance);
}
// Contract address: 0x774f04fe52f7f44d94cdd327186062f62ae84ea9
// Contract name: AirDrop
// Etherscan link: https://etherscan.io/address/0x774f04fe52f7f44d94cdd327186062f62ae84ea9#code
// Поздравляем! Это ваш токен по бесплатной раздаче. Подробнее о проекте: https://echarge.io, таблица бонусов и даты ICO
// Мы планируем получать доход от установки и эксплуатации более 50 000 собственных зарядных станций для электромобилей по эксклюзивному контракту, в первую очередь в отелях, офисах и торговых центрах. Поддержка и система оплаты основаны на
// технологии блокчейн, что позволяет владельцу автомобиля использовать свой автомобиль в качестве аккумуля// Contract address: 0x9ed04a9cde3222ffca0ed2e3c9cb3eb1aa4897e2
// Contract name: Circle
// Etherscan link: https://etherscan.io/address/0x9ed04a9cde3222ffca0ed2e3c9cb3eb1aa4897e2#code
pragma solidity ^0.4.18;
// File: contracts/zeppelin/ownership/Ownable.sol
/**
* @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 {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a n// Contract address: 0xB245b7DadB71DBFD62ebCa8f564D30fBFb6c95Da
// Contract name: SafeMathLibExt
// Etherscan link: https://etherscan.io/address/0xB245b7DadB71DBFD62ebCa8f564D30fBFb6c95Da#code
// Created using Token Wizard https://github.com/poanetwork/token-wizard by POA Network
/**
* This smart contract code is Copyright 2017 TokenMarket Ltd. For more information see https://tokenmarket.net
*
* Licensed under the Apache License, version 2.0: https://github.com/TokenMarketNet/ico/blob/master/LICENSE.txt
*/
pragma solidity ^0.4.6;
/**
* Safe unsigned safe math.
*
* https://blog.aragon.one/library-driven-development-in-solidity-2bebcaf88736#.750gwtwli
*
* Originally from https://raw.githubusercontent.com/AragonOne/zeppelin-solidity/master/contracts/SafeMathLib.sol
*
* Maintained here until merged to mainline zeppelin-solidity.
*
*/
library SafeMathLibExt {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return // Contract address: 0xf598aab521dd147074d6e93d69cc0d4446ecb49d
// Contract name: TokenContribution
// Etherscan link: https://etherscan.io/address/0xf598aab521dd147074d6e93d69cc0d4446ecb49d#code
pragma solidity 0.4.19;
/// @dev `Owned` is a base level contract that assigns an `owner` that can be
/// later changed
contract Owned {
/// @dev `owner` is the only address that can call a function with this
/// modifier
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
address public owner;
/// @notice The Constructor assigns the message sender to be `owner`
function Owned() public {
owner = msg.sender;
}
address public newOwner;
/// @notice `owner` can step down and assign some other address to this role
/// @param _newOwner The address of the new owner. 0x0 can be used to create
/// an unowned neutral vault, however that cannot be undone
function changeOwner(address _newOwner) public onlyOw// Contract address: 0x34094acd5d62f0b9a17aeabf3c6992677ed5484b
// Contract name: DNCEQUITY
// Etherscan link: https://etherscan.io/address/0x34094acd5d62f0b9a17aeabf3c6992677ed5484b#code
pragma solidity ^0.4.4;
contract DNCAsset {
uint256 public totalSupply = 0;
//function balanceOf(address who) constant returns (uint);
//function transfer(address _to, uint _value) returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
}
contract DNCReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data);
}
/* SafeMath for checking eror*/
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
r// Contract address: 0x0db847406c33959dd0b30fd6962b60f1f3bfcce7
// Contract name: TwoXMachine
// Etherscan link: https://etherscan.io/address/0x0db847406c33959dd0b30fd6962b60f1f3bfcce7#code
pragma solidity ^0.4.18;
/**
* @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 {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to // Contract address: 0xe8974f5eb57e425be2de1caf25af926dda53217a
// Contract name: Crowdsale
// Etherscan link: https://etherscan.io/address/0xe8974f5eb57e425be2de1caf25af926dda53217a#code
pragma solidity ^0.4.16;
interface token {
function transfer(address receiver, uint amount) public;
}
contract Crowdsale {
address public beneficiary;
uint public price;
bool crowdsaleClosed = false;
token public tokenReward;
mapping(address => uint256) public balanceOf;
event FundTransfer(address backer, uint amount, bool isContribution);
/**
* Constrctor function
*
* Setup the owner
*/
function Crowdsale () public {
beneficiary = 0x3d9285A330A350ae57F466c316716A1Fb4D3773d;
price = 0.002437 * 1 ether;
tokenReward = token(0x6278ae7b2954ba53925EA940165214da30AFa261);
}
/**
* Fallback function
*
* The function without name is the default function that is called whenever anyone sends funds to // Contract address: 0x103f2fb4d3f4b4b7a118d757409d4ef6599c5889
// Contract name: TeamTokensHolder
// Etherscan link: https://etherscan.io/address/0x103f2fb4d3f4b4b7a118d757409d4ef6599c5889#code
pragma solidity 0.4.19;
/// @dev `Owned` is a base level contract that assigns an `owner` that can be
/// later changed
contract Owned {
/// @dev `owner` is the only address that can call a function with this
/// modifier
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
address public owner;
/// @notice The Constructor assigns the message sender to be `owner`
function Owned() public {
owner = msg.sender;
}
address public newOwner;
/// @notice `owner` can step down and assign some other address to this role
/// @param _newOwner The address of the new owner. 0x0 can be used to create
/// an unowned neutral vault, however that cannot be undone
function changeOwner(address _newOwner) public onlyOwner {
// Contract address: 0x7016af56d4a4709a276b25beb879156c6994798b
// Contract name: Presale
// Etherscan link: https://etherscan.io/address/0x7016af56d4a4709a276b25beb879156c6994798b#code
pragma solidity ^0.4.18;
// File: contracts/IPricingStrategy.sol
interface IPricingStrategy {
function isPricingStrategy() public view returns (bool);
/** Calculate the current price for buy in amount. */
function calculateTokenAmount(uint weiAmount, uint tokensSold) public view returns (uint tokenAmount);
}
// File: zeppelin-solidity/contracts/token/ERC20Basic.sol
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
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);
}
// File: zeppelin-solidity/cont// Contract address: 0x518618096f9d9142aefca566aaa821c8b9a86436
// Contract name: FPINCOIN
// Etherscan link: https://etherscan.io/address/0x518618096f9d9142aefca566aaa821c8b9a86436#code
pragma solidity ^0.4.21;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract FPINCOIN {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
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 frpragma solidity ^0.4.8;
// ----------------------------------------------------------------------------------------------
// Sample fixed supply token contract
// Enjoy. (c) BokkyPooBah 2017. The MIT Licence.
// ----------------------------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/issues/20
contract ERC20Interface {
// Get the total token supply
function totalSupply() constant returns ( totalSupply);
// Get the account balance of another account with address _owner
function balanceOf(address _owner) constant returns (uint256 balance);
// Send _value amount of tokens to address _to
function transfer(address _to, uint256 _value) returns (bool success);
// Send _value amount of tokens from address _from to address _to
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
// Allow _spender to withdraw from your account,pragma solidity ^0.4.15;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
/**
* @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;
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @dev Allows the current owner to trans// Contract address: 0x96dcc593d10c57010fb401d1491d46687f846adc
// Contract name: Telegram
// Etherscan link: https://etherscan.io/address/0x96dcc593d10c57010fb401d1491d46687f846adc#code
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// 'Telegram' token contract
//
// Deployed to : 0x2d57365a7ab22425f09D49bB0baFB0426EB8dDF9
// Symbol : GRAM
// Name : Telegram
// Total supply: 100000000
// Decimals : 18
//
// Enjoy.
//
// (c) by Moritz Neto with BokkyPooBah / Bok Consulting Pty Ltd Au 2017. The MIT Licence.
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSu// Contract address: 0xc34a85c8f884e29a92be83eb2948ead5eca09b4f
// Contract name: AirDrop
// Etherscan link: https://etherscan.io/address/0xc34a85c8f884e29a92be83eb2948ead5eca09b4f#code
// Поздравляем! Это ваш токен по бесплатной раздаче. Подробнее о проекте: https://echarge.io, таблица бонусов и даты ICO
// Мы планируем получать доход от установки и эксплуатации более 50 000 собственных зарядных станций для электромобилей по эксклюзивному контракту, в первую очередь в отелях, офисах и торговых центрах. Поддержка и система оплаты основаны на
// технологии блокчейн, что позволяет владельцу автомобиля использовать свой автомобиль в качестве аккумуля// Contract address: 0x7835Da668Ef2f6793AA845bE2F822d5512Da2d3e
// Contract name: MyAdvancedToken
// Etherscan link: https://etherscan.io/address/0x7835Da668Ef2f6793AA845bE2F822d5512Da2d3e#code
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (add// Contract address: 0x259081e129bed7a71e34b519cdc8c30c07674750
// Contract name: MoatFund
// Etherscan link: https://etherscan.io/address/0x259081e129bed7a71e34b519cdc8c30c07674750#code
pragma solidity ^0.4.18;
/**
* @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;
address public secondOwner;
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 {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier bothOwner() {
require(msg.sender == owner || msg.// Contract address: 0x2D50De5411731843c84232fa7eb807bEE7BEFdf4
// Contract name: ICO
// Etherscan link: https://etherscan.io/address/0x2D50De5411731843c84232fa7eb807bEE7BEFdf4#code
pragma solidity 0.4.19;
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // So// Contract address: 0x861fd33a317863187171aafe80bd7a0cc3b89f03
// Contract name: CHENDE
// Etherscan link: https://etherscan.io/address/0x861fd33a317863187171aafe80bd7a0cc3b89f03#code
pragma solidity ^0.4.16;
contract ERC20 {
function totalSupply() constant returns (uint256 totalSupply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract CHENDE is ERC20 {
string public constant symbol = "CHD";
string public constant name = "CHEpragma solidity ^0.4.17;
contract Adoption {
address[16] public adopters;
// Adopting a pet
function adopt(uint petId) public returns (uint) {
require(petId >= 0 && petId <=15);
adopters[petId] = msg.sender;
return petId;
}
// Retriveing the adopters
function getAdopters() public view returns (address[16]) {
return adopters;
}
}pragma solidity ^0.4.18;
contract Will {
address public owner;
address public beneficiary;
uint256 public deathTimeout = 4 weeks;
uint256 public lastSignOfLife;
function Will(address _beneficiary) public{
owner = msg.sender;
beneficiary = _beneficiary;
}
function ImAlive() public {
require(msg.sender == owner);
lastSignOfLife = now;
}
function withdrawUponDeath() public {
require(now > lastSignOfLife + deathTimeout);
beneficiary.transfer(this.balance);
}
function withdrawWhenAlive(uint256 _amount) public {
require(owner == msg.sender);//only owner can do this
msg.sender.transfer(_amount);
}
function () payable public {
}
function getBalance() public view returns(uint256) {
return this.balance;
}
// Contract address: 0xbf2ef56aead8de9e92ef2b9fa0b0b17bd8682e79
// Contract name: NodeHash
// Etherscan link: https://etherscan.io/address/0xbf2ef56aead8de9e92ef2b9fa0b0b17bd8682e79#code
pragma solidity ^0.4.4;
contract Token {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
i// Contract address: 0xafdd6fec9be6e31ad9dd7e28631625ac8e38f9c3
// Contract name: TokenSale
// Etherscan link: https://etherscan.io/address/0xafdd6fec9be6e31ad9dd7e28631625ac8e38f9c3#code
pragma solidity ^0.4.21;
contract EIP20Interface {
uint256 public totalSupply;
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed burner, uint256 value);
}
/**
* Math operations with safety checks
*/
library SafeMat// Contract address: 0xba313f80d9a23fa5eeea4beda94f87b35c74cb04
// Contract name: Arbitrator
// Etherscan link: https://etherscan.io/address/0xba313f80d9a23fa5eeea4beda94f87b35c74cb04#code
pragma solidity ^0.4.18;
contract Owned {
address public owner;
function Owned()
public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner)
onlyOwner
public {
owner = newOwner;
}
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// Contract address: 0xd9e6c755c7eb0d4df3377b56c9c808e4df2bb4a2
// Contract name: GeocashToken
// Etherscan link: https://etherscan.io/address/0xd9e6c755c7eb0d4df3377b56c9c808e4df2bb4a2#code
pragma solidity ^0.4.18;
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
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);
}
/**
* @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// Contract address: 0x18a574f218c28b0a78e0462ecb98efd7fc3f8d02
// Contract name: Crowdsale
// Etherscan link: https://etherscan.io/address/0x18a574f218c28b0a78e0462ecb98efd7fc3f8d02#code
pragma solidity ^0.4.16;
/*
_____ ______ _____ ______
| __ \| ____| __ \| ____|
| |__) | |__ | |__) | |__
| ___/| __| | ___/| __|
| | | |____| | | |____
|_|___ |______|_| _ |______| _
| __ \| | | | | |/ ____| | | |
| |__) | | | | | | (___ | |__| |
| ___/| | | | | |\___ \| __ |
| | | |___| |__| |____) | | | |
|_| |______\____/|_____/|_| |_|
Tokenized asset solution to the Pepe Plush shortage.
Strictly limited supply (300) and indivisible.
##For the discerning collector##
*/
interface token {
function transfer(address receiver, uint amount);
}
contract Crowdsale {
uint public price;
token public tokenReward;
mapping(address => uint256) pu// Contract address: 0x2f9860d5e8c1cb7b6816040756616c6aeb94063c
// Contract name: GWTCrowdsale
// Etherscan link: https://etherscan.io/address/0x2f9860d5e8c1cb7b6816040756616c6aeb94063c#code
pragma solidity ^0.4.4;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256 balance);
function transfer(address to, uint256 value) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256 remaining);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
libra// Contract address: 0x7f00a7024a559c7c88e8954213eb653c18900f4e
// Contract name: PGPToken
// Etherscan link: https://etherscan.io/address/0x7f00a7024a559c7c88e8954213eb653c18900f4e#code
pragma solidity ^0.4.21;
// ----------------------------------------------------------------------------
// PGP token contract
//
// Deployed to : 0x6f485f486518d5C9aea366dB4D85e417EF5e519d
// Symbol : PGP
// Name : Pretty Good Privacy
// Total supply: 32000000000000000000000000
// Decimals : 18
//
// Enjoy.
//
// (c) by Moritz Neto with BokkyPooBah / Bok Consulting Pty Ltd Au 2017. The MIT Licence.
// Adapted by MGSOLUTIONS
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
// Contract address: 0x089d6ac594a14450f1b516b93065c743bd93124a
// Contract name: ProofOfExtremeStableCoin
// Etherscan link: https://etherscan.io/address/0x089d6ac594a14450f1b516b93065c743bd93124a#code
pragma solidity ^0.4.21;
/*
*
* Same as PoSC, just more extreme.
* 50% divs.
*
*/
contract ProofOfExtremeStableCoin {
using SafeMath for uint256;
event Deposit(address user, uint amount);
event Withdraw(address user, uint amount);
event Claim(address user, uint dividends);
event Reinvest(address user, uint dividends);
address owner = 0x10141345eA2149Ba6dB4E26D222e32A2DDabDc2c;
mapping(address => bool) preauthorized;
bool gameStarted = true;
uint constant depositTaxDivisor = 2;
uint constant withdrawalTaxDivisor = 2;
mapping(address => uint) public investment;
mapping(address => uint) public stake;
uint public totalStake;
uint stakeValue;
mapping(address => uint) dividendCredit;
mapping(address => uint) divi// Contract address: 0x810b54cdb3d8c97d857b500cdfdb5715e1d27837
// Contract name: tokenesia
// Etherscan link: https://etherscan.io/address/0x810b54cdb3d8c97d857b500cdfdb5715e1d27837#code
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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
// Contract address: 0x56D1aE30c97288DA4B58BC39F026091778e4E316
// Contract name: Dagt
// Etherscan link: https://etherscan.io/address/0x56D1aE30c97288DA4B58BC39F026091778e4E316#code
pragma solidity ^0.4.17;
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) // Contract address: 0x0d44b2757f1b6c742ff8707f6eb298a7da1981af
// Contract name: KRWT
// Etherscan link: https://etherscan.io/address/0x0d44b2757f1b6c742ff8707f6eb298a7da1981af#code
pragma solidity ^0.4.21;
// ----------------------------------------------------------------------------
// TOKENMOM Korean Won(KRWT) Smart contract Token V.10
// 토큰맘 거래소 Korean Won 스마트 컨트랙트 토큰
// Deployed to : 0x8af2d2e23f0913af81abc6ccaa6200c945a161b4
// Symbol : BETA
// Name : TOKENMOM Korean Won
// Total supply: 10000000000
// Decimals : 8
// ----------------------------------------------------------------------------
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b)// Contract address: 0x42a8e4d6a899a3095c32381d30bef5a0a9214ea4
// Contract name: Crowdsale
// Etherscan link: https://etherscan.io/address/0x42a8e4d6a899a3095c32381d30bef5a0a9214ea4#code
/*! iam.sol | (c) 2018 Develop by BelovITLab LLC (smartcontract.ru), author @stupidlovejoy | License: MIT */
pragma solidity 0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
if(a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns(uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
// Contract address: 0xaf03be0017d0ba1c924b6c3de17e18d1be74b02a
// Contract name: InfinityHourglass
// Etherscan link: https://etherscan.io/address/0xaf03be0017d0ba1c924b6c3de17e18d1be74b02a#code
pragma solidity ^0.4.20;
/*
___ __ _ _ _
|_ _|_ __ / _(_)_ __ (_) |_ _ _
| || '_ \| |_| | '_ \| | __| | | |
| || | | | _| | | | | | |_| |_| |
|___|_| |_|_| |_|_| |_|_|\__|\__, |
_ _ |___/
| | | | ___ _ _ _ __ __ _| | __ _ ___ ___
| |_| |/ _ \| | | | '__/ _` | |/ _` / __/ __|
| _ | (_) | |_| | | | (_| | | (_| \__ \__ \
|_| |_|\___/ \__,_|_| \__, |_|\__,_|___/___/
|___/
Website: https://InfinityHourglass.io
Discord: https://discord.gg/33Nu2va
Twitter: https://twitter.com/Infinity_ETH
*/
contract InfinityHourglass {
modifier onlyPeopleWithTokens() {
require(myTokens() > 0);_; }
modifier onlyPeopleWpragma solidity ^0.4.18;
library moduleA {
function times10(uint input, uint times) returns (uint) {
return input*(10**times);
}
}
contract Sample {
using moduleA for uint;
uint public a = 3;
event print(uint output);
function times1000(uint times) returns (uint) {
a = a.times10(times);
}
// Contract address: 0x3b1830b36a1eaca80ec55b3bd8676b58c9d023aa
// Contract name: ProofOfStableClone
// Etherscan link: https://etherscan.io/address/0x3b1830b36a1eaca80ec55b3bd8676b58c9d023aa#code
pragma solidity ^0.4.21;
contract ProofOfStableClone {
using SafeMath for uint256;
event Deposit(address user, uint amount);
event Withdraw(address user, uint amount);
event Claim(address user, uint dividends);
event Reinvest(address user, uint dividends);
bool gameStarted;
uint constant depositTaxDivisor = 4;
uint constant withdrawalTaxDivisor = 11;
mapping(address => uint) public investment;
address owner;
mapping(address => uint) public stake;
uint public totalStake;
uint stakeValue;
mapping(address => uint) dividendCredit;
mapping(address => uint) dividendDebit;
function ProofOfStableClone() public {
owner = msg.sender;
}
modifier onlyOwner(){
require(msg.sender == owner || msg.send// Contract address: 0xf2ffc2ab9b0aea831c2115918691b1180a79af94
// Contract name: ProofOfStableClone
// Etherscan link: https://etherscan.io/address/0xf2ffc2ab9b0aea831c2115918691b1180a79af94#code
pragma solidity ^0.4.21;
contract ProofOfStableClone {
using SafeMath for uint256;
event Deposit(address user, uint amount);
event Withdraw(address user, uint amount);
event Claim(address user, uint dividends);
event Reinvest(address user, uint dividends);
bool gameStarted;
uint constant depositTaxDivisor = 4;
uint constant withdrawalTaxDivisor = 11;
mapping(address => uint) public investment;
mapping(bytes32 => bool) public administrators;
mapping(address => uint) public stake;
uint public totalStake;
uint stakeValue;
mapping(address => uint) dividendCredit;
mapping(address => uint) dividendDebit;
function ProofOfStableClone() public {
administrators[0x57c3715aa156394ff48706c09792523c63653d2a90bd4b8c36ba1a99bfbpragma solidity ^0.4.19;
import './SafeMath.sol';
import './oraclizeLib.sol';
//contract DogRace is usingOraclize {
contract DogRace {
using SafeMath for uint256;
string public constant version = "0.0.4";
uint public constant min_bet = 0.1 ether;
uint public constant max_bet = 1 ether;
uint public constant house_fee_pct = 5;
uint public constant claim_period = 30 days;
address public owner; // owner address
// Currencies: BTC, ETH, LTC, BCH, XRP
uint8 constant dogs_count = 5;
// Race states and timing
struct chronus_struct {
bool betting_open; // boolean: check if betting is open
bool race_start; // boolean: check if race has started
bool race_end; // boolean: check if race has ended
bool race_voided; // boolean: check if race has been voided
uint starting_time; // timestamp of when the race starts
uint betting_duration; // duration of betting period
uint race_duration// Contract address: 0x31a4b0e204cd8f6f26b3112cf9e89a5c2a24a174
// Contract name: TokenERC20
// Etherscan link: https://etherscan.io/address/0x31a4b0e204cd8f6f26b3112cf9e89a5c2a24a174#code
pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
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 f// Contract address: 0x8b26a81522747bc66be1261eaac3091c6fff0d6d
// Contract name: Distribution
// Etherscan link: https://etherscan.io/address/0x8b26a81522747bc66be1261eaac3091c6fff0d6d#code
pragma solidity ^0.4.13;
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 {
owner = msg.sender;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
/**
* @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 {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner =// Contract address: 0x5225f66168cc9c145b885d7af72054b52dbe1a0f
// Contract name: MintDRCT
// Etherscan link: https://etherscan.io/address/0x5225f66168cc9c145b885d7af72054b52dbe1a0f#code
pragma solidity ^0.4.21;
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint25// Contract address: 0x5e533a3dac57826aadb3c89aadc674c8319294e8
// Contract name: finco
// Etherscan link: https://etherscan.io/address/0x5e533a3dac57826aadb3c89aadc674c8319294e8#code
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// 'FINCO' token contract
//
// Deployed to : 0xed13b32835ed8b9c1b03c01d1feea31192c6da4d
// Symbol : FNCO
// Name : FINCO Token
// Total supply: 25000000000000000000000000000
// Decimals : 18
//
// Enjoy.
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a)// Contract address: 0xa91464abd4625a23ab719e3f0fce84dadd54e546
// Contract name: InooviToken
// Etherscan link: https://etherscan.io/address/0xa91464abd4625a23ab719e3f0fce84dadd54e546#code
pragma solidity ^0.4.19;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend i// Contract address: 0x01d1c640d58d5a3ed4da3028d70ef52954619024
// Contract name: Gryphon
// Etherscan link: https://etherscan.io/address/0x01d1c640d58d5a3ed4da3028d70ef52954619024#code
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
// Contract address: 0x69c54403fbde6bc7aa9948a27d821cea66c4d803
// Contract name: HourglassV2
// Etherscan link: https://etherscan.io/address/0x69c54403fbde6bc7aa9948a27d821cea66c4d803#code
pragma solidity ^0.4.20;
/*
╔══╗──────────╔╗──────────╔═══╗
║╔╗║──────────║║──────────║╔═╗║
║╚╝║╔══╗╔╗╔╗╔╗║╚═╗────╔╗╔╗╚╝╔╝║
║╔═╝║╔╗║║╚╝╚╝║║╔╗║────║╚╝║╔═╝╔╝
║║──║╚╝║╚╗╔╗╔╝║║║║────╚╗╔╝║ ╚═╗
╚╝──╚══╝─╚╝╚╝─╚╝╚╝─────╚╝─╚═══╝
* -> About P4D
* An autonomousfully automated passive income:
* [x] Created by a team of professional Developers from India who run a software company and specialize in Internet and Cryptographic Security
* [x] Pen-tested mul// Contract address: 0xc99374e2a527f7f290ba33b0eef0d292d8550c9f
// Contract name: Sale
// Etherscan link: https://etherscan.io/address/0xc99374e2a527f7f290ba33b0eef0d292d8550c9f#code
pragma solidity ^0.4.21;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || // Contract address: 0x225e95b196d9739efa22e138bc1dd0b35bc4c983
// Contract name: TonalQuantum
// Etherscan link: https://etherscan.io/address/0x225e95b196d9739efa22e138bc1dd0b35bc4c983#code
pragma solidity ^0.4.19;
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**// Contract address: 0x3f953f2a343df5d48e22d216f9a23db8958c2170
// Contract name: Gryphon
// Etherscan link: https://etherscan.io/address/0x3f953f2a343df5d48e22d216f9a23db8958c2170#code
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
// Contract address: 0xf239fab41de78533fa974b74d7605f1e68f8772e
// Contract name: CPSTestToken1
// Etherscan link: https://etherscan.io/address/0xf239fab41de78533fa974b74d7605f1e68f8772e#code
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
retu// Contract address: 0x05cd43ce7c54a23713841aeed22cb8686b1de820
// Contract name: Gryphon
// Etherscan link: https://etherscan.io/address/0x05cd43ce7c54a23713841aeed22cb8686b1de820#code
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
// Contract address: 0x858e7c5f692feb75209b7c836ff057bcb54c17d9
// Contract name: TonalQuantum
// Etherscan link: https://etherscan.io/address/0x858e7c5f692feb75209b7c836ff057bcb54c17d9#code
pragma solidity ^0.4.19;
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**// Contract address: 0x8325c7406d3c559a421adfa3a51cc53e2b270ff4
// Contract name: Gryphon
// Etherscan link: https://etherscan.io/address/0x8325c7406d3c559a421adfa3a51cc53e2b270ff4#code
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
// Contract address: 0x12db622c98d75f6f19493d9acbc7479fe382ec44
// Contract name: TBECrowdsale
// Etherscan link: https://etherscan.io/address/0x12db622c98d75f6f19493d9acbc7479fe382ec44#code
pragma solidity ^0.4.21;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtr// Contract address: 0x1c07cae8b53ff78ad7ce727f69fd3604758ca37e
// Contract name: Sale
// Etherscan link: https://etherscan.io/address/0x1c07cae8b53ff78ad7ce727f69fd3604758ca37e#code
pragma solidity ^0.4.21;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || // Contract address: 0x9fbd7908b1f8daa833d9c2d0ec07573de9e7ce76
// Contract name: KickcityCrowdsaleStageTwo
// Etherscan link: https://etherscan.io/address/0x9fbd7908b1f8daa833d9c2d0ec07573de9e7ce76#code
pragma solidity ^0.4.13;
contract Utils {
/**
constructor
*/
function Utils() {
}
// verifies that an amount is greater than zero
modifier greaterThanZero(uint256 _amount) {
require(_amount > 0);
_;
}
// validates an address - currently only checks that it isn't null
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
// verifies that the address is different than this contract address
modifier notThis(address _address) {
require(_address != address(this));
_;
}
// Overflow protected math functions
/**
@dev returns the sum of _x and _y, asserts if the calculation overflows
@param _x value 1
@param _y value 2// Contract address: 0xf6da07a8ffb5683314715d8c7a1a5c952b4e74ca
// Contract name: DoubleLandICO
// Etherscan link: https://etherscan.io/address/0xf6da07a8ffb5683314715d8c7a1a5c952b4e74ca#code
pragma solidity ^0.4.21;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a// Contract address: 0xe35fd5d9cbd14a620d6fe66e968abd16099ae220
// Contract name: BountyDistributor
// Etherscan link: https://etherscan.io/address/0xe35fd5d9cbd14a620d6fe66e968abd16099ae220#code
pragma solidity ^0.4.13;
contract Utils {
/**
constructor
*/
function Utils() {
}
// verifies that an amount is greater than zero
modifier greaterThanZero(uint256 _amount) {
require(_amount > 0);
_;
}
// validates an address - currently only checks that it isn't null
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
// verifies that the address is different than this contract address
modifier notThis(address _address) {
require(_address != address(this));
_;
}
// Overflow protected math functions
/**
@dev returns the sum of _x and _y, asserts if the calculation overflows
@param _x value 1
@param _y value 2
// Contract address: 0xf18b97b312ef48c5d2b5c21c739d499b7c65cf96
// Contract name: TBEToken
// Etherscan link: https://etherscan.io/address/0xf18b97b312ef48c5d2b5c21c739d499b7c65cf96#code
pragma solidity ^0.4.21;
contract TBEToken {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function TBEToken() public {
totalSupply = 500000000 * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "TowerBee";
symbol = "TBE";
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_// Contract address: 0x73e603c31d000051bf49c917113d020bcb435535
// Contract name: BitTeamToken
// Etherscan link: https://etherscan.io/address/0x73e603c31d000051bf49c917113d020bcb435535#code
pragma solidity ^0.4.4;
contract ERC20Token {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Token is ERC20Token {
mapping (address => uint256) balances;
mapping (addre// Contract address: 0x55d260f12a6627a11aa10256f00cfacc48994aa8
// Contract name: SkrumbleCandyToken
// Etherscan link: https://etherscan.io/address/0x55d260f12a6627a11aa10256f00cfacc48994aa8#code
pragma solidity ^0.4.18;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
// Contract address: 0xee3c19a4a77eefff2c8b882cdb82b22fea94a09e
// Contract name: KRWT
// Etherscan link: https://etherscan.io/address/0xee3c19a4a77eefff2c8b882cdb82b22fea94a09e#code
pragma solidity ^0.4.21;
// ----------------------------------------------------------------------------
// TOKENMOM Korean Won(KRWT) Smart contract Token V.10
// 토큰맘 거래소 Korean Won 스마트 컨트랙트 토큰
// Deployed to : 0x8af2d2e23f0913af81abc6ccaa6200c945a161b4
// Symbol : BETA
// Name : TOKENMOM Korean Won
// Total supply: 100000000000
// Decimals : 8
// ----------------------------------------------------------------------------
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b// Contract address: 0xe88b9b0826920bf95cd269dcb7515406586609fb
// Contract name: MultiSigWalletWithDailyLimit
// Etherscan link: https://etherscan.io/address/0xe88b9b0826920bf95cd269dcb7515406586609fb#code
pragma solidity ^0.4.15;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract MultiSigWallet {
/*
* Events
*/
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
/*
* Constants
*/
uint constant public MAX// Contract address: 0x137f0a82473df04cd601b20c9943d89cdd592fd6
// Contract name: WebcoinCrowdsale
// Etherscan link: https://etherscan.io/address/0x137f0a82473df04cd601b20c9943d89cdd592fd6#code
pragma solidity ^0.4.18;
// File: contracts/Vault.sol
interface Vault {
function sendFunds() payable public returns (bool);
event Transfer(address beneficiary, uint256 amountWei);
}
// File: zeppelin-solidity/contracts/ownership/Ownable.sol
/**
* @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 {
owner = msg.sender;
}
/**
* @dev Throws if called by any account o